]>
Commit | Line | Data |
---|---|---|
fef939d6 | 1 | /* Target Definitions for ft32. |
85ec4feb | 2 | Copyright (C) 2015-2018 Free Software Foundation, Inc. |
fef939d6 JB |
3 | Contributed by FTDI <support@ftdi.com> |
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 | #ifndef GCC_FT32_H | |
22 | #define GCC_FT32_H | |
23 | ||
24 | #undef STARTFILE_SPEC | |
25 | #define STARTFILE_SPEC "crt0%O%s %{msim:crti.o%s} %{!msim:crti-hw.o%s} crtbegin.o%s" | |
26 | ||
27 | /* Provide an ENDFILE_SPEC appropriate for svr4. Here we tack on our own | |
28 | magical crtend.o file (see crtstuff.c) which provides part of the | |
29 | support for getting C++ file-scope static object constructed before | |
30 | entering `main', followed by the normal svr3/svr4 "finalizer" file, | |
31 | which is either `gcrtn.o' or `crtn.o'. */ | |
32 | ||
33 | #undef ENDFILE_SPEC | |
34 | #define ENDFILE_SPEC "crtend.o%s crtn.o%s" | |
35 | ||
36 | /* Provide a LIB_SPEC appropriate for svr4. Here we tack on the default | |
37 | standard C library (unless we are building a shared library) and | |
38 | the simulator BSP code. */ | |
39 | ||
40 | #undef LIB_SPEC | |
41 | #define LIB_SPEC "%{!shared:%{!symbolic:-lc}} \ | |
7c42a367 | 42 | %{mcompress:--relax} \ |
fef939d6 JB |
43 | %{msim:-Tsim.ld}" |
44 | ||
45 | #undef LINK_SPEC | |
46 | #define LINK_SPEC "%{h*} %{v:-V} \ | |
47 | %{static:-Bstatic} %{shared:-shared} %{symbolic:-Bsymbolic}" | |
48 | ||
49 | /* Layout of Source Language Data Types */ | |
50 | ||
51 | #define INT_TYPE_SIZE 32 | |
52 | #define SHORT_TYPE_SIZE 16 | |
53 | #define LONG_TYPE_SIZE 32 | |
54 | #define LONG_LONG_TYPE_SIZE 64 | |
55 | ||
56 | #define FLOAT_TYPE_SIZE 32 | |
57 | #define DOUBLE_TYPE_SIZE 64 | |
58 | #define LONG_DOUBLE_TYPE_SIZE 64 | |
59 | ||
60 | #define DEFAULT_SIGNED_CHAR 1 | |
61 | ||
62 | #undef SIZE_TYPE | |
63 | #define SIZE_TYPE "unsigned int" | |
64 | ||
65 | #undef PTRDIFF_TYPE | |
66 | #define PTRDIFF_TYPE "int" | |
67 | ||
68 | #undef WCHAR_TYPE | |
69 | #define WCHAR_TYPE "long int" | |
70 | ||
71 | #undef WCHAR_TYPE_SIZE | |
72 | #define WCHAR_TYPE_SIZE BITS_PER_WORD | |
73 | ||
74 | #define REGISTER_NAMES { \ | |
75 | "$fp", "$sp", "$r0", "$r1", \ | |
76 | "$r2", "$r3", "$r4", "$r5", \ | |
77 | "$r6", "$r7", "$r8", "$r9", \ | |
78 | "$r10", "$r11", "$r12", "$r13", \ | |
79 | "$r14", "$r15", "$r16", "$r17", "$r18", "$r19", "$r20", "$r21", "$r22", "$r23", "$r24", "$r25", "$r26", "$r27", "$r28", "$cc", \ | |
80 | "?fp", "?ap", "$pc", "?cc" } | |
81 | ||
82 | #define FT32_FP 0 | |
83 | #define FT32_SP 1 | |
84 | #define FT32_R0 2 | |
85 | #define FT32_R1 3 | |
86 | #define FT32_R2 4 | |
87 | #define FT32_R3 5 | |
88 | #define FT32_R4 6 | |
89 | #define FT32_R5 7 | |
90 | #define FT32_R6 8 | |
91 | #define FT32_R7 9 | |
92 | #define FT32_R8 10 | |
93 | #define FT32_R9 11 | |
94 | #define FT32_R10 12 | |
95 | #define FT32_R11 13 | |
96 | #define FT32_R12 14 | |
97 | #define FT32_R13 15 | |
98 | #define FT32_R14 16 | |
99 | #define FT32_R15 17 | |
100 | #define FT32_R16 18 | |
101 | #define FT32_R17 19 | |
102 | #define FT32_R18 20 | |
103 | #define FT32_R19 21 | |
104 | #define FT32_R20 22 | |
105 | #define FT32_R21 23 | |
106 | #define FT32_R22 24 | |
107 | #define FT32_R23 25 | |
108 | #define FT32_R24 26 | |
109 | #define FT32_R25 27 | |
110 | #define FT32_R26 28 | |
111 | #define FT32_R27 29 | |
112 | #define FT32_R28 30 | |
113 | #define FT32_R29 31 | |
114 | #define FT32_QAP (32 + 1) | |
115 | #define FT32_PC (32 + 2) | |
116 | #define FT32_CC (32 + 3) | |
117 | #define FIRST_PSEUDO_REGISTER (32 + 4) | |
118 | ||
119 | enum reg_class | |
120 | { | |
121 | NO_REGS, | |
122 | GENERAL_REGS, | |
123 | SPECIAL_REGS, | |
124 | CC_REGS, | |
125 | ALL_REGS, | |
126 | LIM_REG_CLASSES | |
127 | }; | |
128 | ||
129 | #define REG_CLASS_CONTENTS \ | |
130 | { { 0x00000000, 0x00000000 }, /* Empty */ \ | |
131 | { 0xFFFFFFFF, 0x00000003 }, /* $fp, $sp, $r0 to $r13, ?fp */ \ | |
132 | { 0x00000000, 0x00000004 }, /* $pc */ \ | |
133 | { 0x00000000, 0x00000008 }, /* ?cc */ \ | |
134 | { 0xFFFFFFFF, 0x0000000F } /* All registers */ \ | |
135 | } | |
136 | ||
137 | #define N_REG_CLASSES LIM_REG_CLASSES | |
138 | ||
139 | #define REG_CLASS_NAMES {\ | |
140 | "NO_REGS", \ | |
141 | "GENERAL_REGS", \ | |
142 | "SPECIAL_REGS", \ | |
143 | "CC_REGS", \ | |
144 | "ALL_REGS" } | |
145 | ||
146 | #define FIXED_REGISTERS /* fp sp r0 r1 */ { 1, 1, 0, 0, \ | |
147 | /* r2 r3 r4 r5 */ 0, 0, 0, 0, \ | |
148 | /* r6 r7 r8 r9 */ 0, 0, 0, 0, \ | |
149 | /* r10 r11 r12 r13 */ 0, 0, 0, 0, \ | |
150 | /* r14 r15 r16 r17 */ 0, 0, 0, 0, \ | |
151 | /* r18 r19 r20 r21 */ 0, 0, 0, 0, \ | |
152 | /* r22 r23 r24 r25 */ 0, 0, 0, 0, \ | |
153 | /* r26 r27 r28 r29 */ 0, 0, 1, 1, \ | |
154 | /* r30 r31 */ 1, 1, 1, 1 } | |
155 | ||
156 | #define CALL_USED_REGISTERS \ | |
157 | /* fp sp r0 r1 */ { 1, 1, 1, 1, \ | |
158 | /* r2 r3 r4 r5 */ 1, 1, 1, 1, \ | |
159 | /* r6 r7 r8 r9 */ 1, 1, 1, 1, \ | |
160 | /* r10 r11 r12 r13 */ 1, 1, 1, 0, \ | |
161 | /* r14 r15 r16 r17 */ 0, 0, 0, 0, \ | |
162 | /* r18 r19 r20 r21 */ 0, 0, 0, 0, \ | |
163 | /* r22 r23 r24 r25 */ 0, 0, 0, 0, \ | |
164 | /* r26 r27 r28 r29 */ 0, 0, 1, 1, \ | |
165 | /* r30 r31 */ 1, 1, 1, 1 } | |
166 | ||
167 | /* We can't copy to or from our CC register. */ | |
168 | #define AVOID_CCMODE_COPIES 1 | |
169 | ||
fef939d6 JB |
170 | /* A C expression whose value is a register class containing hard |
171 | register REGNO. */ | |
172 | #define REGNO_REG_CLASS(R) ((R < FT32_PC) ? GENERAL_REGS : \ | |
173 | (R == FT32_CC ? CC_REGS : SPECIAL_REGS)) | |
174 | ||
fef939d6 JB |
175 | /* The Overall Framework of an Assembler File */ |
176 | ||
177 | #undef ASM_SPEC | |
178 | #define ASM_COMMENT_START "#" | |
179 | #define ASM_APP_ON "" | |
180 | #define ASM_APP_OFF "" | |
181 | ||
182 | #define FILE_ASM_OP "\t.file\n" | |
183 | ||
184 | /* Switch to the text or data segment. */ | |
185 | #define TEXT_SECTION_ASM_OP "\t.text" | |
186 | #define DATA_SECTION_ASM_OP "\t.data" | |
187 | ||
188 | /* Assembler Commands for Alignment */ | |
189 | ||
190 | #define ASM_OUTPUT_ALIGN(STREAM,POWER) \ | |
191 | fprintf (STREAM, "\t.p2align\t%d\n", POWER); | |
192 | ||
193 | /* A C compound statement to output to stdio stream STREAM the | |
194 | assembler syntax for an instruction operand X. */ | |
195 | #define PRINT_OPERAND(STREAM, X, CODE) ft32_print_operand (STREAM, X, CODE) | |
196 | ||
197 | #define PRINT_OPERAND_ADDRESS(STREAM ,X) ft32_print_operand_address (STREAM, X) | |
198 | ||
199 | /* Output and Generation of Labels */ | |
200 | ||
201 | #define GLOBAL_ASM_OP "\t.global\t" | |
202 | ||
7c42a367 | 203 | #define JUMP_TABLES_IN_TEXT_SECTION (TARGET_NOPM ? 0 : 1) |
fef939d6 JB |
204 | |
205 | /* This is how to output an element of a case-vector that is absolute. */ | |
206 | ||
207 | #define ASM_OUTPUT_ADDR_VEC_ELT(FILE, VALUE) \ | |
77abf71f | 208 | fprintf (FILE, "\t.long\t.L%d\n", VALUE) \ |
fef939d6 JB |
209 | |
210 | /* Passing Arguments in Registers */ | |
211 | ||
212 | /* A C type for declaring a variable that is used as the first | |
213 | argument of `FUNCTION_ARG' and other related values. */ | |
214 | #define CUMULATIVE_ARGS unsigned int | |
215 | ||
216 | /* If defined, the maximum amount of space required for outgoing arguments | |
217 | will be computed and placed into the variable | |
218 | `current_function_outgoing_args_size'. No space will be pushed | |
219 | onto the stack for each call; instead, the function prologue should | |
220 | increase the stack frame size by this amount. */ | |
221 | #define ACCUMULATE_OUTGOING_ARGS 1 | |
222 | ||
223 | /* A C statement (sans semicolon) for initializing the variable CUM | |
224 | for the state at the beginning of the argument list. | |
225 | For ft32, the first arg is passed in register 2 (aka $r0). */ | |
226 | #define INIT_CUMULATIVE_ARGS(CUM,FNTYPE,LIBNAME,FNDECL,N_NAMED_ARGS) \ | |
227 | (CUM = FT32_R0) | |
228 | ||
229 | /* How Scalar Function Values Are Returned */ | |
230 | ||
231 | /* STACK AND CALLING */ | |
232 | ||
233 | /* Define this macro if pushing a word onto the stack moves the stack | |
234 | pointer to a smaller address. */ | |
ed1332ee | 235 | #define STACK_GROWS_DOWNWARD 1 |
fef939d6 | 236 | |
fef939d6 JB |
237 | /* Offset from the argument pointer register to the first argument's |
238 | address. On some machines it may depend on the data type of the | |
239 | function. */ | |
240 | #define FIRST_PARM_OFFSET(F) 0 | |
241 | ||
242 | /* Define this macro to nonzero value if the addresses of local variable slots | |
243 | are at negative offsets from the frame pointer. */ | |
244 | #define FRAME_GROWS_DOWNWARD 1 | |
245 | ||
246 | /* EXIT_IGNORE_STACK should be nonzero if, when returning from a function, | |
247 | the stack pointer does not matter. The value is tested only in | |
248 | functions that have frame pointers. | |
249 | No definition is equivalent to always zero. */ | |
250 | ||
251 | #define EXIT_IGNORE_STACK 0 | |
252 | ||
253 | /* Define this macro as a C expression that is nonzero for registers that are | |
254 | used by the epilogue or the return pattern. The stack and frame | |
255 | pointer registers are already assumed to be used as needed. */ | |
256 | #define EPILOGUE_USES(R) (R == FT32_R5) | |
257 | ||
258 | /* A C expression whose value is RTL representing the location of the | |
259 | incoming return address at the beginning of any function, before | |
260 | the prologue. */ | |
261 | #define INCOMING_RETURN_ADDR_RTX \ | |
262 | gen_frame_mem (Pmode, \ | |
263 | plus_constant (Pmode, stack_pointer_rtx, 333 * UNITS_PER_WORD)) | |
264 | ||
265 | #define RETURN_ADDR_RTX(COUNT, FRAMEADDR) \ | |
266 | ((COUNT) == 0 \ | |
267 | ? gen_rtx_MEM (Pmode, gen_rtx_PLUS (Pmode, arg_pointer_rtx, GEN_INT (-4))) \ | |
268 | : NULL_RTX) | |
269 | ||
270 | /* Describe how we implement __builtin_eh_return. */ | |
271 | #define EH_RETURN_DATA_REGNO(N) ((N) < 4 ? (N+2) : INVALID_REGNUM) | |
272 | ||
273 | /* Store the return handler into the call frame. */ | |
274 | #define EH_RETURN_HANDLER_RTX \ | |
275 | gen_frame_mem (Pmode, \ | |
276 | plus_constant (Pmode, frame_pointer_rtx, UNITS_PER_WORD)) | |
277 | ||
278 | /* Storage Layout */ | |
279 | ||
280 | #define BITS_BIG_ENDIAN 0 | |
281 | #define BYTES_BIG_ENDIAN 0 | |
282 | #define WORDS_BIG_ENDIAN 0 | |
283 | ||
284 | /* Alignment required for a function entry point, in bits. */ | |
285 | #define FUNCTION_BOUNDARY 32 | |
286 | ||
287 | #define BRANCH_COST(speed_p, predictable_p) 2 | |
288 | ||
289 | /* Define this macro as a C expression which is nonzero if accessing | |
290 | less than a word of memory (i.e. a `char' or a `short') is no | |
291 | faster than accessing a word of memory. */ | |
292 | #define SLOW_BYTE_ACCESS 1 | |
293 | ||
294 | #define STORE_FLAG_VALUE 1 | |
295 | ||
296 | #define MOVE_RATIO(speed) ((speed) ? 6 : 2) | |
297 | ||
298 | /* Number of storage units in a word; normally the size of a | |
299 | general-purpose register, a power of two from 1 or 8. */ | |
300 | #define UNITS_PER_WORD 4 | |
301 | ||
302 | /* Define this macro to the minimum alignment enforced by hardware | |
303 | for the stack pointer on this machine. The definition is a C | |
304 | expression for the desired alignment (measured in bits). */ | |
305 | #define STACK_BOUNDARY 32 | |
306 | ||
307 | /* Normal alignment required for function parameters on the stack, in | |
308 | bits. All stack parameters receive at least this much alignment | |
309 | regardless of data type. */ | |
310 | #define PARM_BOUNDARY 32 | |
311 | ||
312 | /* Alignment of field after `int : 0' in a structure. */ | |
313 | #define EMPTY_FIELD_BOUNDARY 32 | |
314 | ||
315 | /* No data type wants to be aligned rounder than this. */ | |
316 | #define BIGGEST_ALIGNMENT 32 | |
317 | ||
318 | /* The best alignment to use in cases where we have a choice. */ | |
319 | #define FASTEST_ALIGNMENT 32 | |
320 | ||
321 | /* Align definitions of arrays, unions and structures so that | |
322 | initializations and copies can be made more efficient. This is not | |
323 | ABI-changing, so it only affects places where we can see the | |
324 | definition. Increasing the alignment tends to introduce padding, | |
325 | so don't do this when optimizing for size/conserving stack space. */ | |
326 | #define FT32_EXPAND_ALIGNMENT(COND, EXP, ALIGN) \ | |
327 | (((COND) && ((ALIGN) < BITS_PER_WORD) \ | |
328 | && (TREE_CODE (EXP) == ARRAY_TYPE \ | |
329 | || TREE_CODE (EXP) == UNION_TYPE \ | |
330 | || TREE_CODE (EXP) == RECORD_TYPE)) ? BITS_PER_WORD : (ALIGN)) | |
331 | ||
332 | /* Make arrays of chars word-aligned for the same reasons. */ | |
333 | #define DATA_ALIGNMENT(TYPE, ALIGN) \ | |
334 | (TREE_CODE (TYPE) == ARRAY_TYPE \ | |
335 | && TYPE_MODE (TREE_TYPE (TYPE)) == QImode \ | |
336 | && (ALIGN) < FASTEST_ALIGNMENT ? FASTEST_ALIGNMENT : (ALIGN)) | |
337 | ||
338 | /* Similarly, make sure that objects on the stack are sensibly aligned. */ | |
339 | #define LOCAL_ALIGNMENT(EXP, ALIGN) \ | |
340 | FT32_EXPAND_ALIGNMENT(/*!flag_conserve_stack*/ 1, EXP, ALIGN) | |
341 | ||
342 | /* Every structures size must be a multiple of 8 bits. */ | |
343 | #define STRUCTURE_SIZE_BOUNDARY 8 | |
344 | ||
345 | /* Look at the fundamental type that is used for a bit-field and use | |
346 | that to impose alignment on the enclosing structure. | |
347 | struct s {int a:8}; should have same alignment as "int", not "char". */ | |
348 | #define PCC_BITFIELD_TYPE_MATTERS 1 | |
349 | ||
350 | /* Largest integer machine mode for structures. If undefined, the default | |
351 | is GET_MODE_SIZE(DImode). */ | |
352 | #define MAX_FIXED_MODE_SIZE 32 | |
353 | ||
fef939d6 JB |
354 | /* Set this nonzero if move instructions will actually fail to work |
355 | when given unaligned data. */ | |
356 | #define STRICT_ALIGNMENT 1 | |
357 | ||
358 | /* Generating Code for Profiling */ | |
359 | #define FUNCTION_PROFILER(FILE,LABELNO) (abort (), 0) | |
360 | ||
361 | /* Trampolines for Nested Functions. */ | |
362 | #define TRAMPOLINE_SIZE (2 + 6 + 6 + 2 + 2 + 6) | |
363 | ||
364 | /* Alignment required for trampolines, in bits. */ | |
365 | #define TRAMPOLINE_ALIGNMENT 32 | |
366 | ||
367 | /* An alias for the machine mode for pointers. */ | |
368 | #define Pmode SImode | |
369 | ||
370 | #define PROMOTE_MODE(MODE, UNSIGNEDP, TYPE) \ | |
371 | do { \ | |
372 | if (((MODE) == HImode) \ | |
373 | || ((MODE) == QImode)) \ | |
374 | (MODE) = SImode; \ | |
375 | } while (0) | |
376 | ||
377 | /* An alias for the machine mode used for memory references to | |
378 | functions being called, in `call' RTL expressions. */ | |
379 | #define FUNCTION_MODE QImode | |
380 | ||
381 | #define STATIC_CHAIN_REGNUM FT32_R28 | |
382 | ||
383 | /* The register number of the stack pointer register, which must also | |
384 | be a fixed register according to `FIXED_REGISTERS'. */ | |
385 | #define STACK_POINTER_REGNUM FT32_SP | |
386 | ||
387 | /* The register number of the frame pointer register, which is used to | |
388 | access automatic variables in the stack frame. */ | |
389 | #define FRAME_POINTER_REGNUM FT32_FP | |
390 | ||
391 | /* The register number of the arg pointer register, which is used to | |
392 | access the function's argument list. */ | |
393 | #define ARG_POINTER_REGNUM FT32_QAP | |
394 | ||
395 | #define ELIMINABLE_REGS \ | |
396 | {{ARG_POINTER_REGNUM, STACK_POINTER_REGNUM}, \ | |
397 | {ARG_POINTER_REGNUM, FRAME_POINTER_REGNUM}, \ | |
398 | {FRAME_POINTER_REGNUM, STACK_POINTER_REGNUM}} | |
399 | ||
400 | ||
53680238 BE |
401 | /* This macro returns the initial difference between the specified pair |
402 | of registers. */ | |
fef939d6 JB |
403 | #define INITIAL_ELIMINATION_OFFSET(FROM, TO, OFFSET) \ |
404 | do { \ | |
405 | (OFFSET) = ft32_initial_elimination_offset ((FROM), (TO)); \ | |
406 | } while (0) | |
407 | ||
408 | /* A C expression that is nonzero if REGNO is the number of a hard | |
409 | register in which function arguments are sometimes passed. */ | |
410 | #define FUNCTION_ARG_REGNO_P(r) (r >= FT32_R0 && r <= FT32_R5) | |
411 | ||
412 | /* A macro whose definition is the name of the class to which a valid | |
413 | base register must belong. A base register is one used in an | |
414 | address which is the register value plus a displacement. */ | |
415 | #define BASE_REG_CLASS GENERAL_REGS | |
416 | ||
417 | #define INDEX_REG_CLASS NO_REGS | |
418 | ||
419 | #define HARD_REGNO_OK_FOR_BASE_P(NUM) \ | |
420 | ((unsigned) (NUM) < FIRST_PSEUDO_REGISTER \ | |
421 | && (REGNO_REG_CLASS(NUM) == GENERAL_REGS \ | |
422 | || (NUM) == HARD_FRAME_POINTER_REGNUM)) | |
423 | ||
424 | /* A C expression which is nonzero if register number NUM is suitable | |
425 | for use as a base register in operand addresses. */ | |
426 | #ifdef REG_OK_STRICT | |
427 | #define REGNO_OK_FOR_BASE_P(NUM) \ | |
428 | (HARD_REGNO_OK_FOR_BASE_P(NUM) \ | |
429 | || HARD_REGNO_OK_FOR_BASE_P(reg_renumber[(NUM)])) | |
430 | #else | |
431 | #define REGNO_OK_FOR_BASE_P(NUM) \ | |
432 | ((NUM) >= FIRST_PSEUDO_REGISTER || HARD_REGNO_OK_FOR_BASE_P(NUM)) | |
433 | #endif | |
434 | ||
435 | /* A C expression which is nonzero if register number NUM is suitable | |
436 | for use as an index register in operand addresses. */ | |
437 | #define REGNO_OK_FOR_INDEX_P(NUM) FT32_FP | |
438 | ||
439 | /* The maximum number of bytes that a single instruction can move | |
440 | quickly between memory and registers or between two memory | |
441 | locations. */ | |
442 | #define MOVE_MAX 4 | |
fef939d6 JB |
443 | |
444 | /* Define this to be nonzero if shift instructions ignore all but the low-order | |
445 | few bits. */ | |
446 | #define SHIFT_COUNT_TRUNCATED 1 | |
447 | ||
448 | /* All load operations zero extend. */ | |
449 | #define LOAD_EXTEND_OP(MEM) ZERO_EXTEND | |
450 | ||
451 | /* A number, the maximum number of registers that can appear in a | |
452 | valid memory address. */ | |
453 | #define MAX_REGS_PER_ADDRESS 1 | |
454 | ||
455 | /* An alias for a machine mode name. This is the machine mode that | |
456 | elements of a jump-table should have. */ | |
457 | #define CASE_VECTOR_MODE SImode | |
458 | ||
459 | /* Run-time Target Specification */ | |
460 | ||
461 | #define TARGET_CPU_CPP_BUILTINS() \ | |
462 | { \ | |
463 | builtin_define ("__FT32__"); \ | |
464 | } | |
465 | ||
466 | #define HAS_LONG_UNCOND_BRANCH true | |
467 | ||
468 | #define NO_FUNCTION_CSE 1 | |
469 | ||
470 | #define ADDR_SPACE_PM 1 | |
471 | ||
472 | #define REGISTER_TARGET_PRAGMAS() do { \ | |
7c42a367 | 473 | c_register_addr_space ("__flash__", TARGET_NOPM ? 0 : ADDR_SPACE_PM); \ |
f8575ee9 | 474 | } while (0) |
fef939d6 JB |
475 | |
476 | extern int ft32_is_mem_pm(rtx o); | |
477 | ||
f0f649c3 JB |
478 | #define ASM_OUTPUT_SYMBOL_REF(stream, sym) \ |
479 | do { \ | |
480 | assemble_name (stream, XSTR (sym, 0)); \ | |
481 | int section_debug = in_section && \ | |
482 | (SECTION_STYLE (in_section) == SECTION_NAMED) && \ | |
483 | (in_section->named.common.flags & SECTION_DEBUG); \ | |
484 | if (!section_debug && SYMBOL_REF_FLAGS (sym) & 0x1000) \ | |
485 | asm_fprintf (stream, "-0x800000"); \ | |
486 | } while (0) | |
487 | ||
fef939d6 | 488 | #endif /* GCC_FT32_H */ |