1 /* Definitions of target machine for TI PRU.
2 Copyright (C) 2014-2023 Free Software Foundation, Inc.
3 Contributed by Dimitar Dimitrov <dimitar@dinux.eu>
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_PRU_H
22 #define GCC_PRU_H
23
24 #include "config/pru/pru-opts.h"
25
26 /* Define built-in preprocessor macros. */
27 #define TARGET_CPU_CPP_BUILTINS() \
28 do \
29 { \
30 builtin_define_std ("__PRU__"); \
31 builtin_define_std ("__pru__"); \
32 builtin_define_std ("__PRU_V3__"); \
33 builtin_define_std ("__LITTLE_ENDIAN__"); \
34 builtin_define_std ("__little_endian__"); \
35 /* Trampolines are disabled for now. */ \
36 builtin_define_std ("NO_TRAMPOLINES"); \
37 } \
38 while (0)
39
40 /* TI ABI implementation is not feature-complete enough (e.g. function
41 pointers are not supported), so we cannot list it as a multilib variant.
42 To prevent misuse from users, do not link any of the standard libraries. */
43 #define DRIVER_SELF_SPECS \
44 "%{mabi=ti:-nodefaultlibs} " \
45 "%{mmcu=*:-specs=device-specs/%*%s %<mmcu=*} "
46
47 #undef CPP_SPEC
48 #define CPP_SPEC \
49 "%(cpp_device) " \
50 "%{mabi=ti:-D__PRU_EABI_TI__; :-D__PRU_EABI_GNU__}"
51
52 /* Do not relax when in TI ABI mode since TI tools do not always
53 put PRU_S10_PCREL. */
54 #undef LINK_SPEC
55 #define LINK_SPEC \
56 "%(link_device) " \
57 "%{mabi=ti:--no-relax;:%{mno-relax:--no-relax;:--relax}} " \
58 "%{shared:%eshared is not supported} "
59
60 /* CRT0 is carefully maintained to be compatible with both GNU and TI ABIs. */
61 #undef STARTFILE_SPEC
62 #define STARTFILE_SPEC \
63 "%{!pg:%{minrt:crt0-minrt.o%s}%{!minrt:crt0.o%s}} %{!mabi=ti:-lgcc} "
64
65 #undef ENDFILE_SPEC
66 #define ENDFILE_SPEC "%{!mabi=ti:-lgloss} "
67
68 /* TI ABI mandates that ELF symbols do not start with any prefix. */
69 #undef USER_LABEL_PREFIX
70 #define USER_LABEL_PREFIX ""
71
72 #undef LOCAL_LABEL_PREFIX
73 #define LOCAL_LABEL_PREFIX ".L"
74
75 /* Storage layout. */
76
77 #define DEFAULT_SIGNED_CHAR 0
78 #define BITS_BIG_ENDIAN 0
79 #define BYTES_BIG_ENDIAN 0
80 #define WORDS_BIG_ENDIAN 0
81
82 /* PRU is represented in GCC as an 8-bit CPU with fast 16-bit and 32-bit
83 arithmetic. */
84 #define BITS_PER_WORD 8
85
86 #ifdef IN_LIBGCC2
87 /* This is to get correct SI and DI modes in libgcc2.c (32 and 64 bits). */
88 #define UNITS_PER_WORD 4
89 #else
90 /* Width of a word, in units (bytes). */
91 #define UNITS_PER_WORD 1
92 #endif
93
94 #define POINTER_SIZE 32
95 #define BIGGEST_ALIGNMENT 8
96 #define STRICT_ALIGNMENT 0
97 #define FUNCTION_BOUNDARY 8 /* Func pointers are word-addressed. */
98 #define PARM_BOUNDARY 8
99 #define STACK_BOUNDARY 8
100 #define MAX_FIXED_MODE_SIZE 64
101
102 #define POINTERS_EXTEND_UNSIGNED 1
103
104 /* Layout of source language data types. */
105
106 #define INT_TYPE_SIZE 32
107 #define SHORT_TYPE_SIZE 16
108 #define LONG_TYPE_SIZE 32
109 #define LONG_LONG_TYPE_SIZE 64
110 #define FLOAT_TYPE_SIZE 32
111 #define DOUBLE_TYPE_SIZE 64
112 #define LONG_DOUBLE_TYPE_SIZE DOUBLE_TYPE_SIZE
113
114 #undef SIZE_TYPE
115 #define SIZE_TYPE "unsigned int"
116
117 #undef PTRDIFF_TYPE
118 #define PTRDIFF_TYPE "int"
119
120
121 /* Basic characteristics of PRU registers:
122
123 Regno Name
124 0 r0 Caller Saved. Also used as a static chain register.
125 1 r1 Caller Saved. Also used as a temporary by function.
126 profiler and function prologue/epilogue.
127 2 r2 sp Stack Pointer.
128 3* r3.w0 Caller saved.
129 3* r3.w2 ra Return Address (16-bit).
130 4 r4 fp Frame Pointer, also called Argument Pointer in ABI.
131 5-13 r5-r13 Callee Saved Registers.
132 14-29 r14-r29 Register Arguments. Caller Saved Registers.
133 14-15 r14-r15 Return Location.
134 30 r30 Special I/O register. Not used by compiler.
135 31 r31 Special I/O register. Not used by compiler.
136
137 32 loop_cntr Internal register used as a counter by LOOP insns.
138
139 33 pc Not an actual register.
140
141 34 fake_fp Fake Frame Pointer (always eliminated).
142 35 fake_ap Fake Argument Pointer (always eliminated).
143 36 First Pseudo Register.
144
145 The definitions for some hard register numbers are located in pru.md.
146 Note that GCC's internal register numbering differs from the conventional
147 register naming in PRU ISA. PRU ISA defines word-based register numbers
148 and sub-register suffixes (e.g. RA is r3.w0). GCC uses linear numbering
149 of 8 bit sub-registers (e.g. RA starts at r12). When outputting assembly,
150 GCC will take into account the RTL operand size (e.g. r12:HI) in order to
151 translate to the conventional PRU ISA format expected by GAS (r3.w0).
152 */
153
154 #define FIXED_REGISTERS \
155 { \
156 /* 0 */ 0,0,0,0, 0,0,0,0, 1,1,1,1, 0,0,1,1, \
157 /* 4 */ 0,0,0,0, 0,0,0,0, 0,0,0,0, 0,0,0,0, \
158 /* 8 */ 0,0,0,0, 0,0,0,0, 0,0,0,0, 0,0,0,0, \
159 /* 12 */ 0,0,0,0, 0,0,0,0, 0,0,0,0, 0,0,0,0, \
160 /* 16 */ 0,0,0,0, 0,0,0,0, 0,0,0,0, 0,0,0,0, \
161 /* 20 */ 0,0,0,0, 0,0,0,0, 0,0,0,0, 0,0,0,0, \
162 /* 24 */ 0,0,0,0, 0,0,0,0, 0,0,0,0, 0,0,0,0, \
163 /* 28 */ 0,0,0,0, 0,0,0,0, 1,1,1,1, 1,1,1,1, \
164 /* 32 */ 1,1,1,1, 1,1,1,1, 1,1,1,1, 1,1,1,1 \
165 }
166
167 /* Call used == caller saved + fixed regs + args + ret vals. */
168 #define CALL_USED_REGISTERS \
169 { \
170 /* 0 */ 1,1,1,1, 1,1,1,1, 1,1,1,1, 1,1,1,1, \
171 /* 4 */ 0,0,0,0, 0,0,0,0, 0,0,0,0, 0,0,0,0, \
172 /* 8 */ 0,0,0,0, 0,0,0,0, 0,0,0,0, 0,0,0,0, \
173 /* 12 */ 0,0,0,0, 0,0,0,0, 1,1,1,1, 1,1,1,1, \
174 /* 16 */ 1,1,1,1, 1,1,1,1, 1,1,1,1, 1,1,1,1, \
175 /* 20 */ 1,1,1,1, 1,1,1,1, 1,1,1,1, 1,1,1,1, \
176 /* 24 */ 1,1,1,1, 1,1,1,1, 1,1,1,1, 1,1,1,1, \
177 /* 28 */ 1,1,1,1, 1,1,1,1, 1,1,1,1, 1,1,1,1, \
178 /* 32 */ 1,1,1,1, 1,1,1,1, 1,1,1,1, 1,1,1,1 \
179 }
180
181 #define PRU_SEQ_R(X) (X) * 4 + 0, (X) * 4 + 1, (X) * 4 + 2, (X) * 4 + 3
182 #define PRU_SEQ_R_W0(X) (X) * 4 + 0, (X) * 4 + 1
183 #define PRU_SEQ_R_W2(X) (X) * 4 + 2, (X) * 4 + 3
184 #define REG_ALLOC_ORDER \
185 { \
186 /* Call-clobbered, yet not used for parameters. */ \
187 PRU_SEQ_R (0), PRU_SEQ_R ( 1), \
188 PRU_SEQ_R_W0 (3), \
189 \
190 PRU_SEQ_R (14), PRU_SEQ_R (15), PRU_SEQ_R (16), PRU_SEQ_R (17), \
191 PRU_SEQ_R (18), PRU_SEQ_R (19), PRU_SEQ_R (20), PRU_SEQ_R (21), \
192 PRU_SEQ_R (22), PRU_SEQ_R (23), PRU_SEQ_R (24), PRU_SEQ_R (25), \
193 PRU_SEQ_R (26), PRU_SEQ_R (27), PRU_SEQ_R (28), PRU_SEQ_R (29), \
194 \
195 PRU_SEQ_R ( 5), PRU_SEQ_R ( 6), PRU_SEQ_R ( 7), PRU_SEQ_R ( 8), \
196 PRU_SEQ_R ( 9), PRU_SEQ_R (10), PRU_SEQ_R (11), PRU_SEQ_R (12), \
197 PRU_SEQ_R (13), \
198 \
199 PRU_SEQ_R ( 4), \
200 PRU_SEQ_R ( 2), \
201 PRU_SEQ_R_W2 (3), \
202 \
203 /* I/O and virtual registers. */ \
204 PRU_SEQ_R (30), PRU_SEQ_R (31), PRU_SEQ_R (32), PRU_SEQ_R (33), \
205 PRU_SEQ_R (34), PRU_SEQ_R (35) \
206 }
207
208 /* Register Classes. */
209
210 enum reg_class
211 {
212 NO_REGS,
213 SIB_REGS,
214 LOOPCNTR_REGS,
215 MULDST_REGS,
216 MULSRC0_REGS,
217 MULSRC1_REGS,
218 REGIO_REGS,
219 GP_REGS,
220 ALL_REGS,
221 LIM_REG_CLASSES
222 };
223
224 #define N_REG_CLASSES (int) LIM_REG_CLASSES
225
226 #define REG_CLASS_NAMES \
227 { "NO_REGS", \
228 "SIB_REGS", \
229 "LOOPCNTR_REGS", \
230 "MULDST_REGS", \
231 "MULSRC0_REGS", \
232 "MULSRC1_REGS", \
233 "REGIO_REGS", \
234 "GP_REGS", \
235 "ALL_REGS" }
236
237 #define GENERAL_REGS ALL_REGS
238
239 #define REG_CLASS_CONTENTS \
240 { \
241 /* NO_REGS */ { 0, 0, 0, 0, 0}, \
242 /* SIB_REGS */ { 0xf, 0xff000000, ~0, 0xffffff, 0}, \
243 /* LOOPCNTR_REGS */ { 0, 0, 0, 0, 0xf}, \
244 /* MULDST_REGS */ { 0, 0, 0, 0x00000f00, 0}, \
245 /* MULSRC0_REGS */ { 0, 0, 0, 0x000f0000, 0}, \
246 /* MULSRC1_REGS */ { 0, 0, 0, 0x00f00000, 0}, \
247 /* REGIO_REGS */ { 0, 0, 0, 0xff000000, 0}, \
248 /* GP_REGS */ { ~0, ~0, ~0, ~0, 0}, \
249 /* ALL_REGS */ { ~0,~0, ~0, ~0, ~0} \
250 }
251
252
253 #define GP_REG_P(REGNO) ((unsigned)(REGNO) <= LAST_GP_REGNUM)
254 #define REGNO_REG_CLASS(REGNO) \
255 ((REGNO) == MULDST_REGNUM ? MULDST_REGS \
256 : (REGNO) == MULSRC0_REGNUM ? MULSRC0_REGS \
257 : (REGNO) == MULSRC1_REGNUM ? MULSRC1_REGS \
258 : (REGNO) == R30_REGNUM ? REGIO_REGS \
259 : (REGNO) == R31_REGNUM ? REGIO_REGS \
260 : (REGNO) >= FIRST_ARG_REGNUM \
261 && (REGNO) <= LAST_ARG_REGNUM ? SIB_REGS \
262 : (REGNO) == STATIC_CHAIN_REGNUM ? SIB_REGS \
263 : (REGNO) == LOOPCNTR_REGNUM ? LOOPCNTR_REGS \
264 : (REGNO) <= LAST_NONIO_GP_REGNUM ? GP_REGS \
265 : ALL_REGS)
266
267 #define CLASS_MAX_NREGS(CLASS, MODE) \
268 ((GET_MODE_SIZE (MODE) + UNITS_PER_WORD - 1) / UNITS_PER_WORD)
269
270 /* Arbitrarily set to a non-argument register. Not defined by TI ABI. */
271 #define STATIC_CHAIN_REGNUM 0 /* r0 */
272
273 /* Tests for various kinds of constants used in the PRU port. */
274 #define SHIFT_INT(X) (IN_RANGE ((X), 0, 31))
275
276 #define UHWORD_INT(X) (IN_RANGE ((X), 0, 0xffff))
277 #define SHWORD_INT(X) (IN_RANGE ((X), -32768, 32767))
278 #define UBYTE_INT(X) (IN_RANGE ((X), 0, 0xff))
279 #define SBYTE_INT(X) (IN_RANGE ((X), -128, 127))
280
281 /* Say that the epilogue uses the return address register. Note that
282 in the case of sibcalls, the values "used by the epilogue" are
283 considered live at the start of the called function. */
284 #define EPILOGUE_USES(REGNO) (epilogue_completed \
285 && (((REGNO) == RA_REGNUM) \
286 || (REGNO) == (RA_REGNUM + 1)))
287
288 /* EXIT_IGNORE_STACK should be nonzero if, when returning from a function,
289 the stack pointer does not matter. The value is tested only in
290 functions that have frame pointers.
291 No definition is equivalent to always zero. */
292
293 #define EXIT_IGNORE_STACK 1
294
295 /* Trampolines are not supported, but put a define to keep the build. */
296 #define TRAMPOLINE_SIZE 4
297
298 /* Stack layout. */
299 #define STACK_GROWS_DOWNWARD 1
300 #undef FRAME_GROWS_DOWNWARD
301 #define FIRST_PARM_OFFSET(FUNDECL) 0
302
303 /* Before the prologue, RA lives in r3.w2. */
304 #define INCOMING_RETURN_ADDR_RTX gen_rtx_REG (HImode, RA_REGNUM)
305
306 #define RETURN_ADDR_RTX(C,F) pru_get_return_address (C)
307
308 #define DWARF_FRAME_RETURN_COLUMN RA_REGNUM
309
310 /* The CFA includes the pretend args. */
311 #define ARG_POINTER_CFA_OFFSET(FNDECL) \
312 (gcc_assert ((FNDECL) == current_function_decl), \
313 FIRST_PARM_OFFSET (FNDECL) + crtl->args.pretend_args_size)
314
315 /* Frame/arg pointer elimination settings. */
316 #define ELIMINABLE_REGS \
317 {{ ARG_POINTER_REGNUM, STACK_POINTER_REGNUM}, \
318 { ARG_POINTER_REGNUM, HARD_FRAME_POINTER_REGNUM}, \
319 { FRAME_POINTER_REGNUM, STACK_POINTER_REGNUM}, \
320 { FRAME_POINTER_REGNUM, HARD_FRAME_POINTER_REGNUM}}
321
322 #define INITIAL_ELIMINATION_OFFSET(FROM, TO, OFFSET) \
323 (OFFSET) = pru_initial_elimination_offset ((FROM), (TO))
324
325 #define HARD_REGNO_RENAME_OK(OLD_REG, NEW_REG) \
326 pru_hard_regno_rename_ok (OLD_REG, NEW_REG)
327
328 /* Calling convention definitions. */
329 #if !defined(IN_LIBGCC2)
330
331 #define NUM_ARG_REGS (LAST_ARG_REGNUM - FIRST_ARG_REGNUM + 1)
332
333 typedef struct pru_args
334 {
335 bool regs_used[NUM_ARG_REGS];
336 } CUMULATIVE_ARGS;
337
338 #define INIT_CUMULATIVE_ARGS(CUM, FNTYPE, LIBNAME, FNDECL, N_NAMED_ARGS) \
339 do { \
340 memset ((CUM).regs_used, 0, sizeof ((CUM).regs_used)); \
341 } while (0)
342
343 #define FUNCTION_ARG_REGNO_P(REGNO) \
344 ((REGNO) >= FIRST_ARG_REGNUM && (REGNO) <= LAST_ARG_REGNUM)
345
346 /* Passing function arguments on stack. */
347 #define ACCUMULATE_OUTGOING_ARGS 1
348
349 /* We define TARGET_RETURN_IN_MEMORY, so set to zero. */
350 #define DEFAULT_PCC_STRUCT_RETURN 0
351
352 /* Profiling. */
353 #define PROFILE_BEFORE_PROLOGUE
354 #define NO_PROFILE_COUNTERS 1
355 #define FUNCTION_PROFILER(FILE, LABELNO) \
356 pru_function_profiler ((FILE), (LABELNO))
357
358 #endif /* IN_LIBGCC2 */
359
360 /* Addressing modes. */
361
362 #define CONSTANT_ADDRESS_P(X) \
363 (CONSTANT_P (X) && memory_address_p (SImode, X))
364
365 #define MAX_REGS_PER_ADDRESS 2
366 #define BASE_REG_CLASS ALL_REGS
367 #define INDEX_REG_CLASS ALL_REGS
368
369 #define REGNO_OK_FOR_BASE_P(REGNO) pru_regno_ok_for_base_p ((REGNO), true)
370 #define REGNO_OK_FOR_INDEX_P(REGNO) pru_regno_ok_for_index_p ((REGNO), true)
371
372 /* Limited by the insns in pru-ldst-multiple.md. */
373 #define MOVE_MAX 8
374 #define SLOW_BYTE_ACCESS 1
375
376 /* It is as good to call a constant function address as to call an address
377 kept in a register. */
378 #define NO_FUNCTION_CSE 1
379
380 /* Define output assembler language. */
381
382 #define ASM_APP_ON "#APP\n"
383 #define ASM_APP_OFF "#NO_APP\n"
384
385 #define ASM_COMMENT_START "# "
386
387 #define GLOBAL_ASM_OP "\t.global\t"
388
389 #define PRU_NAME_R(X) X".b0", X".b1", X".b2", X".b3"
390 #define REGISTER_NAMES \
391 { \
392 PRU_NAME_R ("r0"), \
393 PRU_NAME_R ("r1"), \
394 PRU_NAME_R ("r2"), \
395 PRU_NAME_R ("r3"), \
396 PRU_NAME_R ("r4"), \
397 PRU_NAME_R ("r5"), \
398 PRU_NAME_R ("r6"), \
399 PRU_NAME_R ("r7"), \
400 PRU_NAME_R ("r8"), \
401 PRU_NAME_R ("r9"), \
402 PRU_NAME_R ("r10"), \
403 PRU_NAME_R ("r11"), \
404 PRU_NAME_R ("r12"), \
405 PRU_NAME_R ("r13"), \
406 PRU_NAME_R ("r14"), \
407 PRU_NAME_R ("r15"), \
408 PRU_NAME_R ("r16"), \
409 PRU_NAME_R ("r17"), \
410 PRU_NAME_R ("r18"), \
411 PRU_NAME_R ("r19"), \
412 PRU_NAME_R ("r20"), \
413 PRU_NAME_R ("r21"), \
414 PRU_NAME_R ("r22"), \
415 PRU_NAME_R ("r23"), \
416 PRU_NAME_R ("r24"), \
417 PRU_NAME_R ("r25"), \
418 PRU_NAME_R ("r26"), \
419 PRU_NAME_R ("r27"), \
420 PRU_NAME_R ("r28"), \
421 PRU_NAME_R ("r29"), \
422 PRU_NAME_R ("r30"), \
423 PRU_NAME_R ("r31"), \
424 PRU_NAME_R ("loopcntr_reg"), \
425 PRU_NAME_R ("pc"), \
426 PRU_NAME_R ("fake_fp"), \
427 PRU_NAME_R ("fake_ap"), \
428 }
429
430 #define PRU_OVERLAP_R(X) \
431 { "r" #X , X * 4 , 4 }, \
432 { "r" #X ".w0", X * 4 + 0 , 2 }, \
433 { "r" #X ".w1", X * 4 + 1 , 2 }, \
434 { "r" #X ".w2", X * 4 + 2 , 2 }
435
436 #define OVERLAPPING_REGISTER_NAMES \
437 { \
438 /* Aliases. */ \
439 { "sp", 2 * 4, 4 }, \
440 { "ra", 3 * 4, 2 }, \
441 { "fp", 4 * 4, 4 }, \
442 PRU_OVERLAP_R (0), \
443 PRU_OVERLAP_R (1), \
444 PRU_OVERLAP_R (2), \
445 PRU_OVERLAP_R (3), \
446 PRU_OVERLAP_R (4), \
447 PRU_OVERLAP_R (5), \
448 PRU_OVERLAP_R (6), \
449 PRU_OVERLAP_R (7), \
450 PRU_OVERLAP_R (8), \
451 PRU_OVERLAP_R (9), \
452 PRU_OVERLAP_R (10), \
453 PRU_OVERLAP_R (11), \
454 PRU_OVERLAP_R (12), \
455 PRU_OVERLAP_R (13), \
456 PRU_OVERLAP_R (14), \
457 PRU_OVERLAP_R (15), \
458 PRU_OVERLAP_R (16), \
459 PRU_OVERLAP_R (17), \
460 PRU_OVERLAP_R (18), \
461 PRU_OVERLAP_R (19), \
462 PRU_OVERLAP_R (20), \
463 PRU_OVERLAP_R (21), \
464 PRU_OVERLAP_R (22), \
465 PRU_OVERLAP_R (23), \
466 PRU_OVERLAP_R (24), \
467 PRU_OVERLAP_R (25), \
468 PRU_OVERLAP_R (26), \
469 PRU_OVERLAP_R (27), \
470 PRU_OVERLAP_R (28), \
471 PRU_OVERLAP_R (29), \
472 PRU_OVERLAP_R (30), \
473 PRU_OVERLAP_R (31), \
474 }
475
476 #define ASM_OUTPUT_ADDR_VEC_ELT(FILE, VALUE) \
477 do \
478 { \
479 fputs (integer_asm_op (POINTER_SIZE / BITS_PER_UNIT, TRUE), FILE); \
480 fprintf (FILE, "%%pmem(.L%u)\n", (unsigned) (VALUE)); \
481 } \
482 while (0)
483
484 #define ASM_OUTPUT_ADDR_DIFF_ELT(STREAM, BODY, VALUE, REL) \
485 do \
486 { \
487 fputs (integer_asm_op (POINTER_SIZE / BITS_PER_UNIT, TRUE), STREAM); \
488 fprintf (STREAM, "%%pmem(.L%u-.L%u)\n", (unsigned) (VALUE), \
489 (unsigned) (REL)); \
490 } \
491 while (0)
492
493 /* Section directives. */
494
495 /* Output before read-only data. */
496 #define TEXT_SECTION_ASM_OP "\t.section\t.text"
497
498 /* Output before writable data. */
499 #define DATA_SECTION_ASM_OP "\t.section\t.data"
500
501 /* Output before uninitialized data. */
502 #define BSS_SECTION_ASM_OP "\t.section\t.bss"
503
504 #define CTORS_SECTION_ASM_OP "\t.section\t.init_array,\"aw\",%init_array"
505 #define DTORS_SECTION_ASM_OP "\t.section\t.fini_array,\"aw\",%fini_array"
506
507 #undef INIT_SECTION_ASM_OP
508 #undef FINI_SECTION_ASM_OP
509 #define INIT_ARRAY_SECTION_ASM_OP CTORS_SECTION_ASM_OP
510 #define FINI_ARRAY_SECTION_ASM_OP DTORS_SECTION_ASM_OP
511
512 /* Since we use .init_array/.fini_array we don't need the markers at
513 the start and end of the ctors/dtors arrays. */
514 #define CTOR_LIST_BEGIN asm (CTORS_SECTION_ASM_OP)
515 #define CTOR_LIST_END /* empty */
516 #define DTOR_LIST_BEGIN asm (DTORS_SECTION_ASM_OP)
517 #define DTOR_LIST_END /* empty */
518
519 #undef TARGET_ASM_CONSTRUCTOR
520 #define TARGET_ASM_CONSTRUCTOR pru_elf_asm_constructor
521
522 #undef TARGET_ASM_DESTRUCTOR
523 #define TARGET_ASM_DESTRUCTOR pru_elf_asm_destructor
524
525 #define ASM_OUTPUT_ALIGN(FILE, LOG) \
526 do { \
527 fprintf ((FILE), "%s%d\n", ALIGN_ASM_OP, (LOG)); \
528 } while (0)
529
530 #undef ASM_OUTPUT_ALIGNED_COMMON
531 #define ASM_OUTPUT_ALIGNED_COMMON(FILE, NAME, SIZE, ALIGN) \
532 do \
533 { \
534 fprintf ((FILE), "%s", COMMON_ASM_OP); \
535 assemble_name ((FILE), (NAME)); \
536 fprintf ((FILE), "," HOST_WIDE_INT_PRINT_UNSIGNED ",%u\n", (SIZE), \
537 (ALIGN) / BITS_PER_UNIT); \
538 } \
539 while (0)
540
541
542 /* This says how to output assembler code to declare an
543 uninitialized internal linkage data object. Under SVR4,
544 the linker seems to want the alignment of data objects
545 to depend on their types. We do exactly that here. */
546
547 #undef ASM_OUTPUT_ALIGNED_LOCAL
548 #define ASM_OUTPUT_ALIGNED_LOCAL(FILE, NAME, SIZE, ALIGN) \
549 do { \
550 switch_to_section (bss_section); \
551 ASM_OUTPUT_TYPE_DIRECTIVE (FILE, NAME, "object"); \
552 if (!flag_inhibit_size_directive) \
553 ASM_OUTPUT_SIZE_DIRECTIVE (FILE, NAME, SIZE); \
554 ASM_OUTPUT_ALIGN ((FILE), exact_log2 ((ALIGN) / BITS_PER_UNIT)); \
555 ASM_OUTPUT_LABEL (FILE, NAME); \
556 ASM_OUTPUT_SKIP ((FILE), (SIZE) ? (SIZE) : 1); \
557 } while (0)
558
559 /* Misc parameters. */
560
561 #define TARGET_SUPPORTS_WIDE_INT 1
562
563 #define STORE_FLAG_VALUE 1
564 #define Pmode SImode
565 #define FUNCTION_MODE Pmode
566
567 #define CASE_VECTOR_MODE Pmode
568
569 /* See definition of clz pattern for rationale of the value. */
570 #define CLZ_DEFINED_VALUE_AT_ZERO(MODE, VALUE) \
571 ((VALUE) = GET_MODE_BITSIZE (MODE) - 1 - 32, 2)
572
573 /* Jumps are cheap on PRU. */
574 #define LOGICAL_OP_NON_SHORT_CIRCUIT 0
575
576 /* Unfortunately the LBBO instruction does not zero-extend data. */
577 #undef LOAD_EXTEND_OP
578
579 #undef WORD_REGISTER_OPERATIONS
580
581 #define HAS_LONG_UNCOND_BRANCH 1
582 #define HAS_LONG_COND_BRANCH 1
583
584 #define REGISTER_TARGET_PRAGMAS() pru_register_pragmas ()
585
586 #endif /* GCC_PRU_H */