xref: /netbsd-src/external/gpl3/gcc/dist/gcc/config/visium/visium.h (revision 4d5abbe83f525258eb479e5fca29f25cb943f379)
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.
4 
5    This file is part of GCC.
6 
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.
11 
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.
16 
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/>.  */
20 
21 
22 /* Controlling the Compilation Driver, `gcc'  */
23 
24 /* Pass -mtune=* options to the assembler */
25 #undef ASM_SPEC
26 #define ASM_SPEC "%{mcpu=gr6:-mtune=gr6; :-mtune=mcm}"
27 
28 /* Define symbols for the preprocessor.  */
29 #define CPP_SPEC "%{mcpu=gr6:-D__gr6__; :-D__gr5__}"
30 
31 /* Targets of a link */
32 #define LIB_SPEC \
33   "--start-group -lc %{msim:-lsim; mdebug:-ldebug; :-lserial} --end-group"
34 
35 #define ENDFILE_SPEC "crtend.o%s crtn.o%s"
36 #define STARTFILE_SPEC "crti.o%s crtbegin.o%s crt0.o%s"
37 
38 /* Run-time Target Specification */
39 
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.
50 
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.
60 
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
69    preprocessing.  */
70 #define TARGET_CPU_CPP_BUILTINS()			\
71   do							\
72     {							\
73       builtin_define ("__VISIUM__");			\
74       if (TARGET_MCM)					\
75 	builtin_define ("__VISIUM_ARCH_MCM__");		\
76       if (TARGET_BMI)					\
77 	builtin_define ("__VISIUM_ARCH_BMI__");		\
78       if (TARGET_FPU_IEEE)				\
79 	builtin_define ("__VISIUM_ARCH_FPU_IEEE__");	\
80     }							\
81   while (0)
82 
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)
86 
87 /* Defining data structures for per-function information.
88 
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.
94 
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
99    own specific data.
100 
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
105    below.
106 
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.
111 
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
120    supported.
121 
122    The macro and function pointers are described below.
123 
124    INIT_EXPANDERS:
125 
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.
130 
131    init_machine_status:
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
140    structure itself. */
141 
142 #define INIT_EXPANDERS visium_init_expanders ()
143 
144 /* Storage Layout
145 
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
149    the `target_flags'.
150 
151    `BITS_BIG_ENDIAN'
152 
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
159    constant.
160 
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
164 
165 /* `BYTES_BIG_ENDIAN'
166 
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
169    constant.*/
170 #define BYTES_BIG_ENDIAN 1
171 
172 /* `WORDS_BIG_ENDIAN'
173 
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
180 
181 /* `BITS_PER_WORD'
182 
183    Number of bits in a word; normally 32. */
184 #define BITS_PER_WORD 32
185 
186 /* `UNITS_PER_WORD'
187 
188    Number of storage units in a word; normally 4. */
189 #define UNITS_PER_WORD 4
190 
191 /* `POINTER_SIZE'
192 
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
197 
198 /* `PARM_BOUNDARY'
199 
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
205 
206 /* `STACK_BOUNDARY'
207 
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).
211 
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
217 
218 #define VISIUM_STACK_ALIGN(LOC) (((LOC) + 3) & ~3)
219 
220 /* `FUNCTION_BOUNDARY'
221 
222    Alignment required for a function entry point, in bits. */
223 #define FUNCTION_BOUNDARY 32
224 
225 /* `BIGGEST_ALIGNMENT'
226 
227    Biggest alignment that any data type can require on this machine,
228    in bits. */
229 #define BIGGEST_ALIGNMENT 32
230 
231 /* `DATA_ALIGNMENT (TYPE, BASIC-ALIGN)`
232 
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)
238 
239 /* `CONSTANT_ALIGNMENT (CONSTANT, BASIC-ALIGN)`
240 
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
245    align the object. */
246 #define CONSTANT_ALIGNMENT(EXP,ALIGN) \
247   visium_data_alignment (TREE_TYPE (EXP), ALIGN)
248 
249 /* `LOCAL_ALIGNMENT (TYPE, BASIC-ALIGN)`
250 
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)
256 
257 /* `EMPTY_FIELD_BOUNDARY'
258 
259    Alignment in bits to be given to a structure bit field that follows
260    an empty field such as `int : 0;'.
261 
262    Note that `PCC_BITFIELD_TYPE_MATTERS' also affects the alignment
263    that results from an empty field. */
264 #define EMPTY_FIELD_BOUNDARY 32
265 
266 /* `STRICT_ALIGNMENT'
267 
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
272 
273 /* `TARGET_FLOAT_FORMAT'
274 
275    A code distinguishing the floating point format of the target
276    machine.  There are three defined values:
277 
278    `IEEE_FLOAT_FORMAT'
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.
281 
282     `VAX_FLOAT_FORMAT'
283           This code indicates the peculiar format used on the Vax.
284 
285     `UNKNOWN_FLOAT_FORMAT'
286           This code indicates any other format.
287 
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.
292 
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
298 
299 /* Layout of Source Language Data Types
300 
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. */
306 
307 /* `INT_TYPE_SIZE'
308 
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
312 
313 /* `SHORT_TYPE_SIZE'
314 
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
318    up to one unit.) */
319 #define SHORT_TYPE_SIZE 16
320 
321 /* `LONG_TYPE_SIZE'
322 
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
326 
327 /* `LONG_LONG_TYPE_SIZE'
328 
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
334 
335 /* `CHAR_TYPE_SIZE'
336 
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
342 
343 /* `FLOAT_TYPE_SIZE'
344 
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
348 
349 /* `DOUBLE_TYPE_SIZE'
350 
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
353    words. */
354 #define DOUBLE_TYPE_SIZE  64
355 
356 /* `LONG_DOUBLE_TYPE_SIZE'
357 
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
360    words. */
361 #define LONG_DOUBLE_TYPE_SIZE   DOUBLE_TYPE_SIZE
362 
363 /* `WIDEST_HARDWARE_FP_SIZE'
364 
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. */
370 
371 /* `DEFAULT_SIGNED_CHAR'
372 
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
378 
379 /* `SIZE_TYPE'
380 
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.
384 
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
391    on startup.
392 
393    If you don't define this macro, the default is `"long unsigned
394    int"'. */
395 #define SIZE_TYPE "unsigned int"
396 
397 /* `PTRDIFF_TYPE'
398 
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.
403 
404    If you don't define this macro, the default is `"long int"'. */
405 #define PTRDIFF_TYPE "long int"
406 
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"
411 
412 /* `WCHAR_TYPE'
413 
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
417    information.
418 
419    If you don't define this macro, the default is `"int"'. */
420 #define WCHAR_TYPE "short int"
421 
422 /* `WCHAR_TYPE_SIZE'
423 
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
426    `WCHAR_TYPE'. */
427 #define WCHAR_TYPE_SIZE 16
428 
429 /* Register Usage
430 
431    This section explains how to describe what registers the target
432    machine has, and how (in general) they can be used.  */
433 
434 /* `FIRST_PSEUDO_REGISTER'
435 
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.
441 
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
445 
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)
452 
453 #define MDB_REGNUM          32
454 #define MDC_REGNUM          33
455 
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)
461 
462 #define FLAGS_REGNUM        50
463 
464 /* `FIXED_REGISTERS'
465 
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
473    standard use.
474 
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.
478 
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'.
484 
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 */
500 
501 /* `CALL_USED_REGISTERS'
502 
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.
508 
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 */
521 
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 */
536 
537 /* `REG_ALLOC_ORDER'
538 
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).
542 
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 */  \
548    22,                                     /* fp */          \
549    24, 25, 26, 27, 28,                     /* r24 .. r28 */  \
550    31,                                     /* r31 */         \
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 */ \
557    0, 34 }                                 /* r0, f0 */
558 
559 /* `HARD_REGNO_NREGS (REGNO, MODE)'
560 
561    A C expression for the number of consecutive hard registers,
562    starting at register number REGNO, required to hold a value of mode
563    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))
568 
569 /* `HARD_REGNO_RENAME_OK (OLD_REG, NEW_REG)'
570 
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)
575 
576 /*  `HARD_REGNO_MODE_OK (REGNO, MODE)'
577 
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).
581 
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
585     registers. */
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)
593 
594 /* `MODES_TIEABLE_P (MODE1, MODE2)'
595 
596    A C expression that is nonzero if a value of mode MODE1 is
597    accessible in mode MODE2 without copying.
598 
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.
604 
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))
611 
612 /* Register Classes
613 
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".
619 
620    `enum reg_class'
621 
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.
627 
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. */
631 
632 enum reg_class
633 {
634   NO_REGS,
635   MDB,
636   MDC,
637   FP_REGS,
638   FLAGS,
639   R1,
640   R2,
641   R3,
642   SIBCALL_REGS,
643   LOW_REGS,
644   GENERAL_REGS,
645   ALL_REGS,
646   LIM_REG_CLASSES
647 };
648 
649 /* `N_REG_CLASSES'
650 
651    The number of distinct register classes, defined as follows.  */
652 #define N_REG_CLASSES (int) LIM_REG_CLASSES
653 
654 /* `REG_CLASS_NAMES'
655 
656    An initializer containing the names of the register classes as C
657    string constants.  These names are used in writing some of the
658    debugging dumps. */
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"}
662 
663 /* `REG_CLASS_CONTENTS'
664 
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.
669 
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 */
688 
689 /* `REGNO_REG_CLASS (REGNO)'
690 
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 :                     \
705    GENERAL_REGS)
706 
707 /* `BASE_REG_CLASS'
708 
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
713 
714 #define BASE_REGISTER_P(REGNO)        \
715   (GP_REGISTER_P (REGNO)              \
716    || (REGNO) == ARG_POINTER_REGNUM   \
717    || (REGNO) == FRAME_POINTER_REGNUM)
718 
719 /* `INDEX_REG_CLASS'
720 
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
726 
727 /* `REGNO_OK_FOR_BASE_P (NUM)'
728 
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]))
735 
736 /* `REGNO_OK_FOR_INDEX_P (NUM)'
737 
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.
742 
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
752 
753 /* `PREFERRED_RELOAD_CLASS (X, CLASS)'
754 
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.
759 
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.
765 
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
769    registers. */
770 #define PREFERRED_RELOAD_CLASS(X,CLASS) CLASS
771 
772 /*  `CANNOT_CHANGE_MODE_CLASS (from, to, class)
773 
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.
776 
777     It's not obvious from the above that MDB cannot change mode. However
778     difficulties arise from expressions of the form
779 
780     (subreg:SI (reg:DI R_MDB) 0)
781 
782     There is no way to convert that reference to a single machine
783     register and, without the following definition, reload will quietly
784     convert it to
785 
786      (reg:SI R_MDB)  */
787 #define CANNOT_CHANGE_MODE_CLASS(FROM,TO,CLASS) \
788   (CLASS == MDB ? (GET_MODE_SIZE (FROM) != GET_MODE_SIZE (TO)) : 0)
789 
790 /* `CLASS_MAX_NREGS (CLASS, MODE)'
791 
792    A C expression for the maximum number of consecutive registers of
793    class CLASS needed to hold a value of mode MODE.
794 
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.
799 
800    This macro helps control the handling of multiple-word values in
801    the reload pass.  */
802 #define CLASS_MAX_NREGS(CLASS, MODE)    \
803   ((CLASS) == MDB ?                     \
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))
806 
807 /* Stack Layout and Calling Conventions
808 
809    Basic Stack Layout
810 
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
815 
816 /* `STARTING_FRAME_OFFSET'
817 
818    Offset from the frame pointer to the first local variable slot to
819    be allocated.
820 
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
826 
827 /* `FIRST_PARM_OFFSET (FUNDECL)'
828 
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
831    function.
832 
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
836 
837 /* `DYNAMIC_CHAIN_ADDRESS (FRAMEADDR)'
838 
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
842    stack frame itself.
843 
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)
849 
850 /* `RETURN_ADDR_RTX (COUNT, FRAMEADDR)'
851 
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.
857 
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)
863 
864 /* Exception Handling
865 
866    `EH_RETURN_DATA_REGNO'
867 
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
870    are available.
871 
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 ()
877 
878 /* Registers That Address the Stack Frame
879 
880    This discusses registers that address the stack frame.
881 
882    `STACK_POINTER_REGNUM'
883 
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
888 
889 /* `FRAME_POINTER_REGNUM'
890 
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
896 
897 /* `HARD_FRAME_POINTER_REGNUM'
898 
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
908 
909 /* `ARG_POINTER_REGNUM'
910 
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
920 
921 /* `STATIC_CHAIN_REGNUM'
922    `STATIC_CHAIN_INCOMING_REGNUM'
923 
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.
930 
931    The static chain register need not be a fixed register.
932 
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
936 
937 /* `ELIMINABLE_REGS'
938 
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
943    the stack pointer.
944 
945    The definition of this macro is a list of structure
946    initializations, each of which specifies an original and
947    replacement register.
948 
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
954    has been eliminated.
955 
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}}
963 
964 /* `INITIAL_ELIMINATION_OFFSET (FROM-REG, TO-REG, OFFSET-VAR)'
965 
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
969    defined.  */
970 #define INITIAL_ELIMINATION_OFFSET(FROM, TO, OFFSET) \
971   (OFFSET = visium_initial_elimination_offset (FROM, TO))
972 
973 /* Passing Function Arguments on the Stack
974 
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.
978 
979    Passing Arguments in Registers
980 
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
983    in the stack.
984 
985    Define the general purpose, and floating point registers used for
986    passing arguments */
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)
993 
994 /* Define a data type for recording info about an argument list during the
995 processing of that argument list. */
996 
997 struct visium_args
998 {
999   /* The count of general registers used */
1000   int grcount;
1001   /* The count of floating registers used */
1002   int frcount;
1003   /* The number of stack words used by named arguments */
1004   int stack_words;
1005 };
1006 
1007 /* `CUMULATIVE_ARGS'
1008 
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.
1013 
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
1021 
1022 #define INIT_CUMULATIVE_ARGS(CUM,FNTYPE,LIBNAME,FNDECL,N_NAMED_ARGS) \
1023   do {                        \
1024        (CUM).grcount = 0;     \
1025        (CUM).frcount = 0;     \
1026        (CUM).stack_words = 0; \
1027      } while (0)
1028 
1029 /* `FUNCTION_ARG_REGNO_P (REGNO)'
1030 
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
1036    the stack. */
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))
1040 
1041 /* `FUNCTION_VALUE_REGNO_P (REGNO)'
1042 
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.
1045 
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))
1054 
1055 /* How Large Values Are Returned
1056 
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".
1062 
1063    This section describes how to control returning structure values in
1064    memory.
1065 
1066    `DEFAULT_PCC_STRUCT_RETURN'
1067 
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.
1074 
1075    If not defined, this defaults to the value 1. */
1076 #define DEFAULT_PCC_STRUCT_RETURN 0
1077 
1078 /* `STRUCT_VALUE'
1079 
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
1085 
1086 /* Caller-Saves Register Allocation
1087 
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.
1091 
1092    Function Entry and Exit
1093 
1094    This section describes the macros that output function entry
1095    ("prologue") and exit ("epilogue") code.
1096 
1097    `EXIT_IGNORE_STACK'
1098 
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.
1103 
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
1109 
1110 /* `EPILOGUE_USES (REGNO)'
1111 
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
1115    needed. */
1116 #define EPILOGUE_USES(REGNO) visium_epilogue_uses (REGNO)
1117 
1118 /* Generating Code for Profiling
1119 
1120    These macros will help you generate code for profiling. */
1121 
1122 #define PROFILE_HOOK(LABEL) visium_profile_hook ()
1123 #define FUNCTION_PROFILER(FILE, LABELNO) do {} while (0)
1124 #define NO_PROFILE_COUNTERS 1
1125 
1126 /* Trampolines for Nested Functions
1127 
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
1132    trampoline.
1133 
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.
1142 
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.
1150 
1151    On the Visium, the trampoline is
1152 
1153 	moviu	r9,%u FUNCTION
1154 	movil	r9,%l FUNCTION
1155 	moviu	r20,%u STATIC
1156 	bra	tr,r9,r0
1157 	movil	r20,%l STATIC
1158 
1159     A difficulty is setting the correct instruction parity at run time.
1160 
1161 
1162     TRAMPOLINE_SIZE
1163     A C expression for the size in bytes of the trampoline, as an integer. */
1164 #define TRAMPOLINE_SIZE 20
1165 
1166 /* Implicit calls to library routines
1167 
1168    Avoid calling library routines (sqrtf) just to set `errno' to EDOM */
1169 #define TARGET_EDOM 33
1170 
1171 /* Addressing Modes
1172 
1173    `MAX_REGS_PER_ADDRESS'
1174 
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
1178    ever accept.  */
1179 #define MAX_REGS_PER_ADDRESS 1
1180 
1181 /* `LEGITIMIZE_RELOAD_ADDRESS (X, MODE, OPNUM, TYPE, IND_LEVELS, WIN)'
1182 
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) 	\
1189 do									\
1190 {									\
1191   rtx new_x = visium_legitimize_reload_address ((AD), (MODE), (OPNUM),	\
1192 					(int) (TYPE), (IND));		\
1193   if (new_x)								\
1194     {									\
1195       (AD) = new_x;							\
1196       goto WIN;								\
1197     }									\
1198 } while (0)
1199 
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))
1203 
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)
1209 
1210 /* `BRANCH_COST'
1211 
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
1215 
1216 /* Override BRANCH_COST heuristics for complex logical ops.  */
1217 #define LOGICAL_OP_NON_SHORT_CIRCUIT 0
1218 
1219 /* `SLOW_BYTE_ACCESS'
1220 
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.
1226 
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
1235 
1236 /* `MOVE_RATIO (SPEED)`
1237 
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.
1243 
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)
1247 
1248 /* `CLEAR_RATIO (SPEED)`
1249 
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.
1255 
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)
1259 
1260 /* `MOVE_MAX'
1261 
1262    The maximum number of bytes that a single instruction can move
1263    quickly between memory and registers or between two memory
1264    locations. */
1265 #define MOVE_MAX 4
1266 
1267 /* `MAX_MOVE_MAX'
1268 
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
1275 
1276 /* `SHIFT_COUNT_TRUNCATED'
1277 
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
1290 
1291 /* `TRULY_NOOP_TRUNCATION (OUTPREC, INPREC)'
1292 
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.
1297 
1298    On many machines, this expression can be 1.
1299 
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
1305 
1306 /* `STORE_FLAG_VALUE'
1307 
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
1314 
1315 /* `Pmode'
1316 
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'.
1322 
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
1326    `Pmode'. */
1327 #define Pmode SImode
1328 
1329 /* `FUNCTION_MODE'
1330 
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
1335 
1336 /* `NO_IMPLICIT_EXTERN_C'
1337 
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
1343 
1344 /* Dividing the Output into Sections (Texts, Data, ...)
1345 
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
1351    kinds of sections.
1352 
1353    `TEXT_SECTION_ASM_OP'
1354 
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"
1359 
1360 /* `DATA_SECTION_ASM_OP'
1361 
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"
1366 
1367 /* `BSS_SECTION_ASM_OP'
1368 
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.
1375 
1376    `EXTRA_SECTIONS'
1377 
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).
1381 
1382    `EXTRA_SECTION_FUNCTIONS'
1383 
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'.
1388 
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
1392    is used.
1393 
1394    This macro is irrelevant if there is no separate readonly data
1395    section. */
1396 #undef JUMP_TABLES_IN_TEXT_SECTION
1397 
1398 
1399 /* The Overall Framework of an Assembler File
1400 
1401    This describes the overall framework of an assembler file.
1402 
1403    `ASM_COMMENT_START'
1404 
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 ";"
1409 
1410 /* `ASM_APP_ON'
1411 
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"
1418 
1419 /* `ASM_APP_OFF'
1420 
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
1425    output. */
1426 #define ASM_APP_OFF "#NO_APP\n"
1427 
1428 /* Output of Data
1429 
1430    This describes data output.
1431 
1432    Output and Generation of Labels
1433 
1434    This is about outputting labels.
1435 
1436    `ASM_OUTPUT_LABEL (STREAM, NAME)'
1437 
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)
1445 
1446 /* Globalizing directive for a label */
1447 #define GLOBAL_ASM_OP "\t.global "
1448 
1449 /* `ASM_OUTPUT_LABELREF (STREAM, NAME)'
1450 
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)
1458 
1459 /* Output of Assembler Instructions
1460 
1461    This describes assembler instruction output.
1462 
1463    `REGISTER_NAMES'
1464 
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
1468    language. */
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", \
1474   "mdb", "mdc",                                           \
1475   "f0",  "f1",  "f2",  "f3",  "f4",  "f5",  "f6",  "f7",  \
1476   "f8",  "f9",  "f10", "f11", "f12", "f13", "f14", "f15", \
1477   "flags","argp","sfp" }
1478 
1479 /* `ADDITIONAL_REGISTER_NAMES`
1480 
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}}
1487 
1488 /* `PRINT_OPERAND (STREAM, X, CODE)'
1489 
1490    A C compound statement to output to stdio stream STREAM the
1491    assembler syntax for an instruction operand X.  X is an RTL
1492    expression.
1493 
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.
1500 
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'.
1504 
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)
1509 
1510 /* `PRINT_OPERAND_PUNCT_VALID_P (CODE)'
1511 
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) == '#')
1517 
1518 /* `PRINT_OPERAND_ADDRESS (STREAM, X)'
1519 
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.
1523 
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)
1530 
1531 /* `REGISTER_PREFIX'
1532    `LOCAL_LABEL_PREFIX'
1533    `USER_LABEL_PREFIX'
1534    `IMMEDIATE_PREFIX'
1535 
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 "#"
1544 
1545 /* `ASM_OUTPUT_REG_PUSH (STREAM, REGNO)'
1546 
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", \
1552                reg_names[REGNO])
1553 
1554 /* `ASM_OUTPUT_REG_POP (STREAM, REGNO)'
1555 
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", \
1561                reg_names[REGNO])
1562 
1563 
1564 /* Output of Dispatch Tables
1565 
1566    This concerns dispatch tables.
1567 
1568    `ASM_OUTPUT_ADDR_DIFF_ELT (STREAM, VALUE, REL)'
1569 
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
1575    way here.
1576 
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
1580    producing PIC. */
1581 #define ASM_OUTPUT_ADDR_DIFF_ELT(STREAM,BODY,VALUE,REL)  		\
1582   switch (GET_MODE (BODY))						\
1583     {									\
1584     case SImode:							\
1585       asm_fprintf ((STREAM), "\t.long\t%LL%d-%LL%d\n", (VALUE),(REL));	\
1586       break;								\
1587     case HImode:							\
1588       asm_fprintf ((STREAM), "\t.word\t%LL%d-%LL%d\n", (VALUE),(REL));	\
1589       break;								\
1590     case QImode:							\
1591       asm_fprintf ((STREAM), "\t.byte\t%LL%d-%LL%d\n", (VALUE),(REL));	\
1592       break;								\
1593     default:								\
1594       break;								\
1595     }
1596 
1597 /* `ASM_OUTPUT_ADDR_VEC_ELT (STREAM, VALUE)'
1598 
1599    This macro should be provided on machines where the addresses in a
1600    dispatch table are absolute.
1601 
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)
1608 
1609 /* `ASM_OUTPUT_CASE_END (STREAM, NUM, TABLE)'
1610 
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
1616    label.
1617 
1618    If this macro is not defined, nothing special is output at the end
1619    of a jump table.
1620 
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");
1625 
1626 /* Assembler Commands for Alignment
1627 
1628    This describes commands for alignment.
1629 
1630    `ASM_OUTPUT_ALIGN_CODE (STREAM)'
1631 
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
1634    by jumping.
1635 
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
1640 
1641 /* `ASM_OUTPUT_LOOP_ALIGN (STREAM)'
1642 
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.
1645 
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
1650 
1651 /* `ASM_OUTPUT_ALIGN (STREAM, POWER)'
1652 
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)      \
1657   if ((LOG) != 0)                       \
1658     fprintf (STREAM, "\t.align  %d\n", (1<<(LOG)))
1659 
1660 /* `ASM_OUTPUT_MAX_SKIP_ALIGN (STREAM, POWER, MAX_SKIP)`
1661 
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)			\
1668   if ((LOG) != 0) {							\
1669     if ((MAX_SKIP) == 0) fprintf ((STREAM), "\t.p2align %d\n", (LOG));	\
1670     else {								\
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.  */					\
1674       if ((LOG) > 3							\
1675 	  && (1 << (LOG)) > ((MAX_SKIP) + 1)				\
1676 	  && (MAX_SKIP) >= 7)						\
1677 	fputs ("\t.p2align 3\n", (STREAM));				\
1678     }									\
1679   }
1680 
1681 /* Controlling Debugging Information Format
1682 
1683    This describes how to specify debugging information.
1684 
1685     mda is known to GDB, but not to GCC. */
1686 #define DBX_REGISTER_NUMBER(REGNO) \
1687   ((REGNO) > MDB_REGNUM ? (REGNO) + 1 : (REGNO))
1688 
1689 /* `DEBUGGER_AUTO_OFFSET (X)'
1690 
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)
1700 
1701 /* Miscellaneous Parameters
1702 
1703    `CASE_VECTOR_MODE'
1704 
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
1708 
1709 /* `CASE_VECTOR_PC_RELATIVE'
1710    Define this macro if jump-tables should contain relative addresses. */
1711 #undef CASE_VECTOR_PC_RELATIVE
1712 
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))
1719 
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))
1726 
1727 /* Prettify the assembly.  */
1728 extern int visium_indent_opcode;
1729 
1730 #define ASM_OUTPUT_OPCODE(FILE, PTR)	\
1731   do {					\
1732     if (visium_indent_opcode)		\
1733       {					\
1734 	putc (' ', FILE);		\
1735 	visium_indent_opcode = 0;	\
1736       }					\
1737   } while (0)
1738