1 /* Definitions of target machine for Visium.
2 Copyright (C) 2002-2023 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 /* `LOCAL_ALIGNMENT (TYPE, BASIC-ALIGN)`
240
241 If defined, a C expression to compute the alignment for a variable
242 in the local store. TYPE is the data type, and BASIC-ALIGN is the
243 alignment that the object would ordinarily have. The value of this
244 macro is used instead of that alignment to align the object. */
245 #define LOCAL_ALIGNMENT(TYPE,ALIGN) visium_data_alignment (TYPE, ALIGN)
246
247 /* `EMPTY_FIELD_BOUNDARY'
248
249 Alignment in bits to be given to a structure bit field that follows
250 an empty field such as `int : 0;'.
251
252 Note that `PCC_BITFIELD_TYPE_MATTERS' also affects the alignment
253 that results from an empty field. */
254 #define EMPTY_FIELD_BOUNDARY 32
255
256 /* `STRICT_ALIGNMENT'
257
258 Define this macro to be the value 1 if instructions will fail to
259 work if given data not on the nominal alignment. If instructions
260 will merely go slower in that case, define this macro as 0. */
261 #define STRICT_ALIGNMENT 1
262
263 /* `TARGET_FLOAT_FORMAT'
264
265 A code distinguishing the floating point format of the target
266 machine. There are three defined values:
267
268 `IEEE_FLOAT_FORMAT'
269 This code indicates IEEE floating point. It is the default;
270 there is no need to define this macro when the format is IEEE.
271
272 `VAX_FLOAT_FORMAT'
273 This code indicates the peculiar format used on the Vax.
274
275 `UNKNOWN_FLOAT_FORMAT'
276 This code indicates any other format.
277
278 The value of this macro is compared with `HOST_FLOAT_FORMAT' to
279 determine whether the target machine has the same format as the
280 host machine. If any other formats are actually in use on
281 supported machines, new codes should be defined for them.
282
283 The ordering of the component words of floating point values
284 stored in memory is controlled by `FLOAT_WORDS_BIG_ENDIAN' for the
285 target machine and `HOST_FLOAT_WORDS_BIG_ENDIAN' for the host. */
286 #define TARGET_FLOAT_FORMAT IEEE_FLOAT_FORMAT
287 #define UNITS_PER_HWFPVALUE 4
288
289 /* Layout of Source Language Data Types
290
291 These macros define the sizes and other characteristics of the
292 standard basic data types used in programs being compiled. Unlike
293 the macros in the previous section, these apply to specific
294 features of C and related languages, rather than to fundamental
295 aspects of storage layout. */
296
297 /* `INT_TYPE_SIZE'
298
299 A C expression for the size in bits of the type `int' on the target
300 machine. If you don't define this, the default is one word. */
301 #define INT_TYPE_SIZE 32
302
303 /* `SHORT_TYPE_SIZE'
304
305 A C expression for the size in bits of the type `short' on the
306 target machine. If you don't define this, the default is half a
307 word. (If this would be less than one storage unit, it is rounded
308 up to one unit.) */
309 #define SHORT_TYPE_SIZE 16
310
311 /* `LONG_TYPE_SIZE'
312
313 A C expression for the size in bits of the type `long' on the
314 target machine. If you don't define this, the default is one word. */
315 #define LONG_TYPE_SIZE 32
316
317 /* `LONG_LONG_TYPE_SIZE'
318
319 A C expression for the size in bits of the type `long long' on the
320 target machine. If you don't define this, the default is two
321 words. If you want to support GNU Ada on your machine, the value
322 of macro must be at least 64. */
323 #define LONG_LONG_TYPE_SIZE 64
324
325 /* `CHAR_TYPE_SIZE'
326
327 A C expression for the size in bits of the type `char' on the
328 target machine. If you don't define this, the default is one
329 quarter of a word. (If this would be less than one storage unit,
330 it is rounded up to one unit.) */
331 #define CHAR_TYPE_SIZE 8
332
333 /* `FLOAT_TYPE_SIZE'
334
335 A C expression for the size in bits of the type `float' on the
336 target machine. If you don't define this, the default is one word. */
337 #define FLOAT_TYPE_SIZE 32
338
339 /* `DOUBLE_TYPE_SIZE'
340
341 A C expression for the size in bits of the type `double' on the
342 target machine. If you don't define this, the default is two
343 words. */
344 #define DOUBLE_TYPE_SIZE 64
345
346 /* `LONG_DOUBLE_TYPE_SIZE'
347
348 A C expression for the size in bits of the type `long double' on
349 the target machine. If you don't define this, the default is two
350 words. */
351 #define LONG_DOUBLE_TYPE_SIZE DOUBLE_TYPE_SIZE
352
353 /* `WIDEST_HARDWARE_FP_SIZE'
354
355 A C expression for the size in bits of the widest floating-point
356 format supported by the hardware. If you define this macro, you
357 must specify a value less than or equal to the value of
358 `LONG_DOUBLE_TYPE_SIZE'. If you do not define this macro, the
359 value of `LONG_DOUBLE_TYPE_SIZE' is the default. */
360
361 /* `DEFAULT_SIGNED_CHAR'
362
363 An expression whose value is 1 or 0, according to whether the type
364 `char' should be signed or unsigned by default. The user can
365 always override this default with the options `-fsigned-char' and
366 `-funsigned-char'. */
367 #define DEFAULT_SIGNED_CHAR 0
368
369 /* `SIZE_TYPE'
370
371 A C expression for a string describing the name of the data type to
372 use for size values. The typedef name `size_t' is defined using
373 the contents of the string.
374
375 The string can contain more than one keyword. If so, separate them
376 with spaces, and write first any length keyword, then `unsigned' if
377 appropriate, and finally `int'. The string must exactly match one
378 of the data type names defined in the function
379 `init_decl_processing' in the file `c-decl.cc'. You may not omit
380 `int' or change the order--that would cause the compiler to crash
381 on startup.
382
383 If you don't define this macro, the default is `"long unsigned
384 int"'. */
385 #define SIZE_TYPE "unsigned int"
386
387 /* `PTRDIFF_TYPE'
388
389 A C expression for a string describing the name of the data type to
390 use for the result of subtracting two pointers. The typedef name
391 `ptrdiff_t' is defined using the contents of the string. See
392 `SIZE_TYPE' above for more information.
393
394 If you don't define this macro, the default is `"long int"'. */
395 #define PTRDIFF_TYPE "long int"
396
397 /* Newlib uses the unsigned type corresponding to ptrdiff_t for
398 uintptr_t; this is the same as size_t for most newlib-using
399 targets, but not for us. */
400 #define UINTPTR_TYPE "long unsigned int"
401
402 /* `WCHAR_TYPE'
403
404 A C expression for a string describing the name of the data type to
405 use for wide characters. The typedef name `wchar_t' is defined
406 using the contents of the string. See `SIZE_TYPE' above for more
407 information.
408
409 If you don't define this macro, the default is `"int"'. */
410 #define WCHAR_TYPE "short int"
411
412 /* `WCHAR_TYPE_SIZE'
413
414 A C expression for the size in bits of the data type for wide
415 characters. This is used in `cpp', which cannot make use of
416 `WCHAR_TYPE'. */
417 #define WCHAR_TYPE_SIZE 16
418
419 /* Register Usage
420
421 This section explains how to describe what registers the target
422 machine has, and how (in general) they can be used. */
423
424 /* `FIRST_PSEUDO_REGISTER'
425
426 Number of actual hardware registers.
427 The hardware registers are assigned numbers for the compiler
428 from 0 to just below FIRST_PSEUDO_REGISTER.
429 All registers that the compiler knows about must be given numbers,
430 even those that are not normally considered general registers.
431
432 Register 51 is used as the argument pointer register.
433 Register 52 is used as the soft frame pointer register. */
434 #define FIRST_PSEUDO_REGISTER 53
435
436 #define RETURN_REGNUM 1
437 #define PROLOGUE_TMP_REGNUM 9
438 #define LINK_REGNUM 21
439 #define GP_LAST_REGNUM 31
440 #define GP_REGISTER_P(REGNO) \
441 (((unsigned) (REGNO)) <= GP_LAST_REGNUM)
442
443 #define MDB_REGNUM 32
444 #define MDC_REGNUM 33
445
446 #define FP_FIRST_REGNUM 34
447 #define FP_LAST_REGNUM 49
448 #define FP_RETURN_REGNUM (FP_FIRST_REGNUM + 1)
449 #define FP_REGISTER_P(REGNO) \
450 (FP_FIRST_REGNUM <= (REGNO) && (REGNO) <= FP_LAST_REGNUM)
451
452 #define FLAGS_REGNUM 50
453
454 /* `FIXED_REGISTERS'
455
456 An initializer that says which registers are used for fixed
457 purposes all throughout the compiled code and are therefore not
458 available for general allocation. These would include the stack
459 pointer, the frame pointer (except on machines where that can be
460 used as a general register when no frame pointer is needed), the
461 program counter on machines where that is considered one of the
462 addressable registers, and any other numbered register with a
463 standard use.
464
465 This information is expressed as a sequence of numbers, separated
466 by commas and surrounded by braces. The Nth number is 1 if
467 register N is fixed, 0 otherwise.
468
469 The table initialized from this macro, and the table initialized by
470 the following one, may be overridden at run time either
471 automatically, by the actions of the macro
472 `CONDITIONAL_REGISTER_USAGE', or by the user with the command
473 options `-ffixed-REG', `-fcall-used-REG' and `-fcall-saved-REG'.
474
475 r0 and f0 are immutable registers hardwired to 0.
476 r21 is the link register used for procedure linkage.
477 r23 is the stack pointer register.
478 r29 and r30 hold the interrupt context.
479 mdc is a read-only register because the writemdc instruction
480 terminates all the operations of the EAM on the GR6. */
481 #define FIXED_REGISTERS \
482 { 1, 0, 0, 0, 0, 0, 0, 0, /* r0 .. r7 */ \
483 0, 0, 0, 0, 0, 0, 0, 0, /* r8 .. r15 */ \
484 0, 0, 0, 0, 0, 1, 0, 1, /* r16 .. r23 */ \
485 0, 0, 0, 0, 0, 1, 1, 0, /* r24 .. r31 */ \
486 0, 1, /* mdb, mdc */ \
487 1, 0, 0, 0, 0, 0, 0, 0, /* f0 .. f7 */ \
488 0, 0, 0, 0, 0, 0, 0, 0, /* f8 .. f15 */ \
489 1, 1, 1 } /* flags, arg, frame */
490
491 /* Like `CALL_USED_REGISTERS' except this macro doesn't require that
492 the entire set of `FIXED_REGISTERS' be included.
493 (`CALL_USED_REGISTERS' must be a superset of `FIXED_REGISTERS').
494 This macro is optional. If not specified, it defaults to the value
495 of `CALL_USED_REGISTERS'. */
496 #define CALL_REALLY_USED_REGISTERS \
497 { 0, 1, 1, 1, 1, 1, 1, 1, /* r0 .. r7 */ \
498 1, 1, 1, 0, 0, 0, 0, 0, /* r8 .. r15 */ \
499 0, 0, 0, 0, 1, 0, 0, 0, /* r16 .. r23 */ \
500 1, 1, 1, 1, 1, 0, 0, 1, /* r24 .. r31 */ \
501 1, 1, /* mdb, mdc */ \
502 1, 1, 1, 1, 1, 1, 1, 1, /* f0 .. f7 */ \
503 1, 0, 0, 0, 0, 0, 0, 0, /* f8 .. f15 */ \
504 1, 0, 0 } /* flags, arg, frame */
505
506 /* `REG_ALLOC_ORDER'
507
508 If defined, an initializer for a vector of integers, containing the
509 numbers of hard registers in the order in which GCC should prefer
510 to use them (from most preferred to least).
511
512 If this macro is not defined, registers are used lowest numbered
513 first (all else being equal). */
514 #define REG_ALLOC_ORDER \
515 { 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, /* r10 .. r1 */ \
516 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, /* r11 .. r20 */ \
517 22, /* fp */ \
518 24, 25, 26, 27, 28, /* r24 .. r28 */ \
519 31, /* r31 */ \
520 32, 33, /* mdb, mdc */ \
521 42, 41, 40, 39, 38, 37, 36, 35, /* f8 .. f1 */ \
522 43, 44, 45, 46, 47, 48, 49, /* f9 .. f15 */ \
523 21, 23, /* lr, sp */ \
524 29, 30, /* r29, r30 */ \
525 50, 51, 52, /* flags, arg, frame */ \
526 0, 34 } /* r0, f0 */
527
528 /* `HARD_REGNO_RENAME_OK (OLD_REG, NEW_REG)'
529
530 A C expression which is nonzero if hard register NEW_REG can be
531 considered for use as a rename register for hard register OLD_REG. */
532 #define HARD_REGNO_RENAME_OK(OLD_REG, NEW_REG) \
533 visium_hard_regno_rename_ok (OLD_REG, NEW_REG)
534
535 /* Register Classes
536
537 On many machines, the numbered registers are not all equivalent.
538 For example, certain registers may not be allowed for indexed
539 addressing; certain registers may not be allowed in some
540 instructions. These machine restrictions are described to the
541 compiler using "register classes".
542
543 `enum reg_class'
544
545 An enumeral type that must be defined with all the register class
546 names as enumeral values. `NO_REGS' must be first. `ALL_REGS'
547 must be the last register class, followed by one more enumeral
548 value, `LIM_REG_CLASSES', which is not a register class but rather
549 tells how many classes there are.
550
551 Each register class has a number, which is the value of casting the
552 class name to type `int'. The number serves as an index in many of
553 the tables described below. */
554
555 enum reg_class
556 {
557 NO_REGS,
558 MDB,
559 MDC,
560 FP_REGS,
561 FLAGS,
562 R1,
563 R2,
564 R3,
565 SIBCALL_REGS,
566 LOW_REGS,
567 GENERAL_REGS,
568 ALL_REGS,
569 LIM_REG_CLASSES
570 };
571
572 /* `N_REG_CLASSES'
573
574 The number of distinct register classes, defined as follows. */
575 #define N_REG_CLASSES (int) LIM_REG_CLASSES
576
577 /* `REG_CLASS_NAMES'
578
579 An initializer containing the names of the register classes as C
580 string constants. These names are used in writing some of the
581 debugging dumps. */
582 #define REG_CLASS_NAMES \
583 {"NO_REGS", "MDB", "MDC", "FP_REGS", "FLAGS", "R1", "R2", "R3", \
584 "SIBCALL_REGS", "LOW_REGS", "GENERAL_REGS", "ALL_REGS"}
585
586 /* `REG_CLASS_CONTENTS'
587
588 An initializer containing the contents of the register classes, as
589 integers which are bit masks. The Nth integer specifies the
590 contents of class N. The way the integer MASK is interpreted is
591 that register R is in the class if `MASK & (1 << R)' is 1.
592
593 When the machine has more than 32 registers, an integer does not
594 suffice. Then the integers are replaced by sub-initializers,
595 braced groupings containing several integers. Each sub-initializer
596 must be suitable as an initializer for the type `HARD_REG_SET'
597 which is defined in `hard-reg-set.h'. */
598 #define REG_CLASS_CONTENTS { \
599 {0x00000000, 0x00000000}, /* NO_REGS */ \
600 {0x00000000, 0x00000001}, /* MDB */ \
601 {0x00000000, 0x00000002}, /* MDC */ \
602 {0x00000000, 0x0003fffc}, /* FP_REGS */ \
603 {0x00000000, 0x00040000}, /* FLAGS */ \
604 {0x00000002, 0x00000000}, /* R1 */ \
605 {0x00000004, 0x00000000}, /* R2 */ \
606 {0x00000008, 0x00000000}, /* R3 */ \
607 {0x000005ff, 0x00000000}, /* SIBCALL_REGS */ \
608 {0x1fffffff, 0x00000000}, /* LOW_REGS */ \
609 {0xffffffff, 0x00180000}, /* GENERAL_REGS */ \
610 {0xffffffff, 0x001fffff}} /* ALL_REGS */
611
612 /* `REGNO_REG_CLASS (REGNO)'
613
614 A C expression whose value is a register class containing hard
615 register REGNO. In general there is more than one such class;
616 choose a class which is "minimal", meaning that no smaller class
617 also contains the register. */
618 #define REGNO_REG_CLASS(REGNO) \
619 ((REGNO) == MDB_REGNUM ? MDB : \
620 (REGNO) == MDC_REGNUM ? MDC : \
621 FP_REGISTER_P (REGNO) ? FP_REGS : \
622 (REGNO) == FLAGS_REGNUM ? FLAGS : \
623 (REGNO) == 1 ? R1 : \
624 (REGNO) == 2 ? R2 : \
625 (REGNO) == 3 ? R3 : \
626 (REGNO) <= 8 || (REGNO) == 10 ? SIBCALL_REGS : \
627 (REGNO) <= 28 ? LOW_REGS : \
628 GENERAL_REGS)
629
630 /* `BASE_REG_CLASS'
631
632 A macro whose definition is the name of the class to which a valid
633 base register must belong. A base register is one used in an
634 address which is the register value plus a displacement. */
635 #define BASE_REG_CLASS GENERAL_REGS
636
637 #define BASE_REGISTER_P(REGNO) \
638 (GP_REGISTER_P (REGNO) \
639 || (REGNO) == ARG_POINTER_REGNUM \
640 || (REGNO) == FRAME_POINTER_REGNUM)
641
642 /* `INDEX_REG_CLASS'
643
644 A macro whose definition is the name of the class to which a valid
645 index register must belong. An index register is one used in an
646 address where its value is either multiplied by a scale factor or
647 added to another register (as well as added to a displacement). */
648 #define INDEX_REG_CLASS NO_REGS
649
650 /* `REGNO_OK_FOR_BASE_P (NUM)'
651
652 A C expression which is nonzero if register number NUM is suitable
653 for use as a base register in operand addresses. It may be either
654 a suitable hard register or a pseudo register that has been
655 allocated such a hard register. */
656 #define REGNO_OK_FOR_BASE_P(REGNO) \
657 (BASE_REGISTER_P (REGNO) || BASE_REGISTER_P ((unsigned)reg_renumber[REGNO]))
658
659 /* `REGNO_OK_FOR_INDEX_P (NUM)'
660
661 A C expression which is nonzero if register number NUM is suitable
662 for use as an index register in operand addresses. It may be
663 either a suitable hard register or a pseudo register that has been
664 allocated such a hard register.
665
666 The difference between an index register and a base register is
667 that the index register may be scaled. If an address involves the
668 sum of two registers, neither one of them scaled, then either one
669 may be labeled the "base" and the other the "index"; but whichever
670 labeling is used must fit the machine's constraints of which
671 registers may serve in each capacity. The compiler will try both
672 labelings, looking for one that is valid, and will reload one or
673 both registers only if neither labeling works. */
674 #define REGNO_OK_FOR_INDEX_P(REGNO) 0
675
676 /* `PREFERRED_RELOAD_CLASS (X, CLASS)'
677
678 A C expression that places additional restrictions on the register
679 class to use when it is necessary to copy value X into a register
680 in class CLASS. The value is a register class; perhaps CLASS, or
681 perhaps another, smaller class.
682
683 Sometimes returning a more restrictive class makes better code.
684 For example, on the 68000, when X is an integer constant that is in
685 range for a `moveq' instruction, the value of this macro is always
686 `DATA_REGS' as long as CLASS includes the data registers.
687 Requiring a data register guarantees that a `moveq' will be used.
688
689 If X is a `const_double', by returning `NO_REGS' you can force X
690 into a memory constant. This is useful on certain machines where
691 immediate floating values cannot be loaded into certain kinds of
692 registers. */
693 #define PREFERRED_RELOAD_CLASS(X,CLASS) CLASS
694
695 #define CLASS_MAX_NREGS(CLASS, MODE) \
696 ((CLASS) == MDB ? \
697 ((GET_MODE_SIZE (MODE) + 2 * UNITS_PER_WORD - 1) / (2 * UNITS_PER_WORD)) \
698 : ((GET_MODE_SIZE (MODE) + UNITS_PER_WORD - 1) / UNITS_PER_WORD))
699
700 /* Stack Layout and Calling Conventions
701
702 Basic Stack Layout
703
704 `STACK_GROWS_DOWNWARD'
705 Define this macro if pushing a word onto the stack moves the stack
706 pointer to a smaller address. */
707 #define STACK_GROWS_DOWNWARD 1
708
709 /* `FIRST_PARM_OFFSET (FUNDECL)'
710
711 Offset from the argument pointer register to the first argument's
712 address. On some machines it may depend on the data type of the
713 function.
714
715 If `ARGS_GROW_DOWNWARD', this is the offset to the location above
716 the first argument's address. */
717 #define FIRST_PARM_OFFSET(FNDECL) 0
718
719 /* `DYNAMIC_CHAIN_ADDRESS (FRAMEADDR)'
720
721 A C expression whose value is RTL representing the address in a
722 stack frame where the pointer to the caller's frame is stored.
723 Assume that FRAMEADDR is an RTL expression for the address of the
724 stack frame itself.
725
726 If you don't define this macro, the default is to return the value
727 of FRAMEADDR--that is, the stack frame address is also the address
728 of the stack word that points to the previous frame. */
729 #define DYNAMIC_CHAIN_ADDRESS(FRAMEADDR) \
730 visium_dynamic_chain_address (FRAMEADDR)
731
732 /* `RETURN_ADDR_RTX (COUNT, FRAMEADDR)'
733
734 A C expression whose value is RTL representing the value of the
735 return address for the frame COUNT steps up from the current frame,
736 after the prologue. FRAMEADDR is the frame pointer of the COUNT
737 frame, or the frame pointer of the COUNT - 1 frame if
738 `RETURN_ADDR_IN_PREVIOUS_FRAME' is defined.
739
740 The value of the expression must always be the correct address when
741 COUNT is zero, but may be `NULL_RTX' if there is not way to
742 determine the return address of other frames. */
743 #define RETURN_ADDR_RTX(COUNT,FRAMEADDR) \
744 visium_return_addr_rtx (COUNT, FRAMEADDR)
745
746 /* Exception Handling
747
748 `EH_RETURN_DATA_REGNO'
749
750 A C expression whose value is the Nth register number used for data
751 by exception handlers or INVALID_REGNUM if fewer than N registers
752 are available.
753
754 The exception handling library routines communicate with the
755 exception handlers via a set of agreed upon registers. */
756 #define EH_RETURN_DATA_REGNO(N) ((N) < 4 ? (N) + 11 : INVALID_REGNUM)
757 #define EH_RETURN_STACKADJ_RTX gen_rtx_REG (SImode, 8)
758 #define EH_RETURN_HANDLER_RTX visium_eh_return_handler_rtx ()
759
760 /* Registers That Address the Stack Frame
761
762 This discusses registers that address the stack frame.
763
764 `STACK_POINTER_REGNUM'
765
766 The register number of the stack pointer register, which must also
767 be a fixed register according to `FIXED_REGISTERS'. On most
768 machines, the hardware determines which register this is. */
769 #define STACK_POINTER_REGNUM 23
770
771 /* `FRAME_POINTER_REGNUM'
772
773 The register number of the frame pointer register, which is used to
774 access automatic variables in the stack frame. On some machines,
775 the hardware determines which register this is. On other machines,
776 you can choose any register you wish for this purpose. */
777 #define FRAME_POINTER_REGNUM 52
778
779 /* `HARD_FRAME_POINTER_REGNUM'
780
781 On some machines the offset between the frame pointer and starting
782 offset of the automatic variables is not known until after register
783 allocation has been done (for example, because the saved registers
784 are between these two locations). On those machines, define
785 `FRAME_POINTER_REGNUM' the number of a special, fixed register to
786 be used internally until the offset is known, and define
787 `HARD_FRAME_POINTER_REGNUM' to be the actual hard register number
788 used for the frame pointer. */
789 #define HARD_FRAME_POINTER_REGNUM 22
790
791 /* `ARG_POINTER_REGNUM'
792
793 The register number of the arg pointer register, which is used to
794 access the function's argument list. On some machines, this is the
795 same as the frame pointer register. On some machines, the hardware
796 determines which register this is. On other machines, you can
797 choose any register you wish for this purpose. If this is not the
798 same register as the frame pointer register, then you must mark it
799 as a fixed register according to `FIXED_REGISTERS', or arrange to
800 be able to eliminate it (*note Elimination::.). */
801 #define ARG_POINTER_REGNUM 51
802
803 /* `STATIC_CHAIN_REGNUM'
804 `STATIC_CHAIN_INCOMING_REGNUM'
805
806 Register numbers used for passing a function's static chain
807 pointer. If register windows are used, the register number as seen
808 by the called function is `STATIC_CHAIN_INCOMING_REGNUM', while the
809 register number as seen by the calling function is
810 `STATIC_CHAIN_REGNUM'. If these registers are the same,
811 `STATIC_CHAIN_INCOMING_REGNUM' need not be defined.
812
813 The static chain register need not be a fixed register.
814
815 If the static chain is passed in memory, these macros should not be
816 defined; instead, the next two macros should be defined. */
817 #define STATIC_CHAIN_REGNUM 20
818
819 /* `ELIMINABLE_REGS'
820
821 If defined, this macro specifies a table of register pairs used to
822 eliminate unneeded registers that point into the stack frame. If
823 it is not defined, the only elimination attempted by the compiler
824 is to replace references to the frame pointer with references to
825 the stack pointer.
826
827 The definition of this macro is a list of structure
828 initializations, each of which specifies an original and
829 replacement register.
830
831 On some machines, the position of the argument pointer is not known
832 until the compilation is completed. In such a case, a separate
833 hard register must be used for the argument pointer. This register
834 can be eliminated by replacing it with either the frame pointer or
835 the argument pointer, depending on whether or not the frame pointer
836 has been eliminated.
837
838 Note that the elimination of the argument pointer with the stack
839 pointer is specified first since that is the preferred elimination. */
840 #define ELIMINABLE_REGS \
841 {{ ARG_POINTER_REGNUM, STACK_POINTER_REGNUM}, \
842 { ARG_POINTER_REGNUM, HARD_FRAME_POINTER_REGNUM}, \
843 { FRAME_POINTER_REGNUM, STACK_POINTER_REGNUM}, \
844 { FRAME_POINTER_REGNUM, HARD_FRAME_POINTER_REGNUM}}
845
846 /* `INITIAL_ELIMINATION_OFFSET (FROM-REG, TO-REG, OFFSET-VAR)'
847
848 This macro returns the initial difference between the specified pair
849 of registers. */
850 #define INITIAL_ELIMINATION_OFFSET(FROM, TO, OFFSET) \
851 (OFFSET = visium_initial_elimination_offset (FROM, TO))
852
853 /* Passing Function Arguments on the Stack
854
855 The macros in this section control how arguments are passed on the
856 stack. See the following section for other macros that control
857 passing certain arguments in registers.
858
859 Passing Arguments in Registers
860
861 This section describes the macros which let you control how various
862 types of arguments are passed in registers or how they are arranged
863 in the stack.
864
865 Define the general purpose, and floating point registers used for
866 passing arguments */
867 #define MAX_ARGS_IN_GP_REGISTERS 8
868 #define GP_ARG_FIRST 1
869 #define GP_ARG_LAST (GP_ARG_FIRST + MAX_ARGS_IN_GP_REGISTERS - 1)
870 #define MAX_ARGS_IN_FP_REGISTERS 8
871 #define FP_ARG_FIRST (FP_FIRST_REGNUM + 1)
872 #define FP_ARG_LAST (FP_ARG_FIRST + MAX_ARGS_IN_FP_REGISTERS - 1)
873
874 /* Define a data type for recording info about an argument list during the
875 processing of that argument list. */
876
877 struct visium_args
878 {
879 /* The count of general registers used */
880 int grcount;
881 /* The count of floating registers used */
882 int frcount;
883 /* The number of stack words used by named arguments */
884 int stack_words;
885 };
886
887 /* `CUMULATIVE_ARGS'
888
889 A C type for declaring a variable that is used as the first
890 argument of `FUNCTION_ARG' and other related values. For some
891 target machines, the type `int' suffices and can hold the number of
892 bytes of argument so far.
893
894 There is no need to record in `CUMULATIVE_ARGS' anything about the
895 arguments that have been passed on the stack. The compiler has
896 other variables to keep track of that. For target machines on
897 which all arguments are passed on the stack, there is no need to
898 store anything in `CUMULATIVE_ARGS'; however, the data structure
899 must exist and should not be empty, so use `int'. */
900 #define CUMULATIVE_ARGS struct visium_args
901
902 #define INIT_CUMULATIVE_ARGS(CUM,FNTYPE,LIBNAME,FNDECL,N_NAMED_ARGS) \
903 do { \
904 (CUM).grcount = 0; \
905 (CUM).frcount = 0; \
906 (CUM).stack_words = 0; \
907 } while (0)
908
909 /* `FUNCTION_ARG_REGNO_P (REGNO)'
910
911 A C expression that is nonzero if REGNO is the number of a hard
912 register in which function arguments are sometimes passed. This
913 does *not* include implicit arguments such as the static chain and
914 the structure-value address. On many machines, no registers can be
915 used for this purpose since all function arguments are pushed on
916 the stack. */
917 #define FUNCTION_ARG_REGNO_P(N) \
918 ((GP_ARG_FIRST <= (N) && (N) <= GP_ARG_LAST) \
919 || (TARGET_FPU && FP_ARG_FIRST <= (N) && (N) <= FP_ARG_LAST))
920
921 /* `FUNCTION_VALUE_REGNO_P (REGNO)'
922
923 A C expression that is nonzero if REGNO is the number of a hard
924 register in which the values of called function may come back.
925
926 A register whose use for returning values is limited to serving as
927 the second of a pair (for a value of type `double', say) need not
928 be recognized by this macro. If the machine has register windows,
929 so that the caller and the called function use different registers
930 for the return value, this macro should recognize only the caller's
931 register numbers. */
932 #define FUNCTION_VALUE_REGNO_P(N) \
933 ((N) == RETURN_REGNUM || (TARGET_FPU && (N) == FP_RETURN_REGNUM))
934
935 /* How Large Values Are Returned
936
937 When a function value's mode is `BLKmode' (and in some other
938 cases), the value is not returned according to `FUNCTION_VALUE'.
939 Instead, the caller passes the address of a block of memory in
940 which the value should be stored. This address is called the
941 "structure value address".
942
943 This section describes how to control returning structure values in
944 memory.
945
946 `DEFAULT_PCC_STRUCT_RETURN'
947
948 Define this macro to be 1 if all structure and union return values
949 must be in memory. Since this results in slower code, this should
950 be defined only if needed for compatibility with other compilers or
951 with an ABI. If you define this macro to be 0, then the
952 conventions used for structure and union return values are decided
953 by the `RETURN_IN_MEMORY' macro.
954
955 If not defined, this defaults to the value 1. */
956 #define DEFAULT_PCC_STRUCT_RETURN 0
957
958 /* Caller-Saves Register Allocation
959
960 If you enable it, GNU CC can save registers around function calls.
961 This makes it possible to use call-clobbered registers to hold
962 variables that must live across calls.
963
964 Function Entry and Exit
965
966 This section describes the macros that output function entry
967 ("prologue") and exit ("epilogue") code.
968
969 `EXIT_IGNORE_STACK'
970
971 Define this macro as a C expression that is nonzero if the return
972 instruction or the function epilogue ignores the value of the stack
973 pointer; in other words, if it is safe to delete an instruction to
974 adjust the stack pointer before a return from the function.
975
976 Note that this macro's value is relevant only for functions for
977 which frame pointers are maintained. It is never safe to delete a
978 final stack adjustment in a function that has no frame pointer, and
979 the compiler knows this regardless of `EXIT_IGNORE_STACK'. */
980 #define EXIT_IGNORE_STACK 1
981
982 /* `EPILOGUE_USES (REGNO)'
983
984 Define this macro as a C expression that is nonzero for registers
985 are used by the epilogue or the `return' pattern. The stack and
986 frame pointer registers are already be assumed to be used as
987 needed. */
988 #define EPILOGUE_USES(REGNO) visium_epilogue_uses (REGNO)
989
990 /* Generating Code for Profiling
991
992 These macros will help you generate code for profiling. */
993
994 #define PROFILE_HOOK(LABEL) visium_profile_hook ()
995 #define FUNCTION_PROFILER(FILE, LABELNO) do {} while (0)
996 #define NO_PROFILE_COUNTERS 1
997
998 /* Trampolines for Nested Functions
999
1000 A trampoline is a small piece of code that is created at run time
1001 when the address of a nested function is taken. It normally resides
1002 on the stack, in the stack frame of the containing function. These
1003 macros tell GCC how to generate code to allocate and initialize a
1004 trampoline.
1005
1006 The instructions in the trampoline must do two things: load a
1007 constant address into the static chain register, and jump to the
1008 real address of the nested function. On CISC machines such as the
1009 m68k, this requires two instructions, a move immediate and a
1010 jump. Then the two addresses exist in the trampoline as word-long
1011 immediate operands. On RISC machines, it is often necessary to load
1012 each address into a register in two parts. Then pieces of each
1013 address form separate immediate operands.
1014
1015 The code generated to initialize the trampoline must store the
1016 variable parts--the static chain value and the function
1017 address--into the immediate operands of the instructions. On a CISC
1018 machine, this is simply a matter of copying each address to a
1019 memory reference at the proper offset from the start of the
1020 trampoline. On a RISC machine, it may be necessary to take out
1021 pieces of the address and store them separately.
1022
1023 On the Visium, the trampoline is
1024
1025 moviu r9,%u FUNCTION
1026 movil r9,%l FUNCTION
1027 [nop]
1028 moviu r20,%u STATIC
1029 bra tr,r9,r0
1030 movil r20,%l STATIC
1031
1032 A difficulty is setting the correct instruction parity at run time.
1033
1034
1035 TRAMPOLINE_SIZE
1036 A C expression for the size in bytes of the trampoline, as an integer. */
1037 #define TRAMPOLINE_SIZE (visium_cpu == PROCESSOR_GR6 ? 24 : 20)
1038
1039 /* Alignment required for trampolines, in bits. */
1040 #define TRAMPOLINE_ALIGNMENT (visium_cpu == PROCESSOR_GR6 ? 64 : 32)
1041
1042 /* Implicit calls to library routines
1043
1044 Avoid calling library routines (sqrtf) just to set `errno' to EDOM */
1045 #define TARGET_EDOM 33
1046
1047 /* Addressing Modes
1048
1049 `MAX_REGS_PER_ADDRESS'
1050
1051 A number, the maximum number of registers that can appear in a
1052 valid memory address. Note that it is up to you to specify a value
1053 equal to the maximum number that `TARGET_LEGITIMATE_ADDRESS_P' would
1054 ever accept. */
1055 #define MAX_REGS_PER_ADDRESS 1
1056
1057 /* `LEGITIMIZE_RELOAD_ADDRESS (X, MODE, OPNUM, TYPE, IND_LEVELS, WIN)'
1058
1059 A C compound statement that attempts to replace X, which is an
1060 address that needs reloading, with a valid memory address for an
1061 operand of mode MODE. WIN will be a C statement label elsewhere
1062 in the code. It is not necessary to define this macro, but it
1063 might be useful for performance reasons. */
1064 #define LEGITIMIZE_RELOAD_ADDRESS(AD, MODE, OPNUM, TYPE, IND, WIN) \
1065 do \
1066 { \
1067 rtx new_x = visium_legitimize_reload_address ((AD), (MODE), (OPNUM), \
1068 (int) (TYPE), (IND)); \
1069 if (new_x) \
1070 { \
1071 (AD) = new_x; \
1072 goto WIN; \
1073 } \
1074 } while (0)
1075
1076 /* Given a comparison code (EQ, NE, etc.) and the operands of a COMPARE,
1077 return the mode to be used for the comparison. */
1078 #define SELECT_CC_MODE(OP,X,Y) visium_select_cc_mode ((OP), (X), (Y))
1079
1080 /* Return nonzero if MODE implies a floating point inequality can be
1081 reversed. For Visium this is always true because we have a full
1082 compliment of ordered and unordered comparisons, but until generic
1083 code knows how to reverse it correctly we keep the old definition. */
1084 #define REVERSIBLE_CC_MODE(MODE) ((MODE) != CCFPEmode && (MODE) != CCFPmode)
1085
1086 /* `BRANCH_COST'
1087
1088 A C expression for the cost of a branch instruction. A value of 1
1089 is the default; other values are interpreted relative to that. */
1090 #define BRANCH_COST(A,B) 10
1091
1092 /* Override BRANCH_COST heuristics for complex logical ops. */
1093 #define LOGICAL_OP_NON_SHORT_CIRCUIT 0
1094
1095 /* `SLOW_BYTE_ACCESS'
1096
1097 Define this macro as a C expression which is nonzero if accessing
1098 less than a word of memory (i.e. a `char' or a `short') is no
1099 faster than accessing a word of memory, i.e., if such access
1100 require more than one instruction or if there is no difference in
1101 cost between byte and (aligned) word loads.
1102
1103 When this macro is not defined, the compiler will access a field by
1104 finding the smallest containing object; when it is defined, a
1105 fullword load will be used if alignment permits. Unless bytes
1106 accesses are faster than word accesses, using word accesses is
1107 preferable since it may eliminate subsequent memory access if
1108 subsequent accesses occur to other fields in the same word of the
1109 structure, but to different bytes. */
1110 #define SLOW_BYTE_ACCESS 0
1111
1112 /* `MOVE_RATIO (SPEED)`
1113
1114 The threshold of number of scalar memory-to-memory move insns,
1115 _below_ which a sequence of insns should be generated instead of a
1116 string move insn or a library call. Increasing the value will
1117 always make code faster, but eventually incurs high cost in
1118 increased code size.
1119
1120 Since we have a cpymemsi pattern, the default MOVE_RATIO is 2, which
1121 is too low given that cpymemsi will invoke a libcall. */
1122 #define MOVE_RATIO(speed) ((speed) ? 9 : 3)
1123
1124 /* `CLEAR_RATIO (SPEED)`
1125
1126 The threshold of number of scalar move insns, _below_ which a
1127 sequence of insns should be generated to clear memory instead of a
1128 string clear insn or a library call. Increasing the value will
1129 always make code faster, but eventually incurs high cost in
1130 increased code size.
1131
1132 Since we have a setmemsi pattern, the default CLEAR_RATIO is 2, which
1133 is too low given that setmemsi will invoke a libcall. */
1134 #define CLEAR_RATIO(speed) ((speed) ? 13 : 5)
1135
1136 /* `MOVE_MAX'
1137
1138 The maximum number of bytes that a single instruction can move
1139 quickly between memory and registers or between two memory
1140 locations. */
1141 #define MOVE_MAX 4
1142
1143 /* `MAX_MOVE_MAX'
1144
1145 The maximum number of bytes that a single instruction can move
1146 quickly between memory and registers or between two memory
1147 locations. If this is undefined, the default is `MOVE_MAX'.
1148 Otherwise, it is the constant value that is the largest value that
1149 `MOVE_MAX' can have at run-time. */
1150 #define MAX_MOVE_MAX 4
1151
1152 /* `SHIFT_COUNT_TRUNCATED'
1153
1154 A C expression that is nonzero if on this machine the number of
1155 bits actually used for the count of a shift operation is equal to
1156 the number of bits needed to represent the size of the object being
1157 shifted. When this macro is non-zero, the compiler will assume
1158 that it is safe to omit a sign-extend, zero-extend, and certain
1159 bitwise `and' instructions that truncates the count of a shift
1160 operation. On machines that have instructions that act on
1161 bitfields at variable positions, which may include `bit test'
1162 instructions, a nonzero `SHIFT_COUNT_TRUNCATED' also enables
1163 deletion of truncations of the values that serve as arguments to
1164 bitfield instructions. */
1165 #define SHIFT_COUNT_TRUNCATED 0
1166
1167 /* `STORE_FLAG_VALUE'
1168
1169 A C expression describing the value returned by a comparison
1170 operator with an integral mode and stored by a store-flag
1171 instruction (`sCOND') when the condition is true. This description
1172 must apply to *all* the `sCOND' patterns and all the comparison
1173 operators whose results have a `MODE_INT' mode. */
1174 #define STORE_FLAG_VALUE 1
1175
1176 /* `Pmode'
1177
1178 An alias for the machine mode for pointers. On most machines,
1179 define this to be the integer mode corresponding to the width of a
1180 hardware pointer; `SImode' on 32-bit machine or `DImode' on 64-bit
1181 machines. On some machines you must define this to be one of the
1182 partial integer modes, such as `PSImode'.
1183
1184 The width of `Pmode' must be at least as large as the value of
1185 `POINTER_SIZE'. If it is not equal, you must define the macro
1186 `POINTERS_EXTEND_UNSIGNED' to specify how pointers are extended to
1187 `Pmode'. */
1188 #define Pmode SImode
1189
1190 /* `FUNCTION_MODE'
1191
1192 An alias for the machine mode used for memory references to
1193 functions being called, in `call' RTL expressions. On most
1194 machines this should be `QImode'. */
1195 #define FUNCTION_MODE SImode
1196
1197 /* Dividing the Output into Sections (Texts, Data, ...)
1198
1199 An object file is divided into sections containing different types
1200 of data. In the most common case, there are three sections: the
1201 "text section", which holds instructions and read-only data; the
1202 "data section", which holds initialized writable data; and the "bss
1203 section", which holds uninitialized data. Some systems have other
1204 kinds of sections.
1205
1206 `TEXT_SECTION_ASM_OP'
1207
1208 A C expression whose value is a string containing the assembler
1209 operation that should precede instructions and read-only data.
1210 Normally `".text"' is right. */
1211 #define TEXT_SECTION_ASM_OP "\t.text"
1212
1213 /* `DATA_SECTION_ASM_OP'
1214
1215 A C expression whose value is a string containing the assembler
1216 operation to identify the following data as writable initialized
1217 data. Normally `".data"' is right. */
1218 #define DATA_SECTION_ASM_OP "\t.data"
1219
1220 /* `BSS_SECTION_ASM_OP'
1221
1222 If defined, a C expression whose value is a string containing the
1223 assembler operation to identify the following data as uninitialized
1224 global data. If not defined, and neither `ASM_OUTPUT_BSS' nor
1225 `ASM_OUTPUT_ALIGNED_BSS' are defined, uninitialized global data
1226 will be output in the data section if `-fno-common' is passed,
1227 otherwise `ASM_OUTPUT_COMMON' will be used.
1228
1229 `EXTRA_SECTIONS'
1230
1231 A list of names for sections other than the standard two, which are
1232 `in_text' and `in_data'. You need not define this macro on a
1233 system with no other sections (that GCC needs to use).
1234
1235 `EXTRA_SECTION_FUNCTIONS'
1236
1237 One or more functions to be defined in `varasm.cc'. These functions
1238 should do jobs analogous to those of `text_section' and
1239 `data_section', for your additional sections. Do not define this
1240 macro if you do not define `EXTRA_SECTIONS'.
1241
1242 `JUMP_TABLES_IN_TEXT_SECTION' Define this macro if jump tables (for
1243 `tablejump' insns) should be output in the text section, along with
1244 the assembler instructions. Otherwise, the readonly data section
1245 is used.
1246
1247 This macro is irrelevant if there is no separate readonly data
1248 section. */
1249 #undef JUMP_TABLES_IN_TEXT_SECTION
1250
1251
1252 /* The Overall Framework of an Assembler File
1253
1254 This describes the overall framework of an assembler file.
1255
1256 `ASM_COMMENT_START'
1257
1258 A C string constant describing how to begin a comment in the target
1259 assembler language. The compiler assumes that the comment will end
1260 at the end of the line. */
1261 #define ASM_COMMENT_START ";"
1262
1263 /* `ASM_APP_ON'
1264
1265 A C string constant for text to be output before each `asm'
1266 statement or group of consecutive ones. Normally this is `"#APP"',
1267 which is a comment that has no effect on most assemblers but tells
1268 the GNU assembler that it must check the lines that follow for all
1269 valid assembler constructs. */
1270 #define ASM_APP_ON "#APP\n"
1271
1272 /* `ASM_APP_OFF'
1273
1274 A C string constant for text to be output after each `asm'
1275 statement or group of consecutive ones. Normally this is
1276 `"#NO_APP"', which tells the GNU assembler to resume making the
1277 time-saving assumptions that are valid for ordinary compiler
1278 output. */
1279 #define ASM_APP_OFF "#NO_APP\n"
1280
1281 /* Output of Data
1282
1283 This describes data output.
1284
1285 Output and Generation of Labels
1286
1287 This is about outputting labels.
1288
1289 `ASM_OUTPUT_LABEL (STREAM, NAME)'
1290
1291 A C statement (sans semicolon) to output to the stdio stream STREAM
1292 the assembler definition of a label named NAME. Use the expression
1293 `assemble_name (STREAM, NAME)' to output the name itself; before
1294 and after that, output the additional assembler syntax for defining
1295 the name, and a newline. */
1296 #define ASM_OUTPUT_LABEL(STREAM,NAME) \
1297 do { assemble_name (STREAM, NAME); fputs (":\n", STREAM); } while (0)
1298
1299 /* Globalizing directive for a label */
1300 #define GLOBAL_ASM_OP "\t.global "
1301
1302 /* `ASM_OUTPUT_LABELREF (STREAM, NAME)'
1303
1304 A C statement (sans semicolon) to output to the stdio stream STREAM
1305 a reference in assembler syntax to a label named NAME. This should
1306 add `_' to the front of the name, if that is customary on your
1307 operating system, as it is in most Berkeley Unix systems. This
1308 macro is used in `assemble_name'. */
1309 #define ASM_OUTPUT_LABELREF(STREAM,NAME) \
1310 asm_fprintf (STREAM, "%U%s", NAME)
1311
1312 /* Output of Assembler Instructions
1313
1314 This describes assembler instruction output.
1315
1316 `REGISTER_NAMES'
1317
1318 A C initializer containing the assembler's names for the machine
1319 registers, each one as a C string constant. This is what
1320 translates register numbers in the compiler into assembler
1321 language. */
1322 #define REGISTER_NAMES \
1323 {"r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7", \
1324 "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15", \
1325 "r16", "r17", "r18", "r19", "r20", "r21", "fp", "sp", \
1326 "r24", "r25", "r26", "r27", "r28", "r29", "r30", "r31", \
1327 "mdb", "mdc", \
1328 "f0", "f1", "f2", "f3", "f4", "f5", "f6", "f7", \
1329 "f8", "f9", "f10", "f11", "f12", "f13", "f14", "f15", \
1330 "flags","argp","sfp" }
1331
1332 /* `ADDITIONAL_REGISTER_NAMES`
1333
1334 If defined, a C initializer for an array of structures containing
1335 a name and a register number. This macro defines additional names
1336 for hard registers, thus allowing the `asm' option in declarations
1337 to refer to registers using alternate names. */
1338 #define ADDITIONAL_REGISTER_NAMES \
1339 {{"r22", HARD_FRAME_POINTER_REGNUM}, {"r23", STACK_POINTER_REGNUM}}
1340
1341 /* `REGISTER_PREFIX'
1342 `LOCAL_LABEL_PREFIX'
1343 `USER_LABEL_PREFIX'
1344 `IMMEDIATE_PREFIX'
1345
1346 If defined, C string expressions to be used for the `%R', `%L',
1347 `%U', and `%I' options of `asm_fprintf' (see `final.cc'). These are
1348 useful when a single `md' file must support multiple assembler
1349 formats. In that case, the various `tm.h' files can define these
1350 macros differently. */
1351 #define REGISTER_PREFIX ""
1352 #define LOCAL_LABEL_PREFIX "."
1353 #define IMMEDIATE_PREFIX "#"
1354
1355 /* `ASM_OUTPUT_REG_PUSH (STREAM, REGNO)'
1356
1357 A C expression to output to STREAM some assembler code which will
1358 push hard register number REGNO onto the stack. The code need not
1359 be optimal, since this macro is used only when profiling. */
1360 #define ASM_OUTPUT_REG_PUSH(STREAM,REGNO) \
1361 asm_fprintf (STREAM, "\tsubi sp,4\n\twrite.l (sp),%s\n", \
1362 reg_names[REGNO])
1363
1364 /* `ASM_OUTPUT_REG_POP (STREAM, REGNO)'
1365
1366 A C expression to output to STREAM some assembler code which will
1367 pop hard register number REGNO off of the stack. The code need not
1368 be optimal, since this macro is used only when profiling. */
1369 #define ASM_OUTPUT_REG_POP(STREAM,REGNO) \
1370 asm_fprintf (STREAM, "\tread.l %s,(sp)\n\taddi sp,4\n", \
1371 reg_names[REGNO])
1372
1373
1374 /* Output of Dispatch Tables
1375
1376 This concerns dispatch tables.
1377
1378 `ASM_OUTPUT_ADDR_DIFF_ELT (STREAM, VALUE, REL)'
1379
1380 A C statement to output to the stdio stream STREAM an assembler
1381 pseudo-instruction to generate a difference between two labels.
1382 VALUE and REL are the numbers of two internal labels. The
1383 definitions of these labels are output using
1384 `ASM_OUTPUT_INTERNAL_LABEL', and they must be printed in the same
1385 way here.
1386
1387 You must provide this macro on machines where the addresses in a
1388 dispatch table are relative to the table's own address. If
1389 defined, GNU CC will also use this macro on all machines when
1390 producing PIC. */
1391 #define ASM_OUTPUT_ADDR_DIFF_ELT(STREAM,BODY,VALUE,REL) \
1392 switch (GET_MODE (BODY)) \
1393 { \
1394 case E_SImode: \
1395 asm_fprintf ((STREAM), "\t.long\t%LL%d-%LL%d\n", (VALUE),(REL)); \
1396 break; \
1397 case E_HImode: \
1398 asm_fprintf ((STREAM), "\t.word\t%LL%d-%LL%d\n", (VALUE),(REL)); \
1399 break; \
1400 case E_QImode: \
1401 asm_fprintf ((STREAM), "\t.byte\t%LL%d-%LL%d\n", (VALUE),(REL)); \
1402 break; \
1403 default: \
1404 break; \
1405 }
1406
1407 /* `ASM_OUTPUT_ADDR_VEC_ELT (STREAM, VALUE)'
1408
1409 This macro should be provided on machines where the addresses in a
1410 dispatch table are absolute.
1411
1412 The definition should be a C statement to output to the stdio
1413 stream STREAM an assembler pseudo-instruction to generate a
1414 reference to a label. VALUE is the number of an internal label
1415 whose definition is output using `ASM_OUTPUT_INTERNAL_LABEL'. */
1416 #define ASM_OUTPUT_ADDR_VEC_ELT(STREAM, VALUE) \
1417 asm_fprintf (STREAM, "\t.long %LL%d\n", VALUE)
1418
1419 /* `ASM_OUTPUT_CASE_END (STREAM, NUM, TABLE)'
1420
1421 Define this if something special must be output at the end of a
1422 jump-table. The definition should be a C statement to be executed
1423 after the assembler code for the table is written. It should write
1424 the appropriate code to stdio stream STREAM. The argument TABLE is
1425 the jump-table insn, and NUM is the label-number of the preceding
1426 label.
1427
1428 If this macro is not defined, nothing special is output at the end
1429 of a jump table.
1430
1431 Here we output a word of zero so that jump-tables can be seperated
1432 in reverse assembly. */
1433 #define ASM_OUTPUT_CASE_END(STREAM, NUM, TABLE) \
1434 asm_fprintf (STREAM, "\t.long 0\n")
1435
1436 /* Support subalignment values. */
1437
1438 #define SUBALIGN_LOG 3
1439
1440 /* Assembler Commands for Alignment
1441
1442 This describes commands for alignment.
1443
1444 `ASM_OUTPUT_ALIGN_CODE (STREAM)'
1445
1446 A C expression to output text to align the location counter in the
1447 way that is desirable at a point in the code that is reached only
1448 by jumping.
1449
1450 This macro need not be defined if you don't want any special
1451 alignment to be done at such a time. Most machine descriptions do
1452 not currently define the macro. */
1453 #undef ASM_OUTPUT_ALIGN_CODE
1454
1455 /* `ASM_OUTPUT_LOOP_ALIGN (STREAM)'
1456
1457 A C expression to output text to align the location counter in the
1458 way that is desirable at the beginning of a loop.
1459
1460 This macro need not be defined if you don't want any special
1461 alignment to be done at such a time. Most machine descriptions do
1462 not currently define the macro. */
1463 #undef ASM_OUTPUT_LOOP_ALIGN
1464
1465 /* `ASM_OUTPUT_ALIGN (STREAM, POWER)'
1466
1467 A C statement to output to the stdio stream STREAM an assembler
1468 command to advance the location counter to a multiple of 2 to the
1469 POWER bytes. POWER will be a C expression of type `int'. */
1470 #define ASM_OUTPUT_ALIGN(STREAM,LOG) \
1471 if ((LOG) != 0) \
1472 fprintf (STREAM, "\t.align %d\n", (1 << (LOG)))
1473
1474 /* `ASM_OUTPUT_MAX_SKIP_ALIGN (STREAM, POWER, MAX_SKIP)`
1475
1476 A C statement to output to the stdio stream STREAM an assembler
1477 command to advance the location counter to a multiple of 2 to the
1478 POWER bytes, but only if MAX_SKIP or fewer bytes are needed to
1479 satisfy the alignment request. POWER and MAX_SKIP will be a C
1480 expression of type `int'. */
1481 #define ASM_OUTPUT_MAX_SKIP_ALIGN(STREAM,LOG,MAX_SKIP) \
1482 if ((LOG) != 0) { \
1483 if ((MAX_SKIP) == 0 || (MAX_SKIP) >= (1 << (LOG)) - 1) \
1484 fprintf ((STREAM), "\t.p2align %d\n", (LOG)); \
1485 else \
1486 fprintf ((STREAM), "\t.p2align %d,,%d\n", (LOG), (MAX_SKIP)); \
1487 }
1488
1489 /* Controlling Debugging Information Format
1490
1491 This describes how to specify debugging information.
1492
1493 mda is known to GDB, but not to GCC. */
1494 #define DEBUGGER_REGNO(REGNO) \
1495 ((REGNO) > MDB_REGNUM ? (REGNO) + 1 : (REGNO))
1496
1497 /* `DEBUGGER_AUTO_OFFSET (X)'
1498
1499 A C expression that returns the integer offset value for an
1500 automatic variable having address X (an RTL expression). The
1501 default computation assumes that X is based on the frame-pointer
1502 and gives the offset from the frame-pointer. This is required for
1503 targets that produce debugging output for debugger and allow the frame-pointer
1504 to be eliminated when the `-g' options is used. */
1505 #define DEBUGGER_AUTO_OFFSET(X) \
1506 (GET_CODE (X) == PLUS ? INTVAL (XEXP (X, 1)) : 0)
1507
1508 /* Miscellaneous Parameters
1509
1510 `CASE_VECTOR_MODE'
1511
1512 An alias for a machine mode name. This is the machine mode that
1513 elements of a jump-table should have. */
1514 #define CASE_VECTOR_MODE SImode
1515
1516 /* `CASE_VECTOR_PC_RELATIVE'
1517 Define this macro if jump-tables should contain relative addresses. */
1518 #undef CASE_VECTOR_PC_RELATIVE
1519
1520 /* This says how to output assembler code to declare an
1521 unitialised external linkage data object. */
1522 #define ASM_OUTPUT_COMMON(STREAM, NAME, SIZE, ROUNDED) \
1523 ( fputs ("\n\t.comm ", (STREAM)), \
1524 assemble_name ((STREAM), (NAME)), \
1525 fprintf ((STREAM), "," HOST_WIDE_INT_PRINT_UNSIGNED"\n", ROUNDED))
1526
1527 /* This says how to output assembler code to declare an
1528 unitialised internal linkage data object. */
1529 #define ASM_OUTPUT_LOCAL(STREAM, NAME, SIZE, ROUNDED) \
1530 ( fputs ("\n\t.lcomm ", (STREAM)), \
1531 assemble_name ((STREAM), (NAME)), \
1532 fprintf ((STREAM), "," HOST_WIDE_INT_PRINT_UNSIGNED"\n", ROUNDED))
1533
1534 /* Prettify the assembly. */
1535 extern int visium_indent_opcode;
1536
1537 #define ASM_OUTPUT_OPCODE(FILE, PTR) \
1538 do { \
1539 if (visium_indent_opcode) \
1540 { \
1541 putc (' ', FILE); \
1542 visium_indent_opcode = 0; \
1543 } \
1544 } while (0)
1545
1546 /* Configure-time default values for common options. */
1547 #define OPTION_DEFAULT_SPECS { "cpu", "%{!mcpu=*:-mcpu=%(VALUE)}" }
1548
1549 /* Values of TARGET_CPU_DEFAULT specified via --with-cpu. */
1550 #define TARGET_CPU_gr5 0
1551 #define TARGET_CPU_gr6 1
1552
1553 /* Default -mcpu multilib for above values. */
1554 #if TARGET_CPU_DEFAULT == TARGET_CPU_gr5
1555 #define MULTILIB_DEFAULTS { "mcpu=gr5" }
1556 #elif TARGET_CPU_DEFAULT == TARGET_CPU_gr6
1557 #define MULTILIB_DEFAULTS { "mcpu=gr6" }
1558 #else
1559 #error Unrecognized value in TARGET_CPU_DEFAULT
1560 #endif