]>
Commit | Line | Data |
---|---|---|
03984308 | 1 | /* Definitions of Tensilica's Xtensa target machine for GNU compiler. |
5624e564 | 2 | Copyright (C) 2001-2015 Free Software Foundation, Inc. |
03984308 BW |
3 | Contributed by Bob Wilson (bwilson@tensilica.com) at Tensilica. |
4 | ||
5 | This file is part of GCC. | |
6 | ||
7 | GCC is free software; you can redistribute it and/or modify it under | |
8 | the terms of the GNU General Public License as published by the Free | |
2f83c7d6 | 9 | Software Foundation; either version 3, or (at your option) any later |
03984308 BW |
10 | version. |
11 | ||
12 | GCC is distributed in the hope that it will be useful, but WITHOUT ANY | |
13 | WARRANTY; without even the implied warranty of MERCHANTABILITY or | |
14 | FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License | |
15 | for more details. | |
16 | ||
17 | You should have received a copy of the GNU General Public License | |
2f83c7d6 NC |
18 | along with GCC; see the file COPYING3. If not see |
19 | <http://www.gnu.org/licenses/>. */ | |
03984308 BW |
20 | |
21 | /* Get Xtensa configuration settings */ | |
e677f70c | 22 | #include "xtensa-config.h" |
03984308 | 23 | |
03984308 BW |
24 | /* External variables defined in xtensa.c. */ |
25 | ||
03984308 BW |
26 | extern unsigned xtensa_current_frame_size; |
27 | ||
6cedbe44 BW |
28 | /* Macros used in the machine description to select various Xtensa |
29 | configuration options. */ | |
327e3a03 BW |
30 | #ifndef XCHAL_HAVE_MUL32_HIGH |
31 | #define XCHAL_HAVE_MUL32_HIGH 0 | |
32 | #endif | |
2a48b790 BW |
33 | #ifndef XCHAL_HAVE_RELEASE_SYNC |
34 | #define XCHAL_HAVE_RELEASE_SYNC 0 | |
35 | #endif | |
36 | #ifndef XCHAL_HAVE_S32C1I | |
37 | #define XCHAL_HAVE_S32C1I 0 | |
38 | #endif | |
6a7a462c BW |
39 | #ifndef XCHAL_HAVE_THREADPTR |
40 | #define XCHAL_HAVE_THREADPTR 0 | |
41 | #endif | |
f211daa3 MF |
42 | #ifndef XCHAL_HAVE_FP_POSTINC |
43 | #define XCHAL_HAVE_FP_POSTINC 0 | |
44 | #endif | |
6cedbe44 BW |
45 | #define TARGET_BIG_ENDIAN XCHAL_HAVE_BE |
46 | #define TARGET_DENSITY XCHAL_HAVE_DENSITY | |
47 | #define TARGET_MAC16 XCHAL_HAVE_MAC16 | |
48 | #define TARGET_MUL16 XCHAL_HAVE_MUL16 | |
49 | #define TARGET_MUL32 XCHAL_HAVE_MUL32 | |
09fa8841 | 50 | #define TARGET_MUL32_HIGH XCHAL_HAVE_MUL32_HIGH |
6cedbe44 BW |
51 | #define TARGET_DIV32 XCHAL_HAVE_DIV32 |
52 | #define TARGET_NSA XCHAL_HAVE_NSA | |
53 | #define TARGET_MINMAX XCHAL_HAVE_MINMAX | |
54 | #define TARGET_SEXT XCHAL_HAVE_SEXT | |
55 | #define TARGET_BOOLEANS XCHAL_HAVE_BOOLEANS | |
56 | #define TARGET_HARD_FLOAT XCHAL_HAVE_FP | |
57 | #define TARGET_HARD_FLOAT_DIV XCHAL_HAVE_FP_DIV | |
58 | #define TARGET_HARD_FLOAT_RECIP XCHAL_HAVE_FP_RECIP | |
59 | #define TARGET_HARD_FLOAT_SQRT XCHAL_HAVE_FP_SQRT | |
60 | #define TARGET_HARD_FLOAT_RSQRT XCHAL_HAVE_FP_RSQRT | |
f211daa3 | 61 | #define TARGET_HARD_FLOAT_POSTINC XCHAL_HAVE_FP_POSTINC |
6cedbe44 BW |
62 | #define TARGET_ABS XCHAL_HAVE_ABS |
63 | #define TARGET_ADDX XCHAL_HAVE_ADDX | |
2a48b790 BW |
64 | #define TARGET_RELEASE_SYNC XCHAL_HAVE_RELEASE_SYNC |
65 | #define TARGET_S32C1I XCHAL_HAVE_S32C1I | |
7f0ee694 | 66 | #define TARGET_ABSOLUTE_LITERALS XSHAL_USE_ABSOLUTE_LITERALS |
6a7a462c | 67 | #define TARGET_THREADPTR XCHAL_HAVE_THREADPTR |
6383386a | 68 | #define TARGET_LOOPS XCHAL_HAVE_LOOPS |
590e2636 | 69 | #define TARGET_WINDOWED_ABI (XSHAL_ABI == XTHAL_ABI_WINDOWED) |
768b6664 | 70 | #define TARGET_DEBUG XCHAL_HAVE_DEBUG |
6cedbe44 | 71 | |
66e58b33 BW |
72 | #define TARGET_DEFAULT \ |
73 | ((XCHAL_HAVE_L32R ? 0 : MASK_CONST16) | \ | |
74 | MASK_SERIALIZE_VOLATILE) | |
03984308 | 75 | |
6a7a462c BW |
76 | #ifndef HAVE_AS_TLS |
77 | #define HAVE_AS_TLS 0 | |
78 | #endif | |
79 | ||
624f0d60 BW |
80 | \f |
81 | /* Target CPU builtins. */ | |
82 | #define TARGET_CPU_CPP_BUILTINS() \ | |
83 | do { \ | |
84 | builtin_assert ("cpu=xtensa"); \ | |
85 | builtin_assert ("machine=xtensa"); \ | |
48c0150c | 86 | builtin_define ("__xtensa__"); \ |
624f0d60 | 87 | builtin_define ("__XTENSA__"); \ |
590e2636 MF |
88 | builtin_define (TARGET_WINDOWED_ABI ? \ |
89 | "__XTENSA_WINDOWED_ABI__" : "__XTENSA_CALL0_ABI__");\ | |
624f0d60 BW |
90 | builtin_define (TARGET_BIG_ENDIAN ? "__XTENSA_EB__" : "__XTENSA_EL__"); \ |
91 | if (!TARGET_HARD_FLOAT) \ | |
92 | builtin_define ("__XTENSA_SOFT_FLOAT__"); \ | |
624f0d60 | 93 | } while (0) |
03984308 | 94 | |
6a2b287f BW |
95 | #define CPP_SPEC " %(subtarget_cpp_spec) " |
96 | ||
97 | #ifndef SUBTARGET_CPP_SPEC | |
98 | #define SUBTARGET_CPP_SPEC "" | |
99 | #endif | |
100 | ||
ab409f1b | 101 | #define EXTRA_SPECS \ |
6a2b287f BW |
102 | { "subtarget_cpp_spec", SUBTARGET_CPP_SPEC }, |
103 | ||
03984308 BW |
104 | /* Target machine storage layout */ |
105 | ||
03984308 BW |
106 | /* Define this if most significant bit is lowest numbered |
107 | in instructions that operate on numbered bit-fields. */ | |
108 | #define BITS_BIG_ENDIAN (TARGET_BIG_ENDIAN != 0) | |
109 | ||
3bbc2af6 | 110 | /* Define this if most significant byte of a word is the lowest numbered. */ |
03984308 BW |
111 | #define BYTES_BIG_ENDIAN (TARGET_BIG_ENDIAN != 0) |
112 | ||
3bbc2af6 | 113 | /* Define this if most significant word of a multiword number is the lowest. */ |
03984308 BW |
114 | #define WORDS_BIG_ENDIAN (TARGET_BIG_ENDIAN != 0) |
115 | ||
03984308 BW |
116 | #define MAX_BITS_PER_WORD 32 |
117 | ||
118 | /* Width of a word, in units (bytes). */ | |
119 | #define UNITS_PER_WORD 4 | |
120 | #define MIN_UNITS_PER_WORD 4 | |
121 | ||
122 | /* Width of a floating point register. */ | |
123 | #define UNITS_PER_FPREG 4 | |
124 | ||
125 | /* Size in bits of various types on the target machine. */ | |
126 | #define INT_TYPE_SIZE 32 | |
03984308 BW |
127 | #define SHORT_TYPE_SIZE 16 |
128 | #define LONG_TYPE_SIZE 32 | |
03984308 | 129 | #define LONG_LONG_TYPE_SIZE 64 |
03984308 BW |
130 | #define FLOAT_TYPE_SIZE 32 |
131 | #define DOUBLE_TYPE_SIZE 64 | |
132 | #define LONG_DOUBLE_TYPE_SIZE 64 | |
03984308 | 133 | |
03984308 BW |
134 | /* Allocation boundary (in *bits*) for storing pointers in memory. */ |
135 | #define POINTER_BOUNDARY 32 | |
136 | ||
137 | /* Allocation boundary (in *bits*) for storing arguments in argument list. */ | |
138 | #define PARM_BOUNDARY 32 | |
139 | ||
140 | /* Allocation boundary (in *bits*) for the code of a function. */ | |
141 | #define FUNCTION_BOUNDARY 32 | |
142 | ||
143 | /* Alignment of field after 'int : 0' in a structure. */ | |
144 | #define EMPTY_FIELD_BOUNDARY 32 | |
145 | ||
146 | /* Every structure's size must be a multiple of this. */ | |
147 | #define STRUCTURE_SIZE_BOUNDARY 8 | |
148 | ||
149 | /* There is no point aligning anything to a rounder boundary than this. */ | |
150 | #define BIGGEST_ALIGNMENT 128 | |
151 | ||
152 | /* Set this nonzero if move instructions will actually fail to work | |
153 | when given unaligned data. */ | |
154 | #define STRICT_ALIGNMENT 1 | |
155 | ||
156 | /* Promote integer modes smaller than a word to SImode. Set UNSIGNEDP | |
157 | for QImode, because there is no 8-bit load from memory with sign | |
158 | extension. Otherwise, leave UNSIGNEDP alone, since Xtensa has 16-bit | |
159 | loads both with and without sign extension. */ | |
160 | #define PROMOTE_MODE(MODE, UNSIGNEDP, TYPE) \ | |
161 | do { \ | |
162 | if (GET_MODE_CLASS (MODE) == MODE_INT \ | |
163 | && GET_MODE_SIZE (MODE) < UNITS_PER_WORD) \ | |
164 | { \ | |
165 | if ((MODE) == QImode) \ | |
166 | (UNSIGNEDP) = 1; \ | |
167 | (MODE) = SImode; \ | |
168 | } \ | |
169 | } while (0) | |
170 | ||
03984308 BW |
171 | /* Imitate the way many other C compilers handle alignment of |
172 | bitfields and the structures that contain them. */ | |
173 | #define PCC_BITFIELD_TYPE_MATTERS 1 | |
174 | ||
175 | /* Align string constants and constructors to at least a word boundary. | |
176 | The typical use of this macro is to increase alignment for string | |
177 | constants to be word aligned so that 'strcpy' calls that copy | |
178 | constants can be done inline. */ | |
179 | #define CONSTANT_ALIGNMENT(EXP, ALIGN) \ | |
637ece3f MF |
180 | (!optimize_size && \ |
181 | (TREE_CODE (EXP) == STRING_CST || TREE_CODE (EXP) == CONSTRUCTOR) \ | |
03984308 BW |
182 | && (ALIGN) < BITS_PER_WORD \ |
183 | ? BITS_PER_WORD \ | |
184 | : (ALIGN)) | |
185 | ||
186 | /* Align arrays, unions and records to at least a word boundary. | |
187 | One use of this macro is to increase alignment of medium-size | |
188 | data to make it all fit in fewer cache lines. Another is to | |
189 | cause character arrays to be word-aligned so that 'strcpy' calls | |
190 | that copy constants to character arrays can be done inline. */ | |
191 | #undef DATA_ALIGNMENT | |
192 | #define DATA_ALIGNMENT(TYPE, ALIGN) \ | |
637ece3f | 193 | (!optimize_size && (((ALIGN) < BITS_PER_WORD) \ |
03984308 BW |
194 | && (TREE_CODE (TYPE) == ARRAY_TYPE \ |
195 | || TREE_CODE (TYPE) == UNION_TYPE \ | |
196 | || TREE_CODE (TYPE) == RECORD_TYPE)) ? BITS_PER_WORD : (ALIGN)) | |
197 | ||
03984308 BW |
198 | /* Operations between registers always perform the operation |
199 | on the full register even if a narrower mode is specified. */ | |
9e11bfef | 200 | #define WORD_REGISTER_OPERATIONS 1 |
03984308 BW |
201 | |
202 | /* Xtensa loads are zero-extended by default. */ | |
203 | #define LOAD_EXTEND_OP(MODE) ZERO_EXTEND | |
204 | ||
205 | /* Standard register usage. */ | |
206 | ||
207 | /* Number of actual hardware registers. | |
208 | The hardware registers are assigned numbers for the compiler | |
209 | from 0 to just below FIRST_PSEUDO_REGISTER. | |
210 | All registers that the compiler knows about must be given numbers, | |
211 | even those that are not normally considered general registers. | |
212 | ||
213 | The fake frame pointer and argument pointer will never appear in | |
214 | the generated code, since they will always be eliminated and replaced | |
215 | by either the stack pointer or the hard frame pointer. | |
216 | ||
217 | 0 - 15 AR[0] - AR[15] | |
218 | 16 FRAME_POINTER (fake = initial sp) | |
219 | 17 ARG_POINTER (fake = initial sp + framesize) | |
03984308 BW |
220 | 18 BR[0] for floating-point CC |
221 | 19 - 34 FR[0] - FR[15] | |
222 | 35 MAC16 accumulator */ | |
223 | ||
224 | #define FIRST_PSEUDO_REGISTER 36 | |
225 | ||
3bbc2af6 | 226 | /* Return the stabs register number to use for REGNO. */ |
03984308 BW |
227 | #define DBX_REGISTER_NUMBER(REGNO) xtensa_dbx_register_number (REGNO) |
228 | ||
229 | /* 1 for registers that have pervasive standard uses | |
3bbc2af6 | 230 | and are not available for the register allocator. */ |
03984308 BW |
231 | #define FIXED_REGISTERS \ |
232 | { \ | |
233 | 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, \ | |
234 | 1, 1, 0, \ | |
235 | 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, \ | |
236 | 0, \ | |
237 | } | |
238 | ||
239 | /* 1 for registers not available across function calls. | |
240 | These must include the FIXED_REGISTERS and also any | |
241 | registers that can be used without being saved. | |
242 | The latter must include the registers where values are returned | |
243 | and the register where structure-value addresses are passed. | |
590e2636 MF |
244 | Aside from that, you can include as many other registers as you like. |
245 | ||
246 | The value encoding is the following: | |
247 | 1: register is used by all ABIs; | |
248 | bit 1 is set: register is used by windowed ABI; | |
249 | bit 2 is set: register is used by call0 ABI. | |
250 | ||
251 | Proper values are computed in TARGET_CONDITIONAL_REGISTER_USAGE. */ | |
252 | ||
03984308 BW |
253 | #define CALL_USED_REGISTERS \ |
254 | { \ | |
590e2636 | 255 | 1, 1, 4, 4, 4, 4, 4, 4, 1, 1, 1, 1, 2, 2, 2, 2, \ |
03984308 BW |
256 | 1, 1, 1, \ |
257 | 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, \ | |
258 | 1, \ | |
259 | } | |
260 | ||
261 | /* For non-leaf procedures on Xtensa processors, the allocation order | |
262 | is as specified below by REG_ALLOC_ORDER. For leaf procedures, we | |
263 | want to use the lowest numbered registers first to minimize | |
264 | register window overflows. However, local-alloc is not smart | |
265 | enough to consider conflicts with incoming arguments. If an | |
266 | incoming argument in a2 is live throughout the function and | |
267 | local-alloc decides to use a2, then the incoming argument must | |
268 | either be spilled or copied to another register. To get around | |
5a733826 | 269 | this, we define ADJUST_REG_ALLOC_ORDER to redefine |
03984308 BW |
270 | reg_alloc_order for leaf functions such that lowest numbered |
271 | registers are used first with the exception that the incoming | |
272 | argument registers are not used until after other register choices | |
273 | have been exhausted. */ | |
274 | ||
275 | #define REG_ALLOC_ORDER \ | |
985d0d50 BW |
276 | { 8, 9, 10, 11, 12, 13, 14, 15, 7, 6, 5, 4, 3, 2, \ |
277 | 18, \ | |
278 | 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, \ | |
03984308 | 279 | 0, 1, 16, 17, \ |
985d0d50 | 280 | 35, \ |
03984308 BW |
281 | } |
282 | ||
5a733826 | 283 | #define ADJUST_REG_ALLOC_ORDER order_regs_for_local_alloc () |
03984308 BW |
284 | |
285 | /* For Xtensa, the only point of this is to prevent GCC from otherwise | |
286 | giving preference to call-used registers. To minimize window | |
287 | overflows for the AR registers, we want to give preference to the | |
288 | lower-numbered AR registers. For other register files, which are | |
3bbc2af6 | 289 | not windowed, we still prefer call-used registers, if there are any. */ |
03984308 BW |
290 | extern const char xtensa_leaf_regs[FIRST_PSEUDO_REGISTER]; |
291 | #define LEAF_REGISTERS xtensa_leaf_regs | |
292 | ||
293 | /* For Xtensa, no remapping is necessary, but this macro must be | |
3bbc2af6 | 294 | defined if LEAF_REGISTERS is defined. */ |
03984308 BW |
295 | #define LEAF_REG_REMAP(REGNO) (REGNO) |
296 | ||
3bbc2af6 | 297 | /* This must be declared if LEAF_REGISTERS is set. */ |
03984308 BW |
298 | extern int leaf_function; |
299 | ||
3bbc2af6 | 300 | /* Internal macros to classify a register number. */ |
03984308 BW |
301 | |
302 | /* 16 address registers + fake registers */ | |
303 | #define GP_REG_FIRST 0 | |
304 | #define GP_REG_LAST 17 | |
305 | #define GP_REG_NUM (GP_REG_LAST - GP_REG_FIRST + 1) | |
306 | ||
03984308 BW |
307 | /* Coprocessor registers */ |
308 | #define BR_REG_FIRST 18 | |
309 | #define BR_REG_LAST 18 | |
310 | #define BR_REG_NUM (BR_REG_LAST - BR_REG_FIRST + 1) | |
311 | ||
312 | /* 16 floating-point registers */ | |
313 | #define FP_REG_FIRST 19 | |
314 | #define FP_REG_LAST 34 | |
315 | #define FP_REG_NUM (FP_REG_LAST - FP_REG_FIRST + 1) | |
316 | ||
317 | /* MAC16 accumulator */ | |
318 | #define ACC_REG_FIRST 35 | |
319 | #define ACC_REG_LAST 35 | |
320 | #define ACC_REG_NUM (ACC_REG_LAST - ACC_REG_FIRST + 1) | |
321 | ||
322 | #define GP_REG_P(REGNO) ((unsigned) ((REGNO) - GP_REG_FIRST) < GP_REG_NUM) | |
323 | #define BR_REG_P(REGNO) ((unsigned) ((REGNO) - BR_REG_FIRST) < BR_REG_NUM) | |
324 | #define FP_REG_P(REGNO) ((unsigned) ((REGNO) - FP_REG_FIRST) < FP_REG_NUM) | |
325 | #define ACC_REG_P(REGNO) ((unsigned) ((REGNO) - ACC_REG_FIRST) < ACC_REG_NUM) | |
326 | ||
327 | /* Return number of consecutive hard regs needed starting at reg REGNO | |
328 | to hold something of mode MODE. */ | |
329 | #define HARD_REGNO_NREGS(REGNO, MODE) \ | |
330 | (FP_REG_P (REGNO) ? \ | |
331 | ((GET_MODE_SIZE (MODE) + UNITS_PER_FPREG - 1) / UNITS_PER_FPREG) : \ | |
332 | ((GET_MODE_SIZE (MODE) + UNITS_PER_WORD - 1) / UNITS_PER_WORD)) | |
333 | ||
334 | /* Value is 1 if hard register REGNO can hold a value of machine-mode | |
3bbc2af6 | 335 | MODE. */ |
03984308 BW |
336 | extern char xtensa_hard_regno_mode_ok[][FIRST_PSEUDO_REGISTER]; |
337 | ||
338 | #define HARD_REGNO_MODE_OK(REGNO, MODE) \ | |
339 | xtensa_hard_regno_mode_ok[(int) (MODE)][(REGNO)] | |
340 | ||
341 | /* Value is 1 if it is a good idea to tie two pseudo registers | |
342 | when one has mode MODE1 and one has mode MODE2. | |
343 | If HARD_REGNO_MODE_OK could produce different values for MODE1 and MODE2, | |
344 | for any hard reg, then this must be 0 for correct output. */ | |
345 | #define MODES_TIEABLE_P(MODE1, MODE2) \ | |
346 | ((GET_MODE_CLASS (MODE1) == MODE_FLOAT || \ | |
347 | GET_MODE_CLASS (MODE1) == MODE_COMPLEX_FLOAT) \ | |
348 | == (GET_MODE_CLASS (MODE2) == MODE_FLOAT || \ | |
349 | GET_MODE_CLASS (MODE2) == MODE_COMPLEX_FLOAT)) | |
350 | ||
03984308 BW |
351 | /* Register to use for pushing function arguments. */ |
352 | #define STACK_POINTER_REGNUM (GP_REG_FIRST + 1) | |
353 | ||
354 | /* Base register for access to local variables of the function. */ | |
590e2636 MF |
355 | #define HARD_FRAME_POINTER_REGNUM (GP_REG_FIRST + \ |
356 | (TARGET_WINDOWED_ABI ? 7 : 15)) | |
03984308 BW |
357 | |
358 | /* The register number of the frame pointer register, which is used to | |
359 | access automatic variables in the stack frame. For Xtensa, this | |
360 | register never appears in the output. It is always eliminated to | |
3bbc2af6 | 361 | either the stack pointer or the hard frame pointer. */ |
03984308 BW |
362 | #define FRAME_POINTER_REGNUM (GP_REG_FIRST + 16) |
363 | ||
03984308 BW |
364 | /* Base register for access to arguments of the function. */ |
365 | #define ARG_POINTER_REGNUM (GP_REG_FIRST + 17) | |
366 | ||
03984308 BW |
367 | /* For now we don't try to use the full set of boolean registers. Without |
368 | software pipelining of FP operations, there's not much to gain and it's | |
369 | a real pain to get them reloaded. */ | |
370 | #define FPCC_REGNUM (BR_REG_FIRST + 0) | |
371 | ||
03984308 BW |
372 | /* It is as good or better to call a constant function address than to |
373 | call an address kept in a register. */ | |
374 | #define NO_FUNCTION_CSE 1 | |
375 | ||
03984308 BW |
376 | /* Xtensa processors have "register windows". GCC does not currently |
377 | take advantage of the possibility for variable-sized windows; instead, | |
378 | we use a fixed window size of 8. */ | |
379 | ||
380 | #define INCOMING_REGNO(OUT) \ | |
590e2636 MF |
381 | (TARGET_WINDOWED_ABI ? \ |
382 | ((GP_REG_P (OUT) && \ | |
383 | ((unsigned) ((OUT) - GP_REG_FIRST) >= WINDOW_SIZE)) ? \ | |
384 | (OUT) - WINDOW_SIZE : (OUT)) : (OUT)) | |
03984308 BW |
385 | |
386 | #define OUTGOING_REGNO(IN) \ | |
590e2636 MF |
387 | (TARGET_WINDOWED_ABI ? \ |
388 | ((GP_REG_P (IN) && \ | |
389 | ((unsigned) ((IN) - GP_REG_FIRST) < WINDOW_SIZE)) ? \ | |
390 | (IN) + WINDOW_SIZE : (IN)) : (IN)) | |
03984308 BW |
391 | |
392 | ||
393 | /* Define the classes of registers for register constraints in the | |
394 | machine description. */ | |
395 | enum reg_class | |
396 | { | |
397 | NO_REGS, /* no registers in set */ | |
398 | BR_REGS, /* coprocessor boolean registers */ | |
399 | FP_REGS, /* floating point registers */ | |
400 | ACC_REG, /* MAC16 accumulator */ | |
401 | SP_REG, /* sp register (aka a1) */ | |
89f6025d | 402 | RL_REGS, /* preferred reload regs (not sp or fp) */ |
03984308 BW |
403 | GR_REGS, /* integer registers except sp */ |
404 | AR_REGS, /* all integer registers */ | |
405 | ALL_REGS, /* all registers */ | |
406 | LIM_REG_CLASSES /* max value + 1 */ | |
407 | }; | |
408 | ||
409 | #define N_REG_CLASSES (int) LIM_REG_CLASSES | |
410 | ||
411 | #define GENERAL_REGS AR_REGS | |
412 | ||
413 | /* An initializer containing the names of the register classes as C | |
414 | string constants. These names are used in writing some of the | |
415 | debugging dumps. */ | |
416 | #define REG_CLASS_NAMES \ | |
417 | { \ | |
418 | "NO_REGS", \ | |
419 | "BR_REGS", \ | |
420 | "FP_REGS", \ | |
421 | "ACC_REG", \ | |
422 | "SP_REG", \ | |
89f6025d | 423 | "RL_REGS", \ |
03984308 BW |
424 | "GR_REGS", \ |
425 | "AR_REGS", \ | |
426 | "ALL_REGS" \ | |
427 | } | |
428 | ||
429 | /* Contents of the register classes. The Nth integer specifies the | |
430 | contents of class N. The way the integer MASK is interpreted is | |
431 | that register R is in the class if 'MASK & (1 << R)' is 1. */ | |
432 | #define REG_CLASS_CONTENTS \ | |
433 | { \ | |
434 | { 0x00000000, 0x00000000 }, /* no registers */ \ | |
435 | { 0x00040000, 0x00000000 }, /* coprocessor boolean registers */ \ | |
436 | { 0xfff80000, 0x00000007 }, /* floating-point registers */ \ | |
437 | { 0x00000000, 0x00000008 }, /* MAC16 accumulator */ \ | |
438 | { 0x00000002, 0x00000000 }, /* stack pointer register */ \ | |
590e2636 | 439 | { 0x0000fffd, 0x00000000 }, /* preferred reload registers */ \ |
03984308 BW |
440 | { 0x0000fffd, 0x00000000 }, /* general-purpose registers */ \ |
441 | { 0x0003ffff, 0x00000000 }, /* integer registers */ \ | |
442 | { 0xffffffff, 0x0000000f } /* all registers */ \ | |
443 | } | |
444 | ||
445 | /* A C expression whose value is a register class containing hard | |
446 | register REGNO. In general there is more that one such class; | |
447 | choose a class which is "minimal", meaning that no smaller class | |
448 | also contains the register. */ | |
590e2636 | 449 | #define REGNO_REG_CLASS(REGNO) xtensa_regno_to_class (REGNO) |
03984308 BW |
450 | |
451 | /* Use the Xtensa AR register file for base registers. | |
452 | No index registers. */ | |
453 | #define BASE_REG_CLASS AR_REGS | |
454 | #define INDEX_REG_CLASS NO_REGS | |
455 | ||
42db504c SB |
456 | /* The small_register_classes_for_mode_p hook must always return true for |
457 | Xtrnase, because all of the 16 AR registers may be explicitly used in | |
458 | the RTL, as either incoming or outgoing arguments. */ | |
459 | #define TARGET_SMALL_REGISTER_CLASSES_FOR_MODE_P hook_bool_mode_true | |
03984308 | 460 | |
03984308 BW |
461 | /* Stack layout; function entry, exit and calling. */ |
462 | ||
62f9f30b | 463 | #define STACK_GROWS_DOWNWARD 1 |
03984308 BW |
464 | |
465 | /* Offset within stack frame to start allocating local variables at. */ | |
466 | #define STARTING_FRAME_OFFSET \ | |
38173d38 | 467 | crtl->outgoing_args_size |
03984308 BW |
468 | |
469 | /* The ARG_POINTER and FRAME_POINTER are not real Xtensa registers, so | |
470 | they are eliminated to either the stack pointer or hard frame pointer. */ | |
471 | #define ELIMINABLE_REGS \ | |
472 | {{ ARG_POINTER_REGNUM, STACK_POINTER_REGNUM}, \ | |
473 | { ARG_POINTER_REGNUM, HARD_FRAME_POINTER_REGNUM}, \ | |
474 | { FRAME_POINTER_REGNUM, STACK_POINTER_REGNUM}, \ | |
475 | { FRAME_POINTER_REGNUM, HARD_FRAME_POINTER_REGNUM}} | |
476 | ||
03984308 BW |
477 | /* Specify the initial difference between the specified pair of registers. */ |
478 | #define INITIAL_ELIMINATION_OFFSET(FROM, TO, OFFSET) \ | |
479 | do { \ | |
480 | compute_frame_size (get_frame_size ()); \ | |
177b6be0 NS |
481 | switch (FROM) \ |
482 | { \ | |
483 | case FRAME_POINTER_REGNUM: \ | |
484 | (OFFSET) = 0; \ | |
485 | break; \ | |
486 | case ARG_POINTER_REGNUM: \ | |
487 | (OFFSET) = xtensa_current_frame_size; \ | |
488 | break; \ | |
489 | default: \ | |
490 | gcc_unreachable (); \ | |
491 | } \ | |
03984308 BW |
492 | } while (0) |
493 | ||
494 | /* If defined, the maximum amount of space required for outgoing | |
495 | arguments will be computed and placed into the variable | |
38173d38 | 496 | 'crtl->outgoing_args_size'. No space will be pushed |
03984308 BW |
497 | onto the stack for each call; instead, the function prologue |
498 | should increase the stack frame size by this amount. */ | |
499 | #define ACCUMULATE_OUTGOING_ARGS 1 | |
500 | ||
501 | /* Offset from the argument pointer register to the first argument's | |
502 | address. On some machines it may depend on the data type of the | |
503 | function. If 'ARGS_GROW_DOWNWARD', this is the offset to the | |
504 | location above the first argument's address. */ | |
505 | #define FIRST_PARM_OFFSET(FNDECL) 0 | |
506 | ||
507 | /* Align stack frames on 128 bits for Xtensa. This is necessary for | |
508 | 128-bit datatypes defined in TIE (e.g., for Vectra). */ | |
509 | #define STACK_BOUNDARY 128 | |
510 | ||
03984308 | 511 | /* Use a fixed register window size of 8. */ |
590e2636 | 512 | #define WINDOW_SIZE (TARGET_WINDOWED_ABI ? 8 : 0) |
03984308 BW |
513 | |
514 | /* Symbolic macros for the registers used to return integer, floating | |
515 | point, and values of coprocessor and user-defined modes. */ | |
516 | #define GP_RETURN (GP_REG_FIRST + 2 + WINDOW_SIZE) | |
517 | #define GP_OUTGOING_RETURN (GP_REG_FIRST + 2) | |
518 | ||
519 | /* Symbolic macros for the first/last argument registers. */ | |
520 | #define GP_ARG_FIRST (GP_REG_FIRST + 2) | |
521 | #define GP_ARG_LAST (GP_REG_FIRST + 7) | |
522 | #define GP_OUTGOING_ARG_FIRST (GP_REG_FIRST + 2 + WINDOW_SIZE) | |
523 | #define GP_OUTGOING_ARG_LAST (GP_REG_FIRST + 7 + WINDOW_SIZE) | |
524 | ||
525 | #define MAX_ARGS_IN_REGISTERS 6 | |
526 | ||
527 | /* Don't worry about compatibility with PCC. */ | |
528 | #define DEFAULT_PCC_STRUCT_RETURN 0 | |
529 | ||
03984308 BW |
530 | /* A C expression that is nonzero if REGNO is the number of a hard |
531 | register in which function arguments are sometimes passed. This | |
532 | does *not* include implicit arguments such as the static chain and | |
533 | the structure-value address. On many machines, no registers can be | |
534 | used for this purpose since all function arguments are pushed on | |
3bbc2af6 | 535 | the stack. */ |
03984308 BW |
536 | #define FUNCTION_ARG_REGNO_P(N) \ |
537 | ((N) >= GP_OUTGOING_ARG_FIRST && (N) <= GP_OUTGOING_ARG_LAST) | |
538 | ||
997b8b4d BW |
539 | /* Record the number of argument words seen so far, along with a flag to |
540 | indicate whether these are incoming arguments. (FUNCTION_INCOMING_ARG | |
541 | is used for both incoming and outgoing args, so a separate flag is | |
542 | needed. */ | |
543 | typedef struct xtensa_args | |
544 | { | |
545 | int arg_words; | |
546 | int incoming; | |
03984308 BW |
547 | } CUMULATIVE_ARGS; |
548 | ||
0f6937fe | 549 | #define INIT_CUMULATIVE_ARGS(CUM, FNTYPE, LIBNAME, INDIRECT, N_NAMED_ARGS) \ |
997b8b4d | 550 | init_cumulative_args (&CUM, 0) |
03984308 BW |
551 | |
552 | #define INIT_CUMULATIVE_INCOMING_ARGS(CUM, FNTYPE, LIBNAME) \ | |
997b8b4d | 553 | init_cumulative_args (&CUM, 1) |
03984308 | 554 | |
5ee924c2 BW |
555 | /* Profiling Xtensa code is typically done with the built-in profiling |
556 | feature of Tensilica's instruction set simulator, which does not | |
557 | require any compiler support. Profiling code on a real (i.e., | |
558 | non-simulated) Xtensa processor is currently only supported by | |
559 | GNU/Linux with glibc. The glibc version of _mcount doesn't require | |
560 | counter variables. The _mcount function needs the current PC and | |
561 | the current return address to identify an arc in the call graph. | |
562 | Pass the current return address as the first argument; the current | |
563 | PC is available as a0 in _mcount's register window. Both of these | |
564 | values contain window size information in the two most significant | |
565 | bits; we assume that _mcount will mask off those bits. The call to | |
566 | _mcount uses a window size of 8 to make sure that it doesn't clobber | |
3bbc2af6 | 567 | any incoming argument values. */ |
03984308 | 568 | |
9739c90c | 569 | #define NO_PROFILE_COUNTERS 1 |
5ee924c2 BW |
570 | |
571 | #define FUNCTION_PROFILER(FILE, LABELNO) \ | |
03984308 | 572 | do { \ |
5ee924c2 BW |
573 | fprintf (FILE, "\t%s\ta10, a0\n", TARGET_DENSITY ? "mov.n" : "mov"); \ |
574 | if (flag_pic) \ | |
575 | { \ | |
590e2636 MF |
576 | fprintf (FILE, "\tmovi\ta%d, _mcount@PLT\n", WINDOW_SIZE); \ |
577 | fprintf (FILE, "\tcallx%d\ta%d\n", WINDOW_SIZE, WINDOW_SIZE); \ | |
5ee924c2 BW |
578 | } \ |
579 | else \ | |
590e2636 | 580 | fprintf (FILE, "\tcall%d\t_mcount\n", WINDOW_SIZE); \ |
5ee924c2 | 581 | } while (0) |
03984308 BW |
582 | |
583 | /* Stack pointer value doesn't matter at exit. */ | |
584 | #define EXIT_IGNORE_STACK 1 | |
585 | ||
85333688 BW |
586 | /* Size in bytes of the trampoline, as an integer. Make sure this is |
587 | a multiple of TRAMPOLINE_ALIGNMENT to avoid -Wpadded warnings. */ | |
590e2636 MF |
588 | #define TRAMPOLINE_SIZE (TARGET_WINDOWED_ABI ? \ |
589 | (TARGET_CONST16 || TARGET_ABSOLUTE_LITERALS ? \ | |
590 | 60 : 52) : \ | |
591 | (TARGET_CONST16 || TARGET_ABSOLUTE_LITERALS ? \ | |
592 | 32 : 24)) | |
03984308 BW |
593 | |
594 | /* Alignment required for trampolines, in bits. */ | |
7f0ee694 | 595 | #define TRAMPOLINE_ALIGNMENT 32 |
03984308 | 596 | |
03984308 BW |
597 | /* If defined, a C expression that produces the machine-specific code |
598 | to setup the stack so that arbitrary frames can be accessed. | |
599 | ||
600 | On Xtensa, a stack back-trace must always begin from the stack pointer, | |
601 | so that the register overflow save area can be located. However, the | |
602 | stack-walking code in GCC always begins from the hard_frame_pointer | |
603 | register, not the stack pointer. The frame pointer is usually equal | |
604 | to the stack pointer, but the __builtin_return_address and | |
605 | __builtin_frame_address functions will not work if count > 0 and | |
606 | they are called from a routine that uses alloca. These functions | |
607 | are not guaranteed to work at all if count > 0 so maybe that is OK. | |
608 | ||
609 | A nicer solution would be to allow the architecture-specific files to | |
610 | specify whether to start from the stack pointer or frame pointer. That | |
611 | would also allow us to skip the machine->accesses_prev_frame stuff that | |
612 | we currently need to ensure that there is a frame pointer when these | |
3bbc2af6 | 613 | builtin functions are used. */ |
03984308 | 614 | |
0c14a54d | 615 | #define SETUP_FRAME_ADDRESSES xtensa_setup_frame_addresses |
03984308 BW |
616 | |
617 | /* A C expression whose value is RTL representing the address in a | |
618 | stack frame where the pointer to the caller's frame is stored. | |
619 | Assume that FRAMEADDR is an RTL expression for the address of the | |
620 | stack frame itself. | |
621 | ||
622 | For Xtensa, there is no easy way to get the frame pointer if it is | |
623 | not equivalent to the stack pointer. Moreover, the result of this | |
624 | macro is used for continuing to walk back up the stack, so it must | |
625 | return the stack pointer address. Thus, there is some inconsistency | |
626 | here in that __builtin_frame_address will return the frame pointer | |
3bbc2af6 | 627 | when count == 0 and the stack pointer when count > 0. */ |
03984308 BW |
628 | |
629 | #define DYNAMIC_CHAIN_ADDRESS(frame) \ | |
f1c25d3b | 630 | gen_rtx_PLUS (Pmode, frame, GEN_INT (-3 * UNITS_PER_WORD)) |
03984308 BW |
631 | |
632 | /* Define this if the return address of a particular stack frame is | |
3bbc2af6 | 633 | accessed from the frame pointer of the previous stack frame. */ |
590e2636 | 634 | #define RETURN_ADDR_IN_PREVIOUS_FRAME TARGET_WINDOWED_ABI |
03984308 BW |
635 | |
636 | /* A C expression whose value is RTL representing the value of the | |
637 | return address for the frame COUNT steps up from the current | |
0c14a54d BW |
638 | frame, after the prologue. */ |
639 | #define RETURN_ADDR_RTX xtensa_return_addr | |
03984308 BW |
640 | |
641 | /* Addressing modes, and classification of registers for them. */ | |
642 | ||
643 | /* C expressions which are nonzero if register number NUM is suitable | |
da1f39e4 | 644 | for use as a base or index register in operand addresses. */ |
03984308 | 645 | |
da1f39e4 | 646 | #define REGNO_OK_FOR_INDEX_P(NUM) 0 |
03984308 BW |
647 | #define REGNO_OK_FOR_BASE_P(NUM) \ |
648 | (GP_REG_P (NUM) || GP_REG_P ((unsigned) reg_renumber[NUM])) | |
649 | ||
03984308 | 650 | /* C expressions that are nonzero if X (assumed to be a `reg' RTX) is |
da1f39e4 | 651 | valid for use as a base or index register. */ |
03984308 BW |
652 | |
653 | #ifdef REG_OK_STRICT | |
da1f39e4 BW |
654 | #define REG_OK_STRICT_FLAG 1 |
655 | #else | |
656 | #define REG_OK_STRICT_FLAG 0 | |
657 | #endif | |
03984308 | 658 | |
da1f39e4 BW |
659 | #define BASE_REG_P(X, STRICT) \ |
660 | ((!(STRICT) && REGNO (X) >= FIRST_PSEUDO_REGISTER) \ | |
661 | || REGNO_OK_FOR_BASE_P (REGNO (X))) | |
03984308 BW |
662 | |
663 | #define REG_OK_FOR_INDEX_P(X) 0 | |
da1f39e4 | 664 | #define REG_OK_FOR_BASE_P(X) BASE_REG_P (X, REG_OK_STRICT_FLAG) |
03984308 BW |
665 | |
666 | /* Maximum number of registers that can appear in a valid memory address. */ | |
667 | #define MAX_REGS_PER_ADDRESS 1 | |
668 | ||
03984308 BW |
669 | /* A C expression that is 1 if the RTX X is a constant which is a |
670 | valid address. This is defined to be the same as 'CONSTANT_P (X)', | |
671 | but rejecting CONST_DOUBLE. */ | |
672 | #define CONSTANT_ADDRESS_P(X) \ | |
673 | ((GET_CODE (X) == LABEL_REF || GET_CODE (X) == SYMBOL_REF \ | |
674 | || GET_CODE (X) == CONST_INT || GET_CODE (X) == HIGH \ | |
675 | || (GET_CODE (X) == CONST))) | |
676 | ||
03984308 BW |
677 | /* A C expression that is nonzero if X is a legitimate immediate |
678 | operand on the target machine when generating position independent | |
679 | code. */ | |
680 | #define LEGITIMATE_PIC_OPERAND_P(X) \ | |
f1dfe704 BW |
681 | ((GET_CODE (X) != SYMBOL_REF \ |
682 | || (SYMBOL_REF_LOCAL_P (X) && !SYMBOL_REF_EXTERNAL_P (X))) \ | |
03984308 BW |
683 | && GET_CODE (X) != LABEL_REF \ |
684 | && GET_CODE (X) != CONST) | |
685 | ||
03984308 BW |
686 | /* Specify the machine mode that this machine uses |
687 | for the index in the tablejump instruction. */ | |
688 | #define CASE_VECTOR_MODE (SImode) | |
689 | ||
03984308 BW |
690 | /* Define this as 1 if 'char' should by default be signed; else as 0. */ |
691 | #define DEFAULT_SIGNED_CHAR 0 | |
692 | ||
693 | /* Max number of bytes we can move from memory to memory | |
694 | in one reasonably fast instruction. */ | |
695 | #define MOVE_MAX 4 | |
696 | #define MAX_MOVE_MAX 4 | |
697 | ||
698 | /* Prefer word-sized loads. */ | |
699 | #define SLOW_BYTE_ACCESS 1 | |
700 | ||
03984308 BW |
701 | /* Shift instructions ignore all but the low-order few bits. */ |
702 | #define SHIFT_COUNT_TRUNCATED 1 | |
703 | ||
704 | /* Value is 1 if truncating an integer of INPREC bits to OUTPREC bits | |
3bbc2af6 | 705 | is done just by pretending it is already truncated. */ |
03984308 BW |
706 | #define TRULY_NOOP_TRUNCATION(OUTPREC, INPREC) 1 |
707 | ||
09fa8841 BW |
708 | #define CLZ_DEFINED_VALUE_AT_ZERO(MODE, VALUE) ((VALUE) = 32, 1) |
709 | #define CTZ_DEFINED_VALUE_AT_ZERO(MODE, VALUE) ((VALUE) = -1, 1) | |
710 | ||
03984308 BW |
711 | /* Specify the machine mode that pointers have. |
712 | After generation of rtl, the compiler makes no further distinction | |
713 | between pointers and any other objects of this machine mode. */ | |
714 | #define Pmode SImode | |
715 | ||
716 | /* A function address in a call instruction is a word address (for | |
717 | indexing purposes) so give the MEM rtx a words's mode. */ | |
718 | #define FUNCTION_MODE SImode | |
719 | ||
3a4fd356 | 720 | #define BRANCH_COST(speed_p, predictable_p) 3 |
03984308 | 721 | |
03984308 | 722 | /* How to refer to registers in assembler output. |
3bbc2af6 | 723 | This sequence is indexed by compiler's hard-register-number (see above). */ |
03984308 BW |
724 | #define REGISTER_NAMES \ |
725 | { \ | |
726 | "a0", "sp", "a2", "a3", "a4", "a5", "a6", "a7", \ | |
727 | "a8", "a9", "a10", "a11", "a12", "a13", "a14", "a15", \ | |
728 | "fp", "argp", "b0", \ | |
729 | "f0", "f1", "f2", "f3", "f4", "f5", "f6", "f7", \ | |
730 | "f8", "f9", "f10", "f11", "f12", "f13", "f14", "f15", \ | |
731 | "acc" \ | |
732 | } | |
733 | ||
734 | /* If defined, a C initializer for an array of structures containing a | |
735 | name and a register number. This macro defines additional names | |
736 | for hard registers, thus allowing the 'asm' option in declarations | |
3bbc2af6 | 737 | to refer to registers using alternate names. */ |
03984308 BW |
738 | #define ADDITIONAL_REGISTER_NAMES \ |
739 | { \ | |
740 | { "a1", 1 + GP_REG_FIRST } \ | |
741 | } | |
742 | ||
743 | #define PRINT_OPERAND(FILE, X, CODE) print_operand (FILE, X, CODE) | |
744 | #define PRINT_OPERAND_ADDRESS(FILE, ADDR) print_operand_address (FILE, ADDR) | |
745 | ||
506a61b1 KG |
746 | /* Globalizing directive for a label. */ |
747 | #define GLOBAL_ASM_OP "\t.global\t" | |
03984308 | 748 | |
6a2b287f BW |
749 | /* Declare an uninitialized external linkage data object. */ |
750 | #define ASM_OUTPUT_ALIGNED_BSS(FILE, DECL, NAME, SIZE, ALIGN) \ | |
751 | asm_output_aligned_bss (FILE, DECL, NAME, SIZE, ALIGN) | |
03984308 BW |
752 | |
753 | /* This is how to output an element of a case-vector that is absolute. */ | |
754 | #define ASM_OUTPUT_ADDR_VEC_ELT(STREAM, VALUE) \ | |
755 | fprintf (STREAM, "%s%sL%u\n", integer_asm_op (4, TRUE), \ | |
756 | LOCAL_LABEL_PREFIX, VALUE) | |
757 | ||
758 | /* This is how to output an element of a case-vector that is relative. | |
3bbc2af6 | 759 | This is used for pc-relative code. */ |
03984308 BW |
760 | #define ASM_OUTPUT_ADDR_DIFF_ELT(STREAM, BODY, VALUE, REL) \ |
761 | do { \ | |
762 | fprintf (STREAM, "%s%sL%u-%sL%u\n", integer_asm_op (4, TRUE), \ | |
763 | LOCAL_LABEL_PREFIX, (VALUE), \ | |
764 | LOCAL_LABEL_PREFIX, (REL)); \ | |
765 | } while (0) | |
766 | ||
767 | /* This is how to output an assembler line that says to advance the | |
768 | location counter to a multiple of 2**LOG bytes. */ | |
769 | #define ASM_OUTPUT_ALIGN(STREAM, LOG) \ | |
770 | do { \ | |
771 | if ((LOG) != 0) \ | |
772 | fprintf (STREAM, "\t.align\t%d\n", 1 << (LOG)); \ | |
773 | } while (0) | |
774 | ||
775 | /* Indicate that jump tables go in the text section. This is | |
776 | necessary when compiling PIC code. */ | |
777 | #define JUMP_TABLES_IN_TEXT_SECTION (flag_pic) | |
778 | ||
779 | ||
03984308 | 780 | /* Define the strings to put out for each section in the object file. */ |
6a2b287f BW |
781 | #define TEXT_SECTION_ASM_OP "\t.text" |
782 | #define DATA_SECTION_ASM_OP "\t.data" | |
783 | #define BSS_SECTION_ASM_OP "\t.section\t.bss" | |
03984308 BW |
784 | |
785 | ||
9eb8a531 | 786 | /* Define output to appear before the constant pool. */ |
03984308 BW |
787 | #define ASM_OUTPUT_POOL_PROLOGUE(FILE, FUNNAME, FUNDECL, SIZE) \ |
788 | do { \ | |
590e2636 | 789 | if ((SIZE) > 0 || !TARGET_WINDOWED_ABI) \ |
86d8c251 | 790 | { \ |
9eb8a531 | 791 | resolve_unique_section ((FUNDECL), 0, flag_function_sections); \ |
d6b5193b | 792 | switch_to_section (function_section (FUNDECL)); \ |
86d8c251 BW |
793 | fprintf (FILE, "\t.literal_position\n"); \ |
794 | } \ | |
03984308 BW |
795 | } while (0) |
796 | ||
797 | ||
03984308 BW |
798 | /* A C statement (with or without semicolon) to output a constant in |
799 | the constant pool, if it needs special treatment. */ | |
800 | #define ASM_OUTPUT_SPECIAL_POOL_ENTRY(FILE, X, MODE, ALIGN, LABELNO, JUMPTO) \ | |
801 | do { \ | |
802 | xtensa_output_literal (FILE, X, MODE, LABELNO); \ | |
803 | goto JUMPTO; \ | |
804 | } while (0) | |
805 | ||
3bbc2af6 | 806 | /* How to start an assembler comment. */ |
03984308 BW |
807 | #define ASM_COMMENT_START "#" |
808 | ||
6eb065e6 SA |
809 | /* Exception handling. Xtensa uses much of the standard DWARF2 unwinding |
810 | machinery, but the variable size register window save areas are too | |
811 | complicated to efficiently describe with CFI entries. The CFA must | |
812 | still be specified in DWARF so that DW_AT_frame_base is set correctly | |
813 | for debugging. */ | |
4e6c2193 BW |
814 | #define INCOMING_RETURN_ADDR_RTX gen_rtx_REG (Pmode, 0) |
815 | #define DWARF_FRAME_RETURN_COLUMN DWARF_FRAME_REGNUM (0) | |
6eb065e6 SA |
816 | #define DWARF_FRAME_REGISTERS 16 |
817 | #define EH_RETURN_DATA_REGNO(N) ((N) < 2 ? (N) + 2 : INVALID_REGNUM) | |
24eaa34f BW |
818 | #define ASM_PREFERRED_EH_DATA_FORMAT(CODE, GLOBAL) \ |
819 | (flag_pic \ | |
820 | ? (((GLOBAL) ? DW_EH_PE_indirect : 0) \ | |
821 | | DW_EH_PE_pcrel | DW_EH_PE_sdata4) \ | |
822 | : DW_EH_PE_absptr) | |
823 | ||
590e2636 MF |
824 | #define EH_RETURN_STACKADJ_RTX gen_rtx_REG (Pmode, GP_REG_FIRST + 10) |
825 | ||
24eaa34f BW |
826 | /* Emit a PC-relative relocation. */ |
827 | #define ASM_OUTPUT_DWARF_PCREL(FILE, SIZE, LABEL) \ | |
828 | do { \ | |
829 | fputs (integer_asm_op (SIZE, FALSE), FILE); \ | |
830 | assemble_name (FILE, LABEL); \ | |
831 | fputs ("@pcrel", FILE); \ | |
832 | } while (0) | |
03984308 | 833 | |
a7bda3d5 BW |
834 | /* Xtensa constant pool breaks the devices in crtstuff.c to control |
835 | section in where code resides. We have to write it as asm code. Use | |
836 | a MOVI and let the assembler relax it -- for the .init and .fini | |
837 | sections, the assembler knows to put the literal in the right | |
838 | place. */ | |
590e2636 | 839 | #if defined(__XTENSA_WINDOWED_ABI__) |
a7bda3d5 BW |
840 | #define CRT_CALL_STATIC_FUNCTION(SECTION_OP, FUNC) \ |
841 | asm (SECTION_OP "\n\ | |
842 | movi\ta8, " USER_LABEL_PREFIX #FUNC "\n\ | |
843 | callx8\ta8\n" \ | |
844 | TEXT_SECTION_ASM_OP); | |
590e2636 MF |
845 | #elif defined(__XTENSA_CALL0_ABI__) |
846 | #define CRT_CALL_STATIC_FUNCTION(SECTION_OP, FUNC) \ | |
847 | asm (SECTION_OP "\n\ | |
848 | movi\ta0, " USER_LABEL_PREFIX #FUNC "\n\ | |
849 | callx0\ta0\n" \ | |
850 | TEXT_SECTION_ASM_OP); | |
851 | #endif |