Mercurial > hg > CbC > CbC_gcc

comparison gcc/config/alpha/alpha.h @ 111:04ced10e8804

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
gcc 7
author kono
date Fri, 27 Oct 2017 22:46:09 +0900
parents f6334be47118
children 84e7813d76e9
comparison
equal deleted inserted replaced
68:561a7518be6b 111:04ced10e8804
1 /* Definitions of target machine for GNU compiler, for DEC Alpha. 1 /* Definitions of target machine for GNU compiler, for DEC Alpha.
2 Copyright (C) 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2 Copyright (C) 1992-2017 Free Software Foundation, Inc.
3 2000, 2001, 2002, 2004, 2005, 2007, 2008, 2009, 2010
4 Free Software Foundation, Inc.
5 Contributed by Richard Kenner (kenner@vlsi1.ultra.nyu.edu) 3 Contributed by Richard Kenner (kenner@vlsi1.ultra.nyu.edu)
6 4
7 This file is part of GCC. 5 This file is part of GCC.
8 6
9 GCC is free software; you can redistribute it and/or modify 7 GCC is free software; you can redistribute it and/or modify
94 } \ 92 } \
95 } \ 93 } \
96 while (0) 94 while (0)
97 #endif 95 #endif
98 96
99 /* Print subsidiary information on the compiler version in use. */
100 #define TARGET_VERSION
101
102 /* Run-time compilation parameters selecting different hardware subsets. */ 97 /* Run-time compilation parameters selecting different hardware subsets. */
103 98
104 /* Which processor to schedule for. The cpu attribute defines a list that 99 /* Which processor to schedule for. The cpu attribute defines a list that
105 mirrors this list, so changes to alpha.md must be made at the same time. */ 100 mirrors this list, so changes to alpha.md must be made at the same time. */
106 101
144 139
145 /* Invert the easy way to make options work. */ 140 /* Invert the easy way to make options work. */
146 #define TARGET_FP (!TARGET_SOFT_FP) 141 #define TARGET_FP (!TARGET_SOFT_FP)
147 142
148 /* These are for target os support and cannot be changed at runtime. */ 143 /* These are for target os support and cannot be changed at runtime. */
149 #define TARGET_ABI_WINDOWS_NT 0 144 #define TARGET_ABI_OPEN_VMS 0
150 #define TARGET_ABI_OPEN_VMS 0 145 #define TARGET_ABI_OSF (!TARGET_ABI_OPEN_VMS)
151 #define TARGET_ABI_UNICOSMK 0 146
152 #define TARGET_ABI_OSF (!TARGET_ABI_WINDOWS_NT \
153 && !TARGET_ABI_OPEN_VMS \
154 && !TARGET_ABI_UNICOSMK)
155
156 #ifndef TARGET_AS_CAN_SUBTRACT_LABELS
157 #define TARGET_AS_CAN_SUBTRACT_LABELS TARGET_GAS
158 #endif
159 #ifndef TARGET_AS_SLASH_BEFORE_SUFFIX
160 #define TARGET_AS_SLASH_BEFORE_SUFFIX TARGET_GAS
161 #endif
162 #ifndef TARGET_CAN_FAULT_IN_PROLOGUE 147 #ifndef TARGET_CAN_FAULT_IN_PROLOGUE
163 #define TARGET_CAN_FAULT_IN_PROLOGUE 0 148 #define TARGET_CAN_FAULT_IN_PROLOGUE 0
164 #endif 149 #endif
165 #ifndef TARGET_HAS_XFLOATING_LIBS 150 #ifndef TARGET_HAS_XFLOATING_LIBS
166 #define TARGET_HAS_XFLOATING_LIBS TARGET_LONG_DOUBLE_128 151 #define TARGET_HAS_XFLOATING_LIBS TARGET_LONG_DOUBLE_128
167 #endif 152 #endif
168 #ifndef TARGET_PROFILING_NEEDS_GP 153 #ifndef TARGET_PROFILING_NEEDS_GP
169 #define TARGET_PROFILING_NEEDS_GP 0 154 #define TARGET_PROFILING_NEEDS_GP 0
170 #endif
171 #ifndef TARGET_LD_BUGGY_LDGP
172 #define TARGET_LD_BUGGY_LDGP 0
173 #endif 155 #endif
174 #ifndef TARGET_FIXUP_EV5_PREFETCH 156 #ifndef TARGET_FIXUP_EV5_PREFETCH
175 #define TARGET_FIXUP_EV5_PREFETCH 0 157 #define TARGET_FIXUP_EV5_PREFETCH 0
176 #endif 158 #endif
177 #ifndef HAVE_AS_TLS 159 #ifndef HAVE_AS_TLS
218 and `long double' are T. */ 200 and `long double' are T. */
219 201
220 #define FLOAT_TYPE_SIZE 32 202 #define FLOAT_TYPE_SIZE 32
221 #define DOUBLE_TYPE_SIZE 64 203 #define DOUBLE_TYPE_SIZE 64
222 #define LONG_DOUBLE_TYPE_SIZE (TARGET_LONG_DOUBLE_128 ? 128 : 64) 204 #define LONG_DOUBLE_TYPE_SIZE (TARGET_LONG_DOUBLE_128 ? 128 : 64)
223
224 /* Define this to set long double type size to use in libgcc2.c, which can
225 not depend on target_flags. */
226 #ifdef __LONG_DOUBLE_128__
227 #define LIBGCC2_LONG_DOUBLE_TYPE_SIZE 128
228 #else
229 #define LIBGCC2_LONG_DOUBLE_TYPE_SIZE 64
230 #endif
231 205
232 /* Work around target_flags dependency in ada/targtyps.c. */ 206 /* Work around target_flags dependency in ada/targtyps.c. */
233 #define WIDEST_HARDWARE_FP_SIZE 64 207 #define WIDEST_HARDWARE_FP_SIZE 64
234 208
235 #define WCHAR_TYPE "unsigned int" 209 #define WCHAR_TYPE "unsigned int"
298 272
299 /* Every structure's size must be a multiple of this. */ 273 /* Every structure's size must be a multiple of this. */
300 #define STRUCTURE_SIZE_BOUNDARY 8 274 #define STRUCTURE_SIZE_BOUNDARY 8
301 275
302 /* A bit-field declared as `int' forces `int' alignment for the struct. */ 276 /* A bit-field declared as `int' forces `int' alignment for the struct. */
277 #undef PCC_BITFILED_TYPE_MATTERS
303 #define PCC_BITFIELD_TYPE_MATTERS 1 278 #define PCC_BITFIELD_TYPE_MATTERS 1
304 279
305 /* No data type wants to be aligned rounder than this. */ 280 /* No data type wants to be aligned rounder than this. */
306 #define BIGGEST_ALIGNMENT 128 281 #define BIGGEST_ALIGNMENT 128
307 282
312 /* Align all constants and variables to at least a word boundary so 287 /* Align all constants and variables to at least a word boundary so
313 we can pick up pieces of them faster. */ 288 we can pick up pieces of them faster. */
314 /* ??? Only if block-move stuff knows about different source/destination 289 /* ??? Only if block-move stuff knows about different source/destination
315 alignment. */ 290 alignment. */
316 #if 0 291 #if 0
317 #define CONSTANT_ALIGNMENT(EXP, ALIGN) MAX ((ALIGN), BITS_PER_WORD)
318 #define DATA_ALIGNMENT(EXP, ALIGN) MAX ((ALIGN), BITS_PER_WORD) 292 #define DATA_ALIGNMENT(EXP, ALIGN) MAX ((ALIGN), BITS_PER_WORD)
319 #endif 293 #endif
320 294
321 /* Set this nonzero if move instructions will actually fail to work 295 /* Set this nonzero if move instructions will actually fail to work
322 when given unaligned data. 296 when given unaligned data.
323 297
324 Since we get an error message when we do one, call them invalid. */ 298 Since we get an error message when we do one, call them invalid. */
325 299
326 #define STRICT_ALIGNMENT 1 300 #define STRICT_ALIGNMENT 1
327
328 /* Set this nonzero if unaligned move instructions are extremely slow.
329
330 On the Alpha, they trap. */
331
332 #define SLOW_UNALIGNED_ACCESS(MODE, ALIGN) 1
333 301
334 /* Standard register usage. */ 302 /* Standard register usage. */
335 303
336 /* Number of actual hardware registers. 304 /* Number of actual hardware registers.
337 The hardware registers are assigned numbers for the compiler 305 The hardware registers are assigned numbers for the compiler
400 40, 41, /* likewise */ \ 368 40, 41, /* likewise */ \
401 \ 369 \
402 29, 30, 31, 63 /* gp, sp, ap, sfp */ \ 370 29, 30, 31, 63 /* gp, sp, ap, sfp */ \
403 } 371 }
404 372
405 /* Return number of consecutive hard regs needed starting at reg REGNO
406 to hold something of mode MODE.
407 This is ordinarily the length in words of a value of mode MODE
408 but can be less for certain modes in special long registers. */
409
410 #define HARD_REGNO_NREGS(REGNO, MODE) \
411 ((GET_MODE_SIZE (MODE) + UNITS_PER_WORD - 1) / UNITS_PER_WORD)
412
413 /* Value is 1 if hard register REGNO can hold a value of machine-mode MODE.
414 On Alpha, the integer registers can hold any mode. The floating-point
415 registers can hold 64-bit integers as well, but not smaller values. */
416
417 #define HARD_REGNO_MODE_OK(REGNO, MODE) \
418 (IN_RANGE ((REGNO), 32, 62) \
419 ? (MODE) == SFmode || (MODE) == DFmode || (MODE) == DImode \
420 || (MODE) == SCmode || (MODE) == DCmode \
421 : 1)
422
423 /* A C expression that is nonzero if a value of mode
424 MODE1 is accessible in mode MODE2 without copying.
425
426 This asymmetric test is true when MODE1 could be put
427 in an FP register but MODE2 could not. */
428
429 #define MODES_TIEABLE_P(MODE1, MODE2) \
430 (HARD_REGNO_MODE_OK (32, (MODE1)) \
431 ? HARD_REGNO_MODE_OK (32, (MODE2)) \
432 : 1)
433
434 /* Specify the registers used for certain standard purposes. 373 /* Specify the registers used for certain standard purposes.
435 The values of these macros are register numbers. */ 374 The values of these macros are register numbers. */
436 375
437 /* Alpha pc isn't overloaded on a register that the compiler knows about. */ 376 /* Alpha pc isn't overloaded on a register that the compiler knows about. */
438 /* #define PC_REGNUM */ 377 /* #define PC_REGNUM */
513 {0x08000000, 0x00000000}, /* R27_REG */ \ 452 {0x08000000, 0x00000000}, /* R27_REG */ \
514 {0xffffffff, 0x80000000}, /* GENERAL_REGS */ \ 453 {0xffffffff, 0x80000000}, /* GENERAL_REGS */ \
515 {0x00000000, 0x7fffffff}, /* FLOAT_REGS */ \ 454 {0x00000000, 0x7fffffff}, /* FLOAT_REGS */ \
516 {0xffffffff, 0xffffffff} } 455 {0xffffffff, 0xffffffff} }
517 456
518 /* The following macro defines cover classes for Integrated Register
519 Allocator. Cover classes is a set of non-intersected register
520 classes covering all hard registers used for register allocation
521 purpose. Any move between two registers of a cover class should be
522 cheaper than load or store of the registers. The macro value is
523 array of register classes with LIM_REG_CLASSES used as the end
524 marker. */
525
526 #define IRA_COVER_CLASSES \
527 { \
528 GENERAL_REGS, FLOAT_REGS, LIM_REG_CLASSES \
529 }
530
531 /* The same information, inverted: 457 /* The same information, inverted:
532 Return the class number of the smallest class containing 458 Return the class number of the smallest class containing
533 reg number REGNO. This could be a conditional expression 459 reg number REGNO. This could be a conditional expression
534 or could index an array. */ 460 or could index an array. */
535 461
550 In general this is just CLASS; but on some machines 476 In general this is just CLASS; but on some machines
551 in some cases it is preferable to use a more restrictive class. */ 477 in some cases it is preferable to use a more restrictive class. */
552 478
553 #define PREFERRED_RELOAD_CLASS alpha_preferred_reload_class 479 #define PREFERRED_RELOAD_CLASS alpha_preferred_reload_class
554 480
555 /* If we are copying between general and FP registers, we need a memory
556 location unless the FIX extension is available. */
557
558 #define SECONDARY_MEMORY_NEEDED(CLASS1,CLASS2,MODE) \
559 (! TARGET_FIX && (((CLASS1) == FLOAT_REGS && (CLASS2) != FLOAT_REGS) \
560 || ((CLASS2) == FLOAT_REGS && (CLASS1) != FLOAT_REGS)))
561
562 /* Specify the mode to be used for memory when a secondary memory
563 location is needed. If MODE is floating-point, use it. Otherwise,
564 widen to a word like the default. This is needed because we always
565 store integers in FP registers in quadword format. This whole
566 area is very tricky! */
567 #define SECONDARY_MEMORY_NEEDED_MODE(MODE) \
568 (GET_MODE_CLASS (MODE) == MODE_FLOAT ? (MODE) \
569 : GET_MODE_SIZE (MODE) >= 4 ? (MODE) \
570 : mode_for_size (BITS_PER_WORD, GET_MODE_CLASS (MODE), 0))
571
572 /* Return the maximum number of consecutive registers
573 needed to represent mode MODE in a register of class CLASS. */
574
575 #define CLASS_MAX_NREGS(CLASS, MODE) \
576 ((GET_MODE_SIZE (MODE) + UNITS_PER_WORD - 1) / UNITS_PER_WORD)
577
578 /* Return the class of registers that cannot change mode from FROM to TO. */
579
580 #define CANNOT_CHANGE_MODE_CLASS(FROM, TO, CLASS) \
581 (GET_MODE_SIZE (FROM) != GET_MODE_SIZE (TO) \
582 ? reg_classes_intersect_p (FLOAT_REGS, CLASS) : 0)
583
584 /* Define the cost of moving between registers of various classes. Moving
585 between FLOAT_REGS and anything else except float regs is expensive.
586 In fact, we make it quite expensive because we really don't want to
587 do these moves unless it is clearly worth it. Optimizations may
588 reduce the impact of not being able to allocate a pseudo to a
589 hard register. */
590
591 #define REGISTER_MOVE_COST(MODE, CLASS1, CLASS2) \
592 (((CLASS1) == FLOAT_REGS) == ((CLASS2) == FLOAT_REGS) ? 2 \
593 : TARGET_FIX ? ((CLASS1) == FLOAT_REGS ? 6 : 8) \
594 : 4+2*alpha_memory_latency)
595
596 /* A C expressions returning the cost of moving data of MODE from a register to
597 or from memory.
598
599 On the Alpha, bump this up a bit. */
600
601 extern int alpha_memory_latency;
602 #define MEMORY_MOVE_COST(MODE,CLASS,IN) (2*alpha_memory_latency)
603
604 /* Provide the cost of a branch. Exact meaning under development. */ 481 /* Provide the cost of a branch. Exact meaning under development. */
605 #define BRANCH_COST(speed_p, predictable_p) 5 482 #define BRANCH_COST(speed_p, predictable_p) 5
606 483
607 /* Stack layout; function entry, exit and calling. */ 484 /* Stack layout; function entry, exit and calling. */
608 485
609 /* Define this if pushing a word on the stack 486 /* Define this if pushing a word on the stack
610 makes the stack pointer a smaller address. */ 487 makes the stack pointer a smaller address. */
611 #define STACK_GROWS_DOWNWARD 488 #define STACK_GROWS_DOWNWARD 1
612 489
613 /* Define this to nonzero if the nominal address of the stack frame 490 /* Define this to nonzero if the nominal address of the stack frame
614 is at the high-address end of the local variables; 491 is at the high-address end of the local variables;
615 that is, each additional local variable allocated 492 that is, each additional local variable allocated
616 goes at a more negative offset in the frame. */ 493 goes at a more negative offset in the frame. */
617 /* #define FRAME_GROWS_DOWNWARD 0 */ 494 /* #define FRAME_GROWS_DOWNWARD 0 */
618 495
619 /* Offset within stack frame to start allocating local variables at.
620 If FRAME_GROWS_DOWNWARD, this is the offset to the END of the
621 first local allocated. Otherwise, it is the offset to the BEGINNING
622 of the first local allocated. */
623
624 #define STARTING_FRAME_OFFSET 0
625
626 /* If we generate an insn to push BYTES bytes, 496 /* If we generate an insn to push BYTES bytes,
627 this says how many the stack pointer really advances by. 497 this says how many the stack pointer really advances by.
628 On Alpha, don't define this because there are no push insns. */ 498 On Alpha, don't define this because there are no push insns. */
629 /* #define PUSH_ROUNDING(BYTES) */ 499 /* #define PUSH_ROUNDING(BYTES) */
630 500
657 { ARG_POINTER_REGNUM, HARD_FRAME_POINTER_REGNUM}, \ 527 { ARG_POINTER_REGNUM, HARD_FRAME_POINTER_REGNUM}, \
658 { FRAME_POINTER_REGNUM, STACK_POINTER_REGNUM}, \ 528 { FRAME_POINTER_REGNUM, STACK_POINTER_REGNUM}, \
659 { FRAME_POINTER_REGNUM, HARD_FRAME_POINTER_REGNUM}} 529 { FRAME_POINTER_REGNUM, HARD_FRAME_POINTER_REGNUM}}
660 530
661 /* Round up to a multiple of 16 bytes. */ 531 /* Round up to a multiple of 16 bytes. */
662 #define ALPHA_ROUND(X) (((X) + 15) & ~ 15) 532 #define ALPHA_ROUND(X) ROUND_UP ((X), 16)
663 533
664 /* Define the offset between two registers, one to be eliminated, and the other 534 /* Define the offset between two registers, one to be eliminated, and the other
665 its replacement, at the start of a routine. */ 535 its replacement, at the start of a routine. */
666 #define INITIAL_ELIMINATION_OFFSET(FROM, TO, OFFSET) \ 536 #define INITIAL_ELIMINATION_OFFSET(FROM, TO, OFFSET) \
667 ((OFFSET) = alpha_initial_elimination_offset(FROM, TO)) 537 ((OFFSET) = alpha_initial_elimination_offset(FROM, TO))
668 538
669 /* Define this if stack space is still allocated for a parameter passed 539 /* Define this if stack space is still allocated for a parameter passed
670 in a register. */ 540 in a register. */
671 /* #define REG_PARM_STACK_SPACE */ 541 /* #define REG_PARM_STACK_SPACE */
672
673 /* Define how to find the value returned by a function.
674 VALTYPE is the data type of the value (as a tree).
675 If the precise function being called is known, FUNC is its FUNCTION_DECL;
676 otherwise, FUNC is 0.
677
678 On Alpha the value is found in $0 for integer functions and
679 $f0 for floating-point functions. */
680
681 #define FUNCTION_VALUE(VALTYPE, FUNC) \
682 function_value (VALTYPE, FUNC, VOIDmode)
683
684 /* Define how to find the value returned by a library function
685 assuming the value has mode MODE. */
686
687 #define LIBCALL_VALUE(MODE) \
688 function_value (NULL, NULL, MODE)
689
690 /* 1 if N is a possible register number for a function value
691 as seen by the caller. */
692
693 #define FUNCTION_VALUE_REGNO_P(N) \
694 ((N) == 0 || (N) == 1 || (N) == 32 || (N) == 33)
695 542
696 /* 1 if N is a possible register number for function argument passing. 543 /* 1 if N is a possible register number for function argument passing.
697 On Alpha, these are $16-$21 and $f16-$f21. */ 544 On Alpha, these are $16-$21 and $f16-$f21. */
698 545
699 #define FUNCTION_ARG_REGNO_P(N) \ 546 #define FUNCTION_ARG_REGNO_P(N) \
716 For a library call, FNTYPE is 0. */ 563 For a library call, FNTYPE is 0. */
717 564
718 #define INIT_CUMULATIVE_ARGS(CUM, FNTYPE, LIBNAME, INDIRECT, N_NAMED_ARGS) \ 565 #define INIT_CUMULATIVE_ARGS(CUM, FNTYPE, LIBNAME, INDIRECT, N_NAMED_ARGS) \
719 (CUM) = 0 566 (CUM) = 0
720 567
721 /* Define intermediate macro to compute the size (in registers) of an argument 568 /* Define intermediate macro to compute
722 for the Alpha. */ 569 the size (in registers) of an argument. */
723 570
724 #define ALPHA_ARG_SIZE(MODE, TYPE, NAMED) \ 571 #define ALPHA_ARG_SIZE(MODE, TYPE) \
725 ((MODE) == TFmode || (MODE) == TCmode ? 1 \ 572 ((MODE) == TFmode || (MODE) == TCmode ? 1 \
726 : (((MODE) == BLKmode ? int_size_in_bytes (TYPE) : GET_MODE_SIZE (MODE)) \ 573 : CEIL (((MODE) == BLKmode \
727 + (UNITS_PER_WORD - 1)) / UNITS_PER_WORD) 574 ? int_size_in_bytes (TYPE) \
575 : GET_MODE_SIZE (MODE)), \
576 UNITS_PER_WORD))
728 577
729 /* Make (or fake) .linkage entry for function call. 578 /* Make (or fake) .linkage entry for function call.
730 IS_LOCAL is 0 if name is used in call, 1 if name is used in definition. */ 579 IS_LOCAL is 0 if name is used in call, 1 if name is used in definition. */
731 580
732 /* This macro defines the start of an assembly comment. */ 581 /* This macro defines the start of an assembly comment. */
733 582
734 #define ASM_COMMENT_START " #" 583 #define ASM_COMMENT_START " #"
735 584
736 /* This macro produces the initial definition of a function. */ 585 /* This macro produces the initial definition of a function. */
737 586
587 #undef ASM_DECLARE_FUNCTION_NAME
738 #define ASM_DECLARE_FUNCTION_NAME(FILE,NAME,DECL) \ 588 #define ASM_DECLARE_FUNCTION_NAME(FILE,NAME,DECL) \
739 alpha_start_function(FILE,NAME,DECL); 589 alpha_start_function(FILE,NAME,DECL);
740 590
741 /* This macro closes up a function definition for the assembler. */ 591 /* This macro closes up a function definition for the assembler. */
742 592
593 #undef ASM_DECLARE_FUNCTION_SIZE
743 #define ASM_DECLARE_FUNCTION_SIZE(FILE,NAME,DECL) \ 594 #define ASM_DECLARE_FUNCTION_SIZE(FILE,NAME,DECL) \
744 alpha_end_function(FILE,NAME,DECL) 595 alpha_end_function(FILE,NAME,DECL)
745 596
746 /* Output any profiling code before the prologue. */ 597 /* Output any profiling code before the prologue. */
747 598
797 648
798 /* Describe how we implement __builtin_eh_return. */ 649 /* Describe how we implement __builtin_eh_return. */
799 #define EH_RETURN_DATA_REGNO(N) ((N) < 4 ? (N) + 16 : INVALID_REGNUM) 650 #define EH_RETURN_DATA_REGNO(N) ((N) < 4 ? (N) + 16 : INVALID_REGNUM)
800 #define EH_RETURN_STACKADJ_RTX gen_rtx_REG (Pmode, 28) 651 #define EH_RETURN_STACKADJ_RTX gen_rtx_REG (Pmode, 28)
801 #define EH_RETURN_HANDLER_RTX \ 652 #define EH_RETURN_HANDLER_RTX \
802 gen_rtx_MEM (Pmode, plus_constant (stack_pointer_rtx, \ 653 gen_rtx_MEM (Pmode, plus_constant (Pmode, stack_pointer_rtx, \
803 crtl->outgoing_args_size)) 654 crtl->outgoing_args_size))
804 655
805 /* Addressing modes, and classification of registers for them. */ 656 /* Addressing modes, and classification of registers for them. */
806 657
807 /* Macros to check register numbers against specific register classes. */ 658 /* Macros to check register numbers against specific register classes. */
808 659
809 /* These assume that REGNO is a hard or pseudo reg number. 660 /* These assume that REGNO is a hard or pseudo reg number.
810 They give nonzero only if REGNO is a hard reg of the suitable class 661 They give nonzero only if REGNO is a hard reg of the suitable class
811 or a pseudo reg currently allocated to a suitable hard reg. 662 or a pseudo reg currently allocated to a suitable hard reg.
812 Since they use reg_renumber, they are safe only once reg_renumber 663 Since they use reg_renumber, they are safe only once reg_renumber
813 has been allocated, which happens in local-alloc.c. */ 664 has been allocated, which happens in reginfo.c during register
665 allocation. */
814 666
815 #define REGNO_OK_FOR_INDEX_P(REGNO) 0 667 #define REGNO_OK_FOR_INDEX_P(REGNO) 0
816 #define REGNO_OK_FOR_BASE_P(REGNO) \ 668 #define REGNO_OK_FOR_BASE_P(REGNO) \
817 ((REGNO) < 32 || (unsigned) reg_renumber[REGNO] < 32 \ 669 ((REGNO) < 32 || (unsigned) reg_renumber[REGNO] < 32 \
818 || (REGNO) == 63 || reg_renumber[REGNO] == 63) 670 || (REGNO) == 63 || reg_renumber[REGNO] == 63)
825 symbolic addresses into registers. */ 677 symbolic addresses into registers. */
826 678
827 #define CONSTANT_ADDRESS_P(X) \ 679 #define CONSTANT_ADDRESS_P(X) \
828 (CONST_INT_P (X) \ 680 (CONST_INT_P (X) \
829 && (unsigned HOST_WIDE_INT) (INTVAL (X) + 0x8000) < 0x10000) 681 && (unsigned HOST_WIDE_INT) (INTVAL (X) + 0x8000) < 0x10000)
830
831 /* Include all constant integers and constant doubles, but not
832 floating-point, except for floating-point zero. */
833
834 #define LEGITIMATE_CONSTANT_P alpha_legitimate_constant_p
835 682
836 /* The macros REG_OK_FOR..._P assume that the arg is a REG rtx 683 /* The macros REG_OK_FOR..._P assume that the arg is a REG rtx
837 and check its validity for a certain class. 684 and check its validity for a certain class.
838 We have two alternate definitions for each of them. 685 We have two alternate definitions for each of them.
839 The usual definition accepts all pseudo regs; the other rejects 686 The usual definition accepts all pseudo regs; the other rejects
886 X = new_x; \ 733 X = new_x; \
887 goto WIN; \ 734 goto WIN; \
888 } \ 735 } \
889 } while (0) 736 } while (0)
890 737
891 /* Go to LABEL if ADDR (a legitimate address expression)
892 has an effect that depends on the machine mode it is used for.
893 On the Alpha this is true only for the unaligned modes. We can
894 simplify this test since we know that the address must be valid. */
895
896 #define GO_IF_MODE_DEPENDENT_ADDRESS(ADDR,LABEL) \
897 { if (GET_CODE (ADDR) == AND) goto LABEL; }
898 738
899 /* Specify the machine mode that this machine uses 739 /* Specify the machine mode that this machine uses
900 for the index in the tablejump instruction. */ 740 for the index in the tablejump instruction. */
901 #define CASE_VECTOR_MODE SImode 741 #define CASE_VECTOR_MODE SImode
902 742
939 779
940 #define SLOW_BYTE_ACCESS 1 780 #define SLOW_BYTE_ACCESS 1
941 781
942 /* Define if operations between registers always perform the operation 782 /* Define if operations between registers always perform the operation
943 on the full register even if a narrower mode is specified. */ 783 on the full register even if a narrower mode is specified. */
944 #define WORD_REGISTER_OPERATIONS 784 #define WORD_REGISTER_OPERATIONS 1
945 785
946 /* Define if loading in MODE, an integral mode narrower than BITS_PER_WORD 786 /* Define if loading in MODE, an integral mode narrower than BITS_PER_WORD
947 will either zero-extend or sign-extend. The value of this macro should 787 will either zero-extend or sign-extend. The value of this macro should
948 be the code that says which one of the two operations is implicitly 788 be the code that says which one of the two operations is implicitly
949 done, UNKNOWN if none. */ 789 done, UNKNOWN if none. */
950 #define LOAD_EXTEND_OP(MODE) ((MODE) == SImode ? SIGN_EXTEND : ZERO_EXTEND) 790 #define LOAD_EXTEND_OP(MODE) ((MODE) == SImode ? SIGN_EXTEND : ZERO_EXTEND)
951 791
952 /* Define if loading short immediate values into registers sign extends. */ 792 /* Define if loading short immediate values into registers sign extends. */
953 #define SHORT_IMMEDIATES_SIGN_EXTEND 793 #define SHORT_IMMEDIATES_SIGN_EXTEND 1
954
955 /* Value is 1 if truncating an integer of INPREC bits to OUTPREC bits
956 is done just by pretending it is already truncated. */
957 #define TRULY_NOOP_TRUNCATION(OUTPREC, INPREC) 1
958 794
959 /* The CIX ctlz and cttz instructions return 64 for zero. */ 795 /* The CIX ctlz and cttz instructions return 64 for zero. */
960 #define CLZ_DEFINED_VALUE_AT_ZERO(MODE, VALUE) ((VALUE) = 64, TARGET_CIX) 796 #define CLZ_DEFINED_VALUE_AT_ZERO(MODE, VALUE) ((VALUE) = 64, \
961 #define CTZ_DEFINED_VALUE_AT_ZERO(MODE, VALUE) ((VALUE) = 64, TARGET_CIX) 797 TARGET_CIX ? 1 : 0)
798 #define CTZ_DEFINED_VALUE_AT_ZERO(MODE, VALUE) ((VALUE) = 64, \
799 TARGET_CIX ? 1 : 0)
962 800
963 /* Define the value returned by a floating-point comparison instruction. */ 801 /* Define the value returned by a floating-point comparison instruction. */
964 802
965 #define FLOAT_STORE_FLAG_VALUE(MODE) \ 803 #define FLOAT_STORE_FLAG_VALUE(MODE) \
966 REAL_VALUE_ATOF ((TARGET_FLOAT_VAX ? "0.5" : "2.0"), (MODE)) 804 REAL_VALUE_ATOF ((TARGET_FLOAT_VAX ? "0.5" : "2.0"), (MODE))
967
968 /* Canonicalize a comparison from one we don't have to one we do have. */
969
970 #define CANONICALIZE_COMPARISON(CODE,OP0,OP1) \
971 do { \
972 if (((CODE) == GE || (CODE) == GT || (CODE) == GEU || (CODE) == GTU) \
973 && (REG_P (OP1) || (OP1) == const0_rtx)) \
974 { \
975 rtx tem = (OP0); \
976 (OP0) = (OP1); \
977 (OP1) = tem; \
978 (CODE) = swap_condition (CODE); \
979 } \
980 if (((CODE) == LT || (CODE) == LTU) \
981 && CONST_INT_P (OP1) && INTVAL (OP1) == 256) \
982 { \
983 (CODE) = (CODE) == LT ? LE : LEU; \
984 (OP1) = GEN_INT (255); \
985 } \
986 } while (0)
987 805
988 /* Specify the machine mode that pointers have. 806 /* Specify the machine mode that pointers have.
989 After generation of rtl, the compiler makes no further distinction 807 After generation of rtl, the compiler makes no further distinction
990 between pointers and any other objects of this machine mode. */ 808 between pointers and any other objects of this machine mode. */
991 #define Pmode DImode 809 #define Pmode DImode
1002 We define this on the Alpha so that gen_call and gen_call_value 820 We define this on the Alpha so that gen_call and gen_call_value
1003 get to see the SYMBOL_REF (for the hint field of the jsr). It will 821 get to see the SYMBOL_REF (for the hint field of the jsr). It will
1004 then copy it into a register, thus actually letting the address be 822 then copy it into a register, thus actually letting the address be
1005 cse'ed. */ 823 cse'ed. */
1006 824
1007 #define NO_FUNCTION_CSE 825 #define NO_FUNCTION_CSE 1
1008 826
1009 /* Define this to be nonzero if shift instructions ignore all but the low-order 827 /* Define this to be nonzero if shift instructions ignore all but the low-order
1010 few bits. */ 828 few bits. */
1011 #define SHIFT_COUNT_TRUNCATED 1 829 #define SHIFT_COUNT_TRUNCATED 1
1012 830
1019 /* Output to assembler file text saying following lines 837 /* Output to assembler file text saying following lines
1020 no longer contain unusual constructs. */ 838 no longer contain unusual constructs. */
1021 #define ASM_APP_OFF (TARGET_EXPLICIT_RELOCS ? "\t.set\tnomacro\n" : "") 839 #define ASM_APP_OFF (TARGET_EXPLICIT_RELOCS ? "\t.set\tnomacro\n" : "")
1022 840
1023 #define TEXT_SECTION_ASM_OP "\t.text" 841 #define TEXT_SECTION_ASM_OP "\t.text"
1024
1025 /* Output before read-only data. */
1026
1027 #define READONLY_DATA_SECTION_ASM_OP "\t.rdata"
1028 842
1029 /* Output before writable data. */ 843 /* Output before writable data. */
1030 844
1031 #define DATA_SECTION_ASM_OP "\t.data" 845 #define DATA_SECTION_ASM_OP "\t.data"
1032 846
1058 } while (0) 872 } while (0)
1059 873
1060 /* Globalizing directive for a label. */ 874 /* Globalizing directive for a label. */
1061 #define GLOBAL_ASM_OP "\t.globl " 875 #define GLOBAL_ASM_OP "\t.globl "
1062 876
1063 /* The prefix to add to user-visible assembler symbols. */ 877 /* Use dollar signs rather than periods in special g++ assembler names. */
1064 878
1065 #define USER_LABEL_PREFIX "" 879 #undef NO_DOLLAR_IN_LABEL
1066
1067 /* This is how to output a label for a jump table. Arguments are the same as
1068 for (*targetm.asm_out.internal_label), except the insn for the jump table is
1069 passed. */
1070
1071 #define ASM_OUTPUT_CASE_LABEL(FILE,PREFIX,NUM,TABLEINSN) \
1072 { ASM_OUTPUT_ALIGN (FILE, 2); (*targetm.asm_out.internal_label) (FILE, PREFIX, NUM); }
1073 880
1074 /* This is how to store into the string LABEL 881 /* This is how to store into the string LABEL
1075 the symbol_ref name of an internal numbered label where 882 the symbol_ref name of an internal numbered label where
1076 PREFIX is the class of label and NUM is the number within the class. 883 PREFIX is the class of label and NUM is the number within the class.
1077 This is suitable for output with `assemble_name'. */ 884 This is suitable for output with `assemble_name'. */
1078 885
886 #undef ASM_GENERATE_INTERNAL_LABEL
1079 #define ASM_GENERATE_INTERNAL_LABEL(LABEL,PREFIX,NUM) \ 887 #define ASM_GENERATE_INTERNAL_LABEL(LABEL,PREFIX,NUM) \
1080 sprintf ((LABEL), "*$%s%ld", (PREFIX), (long)(NUM)) 888 sprintf ((LABEL), "*$%s%ld", (PREFIX), (long)(NUM))
1081 889
1082 /* We use the default ASCII-output routine, except that we don't write more
1083 than 50 characters since the assembler doesn't support very long lines. */
1084
1085 #define ASM_OUTPUT_ASCII(MYFILE, MYSTRING, MYLENGTH) \
1086 do { \
1087 FILE *_hide_asm_out_file = (MYFILE); \
1088 const unsigned char *_hide_p = (const unsigned char *) (MYSTRING); \
1089 int _hide_thissize = (MYLENGTH); \
1090 int _size_so_far = 0; \
1091 { \
1092 FILE *asm_out_file = _hide_asm_out_file; \
1093 const unsigned char *p = _hide_p; \
1094 int thissize = _hide_thissize; \
1095 int i; \
1096 fprintf (asm_out_file, "\t.ascii \""); \
1097 \
1098 for (i = 0; i < thissize; i++) \
1099 { \
1100 register int c = p[i]; \
1101 \
1102 if (_size_so_far ++ > 50 && i < thissize - 4) \
1103 _size_so_far = 0, fprintf (asm_out_file, "\"\n\t.ascii \""); \
1104 \
1105 if (c == '\"' || c == '\\') \
1106 putc ('\\', asm_out_file); \
1107 if (c >= ' ' && c < 0177) \
1108 putc (c, asm_out_file); \
1109 else \
1110 { \
1111 fprintf (asm_out_file, "\\%o", c); \
1112 /* After an octal-escape, if a digit follows, \
1113 terminate one string constant and start another. \
1114 The VAX assembler fails to stop reading the escape \
1115 after three digits, so this is the only way we \
1116 can get it to parse the data properly. */ \
1117 if (i < thissize - 1 && ISDIGIT (p[i + 1])) \
1118 _size_so_far = 0, fprintf (asm_out_file, "\"\n\t.ascii \""); \
1119 } \
1120 } \
1121 fprintf (asm_out_file, "\"\n"); \
1122 } \
1123 } \
1124 while (0)
1125
1126 /* This is how to output an element of a case-vector that is relative. */ 890 /* This is how to output an element of a case-vector that is relative. */
1127 891
1128 #define ASM_OUTPUT_ADDR_DIFF_ELT(FILE, BODY, VALUE, REL) \ 892 #define ASM_OUTPUT_ADDR_DIFF_ELT(FILE, BODY, VALUE, REL) \
1129 fprintf (FILE, "\t.%s $L%d\n", TARGET_ABI_WINDOWS_NT ? "long" : "gprel32", \ 893 fprintf (FILE, "\t.gprel32 $L%d\n", (VALUE))
1130 (VALUE)) 894
1131
1132 /* This is how to output an assembler line
1133 that says to advance the location counter
1134 to a multiple of 2**LOG bytes. */
1135
1136 #define ASM_OUTPUT_ALIGN(FILE,LOG) \
1137 if ((LOG) != 0) \
1138 fprintf (FILE, "\t.align %d\n", LOG);
1139
1140 /* This is how to advance the location counter by SIZE bytes. */
1141
1142 #define ASM_OUTPUT_SKIP(FILE,SIZE) \
1143 fprintf (FILE, "\t.space "HOST_WIDE_INT_PRINT_UNSIGNED"\n", (SIZE))
1144
1145 /* This says how to output an assembler line
1146 to define a global common symbol. */
1147
1148 #define ASM_OUTPUT_COMMON(FILE, NAME, SIZE, ROUNDED) \
1149 ( fputs ("\t.comm ", (FILE)), \
1150 assemble_name ((FILE), (NAME)), \
1151 fprintf ((FILE), ","HOST_WIDE_INT_PRINT_UNSIGNED"\n", (SIZE)))
1152
1153 /* This says how to output an assembler line
1154 to define a local common symbol. */
1155
1156 #define ASM_OUTPUT_LOCAL(FILE, NAME, SIZE,ROUNDED) \
1157 ( fputs ("\t.lcomm ", (FILE)), \
1158 assemble_name ((FILE), (NAME)), \
1159 fprintf ((FILE), ","HOST_WIDE_INT_PRINT_UNSIGNED"\n", (SIZE)))
1160
1161
1162 /* Print operand X (an rtx) in assembler syntax to file FILE.
1163 CODE is a letter or dot (`z' in `%z0') or 0 if no letter was specified.
1164 For `%' followed by punctuation, CODE is the punctuation and X is null. */
1165
1166 #define PRINT_OPERAND(FILE, X, CODE) print_operand (FILE, X, CODE)
1167
1168 /* Determine which codes are valid without a following integer. These must
1169 not be alphabetic.
1170
1171 ~ Generates the name of the current function.
1172
1173 / Generates the instruction suffix. The TRAP_SUFFIX and ROUND_SUFFIX
1174 attributes are examined to determine what is appropriate.
1175
1176 , Generates single precision suffix for floating point
1177 instructions (s for IEEE, f for VAX)
1178
1179 - Generates double precision suffix for floating point
1180 instructions (t for IEEE, g for VAX)
1181 */
1182
1183 #define PRINT_OPERAND_PUNCT_VALID_P(CODE) \
1184 ((CODE) == '/' || (CODE) == ',' || (CODE) == '-' || (CODE) == '~' \
1185 || (CODE) == '#' || (CODE) == '*' || (CODE) == '&')
1186
1187 /* Print a memory address as an operand to reference that memory location. */
1188
1189 #define PRINT_OPERAND_ADDRESS(FILE, ADDR) \
1190 print_operand_address((FILE), (ADDR))
1191
1192 /* Tell collect that the object format is ECOFF. */
1193 #define OBJECT_FORMAT_COFF
1194 #define EXTENDED_COFF
1195
1196 /* If we use NM, pass -g to it so it only lists globals. */ 895 /* If we use NM, pass -g to it so it only lists globals. */
1197 #define NM_FLAGS "-pg" 896 #define NM_FLAGS "-pg"
1198 897
1199 /* Definitions for debugging. */ 898 /* Definitions for debugging. */
1200
1201 #define SDB_DEBUGGING_INFO 1 /* generate info for mips-tfile */
1202 #define DBX_DEBUGGING_INFO 1 /* generate embedded stabs */
1203 #define MIPS_DEBUGGING_INFO 1 /* MIPS specific debugging info */
1204
1205 #ifndef PREFERRED_DEBUGGING_TYPE /* assume SDB_DEBUGGING_INFO */
1206 #define PREFERRED_DEBUGGING_TYPE SDB_DEBUG
1207 #endif
1208
1209 899
1210 /* Correct the offset of automatic variables and arguments. Note that 900 /* Correct the offset of automatic variables and arguments. Note that
1211 the Alpha debug format wants all automatic variables and arguments 901 the Alpha debug format wants all automatic variables and arguments
1212 to be in terms of two different offsets from the virtual frame pointer, 902 to be in terms of two different offsets from the virtual frame pointer,
1213 which is the stack pointer before any adjustment in the function. 903 which is the stack pointer before any adjustment in the function.
1224 extern long alpha_auto_offset; 914 extern long alpha_auto_offset;
1225 #define DEBUGGER_AUTO_OFFSET(X) \ 915 #define DEBUGGER_AUTO_OFFSET(X) \
1226 ((GET_CODE (X) == PLUS ? INTVAL (XEXP (X, 1)) : 0) + alpha_auto_offset) 916 ((GET_CODE (X) == PLUS ? INTVAL (XEXP (X, 1)) : 0) + alpha_auto_offset)
1227 #define DEBUGGER_ARG_OFFSET(OFFSET, X) (OFFSET + alpha_arg_offset) 917 #define DEBUGGER_ARG_OFFSET(OFFSET, X) (OFFSET + alpha_arg_offset)
1228 918
1229 /* mips-tfile doesn't understand .stabd directives. */
1230 #define DBX_OUTPUT_SOURCE_LINE(STREAM, LINE, COUNTER) do { \
1231 dbxout_begin_stabn_sline (LINE); \
1232 dbxout_stab_value_internal_label ("LM", &COUNTER); \
1233 } while (0)
1234
1235 /* We want to use MIPS-style .loc directives for SDB line numbers. */
1236 extern int num_source_filenames;
1237 #define SDB_OUTPUT_SOURCE_LINE(STREAM, LINE) \
1238 fprintf (STREAM, "\t.loc\t%d %d\n", num_source_filenames, LINE)
1239
1240 #define ASM_OUTPUT_SOURCE_FILENAME(STREAM, NAME) \ 919 #define ASM_OUTPUT_SOURCE_FILENAME(STREAM, NAME) \
1241 alpha_output_filename (STREAM, NAME) 920 alpha_output_filename (STREAM, NAME)
1242 921
1243 /* mips-tfile.c limits us to strings of one page. We must underestimate this
1244 number, because the real length runs past this up to the next
1245 continuation point. This is really a dbxout.c bug. */
1246 #define DBX_CONTIN_LENGTH 3000
1247
1248 /* By default, turn on GDB extensions. */ 922 /* By default, turn on GDB extensions. */
1249 #define DEFAULT_GDB_EXTENSIONS 1 923 #define DEFAULT_GDB_EXTENSIONS 1
1250 924
1251 /* Stabs-in-ECOFF can't handle dbxout_function_end(). */
1252 #define NO_DBX_FUNCTION_END 1
1253
1254 /* If we are smuggling stabs through the ALPHA ECOFF object
1255 format, put a comment in front of the .stab<x> operation so
1256 that the ALPHA assembler does not choke. The mips-tfile program
1257 will correctly put the stab into the object file. */
1258
1259 #define ASM_STABS_OP ((TARGET_GAS) ? "\t.stabs\t" : " #.stabs\t")
1260 #define ASM_STABN_OP ((TARGET_GAS) ? "\t.stabn\t" : " #.stabn\t")
1261 #define ASM_STABD_OP ((TARGET_GAS) ? "\t.stabd\t" : " #.stabd\t")
1262
1263 /* Forward references to tags are allowed. */
1264 #define SDB_ALLOW_FORWARD_REFERENCES
1265
1266 /* Unknown tags are also allowed. */
1267 #define SDB_ALLOW_UNKNOWN_REFERENCES
1268
1269 #define PUT_SDB_DEF(a) \
1270 do { \
1271 fprintf (asm_out_file, "\t%s.def\t", \
1272 (TARGET_GAS) ? "" : "#"); \
1273 ASM_OUTPUT_LABELREF (asm_out_file, a); \
1274 fputc (';', asm_out_file); \
1275 } while (0)
1276
1277 #define PUT_SDB_PLAIN_DEF(a) \
1278 do { \
1279 fprintf (asm_out_file, "\t%s.def\t.%s;", \
1280 (TARGET_GAS) ? "" : "#", (a)); \
1281 } while (0)
1282
1283 #define PUT_SDB_TYPE(a) \
1284 do { \
1285 fprintf (asm_out_file, "\t.type\t0x%x;", (a)); \
1286 } while (0)
1287
1288 /* For block start and end, we create labels, so that
1289 later we can figure out where the correct offset is.
1290 The normal .ent/.end serve well enough for functions,
1291 so those are just commented out. */
1292
1293 extern int sdb_label_count; /* block start/end next label # */
1294
1295 #define PUT_SDB_BLOCK_START(LINE) \
1296 do { \
1297 fprintf (asm_out_file, \
1298 "$Lb%d:\n\t%s.begin\t$Lb%d\t%d\n", \
1299 sdb_label_count, \
1300 (TARGET_GAS) ? "" : "#", \
1301 sdb_label_count, \
1302 (LINE)); \
1303 sdb_label_count++; \
1304 } while (0)
1305
1306 #define PUT_SDB_BLOCK_END(LINE) \
1307 do { \
1308 fprintf (asm_out_file, \
1309 "$Le%d:\n\t%s.bend\t$Le%d\t%d\n", \
1310 sdb_label_count, \
1311 (TARGET_GAS) ? "" : "#", \
1312 sdb_label_count, \
1313 (LINE)); \
1314 sdb_label_count++; \
1315 } while (0)
1316
1317 #define PUT_SDB_FUNCTION_START(LINE)
1318
1319 #define PUT_SDB_FUNCTION_END(LINE)
1320
1321 #define PUT_SDB_EPILOGUE_END(NAME) ((void)(NAME))
1322
1323 /* Macros for mips-tfile.c to encapsulate stabs in ECOFF, and for
1324 mips-tdump.c to print them out.
1325
1326 These must match the corresponding definitions in gdb/mipsread.c.
1327 Unfortunately, gcc and gdb do not currently share any directories. */
1328
1329 #define CODE_MASK 0x8F300
1330 #define MIPS_IS_STAB(sym) (((sym)->index & 0xFFF00) == CODE_MASK)
1331 #define MIPS_MARK_STAB(code) ((code)+CODE_MASK)
1332 #define MIPS_UNMARK_STAB(code) ((code)-CODE_MASK)
1333
1334 /* Override some mips-tfile definitions. */
1335
1336 #define SHASH_SIZE 511
1337 #define THASH_SIZE 55
1338
1339 /* Align ecoff symbol tables to avoid OSF1/1.3 nm complaints. */
1340
1341 #define ALIGN_SYMTABLE_OFFSET(OFFSET) (((OFFSET) + 7) & ~7)
1342
1343 /* The system headers under Alpha systems are generally C++-aware. */ 925 /* The system headers under Alpha systems are generally C++-aware. */
1344 #define NO_IMPLICIT_EXTERN_C 926 #define NO_IMPLICIT_EXTERN_C
927
928 #define TARGET_SUPPORTS_WIDE_INT 1