]>
Commit | Line | Data |
---|---|---|
0969ec7d | 1 | /* Definitions of target machine for Visium. |
cbe34bb5 | 2 | Copyright (C) 2002-2017 Free Software Foundation, Inc. |
0969ec7d EB |
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 */ | |
a76ffff1 EB |
32 | #define LIB_SPEC \ |
33 | "--start-group -lc %{msim:-lsim; mdebug:-ldebug; :-lserial} --end-group" | |
0969ec7d EB |
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 | ||
0969ec7d EB |
576 | /* `MODES_TIEABLE_P (MODE1, MODE2)' |
577 | ||
578 | A C expression that is nonzero if a value of mode MODE1 is | |
579 | accessible in mode MODE2 without copying. | |
580 | ||
f939c3e6 RS |
581 | If `TARGET_HARD_REGNO_MODE_OK (R, MODE1)' and |
582 | `TARGET_HARD_REGNO_MODE_OK (R, MODE2)' are always the same for any R, | |
583 | then `MODES_TIEABLE_P (MODE1, MODE2)' should be nonzero. If they | |
584 | differ for any R, you should define this macro to return zero unless | |
585 | some other mechanism ensures the accessibility of the value in a | |
586 | narrower mode. | |
0969ec7d EB |
587 | |
588 | You should define this macro to return nonzero in as many cases as | |
589 | possible since doing so will allow GNU CC to perform better | |
590 | register allocation. */ | |
591 | #define MODES_TIEABLE_P(MODE1, MODE2) \ | |
592 | ((GET_MODE_CLASS (MODE1) == MODE_INT) \ | |
593 | && (GET_MODE_CLASS (MODE2) == MODE_INT)) | |
594 | ||
595 | /* Register Classes | |
596 | ||
597 | On many machines, the numbered registers are not all equivalent. | |
598 | For example, certain registers may not be allowed for indexed | |
599 | addressing; certain registers may not be allowed in some | |
600 | instructions. These machine restrictions are described to the | |
601 | compiler using "register classes". | |
602 | ||
603 | `enum reg_class' | |
604 | ||
605 | An enumeral type that must be defined with all the register class | |
606 | names as enumeral values. `NO_REGS' must be first. `ALL_REGS' | |
607 | must be the last register class, followed by one more enumeral | |
608 | value, `LIM_REG_CLASSES', which is not a register class but rather | |
609 | tells how many classes there are. | |
610 | ||
611 | Each register class has a number, which is the value of casting the | |
612 | class name to type `int'. The number serves as an index in many of | |
613 | the tables described below. */ | |
614 | ||
615 | enum reg_class | |
616 | { | |
617 | NO_REGS, | |
618 | MDB, | |
619 | MDC, | |
620 | FP_REGS, | |
621 | FLAGS, | |
622 | R1, | |
623 | R2, | |
624 | R3, | |
625 | SIBCALL_REGS, | |
626 | LOW_REGS, | |
627 | GENERAL_REGS, | |
628 | ALL_REGS, | |
629 | LIM_REG_CLASSES | |
630 | }; | |
631 | ||
632 | /* `N_REG_CLASSES' | |
633 | ||
634 | The number of distinct register classes, defined as follows. */ | |
635 | #define N_REG_CLASSES (int) LIM_REG_CLASSES | |
636 | ||
637 | /* `REG_CLASS_NAMES' | |
638 | ||
639 | An initializer containing the names of the register classes as C | |
640 | string constants. These names are used in writing some of the | |
641 | debugging dumps. */ | |
642 | #define REG_CLASS_NAMES \ | |
643 | {"NO_REGS", "MDB", "MDC", "FP_REGS", "FLAGS", "R1", "R2", "R3", \ | |
644 | "SIBCALL_REGS", "LOW_REGS", "GENERAL_REGS", "ALL_REGS"} | |
645 | ||
646 | /* `REG_CLASS_CONTENTS' | |
647 | ||
648 | An initializer containing the contents of the register classes, as | |
649 | integers which are bit masks. The Nth integer specifies the | |
650 | contents of class N. The way the integer MASK is interpreted is | |
651 | that register R is in the class if `MASK & (1 << R)' is 1. | |
652 | ||
653 | When the machine has more than 32 registers, an integer does not | |
654 | suffice. Then the integers are replaced by sub-initializers, | |
655 | braced groupings containing several integers. Each sub-initializer | |
656 | must be suitable as an initializer for the type `HARD_REG_SET' | |
657 | which is defined in `hard-reg-set.h'. */ | |
658 | #define REG_CLASS_CONTENTS { \ | |
659 | {0x00000000, 0x00000000}, /* NO_REGS */ \ | |
660 | {0x00000000, 0x00000001}, /* MDB */ \ | |
661 | {0x00000000, 0x00000002}, /* MDC */ \ | |
662 | {0x00000000, 0x0003fffc}, /* FP_REGS */ \ | |
663 | {0x00000000, 0x00040000}, /* FLAGS */ \ | |
664 | {0x00000002, 0x00000000}, /* R1 */ \ | |
665 | {0x00000004, 0x00000000}, /* R2 */ \ | |
666 | {0x00000008, 0x00000000}, /* R3 */ \ | |
667 | {0x000005ff, 0x00000000}, /* SIBCALL_REGS */ \ | |
668 | {0x1fffffff, 0x00000000}, /* LOW_REGS */ \ | |
669 | {0xffffffff, 0x00180000}, /* GENERAL_REGS */ \ | |
670 | {0xffffffff, 0x001fffff}} /* ALL_REGS */ | |
671 | ||
672 | /* `REGNO_REG_CLASS (REGNO)' | |
673 | ||
674 | A C expression whose value is a register class containing hard | |
675 | register REGNO. In general there is more than one such class; | |
676 | choose a class which is "minimal", meaning that no smaller class | |
677 | also contains the register. */ | |
678 | #define REGNO_REG_CLASS(REGNO) \ | |
679 | ((REGNO) == MDB_REGNUM ? MDB : \ | |
680 | (REGNO) == MDC_REGNUM ? MDC : \ | |
681 | FP_REGISTER_P (REGNO) ? FP_REGS : \ | |
682 | (REGNO) == FLAGS_REGNUM ? FLAGS : \ | |
683 | (REGNO) == 1 ? R1 : \ | |
684 | (REGNO) == 2 ? R2 : \ | |
685 | (REGNO) == 3 ? R3 : \ | |
686 | (REGNO) <= 8 || (REGNO) == 10 ? SIBCALL_REGS : \ | |
687 | (REGNO) <= 28 ? LOW_REGS : \ | |
688 | GENERAL_REGS) | |
689 | ||
690 | /* `BASE_REG_CLASS' | |
691 | ||
692 | A macro whose definition is the name of the class to which a valid | |
693 | base register must belong. A base register is one used in an | |
694 | address which is the register value plus a displacement. */ | |
695 | #define BASE_REG_CLASS GENERAL_REGS | |
696 | ||
697 | #define BASE_REGISTER_P(REGNO) \ | |
698 | (GP_REGISTER_P (REGNO) \ | |
699 | || (REGNO) == ARG_POINTER_REGNUM \ | |
700 | || (REGNO) == FRAME_POINTER_REGNUM) | |
701 | ||
702 | /* `INDEX_REG_CLASS' | |
703 | ||
704 | A macro whose definition is the name of the class to which a valid | |
705 | index register must belong. An index register is one used in an | |
706 | address where its value is either multiplied by a scale factor or | |
707 | added to another register (as well as added to a displacement). */ | |
708 | #define INDEX_REG_CLASS NO_REGS | |
709 | ||
710 | /* `REGNO_OK_FOR_BASE_P (NUM)' | |
711 | ||
712 | A C expression which is nonzero if register number NUM is suitable | |
713 | for use as a base register in operand addresses. It may be either | |
714 | a suitable hard register or a pseudo register that has been | |
715 | allocated such a hard register. */ | |
716 | #define REGNO_OK_FOR_BASE_P(REGNO) \ | |
717 | (BASE_REGISTER_P (REGNO) || BASE_REGISTER_P ((unsigned)reg_renumber[REGNO])) | |
718 | ||
719 | /* `REGNO_OK_FOR_INDEX_P (NUM)' | |
720 | ||
721 | A C expression which is nonzero if register number NUM is suitable | |
722 | for use as an index register in operand addresses. It may be | |
723 | either a suitable hard register or a pseudo register that has been | |
724 | allocated such a hard register. | |
725 | ||
726 | The difference between an index register and a base register is | |
727 | that the index register may be scaled. If an address involves the | |
728 | sum of two registers, neither one of them scaled, then either one | |
729 | may be labeled the "base" and the other the "index"; but whichever | |
730 | labeling is used must fit the machine's constraints of which | |
731 | registers may serve in each capacity. The compiler will try both | |
732 | labelings, looking for one that is valid, and will reload one or | |
733 | both registers only if neither labeling works. */ | |
734 | #define REGNO_OK_FOR_INDEX_P(REGNO) 0 | |
735 | ||
736 | /* `PREFERRED_RELOAD_CLASS (X, CLASS)' | |
737 | ||
738 | A C expression that places additional restrictions on the register | |
739 | class to use when it is necessary to copy value X into a register | |
740 | in class CLASS. The value is a register class; perhaps CLASS, or | |
741 | perhaps another, smaller class. | |
742 | ||
743 | Sometimes returning a more restrictive class makes better code. | |
744 | For example, on the 68000, when X is an integer constant that is in | |
745 | range for a `moveq' instruction, the value of this macro is always | |
746 | `DATA_REGS' as long as CLASS includes the data registers. | |
747 | Requiring a data register guarantees that a `moveq' will be used. | |
748 | ||
749 | If X is a `const_double', by returning `NO_REGS' you can force X | |
750 | into a memory constant. This is useful on certain machines where | |
751 | immediate floating values cannot be loaded into certain kinds of | |
752 | registers. */ | |
753 | #define PREFERRED_RELOAD_CLASS(X,CLASS) CLASS | |
754 | ||
755 | /* `CANNOT_CHANGE_MODE_CLASS (from, to, class) | |
756 | ||
757 | If defined, a C expression that returns nonzero for a `class' for | |
758 | which a change from mode `from' to mode `to' is invalid. | |
759 | ||
760 | It's not obvious from the above that MDB cannot change mode. However | |
761 | difficulties arise from expressions of the form | |
762 | ||
763 | (subreg:SI (reg:DI R_MDB) 0) | |
764 | ||
765 | There is no way to convert that reference to a single machine | |
766 | register and, without the following definition, reload will quietly | |
767 | convert it to | |
768 | ||
769 | (reg:SI R_MDB) */ | |
770 | #define CANNOT_CHANGE_MODE_CLASS(FROM,TO,CLASS) \ | |
771 | (CLASS == MDB ? (GET_MODE_SIZE (FROM) != GET_MODE_SIZE (TO)) : 0) | |
772 | ||
773 | /* `CLASS_MAX_NREGS (CLASS, MODE)' | |
774 | ||
775 | A C expression for the maximum number of consecutive registers of | |
776 | class CLASS needed to hold a value of mode MODE. | |
777 | ||
778 | This is closely related to the macro `HARD_REGNO_NREGS'. In fact, | |
779 | the value of the macro `CLASS_MAX_NREGS (CLASS, MODE)' should be | |
780 | the maximum value of `HARD_REGNO_NREGS (REGNO, MODE)' for all REGNO | |
781 | values in the class CLASS. | |
782 | ||
783 | This macro helps control the handling of multiple-word values in | |
784 | the reload pass. */ | |
785 | #define CLASS_MAX_NREGS(CLASS, MODE) \ | |
786 | ((CLASS) == MDB ? \ | |
787 | ((GET_MODE_SIZE (MODE) + 2 * UNITS_PER_WORD - 1) / (2 * UNITS_PER_WORD)) \ | |
788 | : ((GET_MODE_SIZE (MODE) + UNITS_PER_WORD - 1) / UNITS_PER_WORD)) | |
789 | ||
790 | /* Stack Layout and Calling Conventions | |
791 | ||
792 | Basic Stack Layout | |
793 | ||
794 | `STACK_GROWS_DOWNWARD' | |
795 | Define this macro if pushing a word onto the stack moves the stack | |
796 | pointer to a smaller address. */ | |
797 | #define STACK_GROWS_DOWNWARD 1 | |
798 | ||
799 | /* `STARTING_FRAME_OFFSET' | |
800 | ||
801 | Offset from the frame pointer to the first local variable slot to | |
802 | be allocated. | |
803 | ||
804 | If `FRAME_GROWS_DOWNWARD', find the next slot's offset by | |
805 | subtracting the first slot's length from `STARTING_FRAME_OFFSET'. | |
806 | Otherwise, it is found by adding the length of the first slot to | |
807 | the value `STARTING_FRAME_OFFSET'. */ | |
808 | #define STARTING_FRAME_OFFSET 0 | |
809 | ||
810 | /* `FIRST_PARM_OFFSET (FUNDECL)' | |
811 | ||
812 | Offset from the argument pointer register to the first argument's | |
813 | address. On some machines it may depend on the data type of the | |
814 | function. | |
815 | ||
816 | If `ARGS_GROW_DOWNWARD', this is the offset to the location above | |
817 | the first argument's address. */ | |
818 | #define FIRST_PARM_OFFSET(FNDECL) 0 | |
819 | ||
820 | /* `DYNAMIC_CHAIN_ADDRESS (FRAMEADDR)' | |
821 | ||
822 | A C expression whose value is RTL representing the address in a | |
823 | stack frame where the pointer to the caller's frame is stored. | |
824 | Assume that FRAMEADDR is an RTL expression for the address of the | |
825 | stack frame itself. | |
826 | ||
827 | If you don't define this macro, the default is to return the value | |
828 | of FRAMEADDR--that is, the stack frame address is also the address | |
829 | of the stack word that points to the previous frame. */ | |
830 | #define DYNAMIC_CHAIN_ADDRESS(FRAMEADDR) \ | |
831 | visium_dynamic_chain_address (FRAMEADDR) | |
832 | ||
833 | /* `RETURN_ADDR_RTX (COUNT, FRAMEADDR)' | |
834 | ||
835 | A C expression whose value is RTL representing the value of the | |
836 | return address for the frame COUNT steps up from the current frame, | |
837 | after the prologue. FRAMEADDR is the frame pointer of the COUNT | |
838 | frame, or the frame pointer of the COUNT - 1 frame if | |
839 | `RETURN_ADDR_IN_PREVIOUS_FRAME' is defined. | |
840 | ||
841 | The value of the expression must always be the correct address when | |
842 | COUNT is zero, but may be `NULL_RTX' if there is not way to | |
843 | determine the return address of other frames. */ | |
844 | #define RETURN_ADDR_RTX(COUNT,FRAMEADDR) \ | |
845 | visium_return_addr_rtx (COUNT, FRAMEADDR) | |
846 | ||
847 | /* Exception Handling | |
848 | ||
849 | `EH_RETURN_DATA_REGNO' | |
850 | ||
851 | A C expression whose value is the Nth register number used for data | |
852 | by exception handlers or INVALID_REGNUM if fewer than N registers | |
853 | are available. | |
854 | ||
855 | The exception handling library routines communicate with the | |
856 | exception handlers via a set of agreed upon registers. */ | |
857 | #define EH_RETURN_DATA_REGNO(N) ((N) < 4 ? (N) + 11 : INVALID_REGNUM) | |
858 | #define EH_RETURN_STACKADJ_RTX gen_rtx_REG (SImode, 8) | |
859 | #define EH_RETURN_HANDLER_RTX visium_eh_return_handler_rtx () | |
860 | ||
861 | /* Registers That Address the Stack Frame | |
862 | ||
863 | This discusses registers that address the stack frame. | |
864 | ||
865 | `STACK_POINTER_REGNUM' | |
866 | ||
867 | The register number of the stack pointer register, which must also | |
868 | be a fixed register according to `FIXED_REGISTERS'. On most | |
869 | machines, the hardware determines which register this is. */ | |
870 | #define STACK_POINTER_REGNUM 23 | |
871 | ||
872 | /* `FRAME_POINTER_REGNUM' | |
873 | ||
874 | The register number of the frame pointer register, which is used to | |
875 | access automatic variables in the stack frame. On some machines, | |
876 | the hardware determines which register this is. On other machines, | |
877 | you can choose any register you wish for this purpose. */ | |
878 | #define FRAME_POINTER_REGNUM 52 | |
879 | ||
880 | /* `HARD_FRAME_POINTER_REGNUM' | |
881 | ||
882 | On some machines the offset between the frame pointer and starting | |
883 | offset of the automatic variables is not known until after register | |
884 | allocation has been done (for example, because the saved registers | |
885 | are between these two locations). On those machines, define | |
886 | `FRAME_POINTER_REGNUM' the number of a special, fixed register to | |
887 | be used internally until the offset is known, and define | |
888 | `HARD_FRAME_POINTER_REGNUM' to be the actual hard register number | |
889 | used for the frame pointer. */ | |
890 | #define HARD_FRAME_POINTER_REGNUM 22 | |
891 | ||
892 | /* `ARG_POINTER_REGNUM' | |
893 | ||
894 | The register number of the arg pointer register, which is used to | |
895 | access the function's argument list. On some machines, this is the | |
896 | same as the frame pointer register. On some machines, the hardware | |
897 | determines which register this is. On other machines, you can | |
898 | choose any register you wish for this purpose. If this is not the | |
899 | same register as the frame pointer register, then you must mark it | |
900 | as a fixed register according to `FIXED_REGISTERS', or arrange to | |
901 | be able to eliminate it (*note Elimination::.). */ | |
902 | #define ARG_POINTER_REGNUM 51 | |
903 | ||
904 | /* `STATIC_CHAIN_REGNUM' | |
905 | `STATIC_CHAIN_INCOMING_REGNUM' | |
906 | ||
907 | Register numbers used for passing a function's static chain | |
908 | pointer. If register windows are used, the register number as seen | |
909 | by the called function is `STATIC_CHAIN_INCOMING_REGNUM', while the | |
910 | register number as seen by the calling function is | |
911 | `STATIC_CHAIN_REGNUM'. If these registers are the same, | |
912 | `STATIC_CHAIN_INCOMING_REGNUM' need not be defined. | |
913 | ||
914 | The static chain register need not be a fixed register. | |
915 | ||
916 | If the static chain is passed in memory, these macros should not be | |
917 | defined; instead, the next two macros should be defined. */ | |
918 | #define STATIC_CHAIN_REGNUM 20 | |
919 | ||
920 | /* `ELIMINABLE_REGS' | |
921 | ||
922 | If defined, this macro specifies a table of register pairs used to | |
923 | eliminate unneeded registers that point into the stack frame. If | |
924 | it is not defined, the only elimination attempted by the compiler | |
925 | is to replace references to the frame pointer with references to | |
926 | the stack pointer. | |
927 | ||
928 | The definition of this macro is a list of structure | |
929 | initializations, each of which specifies an original and | |
930 | replacement register. | |
931 | ||
932 | On some machines, the position of the argument pointer is not known | |
933 | until the compilation is completed. In such a case, a separate | |
934 | hard register must be used for the argument pointer. This register | |
935 | can be eliminated by replacing it with either the frame pointer or | |
936 | the argument pointer, depending on whether or not the frame pointer | |
937 | has been eliminated. | |
938 | ||
939 | Note that the elimination of the argument pointer with the stack | |
940 | pointer is specified first since that is the preferred elimination. */ | |
941 | #define ELIMINABLE_REGS \ | |
942 | {{ ARG_POINTER_REGNUM, STACK_POINTER_REGNUM}, \ | |
943 | { ARG_POINTER_REGNUM, HARD_FRAME_POINTER_REGNUM}, \ | |
944 | { FRAME_POINTER_REGNUM, STACK_POINTER_REGNUM}, \ | |
945 | { FRAME_POINTER_REGNUM, HARD_FRAME_POINTER_REGNUM}} | |
946 | ||
947 | /* `INITIAL_ELIMINATION_OFFSET (FROM-REG, TO-REG, OFFSET-VAR)' | |
948 | ||
53680238 BE |
949 | This macro returns the initial difference between the specified pair |
950 | of registers. */ | |
0969ec7d EB |
951 | #define INITIAL_ELIMINATION_OFFSET(FROM, TO, OFFSET) \ |
952 | (OFFSET = visium_initial_elimination_offset (FROM, TO)) | |
953 | ||
954 | /* Passing Function Arguments on the Stack | |
955 | ||
956 | The macros in this section control how arguments are passed on the | |
957 | stack. See the following section for other macros that control | |
958 | passing certain arguments in registers. | |
959 | ||
960 | Passing Arguments in Registers | |
961 | ||
962 | This section describes the macros which let you control how various | |
963 | types of arguments are passed in registers or how they are arranged | |
964 | in the stack. | |
965 | ||
966 | Define the general purpose, and floating point registers used for | |
967 | passing arguments */ | |
968 | #define MAX_ARGS_IN_GP_REGISTERS 8 | |
969 | #define GP_ARG_FIRST 1 | |
970 | #define GP_ARG_LAST (GP_ARG_FIRST + MAX_ARGS_IN_GP_REGISTERS - 1) | |
971 | #define MAX_ARGS_IN_FP_REGISTERS 8 | |
972 | #define FP_ARG_FIRST (FP_FIRST_REGNUM + 1) | |
973 | #define FP_ARG_LAST (FP_ARG_FIRST + MAX_ARGS_IN_FP_REGISTERS - 1) | |
974 | ||
975 | /* Define a data type for recording info about an argument list during the | |
976 | processing of that argument list. */ | |
977 | ||
978 | struct visium_args | |
979 | { | |
980 | /* The count of general registers used */ | |
981 | int grcount; | |
982 | /* The count of floating registers used */ | |
983 | int frcount; | |
984 | /* The number of stack words used by named arguments */ | |
985 | int stack_words; | |
986 | }; | |
987 | ||
988 | /* `CUMULATIVE_ARGS' | |
989 | ||
990 | A C type for declaring a variable that is used as the first | |
991 | argument of `FUNCTION_ARG' and other related values. For some | |
992 | target machines, the type `int' suffices and can hold the number of | |
993 | bytes of argument so far. | |
994 | ||
995 | There is no need to record in `CUMULATIVE_ARGS' anything about the | |
996 | arguments that have been passed on the stack. The compiler has | |
997 | other variables to keep track of that. For target machines on | |
998 | which all arguments are passed on the stack, there is no need to | |
999 | store anything in `CUMULATIVE_ARGS'; however, the data structure | |
1000 | must exist and should not be empty, so use `int'. */ | |
1001 | #define CUMULATIVE_ARGS struct visium_args | |
1002 | ||
1003 | #define INIT_CUMULATIVE_ARGS(CUM,FNTYPE,LIBNAME,FNDECL,N_NAMED_ARGS) \ | |
1004 | do { \ | |
1005 | (CUM).grcount = 0; \ | |
1006 | (CUM).frcount = 0; \ | |
1007 | (CUM).stack_words = 0; \ | |
1008 | } while (0) | |
1009 | ||
1010 | /* `FUNCTION_ARG_REGNO_P (REGNO)' | |
1011 | ||
1012 | A C expression that is nonzero if REGNO is the number of a hard | |
1013 | register in which function arguments are sometimes passed. This | |
1014 | does *not* include implicit arguments such as the static chain and | |
1015 | the structure-value address. On many machines, no registers can be | |
1016 | used for this purpose since all function arguments are pushed on | |
1017 | the stack. */ | |
1018 | #define FUNCTION_ARG_REGNO_P(N) \ | |
1019 | ((GP_ARG_FIRST <= (N) && (N) <= GP_ARG_LAST) \ | |
1020 | || (TARGET_FPU && FP_ARG_FIRST <= (N) && (N) <= FP_ARG_LAST)) | |
1021 | ||
1022 | /* `FUNCTION_VALUE_REGNO_P (REGNO)' | |
1023 | ||
1024 | A C expression that is nonzero if REGNO is the number of a hard | |
1025 | register in which the values of called function may come back. | |
1026 | ||
1027 | A register whose use for returning values is limited to serving as | |
1028 | the second of a pair (for a value of type `double', say) need not | |
1029 | be recognized by this macro. If the machine has register windows, | |
1030 | so that the caller and the called function use different registers | |
1031 | for the return value, this macro should recognize only the caller's | |
1032 | register numbers. */ | |
1033 | #define FUNCTION_VALUE_REGNO_P(N) \ | |
1034 | ((N) == RETURN_REGNUM || (TARGET_FPU && (N) == FP_RETURN_REGNUM)) | |
1035 | ||
1036 | /* How Large Values Are Returned | |
1037 | ||
1038 | When a function value's mode is `BLKmode' (and in some other | |
1039 | cases), the value is not returned according to `FUNCTION_VALUE'. | |
1040 | Instead, the caller passes the address of a block of memory in | |
1041 | which the value should be stored. This address is called the | |
1042 | "structure value address". | |
1043 | ||
1044 | This section describes how to control returning structure values in | |
1045 | memory. | |
1046 | ||
1047 | `DEFAULT_PCC_STRUCT_RETURN' | |
1048 | ||
1049 | Define this macro to be 1 if all structure and union return values | |
1050 | must be in memory. Since this results in slower code, this should | |
1051 | be defined only if needed for compatibility with other compilers or | |
1052 | with an ABI. If you define this macro to be 0, then the | |
1053 | conventions used for structure and union return values are decided | |
1054 | by the `RETURN_IN_MEMORY' macro. | |
1055 | ||
1056 | If not defined, this defaults to the value 1. */ | |
1057 | #define DEFAULT_PCC_STRUCT_RETURN 0 | |
1058 | ||
0969ec7d EB |
1059 | /* Caller-Saves Register Allocation |
1060 | ||
1061 | If you enable it, GNU CC can save registers around function calls. | |
1062 | This makes it possible to use call-clobbered registers to hold | |
1063 | variables that must live across calls. | |
1064 | ||
1065 | Function Entry and Exit | |
1066 | ||
1067 | This section describes the macros that output function entry | |
1068 | ("prologue") and exit ("epilogue") code. | |
1069 | ||
1070 | `EXIT_IGNORE_STACK' | |
1071 | ||
1072 | Define this macro as a C expression that is nonzero if the return | |
1073 | instruction or the function epilogue ignores the value of the stack | |
1074 | pointer; in other words, if it is safe to delete an instruction to | |
1075 | adjust the stack pointer before a return from the function. | |
1076 | ||
1077 | Note that this macro's value is relevant only for functions for | |
1078 | which frame pointers are maintained. It is never safe to delete a | |
1079 | final stack adjustment in a function that has no frame pointer, and | |
1080 | the compiler knows this regardless of `EXIT_IGNORE_STACK'. */ | |
1081 | #define EXIT_IGNORE_STACK 1 | |
1082 | ||
1083 | /* `EPILOGUE_USES (REGNO)' | |
1084 | ||
1085 | Define this macro as a C expression that is nonzero for registers | |
1086 | are used by the epilogue or the `return' pattern. The stack and | |
1087 | frame pointer registers are already be assumed to be used as | |
1088 | needed. */ | |
1089 | #define EPILOGUE_USES(REGNO) visium_epilogue_uses (REGNO) | |
1090 | ||
1091 | /* Generating Code for Profiling | |
1092 | ||
1093 | These macros will help you generate code for profiling. */ | |
1094 | ||
1095 | #define PROFILE_HOOK(LABEL) visium_profile_hook () | |
1096 | #define FUNCTION_PROFILER(FILE, LABELNO) do {} while (0) | |
1097 | #define NO_PROFILE_COUNTERS 1 | |
1098 | ||
1099 | /* Trampolines for Nested Functions | |
1100 | ||
1101 | A trampoline is a small piece of code that is created at run time | |
1102 | when the address of a nested function is taken. It normally resides | |
1103 | on the stack, in the stack frame of the containing function. These | |
1104 | macros tell GCC how to generate code to allocate and initialize a | |
1105 | trampoline. | |
1106 | ||
1107 | The instructions in the trampoline must do two things: load a | |
1108 | constant address into the static chain register, and jump to the | |
1109 | real address of the nested function. On CISC machines such as the | |
1110 | m68k, this requires two instructions, a move immediate and a | |
1111 | jump. Then the two addresses exist in the trampoline as word-long | |
1112 | immediate operands. On RISC machines, it is often necessary to load | |
1113 | each address into a register in two parts. Then pieces of each | |
1114 | address form separate immediate operands. | |
1115 | ||
1116 | The code generated to initialize the trampoline must store the | |
1117 | variable parts--the static chain value and the function | |
1118 | address--into the immediate operands of the instructions. On a CISC | |
1119 | machine, this is simply a matter of copying each address to a | |
1120 | memory reference at the proper offset from the start of the | |
1121 | trampoline. On a RISC machine, it may be necessary to take out | |
1122 | pieces of the address and store them separately. | |
1123 | ||
1124 | On the Visium, the trampoline is | |
1125 | ||
1126 | moviu r9,%u FUNCTION | |
1127 | movil r9,%l FUNCTION | |
1128 | moviu r20,%u STATIC | |
1129 | bra tr,r9,r0 | |
1130 | movil r20,%l STATIC | |
1131 | ||
1132 | A difficulty is setting the correct instruction parity at run time. | |
1133 | ||
1134 | ||
1135 | TRAMPOLINE_SIZE | |
1136 | A C expression for the size in bytes of the trampoline, as an integer. */ | |
1137 | #define TRAMPOLINE_SIZE 20 | |
1138 | ||
1139 | /* Implicit calls to library routines | |
1140 | ||
1141 | Avoid calling library routines (sqrtf) just to set `errno' to EDOM */ | |
1142 | #define TARGET_EDOM 33 | |
1143 | ||
1144 | /* Addressing Modes | |
1145 | ||
1146 | `MAX_REGS_PER_ADDRESS' | |
1147 | ||
1148 | A number, the maximum number of registers that can appear in a | |
1149 | valid memory address. Note that it is up to you to specify a value | |
1150 | equal to the maximum number that `TARGET_LEGITIMATE_ADDRESS_P' would | |
1151 | ever accept. */ | |
1152 | #define MAX_REGS_PER_ADDRESS 1 | |
1153 | ||
1154 | /* `LEGITIMIZE_RELOAD_ADDRESS (X, MODE, OPNUM, TYPE, IND_LEVELS, WIN)' | |
1155 | ||
1156 | A C compound statement that attempts to replace X, which is an | |
1157 | address that needs reloading, with a valid memory address for an | |
1158 | operand of mode MODE. WIN will be a C statement label elsewhere | |
1159 | in the code. It is not necessary to define this macro, but it | |
1160 | might be useful for performance reasons. */ | |
1161 | #define LEGITIMIZE_RELOAD_ADDRESS(AD, MODE, OPNUM, TYPE, IND, WIN) \ | |
1162 | do \ | |
1163 | { \ | |
1164 | rtx new_x = visium_legitimize_reload_address ((AD), (MODE), (OPNUM), \ | |
1165 | (int) (TYPE), (IND)); \ | |
1166 | if (new_x) \ | |
1167 | { \ | |
1168 | (AD) = new_x; \ | |
1169 | goto WIN; \ | |
1170 | } \ | |
1171 | } while (0) | |
1172 | ||
1173 | /* Given a comparison code (EQ, NE, etc.) and the operands of a COMPARE, | |
1174 | return the mode to be used for the comparison. */ | |
1175 | #define SELECT_CC_MODE(OP,X,Y) visium_select_cc_mode ((OP), (X), (Y)) | |
1176 | ||
1177 | /* Return nonzero if MODE implies a floating point inequality can be | |
1178 | reversed. For Visium this is always true because we have a full | |
1179 | compliment of ordered and unordered comparisons, but until generic | |
1180 | code knows how to reverse it correctly we keep the old definition. */ | |
1181 | #define REVERSIBLE_CC_MODE(MODE) ((MODE) != CCFPEmode && (MODE) != CCFPmode) | |
1182 | ||
1183 | /* `BRANCH_COST' | |
1184 | ||
1185 | A C expression for the cost of a branch instruction. A value of 1 | |
1186 | is the default; other values are interpreted relative to that. */ | |
1187 | #define BRANCH_COST(A,B) 10 | |
1188 | ||
1189 | /* Override BRANCH_COST heuristics for complex logical ops. */ | |
1190 | #define LOGICAL_OP_NON_SHORT_CIRCUIT 0 | |
1191 | ||
1192 | /* `SLOW_BYTE_ACCESS' | |
1193 | ||
1194 | Define this macro as a C expression which is nonzero if accessing | |
1195 | less than a word of memory (i.e. a `char' or a `short') is no | |
1196 | faster than accessing a word of memory, i.e., if such access | |
1197 | require more than one instruction or if there is no difference in | |
1198 | cost between byte and (aligned) word loads. | |
1199 | ||
1200 | When this macro is not defined, the compiler will access a field by | |
1201 | finding the smallest containing object; when it is defined, a | |
1202 | fullword load will be used if alignment permits. Unless bytes | |
1203 | accesses are faster than word accesses, using word accesses is | |
1204 | preferable since it may eliminate subsequent memory access if | |
1205 | subsequent accesses occur to other fields in the same word of the | |
1206 | structure, but to different bytes. */ | |
1207 | #define SLOW_BYTE_ACCESS 0 | |
1208 | ||
1209 | /* `MOVE_RATIO (SPEED)` | |
1210 | ||
1211 | The threshold of number of scalar memory-to-memory move insns, | |
1212 | _below_ which a sequence of insns should be generated instead of a | |
1213 | string move insn or a library call. Increasing the value will | |
1214 | always make code faster, but eventually incurs high cost in | |
1215 | increased code size. | |
1216 | ||
1217 | Since we have a movmemsi pattern, the default MOVE_RATIO is 2, which | |
1218 | is too low given that movmemsi will invoke a libcall. */ | |
1219 | #define MOVE_RATIO(speed) ((speed) ? 9 : 3) | |
1220 | ||
1221 | /* `CLEAR_RATIO (SPEED)` | |
1222 | ||
1223 | The threshold of number of scalar move insns, _below_ which a | |
1224 | sequence of insns should be generated to clear memory instead of a | |
1225 | string clear insn or a library call. Increasing the value will | |
1226 | always make code faster, but eventually incurs high cost in | |
1227 | increased code size. | |
1228 | ||
1229 | Since we have a setmemsi pattern, the default CLEAR_RATIO is 2, which | |
1230 | is too low given that setmemsi will invoke a libcall. */ | |
1231 | #define CLEAR_RATIO(speed) ((speed) ? 13 : 5) | |
1232 | ||
1233 | /* `MOVE_MAX' | |
1234 | ||
1235 | The maximum number of bytes that a single instruction can move | |
1236 | quickly between memory and registers or between two memory | |
1237 | locations. */ | |
1238 | #define MOVE_MAX 4 | |
1239 | ||
1240 | /* `MAX_MOVE_MAX' | |
1241 | ||
1242 | The maximum number of bytes that a single instruction can move | |
1243 | quickly between memory and registers or between two memory | |
1244 | locations. If this is undefined, the default is `MOVE_MAX'. | |
1245 | Otherwise, it is the constant value that is the largest value that | |
1246 | `MOVE_MAX' can have at run-time. */ | |
1247 | #define MAX_MOVE_MAX 4 | |
1248 | ||
1249 | /* `SHIFT_COUNT_TRUNCATED' | |
1250 | ||
1251 | A C expression that is nonzero if on this machine the number of | |
1252 | bits actually used for the count of a shift operation is equal to | |
1253 | the number of bits needed to represent the size of the object being | |
1254 | shifted. When this macro is non-zero, the compiler will assume | |
1255 | that it is safe to omit a sign-extend, zero-extend, and certain | |
1256 | bitwise `and' instructions that truncates the count of a shift | |
1257 | operation. On machines that have instructions that act on | |
1258 | bitfields at variable positions, which may include `bit test' | |
1259 | instructions, a nonzero `SHIFT_COUNT_TRUNCATED' also enables | |
1260 | deletion of truncations of the values that serve as arguments to | |
1261 | bitfield instructions. */ | |
1262 | #define SHIFT_COUNT_TRUNCATED 0 | |
1263 | ||
1264 | /* `TRULY_NOOP_TRUNCATION (OUTPREC, INPREC)' | |
1265 | ||
1266 | A C expression which is nonzero if on this machine it is safe to | |
1267 | "convert" an integer of INPREC bits to one of OUTPREC bits (where | |
1268 | OUTPREC is smaller than INPREC) by merely operating on it as if it | |
1269 | had only OUTPREC bits. | |
1270 | ||
1271 | On many machines, this expression can be 1. | |
1272 | ||
1273 | When `TRULY_NOOP_TRUNCATION' returns 1 for a pair of sizes for | |
1274 | modes for which `MODES_TIEABLE_P' is 0, suboptimal code can result. | |
1275 | If this is the case, making `TRULY_NOOP_TRUNCATION' return 0 in | |
1276 | such cases may improve things. */ | |
1277 | #define TRULY_NOOP_TRUNCATION(OUTPREC, INPREC) 1 | |
1278 | ||
1279 | /* `STORE_FLAG_VALUE' | |
1280 | ||
1281 | A C expression describing the value returned by a comparison | |
1282 | operator with an integral mode and stored by a store-flag | |
1283 | instruction (`sCOND') when the condition is true. This description | |
1284 | must apply to *all* the `sCOND' patterns and all the comparison | |
1285 | operators whose results have a `MODE_INT' mode. */ | |
1286 | #define STORE_FLAG_VALUE 1 | |
1287 | ||
1288 | /* `Pmode' | |
1289 | ||
1290 | An alias for the machine mode for pointers. On most machines, | |
1291 | define this to be the integer mode corresponding to the width of a | |
1292 | hardware pointer; `SImode' on 32-bit machine or `DImode' on 64-bit | |
1293 | machines. On some machines you must define this to be one of the | |
1294 | partial integer modes, such as `PSImode'. | |
1295 | ||
1296 | The width of `Pmode' must be at least as large as the value of | |
1297 | `POINTER_SIZE'. If it is not equal, you must define the macro | |
1298 | `POINTERS_EXTEND_UNSIGNED' to specify how pointers are extended to | |
1299 | `Pmode'. */ | |
1300 | #define Pmode SImode | |
1301 | ||
1302 | /* `FUNCTION_MODE' | |
1303 | ||
1304 | An alias for the machine mode used for memory references to | |
1305 | functions being called, in `call' RTL expressions. On most | |
1306 | machines this should be `QImode'. */ | |
1307 | #define FUNCTION_MODE SImode | |
1308 | ||
1309 | /* `NO_IMPLICIT_EXTERN_C' | |
1310 | ||
1311 | Define this macro if the system header files support C++ as well as | |
1312 | C. This macro inhibits the usual method of using system header | |
1313 | files in C++, which is to pretend that the file's contents are | |
1314 | enclosed in `extern "C" {...}'. */ | |
1315 | #define NO_IMPLICIT_EXTERN_C | |
1316 | ||
1317 | /* Dividing the Output into Sections (Texts, Data, ...) | |
1318 | ||
1319 | An object file is divided into sections containing different types | |
1320 | of data. In the most common case, there are three sections: the | |
1321 | "text section", which holds instructions and read-only data; the | |
1322 | "data section", which holds initialized writable data; and the "bss | |
1323 | section", which holds uninitialized data. Some systems have other | |
1324 | kinds of sections. | |
1325 | ||
1326 | `TEXT_SECTION_ASM_OP' | |
1327 | ||
1328 | A C expression whose value is a string containing the assembler | |
1329 | operation that should precede instructions and read-only data. | |
1330 | Normally `".text"' is right. */ | |
1331 | #define TEXT_SECTION_ASM_OP "\t.text" | |
1332 | ||
1333 | /* `DATA_SECTION_ASM_OP' | |
1334 | ||
1335 | A C expression whose value is a string containing the assembler | |
1336 | operation to identify the following data as writable initialized | |
1337 | data. Normally `".data"' is right. */ | |
1338 | #define DATA_SECTION_ASM_OP "\t.data" | |
1339 | ||
1340 | /* `BSS_SECTION_ASM_OP' | |
1341 | ||
1342 | If defined, a C expression whose value is a string containing the | |
1343 | assembler operation to identify the following data as uninitialized | |
1344 | global data. If not defined, and neither `ASM_OUTPUT_BSS' nor | |
1345 | `ASM_OUTPUT_ALIGNED_BSS' are defined, uninitialized global data | |
1346 | will be output in the data section if `-fno-common' is passed, | |
1347 | otherwise `ASM_OUTPUT_COMMON' will be used. | |
1348 | ||
1349 | `EXTRA_SECTIONS' | |
1350 | ||
1351 | A list of names for sections other than the standard two, which are | |
1352 | `in_text' and `in_data'. You need not define this macro on a | |
1353 | system with no other sections (that GCC needs to use). | |
1354 | ||
1355 | `EXTRA_SECTION_FUNCTIONS' | |
1356 | ||
1357 | One or more functions to be defined in `varasm.c'. These functions | |
1358 | should do jobs analogous to those of `text_section' and | |
1359 | `data_section', for your additional sections. Do not define this | |
1360 | macro if you do not define `EXTRA_SECTIONS'. | |
1361 | ||
1362 | `JUMP_TABLES_IN_TEXT_SECTION' Define this macro if jump tables (for | |
1363 | `tablejump' insns) should be output in the text section, along with | |
1364 | the assembler instructions. Otherwise, the readonly data section | |
1365 | is used. | |
1366 | ||
1367 | This macro is irrelevant if there is no separate readonly data | |
1368 | section. */ | |
1369 | #undef JUMP_TABLES_IN_TEXT_SECTION | |
1370 | ||
1371 | ||
1372 | /* The Overall Framework of an Assembler File | |
1373 | ||
1374 | This describes the overall framework of an assembler file. | |
1375 | ||
1376 | `ASM_COMMENT_START' | |
1377 | ||
1378 | A C string constant describing how to begin a comment in the target | |
1379 | assembler language. The compiler assumes that the comment will end | |
1380 | at the end of the line. */ | |
1381 | #define ASM_COMMENT_START ";" | |
1382 | ||
1383 | /* `ASM_APP_ON' | |
1384 | ||
1385 | A C string constant for text to be output before each `asm' | |
1386 | statement or group of consecutive ones. Normally this is `"#APP"', | |
1387 | which is a comment that has no effect on most assemblers but tells | |
1388 | the GNU assembler that it must check the lines that follow for all | |
1389 | valid assembler constructs. */ | |
1390 | #define ASM_APP_ON "#APP\n" | |
1391 | ||
1392 | /* `ASM_APP_OFF' | |
1393 | ||
1394 | A C string constant for text to be output after each `asm' | |
1395 | statement or group of consecutive ones. Normally this is | |
1396 | `"#NO_APP"', which tells the GNU assembler to resume making the | |
1397 | time-saving assumptions that are valid for ordinary compiler | |
1398 | output. */ | |
1399 | #define ASM_APP_OFF "#NO_APP\n" | |
1400 | ||
1401 | /* Output of Data | |
1402 | ||
1403 | This describes data output. | |
1404 | ||
1405 | Output and Generation of Labels | |
1406 | ||
1407 | This is about outputting labels. | |
1408 | ||
1409 | `ASM_OUTPUT_LABEL (STREAM, NAME)' | |
1410 | ||
1411 | A C statement (sans semicolon) to output to the stdio stream STREAM | |
1412 | the assembler definition of a label named NAME. Use the expression | |
1413 | `assemble_name (STREAM, NAME)' to output the name itself; before | |
1414 | and after that, output the additional assembler syntax for defining | |
1415 | the name, and a newline. */ | |
1416 | #define ASM_OUTPUT_LABEL(STREAM,NAME) \ | |
1417 | do { assemble_name (STREAM, NAME); fputs (":\n", STREAM); } while (0) | |
1418 | ||
1419 | /* Globalizing directive for a label */ | |
1420 | #define GLOBAL_ASM_OP "\t.global " | |
1421 | ||
1422 | /* `ASM_OUTPUT_LABELREF (STREAM, NAME)' | |
1423 | ||
1424 | A C statement (sans semicolon) to output to the stdio stream STREAM | |
1425 | a reference in assembler syntax to a label named NAME. This should | |
1426 | add `_' to the front of the name, if that is customary on your | |
1427 | operating system, as it is in most Berkeley Unix systems. This | |
1428 | macro is used in `assemble_name'. */ | |
1429 | #define ASM_OUTPUT_LABELREF(STREAM,NAME) \ | |
1430 | asm_fprintf (STREAM, "%U%s", NAME) | |
1431 | ||
1432 | /* Output of Assembler Instructions | |
1433 | ||
1434 | This describes assembler instruction output. | |
1435 | ||
1436 | `REGISTER_NAMES' | |
1437 | ||
1438 | A C initializer containing the assembler's names for the machine | |
1439 | registers, each one as a C string constant. This is what | |
1440 | translates register numbers in the compiler into assembler | |
1441 | language. */ | |
1442 | #define REGISTER_NAMES \ | |
1443 | {"r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7", \ | |
1444 | "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15", \ | |
1445 | "r16", "r17", "r18", "r19", "r20", "r21", "fp", "sp", \ | |
1446 | "r24", "r25", "r26", "r27", "r28", "r29", "r30", "r31", \ | |
1447 | "mdb", "mdc", \ | |
1448 | "f0", "f1", "f2", "f3", "f4", "f5", "f6", "f7", \ | |
1449 | "f8", "f9", "f10", "f11", "f12", "f13", "f14", "f15", \ | |
1450 | "flags","argp","sfp" } | |
1451 | ||
1452 | /* `ADDITIONAL_REGISTER_NAMES` | |
1453 | ||
1454 | If defined, a C initializer for an array of structures containing | |
1455 | a name and a register number. This macro defines additional names | |
1456 | for hard registers, thus allowing the `asm' option in declarations | |
1457 | to refer to registers using alternate names. */ | |
1458 | #define ADDITIONAL_REGISTER_NAMES \ | |
1459 | {{"r22", HARD_FRAME_POINTER_REGNUM}, {"r23", STACK_POINTER_REGNUM}} | |
1460 | ||
0969ec7d EB |
1461 | /* `REGISTER_PREFIX' |
1462 | `LOCAL_LABEL_PREFIX' | |
1463 | `USER_LABEL_PREFIX' | |
1464 | `IMMEDIATE_PREFIX' | |
1465 | ||
1466 | If defined, C string expressions to be used for the `%R', `%L', | |
1467 | `%U', and `%I' options of `asm_fprintf' (see `final.c'). These are | |
1468 | useful when a single `md' file must support multiple assembler | |
1469 | formats. In that case, the various `tm.h' files can define these | |
1470 | macros differently. */ | |
1471 | #define REGISTER_PREFIX "" | |
1472 | #define LOCAL_LABEL_PREFIX "." | |
1473 | #define IMMEDIATE_PREFIX "#" | |
1474 | ||
1475 | /* `ASM_OUTPUT_REG_PUSH (STREAM, REGNO)' | |
1476 | ||
1477 | A C expression to output to STREAM some assembler code which will | |
1478 | push hard register number REGNO onto the stack. The code need not | |
1479 | be optimal, since this macro is used only when profiling. */ | |
1480 | #define ASM_OUTPUT_REG_PUSH(STREAM,REGNO) \ | |
1481 | asm_fprintf (STREAM, "\tsubi sp,4\n\twrite.l (sp),%s\n", \ | |
1482 | reg_names[REGNO]) | |
1483 | ||
1484 | /* `ASM_OUTPUT_REG_POP (STREAM, REGNO)' | |
1485 | ||
1486 | A C expression to output to STREAM some assembler code which will | |
1487 | pop hard register number REGNO off of the stack. The code need not | |
1488 | be optimal, since this macro is used only when profiling. */ | |
1489 | #define ASM_OUTPUT_REG_POP(STREAM,REGNO) \ | |
1490 | asm_fprintf (STREAM, "\tread.l %s,(sp)\n\taddi sp,4\n", \ | |
1491 | reg_names[REGNO]) | |
1492 | ||
1493 | ||
1494 | /* Output of Dispatch Tables | |
1495 | ||
1496 | This concerns dispatch tables. | |
1497 | ||
1498 | `ASM_OUTPUT_ADDR_DIFF_ELT (STREAM, VALUE, REL)' | |
1499 | ||
1500 | A C statement to output to the stdio stream STREAM an assembler | |
1501 | pseudo-instruction to generate a difference between two labels. | |
1502 | VALUE and REL are the numbers of two internal labels. The | |
1503 | definitions of these labels are output using | |
1504 | `ASM_OUTPUT_INTERNAL_LABEL', and they must be printed in the same | |
1505 | way here. | |
1506 | ||
1507 | You must provide this macro on machines where the addresses in a | |
1508 | dispatch table are relative to the table's own address. If | |
1509 | defined, GNU CC will also use this macro on all machines when | |
1510 | producing PIC. */ | |
1511 | #define ASM_OUTPUT_ADDR_DIFF_ELT(STREAM,BODY,VALUE,REL) \ | |
1512 | switch (GET_MODE (BODY)) \ | |
1513 | { \ | |
4e10a5a7 | 1514 | case E_SImode: \ |
0969ec7d EB |
1515 | asm_fprintf ((STREAM), "\t.long\t%LL%d-%LL%d\n", (VALUE),(REL)); \ |
1516 | break; \ | |
4e10a5a7 | 1517 | case E_HImode: \ |
0969ec7d EB |
1518 | asm_fprintf ((STREAM), "\t.word\t%LL%d-%LL%d\n", (VALUE),(REL)); \ |
1519 | break; \ | |
4e10a5a7 | 1520 | case E_QImode: \ |
0969ec7d EB |
1521 | asm_fprintf ((STREAM), "\t.byte\t%LL%d-%LL%d\n", (VALUE),(REL)); \ |
1522 | break; \ | |
1523 | default: \ | |
1524 | break; \ | |
1525 | } | |
1526 | ||
1527 | /* `ASM_OUTPUT_ADDR_VEC_ELT (STREAM, VALUE)' | |
1528 | ||
1529 | This macro should be provided on machines where the addresses in a | |
1530 | dispatch table are absolute. | |
1531 | ||
1532 | The definition should be a C statement to output to the stdio | |
1533 | stream STREAM an assembler pseudo-instruction to generate a | |
1534 | reference to a label. VALUE is the number of an internal label | |
1535 | whose definition is output using `ASM_OUTPUT_INTERNAL_LABEL'. */ | |
1536 | #define ASM_OUTPUT_ADDR_VEC_ELT(STREAM, VALUE) \ | |
1537 | asm_fprintf (STREAM, "\t.long %LL%d\n", VALUE) | |
1538 | ||
1539 | /* `ASM_OUTPUT_CASE_END (STREAM, NUM, TABLE)' | |
1540 | ||
1541 | Define this if something special must be output at the end of a | |
1542 | jump-table. The definition should be a C statement to be executed | |
1543 | after the assembler code for the table is written. It should write | |
1544 | the appropriate code to stdio stream STREAM. The argument TABLE is | |
1545 | the jump-table insn, and NUM is the label-number of the preceding | |
1546 | label. | |
1547 | ||
1548 | If this macro is not defined, nothing special is output at the end | |
1549 | of a jump table. | |
1550 | ||
1551 | Here we output a word of zero so that jump-tables can be seperated | |
1552 | in reverse assembly. */ | |
1553 | #define ASM_OUTPUT_CASE_END(STREAM, NUM, TABLE) \ | |
1554 | asm_fprintf (STREAM, "\t.long 0\n"); | |
1555 | ||
1556 | /* Assembler Commands for Alignment | |
1557 | ||
1558 | This describes commands for alignment. | |
1559 | ||
1560 | `ASM_OUTPUT_ALIGN_CODE (STREAM)' | |
1561 | ||
1562 | A C expression to output text to align the location counter in the | |
1563 | way that is desirable at a point in the code that is reached only | |
1564 | by jumping. | |
1565 | ||
1566 | This macro need not be defined if you don't want any special | |
1567 | alignment to be done at such a time. Most machine descriptions do | |
1568 | not currently define the macro. */ | |
1569 | #undef ASM_OUTPUT_ALIGN_CODE | |
1570 | ||
1571 | /* `ASM_OUTPUT_LOOP_ALIGN (STREAM)' | |
1572 | ||
1573 | A C expression to output text to align the location counter in the | |
1574 | way that is desirable at the beginning of a loop. | |
1575 | ||
1576 | This macro need not be defined if you don't want any special | |
1577 | alignment to be done at such a time. Most machine descriptions do | |
1578 | not currently define the macro. */ | |
1579 | #undef ASM_OUTPUT_LOOP_ALIGN | |
1580 | ||
1581 | /* `ASM_OUTPUT_ALIGN (STREAM, POWER)' | |
1582 | ||
1583 | A C statement to output to the stdio stream STREAM an assembler | |
1584 | command to advance the location counter to a multiple of 2 to the | |
1585 | POWER bytes. POWER will be a C expression of type `int'. */ | |
1586 | #define ASM_OUTPUT_ALIGN(STREAM,LOG) \ | |
1587 | if ((LOG) != 0) \ | |
1588 | fprintf (STREAM, "\t.align %d\n", (1<<(LOG))) | |
1589 | ||
1590 | /* `ASM_OUTPUT_MAX_SKIP_ALIGN (STREAM, POWER, MAX_SKIP)` | |
1591 | ||
1592 | A C statement to output to the stdio stream STREAM an assembler | |
1593 | command to advance the location counter to a multiple of 2 to the | |
1594 | POWER bytes, but only if MAX_SKIP or fewer bytes are needed to | |
1595 | satisfy the alignment request. POWER and MAX_SKIP will be a C | |
1596 | expression of type `int'. */ | |
1597 | #define ASM_OUTPUT_MAX_SKIP_ALIGN(STREAM,LOG,MAX_SKIP) \ | |
1598 | if ((LOG) != 0) { \ | |
1599 | if ((MAX_SKIP) == 0) fprintf ((STREAM), "\t.p2align %d\n", (LOG)); \ | |
1600 | else { \ | |
1601 | fprintf ((STREAM), "\t.p2align %d,,%d\n", (LOG), (MAX_SKIP)); \ | |
1602 | /* Make sure that we have at least 8-byte alignment if > 8-byte \ | |
1603 | alignment is preferred. */ \ | |
1604 | if ((LOG) > 3 \ | |
1605 | && (1 << (LOG)) > ((MAX_SKIP) + 1) \ | |
1606 | && (MAX_SKIP) >= 7) \ | |
1607 | fputs ("\t.p2align 3\n", (STREAM)); \ | |
1608 | } \ | |
1609 | } | |
1610 | ||
1611 | /* Controlling Debugging Information Format | |
1612 | ||
1613 | This describes how to specify debugging information. | |
1614 | ||
1615 | mda is known to GDB, but not to GCC. */ | |
1616 | #define DBX_REGISTER_NUMBER(REGNO) \ | |
1617 | ((REGNO) > MDB_REGNUM ? (REGNO) + 1 : (REGNO)) | |
1618 | ||
1619 | /* `DEBUGGER_AUTO_OFFSET (X)' | |
1620 | ||
1621 | A C expression that returns the integer offset value for an | |
1622 | automatic variable having address X (an RTL expression). The | |
1623 | default computation assumes that X is based on the frame-pointer | |
1624 | and gives the offset from the frame-pointer. This is required for | |
1625 | targets that produce debugging output for DBX or COFF-style | |
1626 | debugging output for SDB and allow the frame-pointer to be | |
1627 | eliminated when the `-g' options is used. */ | |
1628 | #define DEBUGGER_AUTO_OFFSET(X) \ | |
1629 | (GET_CODE (X) == PLUS ? INTVAL (XEXP (X, 1)) : 0) | |
1630 | ||
1631 | /* Miscellaneous Parameters | |
1632 | ||
1633 | `CASE_VECTOR_MODE' | |
1634 | ||
1635 | An alias for a machine mode name. This is the machine mode that | |
1636 | elements of a jump-table should have. */ | |
1637 | #define CASE_VECTOR_MODE SImode | |
1638 | ||
1639 | /* `CASE_VECTOR_PC_RELATIVE' | |
1640 | Define this macro if jump-tables should contain relative addresses. */ | |
1641 | #undef CASE_VECTOR_PC_RELATIVE | |
1642 | ||
1643 | /* This says how to output assembler code to declare an | |
1644 | unitialised external linkage data object. */ | |
1645 | #define ASM_OUTPUT_COMMON(STREAM, NAME, SIZE, ROUNDED) \ | |
1646 | ( fputs ("\n\t.comm ", (STREAM)), \ | |
1647 | assemble_name ((STREAM), (NAME)), \ | |
16998094 | 1648 | fprintf ((STREAM), "," HOST_WIDE_INT_PRINT_UNSIGNED"\n", ROUNDED)) |
0969ec7d EB |
1649 | |
1650 | /* This says how to output assembler code to declare an | |
1651 | unitialised internal linkage data object. */ | |
1652 | #define ASM_OUTPUT_LOCAL(STREAM, NAME, SIZE, ROUNDED) \ | |
1653 | ( fputs ("\n\t.lcomm ", (STREAM)), \ | |
1654 | assemble_name ((STREAM), (NAME)), \ | |
16998094 | 1655 | fprintf ((STREAM), "," HOST_WIDE_INT_PRINT_UNSIGNED"\n", ROUNDED)) |
0969ec7d EB |
1656 | |
1657 | /* Prettify the assembly. */ | |
1658 | extern int visium_indent_opcode; | |
1659 | ||
1660 | #define ASM_OUTPUT_OPCODE(FILE, PTR) \ | |
1661 | do { \ | |
1662 | if (visium_indent_opcode) \ | |
1663 | { \ | |
1664 | putc (' ', FILE); \ | |
1665 | visium_indent_opcode = 0; \ | |
1666 | } \ | |
1667 | } while (0) | |
175650bc OH |
1668 | |
1669 | /* Configure-time default values for common options. */ | |
1670 | #define OPTION_DEFAULT_SPECS { "cpu", "%{!mcpu=*:-mcpu=%(VALUE)}" } | |
1671 | ||
1672 | /* Values of TARGET_CPU_DEFAULT specified via --with-cpu. */ | |
1673 | #define TARGET_CPU_gr5 0 | |
1674 | #define TARGET_CPU_gr6 1 | |
1675 | ||
1676 | /* Default -mcpu multilib for above values. */ | |
1677 | #if TARGET_CPU_DEFAULT == TARGET_CPU_gr5 | |
1678 | #define MULTILIB_DEFAULTS { "mcpu=gr5" } | |
1679 | #elif TARGET_CPU_DEFAULT == TARGET_CPU_gr6 | |
1680 | #define MULTILIB_DEFAULTS { "mcpu=gr6" } | |
1681 | #else | |
1682 | #error Unrecognized value in TARGET_CPU_DEFAULT | |
1683 | #endif |