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