]>
git.ipfire.org Git - thirdparty/gcc.git/blob - gcc/config/visium/visium.h
1 /* Definitions of target machine for Visium.
2 Copyright (C) 2002-2015 Free Software Foundation, Inc.
3 Contributed by C.Nettleton, J.P.Parkes and P.Garbett.
5 This file is part of GCC.
7 GCC is free software; you can redistribute it and/or modify it
8 under the terms of the GNU General Public License as published
9 by the Free Software Foundation; either version 3, or (at your
10 option) any later version.
12 GCC is distributed in the hope that it will be useful, but WITHOUT
13 ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
14 or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public
15 License for more details.
17 You should have received a copy of the GNU General Public License
18 along with GCC; see the file COPYING3. If not see
19 <http://www.gnu.org/licenses/>. */
22 /* Controlling the Compilation Driver, `gcc' */
24 /* Pass -mtune=* options to the assembler */
26 #define ASM_SPEC "%{mcpu=gr6:-mtune=gr6; :-mtune=mcm}"
28 /* Define symbols for the preprocessor. */
29 #define CPP_SPEC "%{mcpu=gr6:-D__gr6__; :-D__gr5__}"
31 /* Targets of a link */
33 "--start-group -lc %{msim:-lsim; mdebug:-ldebug; :-lserial} --end-group"
35 #define ENDFILE_SPEC "crtend.o%s crtn.o%s"
36 #define STARTFILE_SPEC "crti.o%s crtbegin.o%s crt0.o%s"
38 /* Run-time Target Specification */
40 /* TARGET_CPU_CPP_BUILTINS() This function-like macro expands to a
41 block of code that defines built-in preprocessor macros and
42 assertions for the target cpu, using the functions builtin_define,
43 builtin_define_std and builtin_assert. When the front end calls
44 this macro it provides a trailing semicolon, and since it has
45 finished command line option processing your code can use those
46 results freely. builtin_assert takes a string in the form you pass
47 to the command-line option -A, such as cpu=mips, and creates the
48 assertion. builtin_define takes a string in the form accepted by
49 option -D and unconditionally defines the macro.
51 builtin_define_std takes a string representing the name of an
52 object-like macro. If it doesn't lie in the user's namespace,
53 builtin_define_std defines it unconditionally. Otherwise, it
54 defines a version with two leading underscores, and another version
55 with two leading and trailing underscores, and defines the original
56 only if an ISO standard was not requested on the command line. For
57 example, passing unix defines __unix, __unix__ and possibly unix;
58 passing _mips defines __mips, __mips__ and possibly _mips, and
59 passing _ABI64 defines only _ABI64.
61 You can also test for the C dialect being compiled. The variable
62 c_language is set to one of clk_c, clk_cplusplus or
63 clk_objective_c. Note that if we are preprocessing assembler, this
64 variable will be clk_c but the function-like macro
65 preprocessing_asm_p() will return true, so you might want to check
66 for that first. If you need to check for strict ANSI, the variable
67 flag_iso can be used. The function-like macro
68 preprocessing_trad_p() can be used to check for traditional
70 #define TARGET_CPU_CPP_BUILTINS() \
73 builtin_define ("__VISIUM__"); \
75 builtin_define ("__VISIUM_ARCH_MCM__"); \
77 builtin_define ("__VISIUM_ARCH_BMI__"); \
78 if (TARGET_FPU_IEEE) \
79 builtin_define ("__VISIUM_ARCH_FPU_IEEE__"); \
83 /* Recast the cpu class to be the cpu attribute.
84 Every file includes us, but not every file includes insn-attr.h. */
85 #define visium_cpu_attr ((enum attr_cpu) visium_cpu)
87 /* Defining data structures for per-function information.
89 If the target needs to store information on a per-function basis,
90 GCC provides a macro and a couple of variables to allow this. Note,
91 just using statics to store the information is a bad idea, since
92 GCC supports nested functions, so you can be halfway through
93 encoding one function when another one comes along.
95 GCC defines a data structure called struct function which contains
96 all of the data specific to an individual function. This structure
97 contains a field called machine whose type is struct
98 machine_function *, which can be used by targets to point to their
101 If a target needs per-function specific data it should define the
102 type struct machine_function and also the macro
103 INIT_EXPANDERS. This macro should be used to initialize the
104 function pointer init_machine_status. This pointer is explained
107 One typical use of per-function, target specific data is to create
108 an RTX to hold the register containing the function's return
109 address. This RTX can then be used to implement the
110 __builtin_return_address function, for level 0.
112 Note--earlier implementations of GCC used a single data area to
113 hold all of the per-function information. Thus when processing of a
114 nested function began the old per-function data had to be pushed
115 onto a stack, and when the processing was finished, it had to be
116 popped off the stack. GCC used to provide function pointers called
117 save_machine_status and restore_machine_status to handle the saving
118 and restoring of the target specific information. Since the single
119 data area approach is no longer used, these pointers are no longer
122 The macro and function pointers are described below.
126 Macro called to initialize any target specific information. This
127 macro is called once per function, before generation of any RTL has
128 begun. The intention of this macro is to allow the initialization
129 of the function pointers below.
132 This is a void (*)(struct function *) function pointer. If this
133 pointer is non-NULL it will be called once per function, before
134 function compilation starts, in order to allow the target to
135 perform any target specific initialization of the struct function
136 structure. It is intended that this would be used to initialize the
137 machine of that structure. struct machine_function structures are
138 expected to be freed by GC. Generally, any memory that they
139 reference must be allocated by using ggc_alloc, including the
142 #define INIT_EXPANDERS visium_init_expanders ()
146 Note that the definitions of the macros in this table which are
147 sizes or alignments measured in bits do not need to be constant.
148 They can be C expressions that refer to static variables, such as
153 Define this macro to have the value 1 if the most significant bit
154 in a byte has the lowest number; otherwise define it to have the
155 value zero. This means that bit-field instructions count from the
156 most significant bit. If the machine has no bit-field
157 instructions, then this must still be defined, but it doesn't
158 matter which value it is defined to. This macro need not be a
161 This macro does not affect the way structure fields are packed into
162 bytes or words; that is controlled by `BYTES_BIG_ENDIAN'. */
163 #define BITS_BIG_ENDIAN 1
165 /* `BYTES_BIG_ENDIAN'
167 Define this macro to have the value 1 if the most significant byte
168 in a word has the lowest number. This macro need not be a
170 #define BYTES_BIG_ENDIAN 1
172 /* `WORDS_BIG_ENDIAN'
174 Define this macro to have the value 1 if, in a multiword object,
175 the most significant word has the lowest number. This applies to
176 both memory locations and registers; GNU CC fundamentally assumes
177 that the order of words in memory is the same as the order in
178 registers. This macro need not be a constant. */
179 #define WORDS_BIG_ENDIAN 1
183 Number of bits in a word; normally 32. */
184 #define BITS_PER_WORD 32
188 Number of storage units in a word; normally 4. */
189 #define UNITS_PER_WORD 4
193 Width of a pointer, in bits. You must specify a value no wider
194 than the width of `Pmode'. If it is not equal to the width of
195 `Pmode', you must define `POINTERS_EXTEND_UNSIGNED'. */
196 #define POINTER_SIZE 32
200 Normal alignment required for function parameters on the stack, in
201 bits. All stack parameters receive at least this much alignment
202 regardless of data type. On most machines, this is the same as the
203 size of an integer. */
204 #define PARM_BOUNDARY 32
208 Define this macro if you wish to preserve a certain alignment for
209 the stack pointer. The definition is a C expression for the
210 desired alignment (measured in bits).
212 If `PUSH_ROUNDING' is not defined, the stack will always be aligned
213 to the specified boundary. If `PUSH_ROUNDING' is defined and
214 specifies a less strict alignment than `STACK_BOUNDARY', the stack
215 may be momentarily unaligned while pushing arguments. */
216 #define STACK_BOUNDARY 32
218 #define VISIUM_STACK_ALIGN(LOC) (((LOC) + 3) & ~3)
220 /* `FUNCTION_BOUNDARY'
222 Alignment required for a function entry point, in bits. */
223 #define FUNCTION_BOUNDARY 32
225 /* `BIGGEST_ALIGNMENT'
227 Biggest alignment that any data type can require on this machine,
229 #define BIGGEST_ALIGNMENT 32
231 /* `DATA_ALIGNMENT (TYPE, BASIC-ALIGN)`
233 If defined, a C expression to compute the alignment for a variable
234 in the static store. TYPE is the data type, and BASIC-ALIGN is
235 the alignment that the object would ordinarily have. The value of
236 this macro is used instead of that alignment to align the object. */
237 #define DATA_ALIGNMENT(TYPE,ALIGN) visium_data_alignment (TYPE, ALIGN)
239 /* `CONSTANT_ALIGNMENT (CONSTANT, BASIC-ALIGN)`
241 If defined, a C expression to compute the alignment given to a
242 constant that is being placed in memory. CONSTANT is the constant
243 and BASIC-ALIGN is the alignment that the object would ordinarily
244 have. The value of this macro is used instead of that alignment to
246 #define CONSTANT_ALIGNMENT(EXP,ALIGN) \
247 visium_data_alignment (TREE_TYPE (EXP), ALIGN)
249 /* `LOCAL_ALIGNMENT (TYPE, BASIC-ALIGN)`
251 If defined, a C expression to compute the alignment for a variable
252 in the local store. TYPE is the data type, and BASIC-ALIGN is the
253 alignment that the object would ordinarily have. The value of this
254 macro is used instead of that alignment to align the object. */
255 #define LOCAL_ALIGNMENT(TYPE,ALIGN) visium_data_alignment (TYPE, ALIGN)
257 /* `EMPTY_FIELD_BOUNDARY'
259 Alignment in bits to be given to a structure bit field that follows
260 an empty field such as `int : 0;'.
262 Note that `PCC_BITFIELD_TYPE_MATTERS' also affects the alignment
263 that results from an empty field. */
264 #define EMPTY_FIELD_BOUNDARY 32
266 /* `STRICT_ALIGNMENT'
268 Define this macro to be the value 1 if instructions will fail to
269 work if given data not on the nominal alignment. If instructions
270 will merely go slower in that case, define this macro as 0. */
271 #define STRICT_ALIGNMENT 1
273 /* `TARGET_FLOAT_FORMAT'
275 A code distinguishing the floating point format of the target
276 machine. There are three defined values:
279 This code indicates IEEE floating point. It is the default;
280 there is no need to define this macro when the format is IEEE.
283 This code indicates the peculiar format used on the Vax.
285 `UNKNOWN_FLOAT_FORMAT'
286 This code indicates any other format.
288 The value of this macro is compared with `HOST_FLOAT_FORMAT' to
289 determine whether the target machine has the same format as the
290 host machine. If any other formats are actually in use on
291 supported machines, new codes should be defined for them.
293 The ordering of the component words of floating point values
294 stored in memory is controlled by `FLOAT_WORDS_BIG_ENDIAN' for the
295 target machine and `HOST_FLOAT_WORDS_BIG_ENDIAN' for the host. */
296 #define TARGET_FLOAT_FORMAT IEEE_FLOAT_FORMAT
297 #define UNITS_PER_HWFPVALUE 4
299 /* Layout of Source Language Data Types
301 These macros define the sizes and other characteristics of the
302 standard basic data types used in programs being compiled. Unlike
303 the macros in the previous section, these apply to specific
304 features of C and related languages, rather than to fundamental
305 aspects of storage layout. */
309 A C expression for the size in bits of the type `int' on the target
310 machine. If you don't define this, the default is one word. */
311 #define INT_TYPE_SIZE 32
315 A C expression for the size in bits of the type `short' on the
316 target machine. If you don't define this, the default is half a
317 word. (If this would be less than one storage unit, it is rounded
319 #define SHORT_TYPE_SIZE 16
323 A C expression for the size in bits of the type `long' on the
324 target machine. If you don't define this, the default is one word. */
325 #define LONG_TYPE_SIZE 32
327 /* `LONG_LONG_TYPE_SIZE'
329 A C expression for the size in bits of the type `long long' on the
330 target machine. If you don't define this, the default is two
331 words. If you want to support GNU Ada on your machine, the value
332 of macro must be at least 64. */
333 #define LONG_LONG_TYPE_SIZE 64
337 A C expression for the size in bits of the type `char' on the
338 target machine. If you don't define this, the default is one
339 quarter of a word. (If this would be less than one storage unit,
340 it is rounded up to one unit.) */
341 #define CHAR_TYPE_SIZE 8
345 A C expression for the size in bits of the type `float' on the
346 target machine. If you don't define this, the default is one word. */
347 #define FLOAT_TYPE_SIZE 32
349 /* `DOUBLE_TYPE_SIZE'
351 A C expression for the size in bits of the type `double' on the
352 target machine. If you don't define this, the default is two
354 #define DOUBLE_TYPE_SIZE 64
356 /* `LONG_DOUBLE_TYPE_SIZE'
358 A C expression for the size in bits of the type `long double' on
359 the target machine. If you don't define this, the default is two
361 #define LONG_DOUBLE_TYPE_SIZE DOUBLE_TYPE_SIZE
363 /* `WIDEST_HARDWARE_FP_SIZE'
365 A C expression for the size in bits of the widest floating-point
366 format supported by the hardware. If you define this macro, you
367 must specify a value less than or equal to the value of
368 `LONG_DOUBLE_TYPE_SIZE'. If you do not define this macro, the
369 value of `LONG_DOUBLE_TYPE_SIZE' is the default. */
371 /* `DEFAULT_SIGNED_CHAR'
373 An expression whose value is 1 or 0, according to whether the type
374 `char' should be signed or unsigned by default. The user can
375 always override this default with the options `-fsigned-char' and
376 `-funsigned-char'. */
377 #define DEFAULT_SIGNED_CHAR 0
381 A C expression for a string describing the name of the data type to
382 use for size values. The typedef name `size_t' is defined using
383 the contents of the string.
385 The string can contain more than one keyword. If so, separate them
386 with spaces, and write first any length keyword, then `unsigned' if
387 appropriate, and finally `int'. The string must exactly match one
388 of the data type names defined in the function
389 `init_decl_processing' in the file `c-decl.c'. You may not omit
390 `int' or change the order--that would cause the compiler to crash
393 If you don't define this macro, the default is `"long unsigned
395 #define SIZE_TYPE "unsigned int"
399 A C expression for a string describing the name of the data type to
400 use for the result of subtracting two pointers. The typedef name
401 `ptrdiff_t' is defined using the contents of the string. See
402 `SIZE_TYPE' above for more information.
404 If you don't define this macro, the default is `"long int"'. */
405 #define PTRDIFF_TYPE "long int"
407 /* Newlib uses the unsigned type corresponding to ptrdiff_t for
408 uintptr_t; this is the same as size_t for most newlib-using
409 targets, but not for us. */
410 #define UINTPTR_TYPE "long unsigned int"
414 A C expression for a string describing the name of the data type to
415 use for wide characters. The typedef name `wchar_t' is defined
416 using the contents of the string. See `SIZE_TYPE' above for more
419 If you don't define this macro, the default is `"int"'. */
420 #define WCHAR_TYPE "short int"
424 A C expression for the size in bits of the data type for wide
425 characters. This is used in `cpp', which cannot make use of
427 #define WCHAR_TYPE_SIZE 16
431 This section explains how to describe what registers the target
432 machine has, and how (in general) they can be used. */
434 /* `FIRST_PSEUDO_REGISTER'
436 Number of actual hardware registers.
437 The hardware registers are assigned numbers for the compiler
438 from 0 to just below FIRST_PSEUDO_REGISTER.
439 All registers that the compiler knows about must be given numbers,
440 even those that are not normally considered general registers.
442 Register 51 is used as the argument pointer register.
443 Register 52 is used as the soft frame pointer register. */
444 #define FIRST_PSEUDO_REGISTER 53
446 #define RETURN_REGNUM 1
447 #define PROLOGUE_TMP_REGNUM 9
448 #define LINK_REGNUM 21
449 #define GP_LAST_REGNUM 31
450 #define GP_REGISTER_P(REGNO) \
451 (((unsigned) (REGNO)) <= GP_LAST_REGNUM)
453 #define MDB_REGNUM 32
454 #define MDC_REGNUM 33
456 #define FP_FIRST_REGNUM 34
457 #define FP_LAST_REGNUM 49
458 #define FP_RETURN_REGNUM (FP_FIRST_REGNUM + 1)
459 #define FP_REGISTER_P(REGNO) \
460 (FP_FIRST_REGNUM <= (REGNO) && (REGNO) <= FP_LAST_REGNUM)
462 #define FLAGS_REGNUM 50
466 An initializer that says which registers are used for fixed
467 purposes all throughout the compiled code and are therefore not
468 available for general allocation. These would include the stack
469 pointer, the frame pointer (except on machines where that can be
470 used as a general register when no frame pointer is needed), the
471 program counter on machines where that is considered one of the
472 addressable registers, and any other numbered register with a
475 This information is expressed as a sequence of numbers, separated
476 by commas and surrounded by braces. The Nth number is 1 if
477 register N is fixed, 0 otherwise.
479 The table initialized from this macro, and the table initialized by
480 the following one, may be overridden at run time either
481 automatically, by the actions of the macro
482 `CONDITIONAL_REGISTER_USAGE', or by the user with the command
483 options `-ffixed-REG', `-fcall-used-REG' and `-fcall-saved-REG'.
485 r0 and f0 are immutable registers hardwired to 0.
486 r21 is the link register used for procedure linkage.
487 r23 is the stack pointer register.
488 r29 and r30 hold the interrupt context.
489 mdc is a read-only register because the writemdc instruction
490 terminates all the operations of the EAM on the GR6. */
491 #define FIXED_REGISTERS \
492 { 1, 0, 0, 0, 0, 0, 0, 0, /* r0 .. r7 */ \
493 0, 0, 0, 0, 0, 0, 0, 0, /* r8 .. r15 */ \
494 0, 0, 0, 0, 0, 1, 0, 1, /* r16 .. r23 */ \
495 0, 0, 0, 0, 0, 1, 1, 0, /* r24 .. r31 */ \
496 0, 1, /* mdb, mdc */ \
497 1, 0, 0, 0, 0, 0, 0, 0, /* f0 .. f7 */ \
498 0, 0, 0, 0, 0, 0, 0, 0, /* f8 .. f15 */ \
499 1, 1, 1 } /* flags, arg, frame */
501 /* `CALL_USED_REGISTERS'
503 Like `FIXED_REGISTERS' but has 1 for each register that is
504 clobbered (in general) by function calls as well as for fixed
505 registers. This macro therefore identifies the registers that are
506 not available for general allocation of values that must live
507 across function calls.
509 If a register has 0 in `CALL_USED_REGISTERS', the compiler
510 automatically saves it on function entry and restores it on
511 function exit, if the register is used within the function. */
512 #define CALL_USED_REGISTERS \
513 { 1, 1, 1, 1, 1, 1, 1, 1, /* r0 .. r7 */ \
514 1, 1, 1, 0, 0, 0, 0, 0, /* r8 .. r15 */ \
515 0, 0, 0, 0, 1, 1, 0, 1, /* r16 .. r23 */ \
516 1, 1, 1, 1, 1, 1, 1, 1, /* r24 .. r31 */ \
517 1, 1, /* mdb, mdc */ \
518 1, 1, 1, 1, 1, 1, 1, 1, /* f0 .. f7 */ \
519 1, 0, 0, 0, 0, 0, 0, 0, /* f8 .. f15 */ \
520 1, 1, 1 } /* flags, arg, frame */
522 /* Like `CALL_USED_REGISTERS' except this macro doesn't require that
523 the entire set of `FIXED_REGISTERS' be included.
524 (`CALL_USED_REGISTERS' must be a superset of `FIXED_REGISTERS').
525 This macro is optional. If not specified, it defaults to the value
526 of `CALL_USED_REGISTERS'. */
527 #define CALL_REALLY_USED_REGISTERS \
528 { 0, 1, 1, 1, 1, 1, 1, 1, /* r0 .. r7 */ \
529 1, 1, 1, 0, 0, 0, 0, 0, /* r8 .. r15 */ \
530 0, 0, 0, 0, 1, 0, 0, 0, /* r16 .. r23 */ \
531 1, 1, 1, 1, 1, 0, 0, 1, /* r24 .. r31 */ \
532 1, 1, /* mdb, mdc */ \
533 1, 1, 1, 1, 1, 1, 1, 1, /* f0 .. f7 */ \
534 1, 0, 0, 0, 0, 0, 0, 0, /* f8 .. f15 */ \
535 1, 0, 0 } /* flags, arg, frame */
539 If defined, an initializer for a vector of integers, containing the
540 numbers of hard registers in the order in which GCC should prefer
541 to use them (from most preferred to least).
543 If this macro is not defined, registers are used lowest numbered
544 first (all else being equal). */
545 #define REG_ALLOC_ORDER \
546 { 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, /* r10 .. r1 */ \
547 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, /* r11 .. r20 */ \
549 24, 25, 26, 27, 28, /* r24 .. r28 */ \
551 32, 33, /* mdb, mdc */ \
552 42, 41, 40, 39, 38, 37, 36, 35, /* f8 .. f1 */ \
553 43, 44, 45, 46, 47, 48, 49, /* f9 .. f15 */ \
554 21, 23, /* lr, sp */ \
555 29, 30, /* r29, r30 */ \
556 50, 51, 52, /* flags, arg, frame */ \
559 /* `HARD_REGNO_NREGS (REGNO, MODE)'
561 A C expression for the number of consecutive hard registers,
562 starting at register number REGNO, required to hold a value of mode
564 #define HARD_REGNO_NREGS(REGNO, MODE) \
565 ((REGNO) == MDB_REGNUM ? \
566 ((GET_MODE_SIZE (MODE) + 2 * UNITS_PER_WORD - 1) / (2 * UNITS_PER_WORD)) \
567 : ((GET_MODE_SIZE (MODE) + UNITS_PER_WORD - 1) / UNITS_PER_WORD))
569 /* `HARD_REGNO_RENAME_OK (OLD_REG, NEW_REG)'
571 A C expression which is nonzero if hard register NEW_REG can be
572 considered for use as a rename register for hard register OLD_REG. */
573 #define HARD_REGNO_RENAME_OK(OLD_REG, NEW_REG) \
574 visium_hard_regno_rename_ok (OLD_REG, NEW_REG)
576 /* `HARD_REGNO_MODE_OK (REGNO, MODE)'
578 A C expression that is nonzero if it is permissible to store a
579 value of mode MODE in hard register number REGNO (or in several
580 registers starting with that one).
582 Modes with sizes which cross from the one register class to the
583 other cannot be allowed. Only single floats are allowed in the
584 floating point registers, and only fixed point values in the EAM
586 #define HARD_REGNO_MODE_OK(REGNO, MODE) \
587 (GP_REGISTER_P (REGNO) ? \
588 GP_REGISTER_P (REGNO + HARD_REGNO_NREGS (REGNO, MODE) - 1) \
589 : FP_REGISTER_P (REGNO) ? \
590 (MODE) == SFmode || ((MODE) == SImode && TARGET_FPU_IEEE) \
591 : GET_MODE_CLASS (MODE) == MODE_INT \
592 && HARD_REGNO_NREGS (REGNO, MODE) == 1)
594 /* `MODES_TIEABLE_P (MODE1, MODE2)'
596 A C expression that is nonzero if a value of mode MODE1 is
597 accessible in mode MODE2 without copying.
599 If `HARD_REGNO_MODE_OK (R, MODE1)' and `HARD_REGNO_MODE_OK (R,
600 MODE2)' are always the same for any R, then `MODES_TIEABLE_P
601 (MODE1, MODE2)' should be nonzero. If they differ for any R, you
602 should define this macro to return zero unless some other mechanism
603 ensures the accessibility of the value in a narrower mode.
605 You should define this macro to return nonzero in as many cases as
606 possible since doing so will allow GNU CC to perform better
607 register allocation. */
608 #define MODES_TIEABLE_P(MODE1, MODE2) \
609 ((GET_MODE_CLASS (MODE1) == MODE_INT) \
610 && (GET_MODE_CLASS (MODE2) == MODE_INT))
614 On many machines, the numbered registers are not all equivalent.
615 For example, certain registers may not be allowed for indexed
616 addressing; certain registers may not be allowed in some
617 instructions. These machine restrictions are described to the
618 compiler using "register classes".
622 An enumeral type that must be defined with all the register class
623 names as enumeral values. `NO_REGS' must be first. `ALL_REGS'
624 must be the last register class, followed by one more enumeral
625 value, `LIM_REG_CLASSES', which is not a register class but rather
626 tells how many classes there are.
628 Each register class has a number, which is the value of casting the
629 class name to type `int'. The number serves as an index in many of
630 the tables described below. */
651 The number of distinct register classes, defined as follows. */
652 #define N_REG_CLASSES (int) LIM_REG_CLASSES
656 An initializer containing the names of the register classes as C
657 string constants. These names are used in writing some of the
659 #define REG_CLASS_NAMES \
660 {"NO_REGS", "MDB", "MDC", "FP_REGS", "FLAGS", "R1", "R2", "R3", \
661 "SIBCALL_REGS", "LOW_REGS", "GENERAL_REGS", "ALL_REGS"}
663 /* `REG_CLASS_CONTENTS'
665 An initializer containing the contents of the register classes, as
666 integers which are bit masks. The Nth integer specifies the
667 contents of class N. The way the integer MASK is interpreted is
668 that register R is in the class if `MASK & (1 << R)' is 1.
670 When the machine has more than 32 registers, an integer does not
671 suffice. Then the integers are replaced by sub-initializers,
672 braced groupings containing several integers. Each sub-initializer
673 must be suitable as an initializer for the type `HARD_REG_SET'
674 which is defined in `hard-reg-set.h'. */
675 #define REG_CLASS_CONTENTS { \
676 {0x00000000, 0x00000000}, /* NO_REGS */ \
677 {0x00000000, 0x00000001}, /* MDB */ \
678 {0x00000000, 0x00000002}, /* MDC */ \
679 {0x00000000, 0x0003fffc}, /* FP_REGS */ \
680 {0x00000000, 0x00040000}, /* FLAGS */ \
681 {0x00000002, 0x00000000}, /* R1 */ \
682 {0x00000004, 0x00000000}, /* R2 */ \
683 {0x00000008, 0x00000000}, /* R3 */ \
684 {0x000005ff, 0x00000000}, /* SIBCALL_REGS */ \
685 {0x1fffffff, 0x00000000}, /* LOW_REGS */ \
686 {0xffffffff, 0x00180000}, /* GENERAL_REGS */ \
687 {0xffffffff, 0x001fffff}} /* ALL_REGS */
689 /* `REGNO_REG_CLASS (REGNO)'
691 A C expression whose value is a register class containing hard
692 register REGNO. In general there is more than one such class;
693 choose a class which is "minimal", meaning that no smaller class
694 also contains the register. */
695 #define REGNO_REG_CLASS(REGNO) \
696 ((REGNO) == MDB_REGNUM ? MDB : \
697 (REGNO) == MDC_REGNUM ? MDC : \
698 FP_REGISTER_P (REGNO) ? FP_REGS : \
699 (REGNO) == FLAGS_REGNUM ? FLAGS : \
700 (REGNO) == 1 ? R1 : \
701 (REGNO) == 2 ? R2 : \
702 (REGNO) == 3 ? R3 : \
703 (REGNO) <= 8 || (REGNO) == 10 ? SIBCALL_REGS : \
704 (REGNO) <= 28 ? LOW_REGS : \
709 A macro whose definition is the name of the class to which a valid
710 base register must belong. A base register is one used in an
711 address which is the register value plus a displacement. */
712 #define BASE_REG_CLASS GENERAL_REGS
714 #define BASE_REGISTER_P(REGNO) \
715 (GP_REGISTER_P (REGNO) \
716 || (REGNO) == ARG_POINTER_REGNUM \
717 || (REGNO) == FRAME_POINTER_REGNUM)
721 A macro whose definition is the name of the class to which a valid
722 index register must belong. An index register is one used in an
723 address where its value is either multiplied by a scale factor or
724 added to another register (as well as added to a displacement). */
725 #define INDEX_REG_CLASS NO_REGS
727 /* `REGNO_OK_FOR_BASE_P (NUM)'
729 A C expression which is nonzero if register number NUM is suitable
730 for use as a base register in operand addresses. It may be either
731 a suitable hard register or a pseudo register that has been
732 allocated such a hard register. */
733 #define REGNO_OK_FOR_BASE_P(REGNO) \
734 (BASE_REGISTER_P (REGNO) || BASE_REGISTER_P ((unsigned)reg_renumber[REGNO]))
736 /* `REGNO_OK_FOR_INDEX_P (NUM)'
738 A C expression which is nonzero if register number NUM is suitable
739 for use as an index register in operand addresses. It may be
740 either a suitable hard register or a pseudo register that has been
741 allocated such a hard register.
743 The difference between an index register and a base register is
744 that the index register may be scaled. If an address involves the
745 sum of two registers, neither one of them scaled, then either one
746 may be labeled the "base" and the other the "index"; but whichever
747 labeling is used must fit the machine's constraints of which
748 registers may serve in each capacity. The compiler will try both
749 labelings, looking for one that is valid, and will reload one or
750 both registers only if neither labeling works. */
751 #define REGNO_OK_FOR_INDEX_P(REGNO) 0
753 /* `PREFERRED_RELOAD_CLASS (X, CLASS)'
755 A C expression that places additional restrictions on the register
756 class to use when it is necessary to copy value X into a register
757 in class CLASS. The value is a register class; perhaps CLASS, or
758 perhaps another, smaller class.
760 Sometimes returning a more restrictive class makes better code.
761 For example, on the 68000, when X is an integer constant that is in
762 range for a `moveq' instruction, the value of this macro is always
763 `DATA_REGS' as long as CLASS includes the data registers.
764 Requiring a data register guarantees that a `moveq' will be used.
766 If X is a `const_double', by returning `NO_REGS' you can force X
767 into a memory constant. This is useful on certain machines where
768 immediate floating values cannot be loaded into certain kinds of
770 #define PREFERRED_RELOAD_CLASS(X,CLASS) CLASS
772 /* `CANNOT_CHANGE_MODE_CLASS (from, to, class)
774 If defined, a C expression that returns nonzero for a `class' for
775 which a change from mode `from' to mode `to' is invalid.
777 It's not obvious from the above that MDB cannot change mode. However
778 difficulties arise from expressions of the form
780 (subreg:SI (reg:DI R_MDB) 0)
782 There is no way to convert that reference to a single machine
783 register and, without the following definition, reload will quietly
787 #define CANNOT_CHANGE_MODE_CLASS(FROM,TO,CLASS) \
788 (CLASS == MDB ? (GET_MODE_SIZE (FROM) != GET_MODE_SIZE (TO)) : 0)
790 /* `CLASS_MAX_NREGS (CLASS, MODE)'
792 A C expression for the maximum number of consecutive registers of
793 class CLASS needed to hold a value of mode MODE.
795 This is closely related to the macro `HARD_REGNO_NREGS'. In fact,
796 the value of the macro `CLASS_MAX_NREGS (CLASS, MODE)' should be
797 the maximum value of `HARD_REGNO_NREGS (REGNO, MODE)' for all REGNO
798 values in the class CLASS.
800 This macro helps control the handling of multiple-word values in
802 #define CLASS_MAX_NREGS(CLASS, MODE) \
804 ((GET_MODE_SIZE (MODE) + 2 * UNITS_PER_WORD - 1) / (2 * UNITS_PER_WORD)) \
805 : ((GET_MODE_SIZE (MODE) + UNITS_PER_WORD - 1) / UNITS_PER_WORD))
807 /* Stack Layout and Calling Conventions
811 `STACK_GROWS_DOWNWARD'
812 Define this macro if pushing a word onto the stack moves the stack
813 pointer to a smaller address. */
814 #define STACK_GROWS_DOWNWARD 1
816 /* `STARTING_FRAME_OFFSET'
818 Offset from the frame pointer to the first local variable slot to
821 If `FRAME_GROWS_DOWNWARD', find the next slot's offset by
822 subtracting the first slot's length from `STARTING_FRAME_OFFSET'.
823 Otherwise, it is found by adding the length of the first slot to
824 the value `STARTING_FRAME_OFFSET'. */
825 #define STARTING_FRAME_OFFSET 0
827 /* `FIRST_PARM_OFFSET (FUNDECL)'
829 Offset from the argument pointer register to the first argument's
830 address. On some machines it may depend on the data type of the
833 If `ARGS_GROW_DOWNWARD', this is the offset to the location above
834 the first argument's address. */
835 #define FIRST_PARM_OFFSET(FNDECL) 0
837 /* `DYNAMIC_CHAIN_ADDRESS (FRAMEADDR)'
839 A C expression whose value is RTL representing the address in a
840 stack frame where the pointer to the caller's frame is stored.
841 Assume that FRAMEADDR is an RTL expression for the address of the
844 If you don't define this macro, the default is to return the value
845 of FRAMEADDR--that is, the stack frame address is also the address
846 of the stack word that points to the previous frame. */
847 #define DYNAMIC_CHAIN_ADDRESS(FRAMEADDR) \
848 visium_dynamic_chain_address (FRAMEADDR)
850 /* `RETURN_ADDR_RTX (COUNT, FRAMEADDR)'
852 A C expression whose value is RTL representing the value of the
853 return address for the frame COUNT steps up from the current frame,
854 after the prologue. FRAMEADDR is the frame pointer of the COUNT
855 frame, or the frame pointer of the COUNT - 1 frame if
856 `RETURN_ADDR_IN_PREVIOUS_FRAME' is defined.
858 The value of the expression must always be the correct address when
859 COUNT is zero, but may be `NULL_RTX' if there is not way to
860 determine the return address of other frames. */
861 #define RETURN_ADDR_RTX(COUNT,FRAMEADDR) \
862 visium_return_addr_rtx (COUNT, FRAMEADDR)
864 /* Exception Handling
866 `EH_RETURN_DATA_REGNO'
868 A C expression whose value is the Nth register number used for data
869 by exception handlers or INVALID_REGNUM if fewer than N registers
872 The exception handling library routines communicate with the
873 exception handlers via a set of agreed upon registers. */
874 #define EH_RETURN_DATA_REGNO(N) ((N) < 4 ? (N) + 11 : INVALID_REGNUM)
875 #define EH_RETURN_STACKADJ_RTX gen_rtx_REG (SImode, 8)
876 #define EH_RETURN_HANDLER_RTX visium_eh_return_handler_rtx ()
878 /* Registers That Address the Stack Frame
880 This discusses registers that address the stack frame.
882 `STACK_POINTER_REGNUM'
884 The register number of the stack pointer register, which must also
885 be a fixed register according to `FIXED_REGISTERS'. On most
886 machines, the hardware determines which register this is. */
887 #define STACK_POINTER_REGNUM 23
889 /* `FRAME_POINTER_REGNUM'
891 The register number of the frame pointer register, which is used to
892 access automatic variables in the stack frame. On some machines,
893 the hardware determines which register this is. On other machines,
894 you can choose any register you wish for this purpose. */
895 #define FRAME_POINTER_REGNUM 52
897 /* `HARD_FRAME_POINTER_REGNUM'
899 On some machines the offset between the frame pointer and starting
900 offset of the automatic variables is not known until after register
901 allocation has been done (for example, because the saved registers
902 are between these two locations). On those machines, define
903 `FRAME_POINTER_REGNUM' the number of a special, fixed register to
904 be used internally until the offset is known, and define
905 `HARD_FRAME_POINTER_REGNUM' to be the actual hard register number
906 used for the frame pointer. */
907 #define HARD_FRAME_POINTER_REGNUM 22
909 /* `ARG_POINTER_REGNUM'
911 The register number of the arg pointer register, which is used to
912 access the function's argument list. On some machines, this is the
913 same as the frame pointer register. On some machines, the hardware
914 determines which register this is. On other machines, you can
915 choose any register you wish for this purpose. If this is not the
916 same register as the frame pointer register, then you must mark it
917 as a fixed register according to `FIXED_REGISTERS', or arrange to
918 be able to eliminate it (*note Elimination::.). */
919 #define ARG_POINTER_REGNUM 51
921 /* `STATIC_CHAIN_REGNUM'
922 `STATIC_CHAIN_INCOMING_REGNUM'
924 Register numbers used for passing a function's static chain
925 pointer. If register windows are used, the register number as seen
926 by the called function is `STATIC_CHAIN_INCOMING_REGNUM', while the
927 register number as seen by the calling function is
928 `STATIC_CHAIN_REGNUM'. If these registers are the same,
929 `STATIC_CHAIN_INCOMING_REGNUM' need not be defined.
931 The static chain register need not be a fixed register.
933 If the static chain is passed in memory, these macros should not be
934 defined; instead, the next two macros should be defined. */
935 #define STATIC_CHAIN_REGNUM 20
939 If defined, this macro specifies a table of register pairs used to
940 eliminate unneeded registers that point into the stack frame. If
941 it is not defined, the only elimination attempted by the compiler
942 is to replace references to the frame pointer with references to
945 The definition of this macro is a list of structure
946 initializations, each of which specifies an original and
947 replacement register.
949 On some machines, the position of the argument pointer is not known
950 until the compilation is completed. In such a case, a separate
951 hard register must be used for the argument pointer. This register
952 can be eliminated by replacing it with either the frame pointer or
953 the argument pointer, depending on whether or not the frame pointer
956 Note that the elimination of the argument pointer with the stack
957 pointer is specified first since that is the preferred elimination. */
958 #define ELIMINABLE_REGS \
959 {{ ARG_POINTER_REGNUM, STACK_POINTER_REGNUM}, \
960 { ARG_POINTER_REGNUM, HARD_FRAME_POINTER_REGNUM}, \
961 { FRAME_POINTER_REGNUM, STACK_POINTER_REGNUM}, \
962 { FRAME_POINTER_REGNUM, HARD_FRAME_POINTER_REGNUM}}
964 /* `INITIAL_ELIMINATION_OFFSET (FROM-REG, TO-REG, OFFSET-VAR)'
966 This macro is similar to `INITIAL_FRAME_POINTER_OFFSET'. It
967 specifies the initial difference between the specified pair of
968 registers. This macro must be defined if `ELIMINABLE_REGS' is
970 #define INITIAL_ELIMINATION_OFFSET(FROM, TO, OFFSET) \
971 (OFFSET = visium_initial_elimination_offset (FROM, TO))
973 /* Passing Function Arguments on the Stack
975 The macros in this section control how arguments are passed on the
976 stack. See the following section for other macros that control
977 passing certain arguments in registers.
979 Passing Arguments in Registers
981 This section describes the macros which let you control how various
982 types of arguments are passed in registers or how they are arranged
985 Define the general purpose, and floating point registers used for
987 #define MAX_ARGS_IN_GP_REGISTERS 8
988 #define GP_ARG_FIRST 1
989 #define GP_ARG_LAST (GP_ARG_FIRST + MAX_ARGS_IN_GP_REGISTERS - 1)
990 #define MAX_ARGS_IN_FP_REGISTERS 8
991 #define FP_ARG_FIRST (FP_FIRST_REGNUM + 1)
992 #define FP_ARG_LAST (FP_ARG_FIRST + MAX_ARGS_IN_FP_REGISTERS - 1)
994 /* Define a data type for recording info about an argument list during the
995 processing of that argument list. */
999 /* The count of general registers used */
1001 /* The count of floating registers used */
1003 /* The number of stack words used by named arguments */
1007 /* `CUMULATIVE_ARGS'
1009 A C type for declaring a variable that is used as the first
1010 argument of `FUNCTION_ARG' and other related values. For some
1011 target machines, the type `int' suffices and can hold the number of
1012 bytes of argument so far.
1014 There is no need to record in `CUMULATIVE_ARGS' anything about the
1015 arguments that have been passed on the stack. The compiler has
1016 other variables to keep track of that. For target machines on
1017 which all arguments are passed on the stack, there is no need to
1018 store anything in `CUMULATIVE_ARGS'; however, the data structure
1019 must exist and should not be empty, so use `int'. */
1020 #define CUMULATIVE_ARGS struct visium_args
1022 #define INIT_CUMULATIVE_ARGS(CUM,FNTYPE,LIBNAME,FNDECL,N_NAMED_ARGS) \
1024 (CUM).grcount = 0; \
1025 (CUM).frcount = 0; \
1026 (CUM).stack_words = 0; \
1029 /* `FUNCTION_ARG_REGNO_P (REGNO)'
1031 A C expression that is nonzero if REGNO is the number of a hard
1032 register in which function arguments are sometimes passed. This
1033 does *not* include implicit arguments such as the static chain and
1034 the structure-value address. On many machines, no registers can be
1035 used for this purpose since all function arguments are pushed on
1037 #define FUNCTION_ARG_REGNO_P(N) \
1038 ((GP_ARG_FIRST <= (N) && (N) <= GP_ARG_LAST) \
1039 || (TARGET_FPU && FP_ARG_FIRST <= (N) && (N) <= FP_ARG_LAST))
1041 /* `FUNCTION_VALUE_REGNO_P (REGNO)'
1043 A C expression that is nonzero if REGNO is the number of a hard
1044 register in which the values of called function may come back.
1046 A register whose use for returning values is limited to serving as
1047 the second of a pair (for a value of type `double', say) need not
1048 be recognized by this macro. If the machine has register windows,
1049 so that the caller and the called function use different registers
1050 for the return value, this macro should recognize only the caller's
1051 register numbers. */
1052 #define FUNCTION_VALUE_REGNO_P(N) \
1053 ((N) == RETURN_REGNUM || (TARGET_FPU && (N) == FP_RETURN_REGNUM))
1055 /* How Large Values Are Returned
1057 When a function value's mode is `BLKmode' (and in some other
1058 cases), the value is not returned according to `FUNCTION_VALUE'.
1059 Instead, the caller passes the address of a block of memory in
1060 which the value should be stored. This address is called the
1061 "structure value address".
1063 This section describes how to control returning structure values in
1066 `DEFAULT_PCC_STRUCT_RETURN'
1068 Define this macro to be 1 if all structure and union return values
1069 must be in memory. Since this results in slower code, this should
1070 be defined only if needed for compatibility with other compilers or
1071 with an ABI. If you define this macro to be 0, then the
1072 conventions used for structure and union return values are decided
1073 by the `RETURN_IN_MEMORY' macro.
1075 If not defined, this defaults to the value 1. */
1076 #define DEFAULT_PCC_STRUCT_RETURN 0
1080 If the structure value address is not passed in a register, define
1081 `STRUCT_VALUE' as an expression returning an RTX for the place
1082 where the address is passed. If it returns 0, the address is
1083 passed as an "invisible" first argument. */
1084 #define STRUCT_VALUE 0
1086 /* Caller-Saves Register Allocation
1088 If you enable it, GNU CC can save registers around function calls.
1089 This makes it possible to use call-clobbered registers to hold
1090 variables that must live across calls.
1092 Function Entry and Exit
1094 This section describes the macros that output function entry
1095 ("prologue") and exit ("epilogue") code.
1099 Define this macro as a C expression that is nonzero if the return
1100 instruction or the function epilogue ignores the value of the stack
1101 pointer; in other words, if it is safe to delete an instruction to
1102 adjust the stack pointer before a return from the function.
1104 Note that this macro's value is relevant only for functions for
1105 which frame pointers are maintained. It is never safe to delete a
1106 final stack adjustment in a function that has no frame pointer, and
1107 the compiler knows this regardless of `EXIT_IGNORE_STACK'. */
1108 #define EXIT_IGNORE_STACK 1
1110 /* `EPILOGUE_USES (REGNO)'
1112 Define this macro as a C expression that is nonzero for registers
1113 are used by the epilogue or the `return' pattern. The stack and
1114 frame pointer registers are already be assumed to be used as
1116 #define EPILOGUE_USES(REGNO) visium_epilogue_uses (REGNO)
1118 /* Generating Code for Profiling
1120 These macros will help you generate code for profiling. */
1122 #define PROFILE_HOOK(LABEL) visium_profile_hook ()
1123 #define FUNCTION_PROFILER(FILE, LABELNO) do {} while (0)
1124 #define NO_PROFILE_COUNTERS 1
1126 /* Trampolines for Nested Functions
1128 A trampoline is a small piece of code that is created at run time
1129 when the address of a nested function is taken. It normally resides
1130 on the stack, in the stack frame of the containing function. These
1131 macros tell GCC how to generate code to allocate and initialize a
1134 The instructions in the trampoline must do two things: load a
1135 constant address into the static chain register, and jump to the
1136 real address of the nested function. On CISC machines such as the
1137 m68k, this requires two instructions, a move immediate and a
1138 jump. Then the two addresses exist in the trampoline as word-long
1139 immediate operands. On RISC machines, it is often necessary to load
1140 each address into a register in two parts. Then pieces of each
1141 address form separate immediate operands.
1143 The code generated to initialize the trampoline must store the
1144 variable parts--the static chain value and the function
1145 address--into the immediate operands of the instructions. On a CISC
1146 machine, this is simply a matter of copying each address to a
1147 memory reference at the proper offset from the start of the
1148 trampoline. On a RISC machine, it may be necessary to take out
1149 pieces of the address and store them separately.
1151 On the Visium, the trampoline is
1153 moviu r9,%u FUNCTION
1154 movil r9,%l FUNCTION
1159 A difficulty is setting the correct instruction parity at run time.
1163 A C expression for the size in bytes of the trampoline, as an integer. */
1164 #define TRAMPOLINE_SIZE 20
1166 /* Implicit calls to library routines
1168 Avoid calling library routines (sqrtf) just to set `errno' to EDOM */
1169 #define TARGET_EDOM 33
1173 `MAX_REGS_PER_ADDRESS'
1175 A number, the maximum number of registers that can appear in a
1176 valid memory address. Note that it is up to you to specify a value
1177 equal to the maximum number that `TARGET_LEGITIMATE_ADDRESS_P' would
1179 #define MAX_REGS_PER_ADDRESS 1
1181 /* `LEGITIMIZE_RELOAD_ADDRESS (X, MODE, OPNUM, TYPE, IND_LEVELS, WIN)'
1183 A C compound statement that attempts to replace X, which is an
1184 address that needs reloading, with a valid memory address for an
1185 operand of mode MODE. WIN will be a C statement label elsewhere
1186 in the code. It is not necessary to define this macro, but it
1187 might be useful for performance reasons. */
1188 #define LEGITIMIZE_RELOAD_ADDRESS(AD, MODE, OPNUM, TYPE, IND, WIN) \
1191 rtx new_x = visium_legitimize_reload_address ((AD), (MODE), (OPNUM), \
1192 (int) (TYPE), (IND)); \
1200 /* Given a comparison code (EQ, NE, etc.) and the operands of a COMPARE,
1201 return the mode to be used for the comparison. */
1202 #define SELECT_CC_MODE(OP,X,Y) visium_select_cc_mode ((OP), (X), (Y))
1204 /* Return nonzero if MODE implies a floating point inequality can be
1205 reversed. For Visium this is always true because we have a full
1206 compliment of ordered and unordered comparisons, but until generic
1207 code knows how to reverse it correctly we keep the old definition. */
1208 #define REVERSIBLE_CC_MODE(MODE) ((MODE) != CCFPEmode && (MODE) != CCFPmode)
1212 A C expression for the cost of a branch instruction. A value of 1
1213 is the default; other values are interpreted relative to that. */
1214 #define BRANCH_COST(A,B) 10
1216 /* Override BRANCH_COST heuristics for complex logical ops. */
1217 #define LOGICAL_OP_NON_SHORT_CIRCUIT 0
1219 /* `SLOW_BYTE_ACCESS'
1221 Define this macro as a C expression which is nonzero if accessing
1222 less than a word of memory (i.e. a `char' or a `short') is no
1223 faster than accessing a word of memory, i.e., if such access
1224 require more than one instruction or if there is no difference in
1225 cost between byte and (aligned) word loads.
1227 When this macro is not defined, the compiler will access a field by
1228 finding the smallest containing object; when it is defined, a
1229 fullword load will be used if alignment permits. Unless bytes
1230 accesses are faster than word accesses, using word accesses is
1231 preferable since it may eliminate subsequent memory access if
1232 subsequent accesses occur to other fields in the same word of the
1233 structure, but to different bytes. */
1234 #define SLOW_BYTE_ACCESS 0
1236 /* `MOVE_RATIO (SPEED)`
1238 The threshold of number of scalar memory-to-memory move insns,
1239 _below_ which a sequence of insns should be generated instead of a
1240 string move insn or a library call. Increasing the value will
1241 always make code faster, but eventually incurs high cost in
1242 increased code size.
1244 Since we have a movmemsi pattern, the default MOVE_RATIO is 2, which
1245 is too low given that movmemsi will invoke a libcall. */
1246 #define MOVE_RATIO(speed) ((speed) ? 9 : 3)
1248 /* `CLEAR_RATIO (SPEED)`
1250 The threshold of number of scalar move insns, _below_ which a
1251 sequence of insns should be generated to clear memory instead of a
1252 string clear insn or a library call. Increasing the value will
1253 always make code faster, but eventually incurs high cost in
1254 increased code size.
1256 Since we have a setmemsi pattern, the default CLEAR_RATIO is 2, which
1257 is too low given that setmemsi will invoke a libcall. */
1258 #define CLEAR_RATIO(speed) ((speed) ? 13 : 5)
1262 The maximum number of bytes that a single instruction can move
1263 quickly between memory and registers or between two memory
1269 The maximum number of bytes that a single instruction can move
1270 quickly between memory and registers or between two memory
1271 locations. If this is undefined, the default is `MOVE_MAX'.
1272 Otherwise, it is the constant value that is the largest value that
1273 `MOVE_MAX' can have at run-time. */
1274 #define MAX_MOVE_MAX 4
1276 /* `SHIFT_COUNT_TRUNCATED'
1278 A C expression that is nonzero if on this machine the number of
1279 bits actually used for the count of a shift operation is equal to
1280 the number of bits needed to represent the size of the object being
1281 shifted. When this macro is non-zero, the compiler will assume
1282 that it is safe to omit a sign-extend, zero-extend, and certain
1283 bitwise `and' instructions that truncates the count of a shift
1284 operation. On machines that have instructions that act on
1285 bitfields at variable positions, which may include `bit test'
1286 instructions, a nonzero `SHIFT_COUNT_TRUNCATED' also enables
1287 deletion of truncations of the values that serve as arguments to
1288 bitfield instructions. */
1289 #define SHIFT_COUNT_TRUNCATED 0
1291 /* `TRULY_NOOP_TRUNCATION (OUTPREC, INPREC)'
1293 A C expression which is nonzero if on this machine it is safe to
1294 "convert" an integer of INPREC bits to one of OUTPREC bits (where
1295 OUTPREC is smaller than INPREC) by merely operating on it as if it
1296 had only OUTPREC bits.
1298 On many machines, this expression can be 1.
1300 When `TRULY_NOOP_TRUNCATION' returns 1 for a pair of sizes for
1301 modes for which `MODES_TIEABLE_P' is 0, suboptimal code can result.
1302 If this is the case, making `TRULY_NOOP_TRUNCATION' return 0 in
1303 such cases may improve things. */
1304 #define TRULY_NOOP_TRUNCATION(OUTPREC, INPREC) 1
1306 /* `STORE_FLAG_VALUE'
1308 A C expression describing the value returned by a comparison
1309 operator with an integral mode and stored by a store-flag
1310 instruction (`sCOND') when the condition is true. This description
1311 must apply to *all* the `sCOND' patterns and all the comparison
1312 operators whose results have a `MODE_INT' mode. */
1313 #define STORE_FLAG_VALUE 1
1317 An alias for the machine mode for pointers. On most machines,
1318 define this to be the integer mode corresponding to the width of a
1319 hardware pointer; `SImode' on 32-bit machine or `DImode' on 64-bit
1320 machines. On some machines you must define this to be one of the
1321 partial integer modes, such as `PSImode'.
1323 The width of `Pmode' must be at least as large as the value of
1324 `POINTER_SIZE'. If it is not equal, you must define the macro
1325 `POINTERS_EXTEND_UNSIGNED' to specify how pointers are extended to
1327 #define Pmode SImode
1331 An alias for the machine mode used for memory references to
1332 functions being called, in `call' RTL expressions. On most
1333 machines this should be `QImode'. */
1334 #define FUNCTION_MODE SImode
1336 /* `NO_IMPLICIT_EXTERN_C'
1338 Define this macro if the system header files support C++ as well as
1339 C. This macro inhibits the usual method of using system header
1340 files in C++, which is to pretend that the file's contents are
1341 enclosed in `extern "C" {...}'. */
1342 #define NO_IMPLICIT_EXTERN_C
1344 /* Dividing the Output into Sections (Texts, Data, ...)
1346 An object file is divided into sections containing different types
1347 of data. In the most common case, there are three sections: the
1348 "text section", which holds instructions and read-only data; the
1349 "data section", which holds initialized writable data; and the "bss
1350 section", which holds uninitialized data. Some systems have other
1353 `TEXT_SECTION_ASM_OP'
1355 A C expression whose value is a string containing the assembler
1356 operation that should precede instructions and read-only data.
1357 Normally `".text"' is right. */
1358 #define TEXT_SECTION_ASM_OP "\t.text"
1360 /* `DATA_SECTION_ASM_OP'
1362 A C expression whose value is a string containing the assembler
1363 operation to identify the following data as writable initialized
1364 data. Normally `".data"' is right. */
1365 #define DATA_SECTION_ASM_OP "\t.data"
1367 /* `BSS_SECTION_ASM_OP'
1369 If defined, a C expression whose value is a string containing the
1370 assembler operation to identify the following data as uninitialized
1371 global data. If not defined, and neither `ASM_OUTPUT_BSS' nor
1372 `ASM_OUTPUT_ALIGNED_BSS' are defined, uninitialized global data
1373 will be output in the data section if `-fno-common' is passed,
1374 otherwise `ASM_OUTPUT_COMMON' will be used.
1378 A list of names for sections other than the standard two, which are
1379 `in_text' and `in_data'. You need not define this macro on a
1380 system with no other sections (that GCC needs to use).
1382 `EXTRA_SECTION_FUNCTIONS'
1384 One or more functions to be defined in `varasm.c'. These functions
1385 should do jobs analogous to those of `text_section' and
1386 `data_section', for your additional sections. Do not define this
1387 macro if you do not define `EXTRA_SECTIONS'.
1389 `JUMP_TABLES_IN_TEXT_SECTION' Define this macro if jump tables (for
1390 `tablejump' insns) should be output in the text section, along with
1391 the assembler instructions. Otherwise, the readonly data section
1394 This macro is irrelevant if there is no separate readonly data
1396 #undef JUMP_TABLES_IN_TEXT_SECTION
1399 /* The Overall Framework of an Assembler File
1401 This describes the overall framework of an assembler file.
1405 A C string constant describing how to begin a comment in the target
1406 assembler language. The compiler assumes that the comment will end
1407 at the end of the line. */
1408 #define ASM_COMMENT_START ";"
1412 A C string constant for text to be output before each `asm'
1413 statement or group of consecutive ones. Normally this is `"#APP"',
1414 which is a comment that has no effect on most assemblers but tells
1415 the GNU assembler that it must check the lines that follow for all
1416 valid assembler constructs. */
1417 #define ASM_APP_ON "#APP\n"
1421 A C string constant for text to be output after each `asm'
1422 statement or group of consecutive ones. Normally this is
1423 `"#NO_APP"', which tells the GNU assembler to resume making the
1424 time-saving assumptions that are valid for ordinary compiler
1426 #define ASM_APP_OFF "#NO_APP\n"
1430 This describes data output.
1432 Output and Generation of Labels
1434 This is about outputting labels.
1436 `ASM_OUTPUT_LABEL (STREAM, NAME)'
1438 A C statement (sans semicolon) to output to the stdio stream STREAM
1439 the assembler definition of a label named NAME. Use the expression
1440 `assemble_name (STREAM, NAME)' to output the name itself; before
1441 and after that, output the additional assembler syntax for defining
1442 the name, and a newline. */
1443 #define ASM_OUTPUT_LABEL(STREAM,NAME) \
1444 do { assemble_name (STREAM, NAME); fputs (":\n", STREAM); } while (0)
1446 /* Globalizing directive for a label */
1447 #define GLOBAL_ASM_OP "\t.global "
1449 /* `ASM_OUTPUT_LABELREF (STREAM, NAME)'
1451 A C statement (sans semicolon) to output to the stdio stream STREAM
1452 a reference in assembler syntax to a label named NAME. This should
1453 add `_' to the front of the name, if that is customary on your
1454 operating system, as it is in most Berkeley Unix systems. This
1455 macro is used in `assemble_name'. */
1456 #define ASM_OUTPUT_LABELREF(STREAM,NAME) \
1457 asm_fprintf (STREAM, "%U%s", NAME)
1459 /* Output of Assembler Instructions
1461 This describes assembler instruction output.
1465 A C initializer containing the assembler's names for the machine
1466 registers, each one as a C string constant. This is what
1467 translates register numbers in the compiler into assembler
1469 #define REGISTER_NAMES \
1470 {"r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7", \
1471 "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15", \
1472 "r16", "r17", "r18", "r19", "r20", "r21", "fp", "sp", \
1473 "r24", "r25", "r26", "r27", "r28", "r29", "r30", "r31", \
1475 "f0", "f1", "f2", "f3", "f4", "f5", "f6", "f7", \
1476 "f8", "f9", "f10", "f11", "f12", "f13", "f14", "f15", \
1477 "flags","argp","sfp" }
1479 /* `ADDITIONAL_REGISTER_NAMES`
1481 If defined, a C initializer for an array of structures containing
1482 a name and a register number. This macro defines additional names
1483 for hard registers, thus allowing the `asm' option in declarations
1484 to refer to registers using alternate names. */
1485 #define ADDITIONAL_REGISTER_NAMES \
1486 {{"r22", HARD_FRAME_POINTER_REGNUM}, {"r23", STACK_POINTER_REGNUM}}
1488 /* `PRINT_OPERAND (STREAM, X, CODE)'
1490 A C compound statement to output to stdio stream STREAM the
1491 assembler syntax for an instruction operand X. X is an RTL
1494 CODE is a value that can be used to specify one of several ways of
1495 printing the operand. It is used when identical operands must be
1496 printed differently depending on the context. CODE comes from the
1497 `%' specification that was used to request printing of the operand.
1498 If the specification was just `%DIGIT' then CODE is 0; if the
1499 specification was `%LTR DIGIT' then CODE is the ASCII code for LTR.
1501 If X is a register, this macro should print the register's name.
1502 The names can be found in an array `reg_names' whose type is `char
1503 *[]'. `reg_names' is initialized from `REGISTER_NAMES'.
1505 When the machine description has a specification `%PUNCT' (a `%'
1506 followed by a punctuation character), this macro is called with a
1507 null pointer for X and the punctuation character for CODE. */
1508 #define PRINT_OPERAND(STREAM, X, CODE) print_operand (STREAM, X, CODE)
1510 /* `PRINT_OPERAND_PUNCT_VALID_P (CODE)'
1512 A C expression which evaluates to true if CODE is a valid
1513 punctuation character for use in the `PRINT_OPERAND' macro. If
1514 `PRINT_OPERAND_PUNCT_VALID_P' is not defined, it means that no
1515 punctuation characters (except for the standard one, `%') are used */
1516 #define PRINT_OPERAND_PUNCT_VALID_P(CODE) ((CODE) == '#')
1518 /* `PRINT_OPERAND_ADDRESS (STREAM, X)'
1520 A C compound statement to output to stdio stream STREAM the
1521 assembler syntax for an instruction operand that is a memory
1522 reference whose address is X. X is an RTL expression.
1524 On some machines, the syntax for a symbolic address depends on the
1525 section that the address refers to. On these machines, define the
1526 macro `ENCODE_SECTION_INFO' to store the information into the
1527 `symbol_ref', and then check for it here. */
1528 #define PRINT_OPERAND_ADDRESS(STREAM, ADDR) \
1529 print_operand_address (STREAM, ADDR)
1531 /* `REGISTER_PREFIX'
1532 `LOCAL_LABEL_PREFIX'
1536 If defined, C string expressions to be used for the `%R', `%L',
1537 `%U', and `%I' options of `asm_fprintf' (see `final.c'). These are
1538 useful when a single `md' file must support multiple assembler
1539 formats. In that case, the various `tm.h' files can define these
1540 macros differently. */
1541 #define REGISTER_PREFIX ""
1542 #define LOCAL_LABEL_PREFIX "."
1543 #define IMMEDIATE_PREFIX "#"
1545 /* `ASM_OUTPUT_REG_PUSH (STREAM, REGNO)'
1547 A C expression to output to STREAM some assembler code which will
1548 push hard register number REGNO onto the stack. The code need not
1549 be optimal, since this macro is used only when profiling. */
1550 #define ASM_OUTPUT_REG_PUSH(STREAM,REGNO) \
1551 asm_fprintf (STREAM, "\tsubi sp,4\n\twrite.l (sp),%s\n", \
1554 /* `ASM_OUTPUT_REG_POP (STREAM, REGNO)'
1556 A C expression to output to STREAM some assembler code which will
1557 pop hard register number REGNO off of the stack. The code need not
1558 be optimal, since this macro is used only when profiling. */
1559 #define ASM_OUTPUT_REG_POP(STREAM,REGNO) \
1560 asm_fprintf (STREAM, "\tread.l %s,(sp)\n\taddi sp,4\n", \
1564 /* Output of Dispatch Tables
1566 This concerns dispatch tables.
1568 `ASM_OUTPUT_ADDR_DIFF_ELT (STREAM, VALUE, REL)'
1570 A C statement to output to the stdio stream STREAM an assembler
1571 pseudo-instruction to generate a difference between two labels.
1572 VALUE and REL are the numbers of two internal labels. The
1573 definitions of these labels are output using
1574 `ASM_OUTPUT_INTERNAL_LABEL', and they must be printed in the same
1577 You must provide this macro on machines where the addresses in a
1578 dispatch table are relative to the table's own address. If
1579 defined, GNU CC will also use this macro on all machines when
1581 #define ASM_OUTPUT_ADDR_DIFF_ELT(STREAM,BODY,VALUE,REL) \
1582 switch (GET_MODE (BODY)) \
1585 asm_fprintf ((STREAM), "\t.long\t%LL%d-%LL%d\n", (VALUE),(REL)); \
1588 asm_fprintf ((STREAM), "\t.word\t%LL%d-%LL%d\n", (VALUE),(REL)); \
1591 asm_fprintf ((STREAM), "\t.byte\t%LL%d-%LL%d\n", (VALUE),(REL)); \
1597 /* `ASM_OUTPUT_ADDR_VEC_ELT (STREAM, VALUE)'
1599 This macro should be provided on machines where the addresses in a
1600 dispatch table are absolute.
1602 The definition should be a C statement to output to the stdio
1603 stream STREAM an assembler pseudo-instruction to generate a
1604 reference to a label. VALUE is the number of an internal label
1605 whose definition is output using `ASM_OUTPUT_INTERNAL_LABEL'. */
1606 #define ASM_OUTPUT_ADDR_VEC_ELT(STREAM, VALUE) \
1607 asm_fprintf (STREAM, "\t.long %LL%d\n", VALUE)
1609 /* `ASM_OUTPUT_CASE_END (STREAM, NUM, TABLE)'
1611 Define this if something special must be output at the end of a
1612 jump-table. The definition should be a C statement to be executed
1613 after the assembler code for the table is written. It should write
1614 the appropriate code to stdio stream STREAM. The argument TABLE is
1615 the jump-table insn, and NUM is the label-number of the preceding
1618 If this macro is not defined, nothing special is output at the end
1621 Here we output a word of zero so that jump-tables can be seperated
1622 in reverse assembly. */
1623 #define ASM_OUTPUT_CASE_END(STREAM, NUM, TABLE) \
1624 asm_fprintf (STREAM, "\t.long 0\n");
1626 /* Assembler Commands for Alignment
1628 This describes commands for alignment.
1630 `ASM_OUTPUT_ALIGN_CODE (STREAM)'
1632 A C expression to output text to align the location counter in the
1633 way that is desirable at a point in the code that is reached only
1636 This macro need not be defined if you don't want any special
1637 alignment to be done at such a time. Most machine descriptions do
1638 not currently define the macro. */
1639 #undef ASM_OUTPUT_ALIGN_CODE
1641 /* `ASM_OUTPUT_LOOP_ALIGN (STREAM)'
1643 A C expression to output text to align the location counter in the
1644 way that is desirable at the beginning of a loop.
1646 This macro need not be defined if you don't want any special
1647 alignment to be done at such a time. Most machine descriptions do
1648 not currently define the macro. */
1649 #undef ASM_OUTPUT_LOOP_ALIGN
1651 /* `ASM_OUTPUT_ALIGN (STREAM, POWER)'
1653 A C statement to output to the stdio stream STREAM an assembler
1654 command to advance the location counter to a multiple of 2 to the
1655 POWER bytes. POWER will be a C expression of type `int'. */
1656 #define ASM_OUTPUT_ALIGN(STREAM,LOG) \
1658 fprintf (STREAM, "\t.align %d\n", (1<<(LOG)))
1660 /* `ASM_OUTPUT_MAX_SKIP_ALIGN (STREAM, POWER, MAX_SKIP)`
1662 A C statement to output to the stdio stream STREAM an assembler
1663 command to advance the location counter to a multiple of 2 to the
1664 POWER bytes, but only if MAX_SKIP or fewer bytes are needed to
1665 satisfy the alignment request. POWER and MAX_SKIP will be a C
1666 expression of type `int'. */
1667 #define ASM_OUTPUT_MAX_SKIP_ALIGN(STREAM,LOG,MAX_SKIP) \
1669 if ((MAX_SKIP) == 0) fprintf ((STREAM), "\t.p2align %d\n", (LOG)); \
1671 fprintf ((STREAM), "\t.p2align %d,,%d\n", (LOG), (MAX_SKIP)); \
1672 /* Make sure that we have at least 8-byte alignment if > 8-byte \
1673 alignment is preferred. */ \
1675 && (1 << (LOG)) > ((MAX_SKIP) + 1) \
1676 && (MAX_SKIP) >= 7) \
1677 fputs ("\t.p2align 3\n", (STREAM)); \
1681 /* Controlling Debugging Information Format
1683 This describes how to specify debugging information.
1685 mda is known to GDB, but not to GCC. */
1686 #define DBX_REGISTER_NUMBER(REGNO) \
1687 ((REGNO) > MDB_REGNUM ? (REGNO) + 1 : (REGNO))
1689 /* `DEBUGGER_AUTO_OFFSET (X)'
1691 A C expression that returns the integer offset value for an
1692 automatic variable having address X (an RTL expression). The
1693 default computation assumes that X is based on the frame-pointer
1694 and gives the offset from the frame-pointer. This is required for
1695 targets that produce debugging output for DBX or COFF-style
1696 debugging output for SDB and allow the frame-pointer to be
1697 eliminated when the `-g' options is used. */
1698 #define DEBUGGER_AUTO_OFFSET(X) \
1699 (GET_CODE (X) == PLUS ? INTVAL (XEXP (X, 1)) : 0)
1701 /* Miscellaneous Parameters
1705 An alias for a machine mode name. This is the machine mode that
1706 elements of a jump-table should have. */
1707 #define CASE_VECTOR_MODE SImode
1709 /* `CASE_VECTOR_PC_RELATIVE'
1710 Define this macro if jump-tables should contain relative addresses. */
1711 #undef CASE_VECTOR_PC_RELATIVE
1713 /* This says how to output assembler code to declare an
1714 unitialised external linkage data object. */
1715 #define ASM_OUTPUT_COMMON(STREAM, NAME, SIZE, ROUNDED) \
1716 ( fputs ("\n\t.comm ", (STREAM)), \
1717 assemble_name ((STREAM), (NAME)), \
1718 fprintf ((STREAM), "," HOST_WIDE_INT_PRINT_UNSIGNED"\n", ROUNDED))
1720 /* This says how to output assembler code to declare an
1721 unitialised internal linkage data object. */
1722 #define ASM_OUTPUT_LOCAL(STREAM, NAME, SIZE, ROUNDED) \
1723 ( fputs ("\n\t.lcomm ", (STREAM)), \
1724 assemble_name ((STREAM), (NAME)), \
1725 fprintf ((STREAM), "," HOST_WIDE_INT_PRINT_UNSIGNED"\n", ROUNDED))
1727 /* Prettify the assembly. */
1728 extern int visium_indent_opcode
;
1730 #define ASM_OUTPUT_OPCODE(FILE, PTR) \
1732 if (visium_indent_opcode) \
1735 visium_indent_opcode = 0; \