1 /* Target Definitions for moxie.
2 Copyright (C) 2008-2023 Free Software Foundation, Inc.
3 Contributed by Anthony Green.
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_MOXIE_H
22 #define GCC_MOXIE_H
23
24 #undef STARTFILE_SPEC
25 #define STARTFILE_SPEC "%{!mno-crt0:crt0%O%s} crti.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}}"
42
43 #undef LINK_SPEC
44 #define LINK_SPEC "%{h*} %{v:-V} %{!mel:-EB} %{mel:-EL}\
45 %{static:-Bstatic} %{shared:-shared} %{symbolic:-Bsymbolic}"
46
47 #ifndef MULTILIB_DEFAULTS
48 #define MULTILIB_DEFAULTS { "meb" }
49 #endif
50
51 /* Layout of Source Language Data Types */
52
53 #define INT_TYPE_SIZE 32
54 #define SHORT_TYPE_SIZE 16
55 #define LONG_TYPE_SIZE 32
56 #define LONG_LONG_TYPE_SIZE 64
57
58 #define FLOAT_TYPE_SIZE 32
59 #define DOUBLE_TYPE_SIZE 64
60 #define LONG_DOUBLE_TYPE_SIZE 64
61
62 #define DEFAULT_SIGNED_CHAR 0
63
64 #undef SIZE_TYPE
65 #define SIZE_TYPE "unsigned int"
66
67 #undef PTRDIFF_TYPE
68 #define PTRDIFF_TYPE "int"
69
70 #undef WCHAR_TYPE
71 #define WCHAR_TYPE "unsigned int"
72
73 #undef WCHAR_TYPE_SIZE
74 #define WCHAR_TYPE_SIZE BITS_PER_WORD
75
76 /* Registers...
77
78 $fp - frame pointer
79 $sp - stack pointer
80 $r0 - general purpose 32-bit register.
81 $r1 - general purpose 32-bit register.
82 $r2 - general purpose 32-bit register.
83 $r3 - general purpose 32-bit register.
84 $r4 - general purpose 32-bit register.
85 $r5 - general purpose 32-bit register.
86 $r6 - general purpose 32-bit register.
87 $r7 - general purpose 32-bit register.
88 $r8 - general purpose 32-bit register.
89 $r9 - general purpose 32-bit register.
90 $r10 - general purpose 32-bit register.
91 $r11 - general purpose 32-bit register.
92 $r12 - general purpose 32-bit register.
93 $r13 - reserved for execution environment.
94
95 Special Registers...
96
97 $pc - 32-bit program counter.
98
99 */
100
101 #define REGISTER_NAMES { \
102 "$fp", "$sp", "$r0", "$r1", \
103 "$r2", "$r3", "$r4", "$r5", \
104 "$r6", "$r7", "$r8", "$r9", \
105 "$r10", "$r11", "$r12", "$r13", \
106 "?fp", "?ap", "$pc", "?cc" }
107
108 #define MOXIE_FP 0
109 #define MOXIE_SP 1
110 #define MOXIE_R0 2
111 #define MOXIE_R1 3
112 #define MOXIE_R2 4
113 #define MOXIE_R3 5
114 #define MOXIE_R4 6
115 #define MOXIE_R5 7
116 #define MOXIE_R6 8
117 #define MOXIE_R7 9
118 #define MOXIE_R8 10
119 #define MOXIE_R9 11
120 #define MOXIE_R10 12
121 #define MOXIE_R11 13
122 #define MOXIE_R12 14
123 #define MOXIE_R13 15
124 #define MOXIE_QFP 16
125 #define MOXIE_QAP 17
126 #define MOXIE_PC 18
127 #define MOXIE_CC 19
128
129 #define FIRST_PSEUDO_REGISTER 20
130
131 enum reg_class
132 {
133 NO_REGS,
134 GENERAL_REGS,
135 SPECIAL_REGS,
136 CC_REGS,
137 ALL_REGS,
138 LIM_REG_CLASSES
139 };
140
141
142 #define REG_CLASS_CONTENTS \
143 { { 0x00000000 }, /* Empty */ \
144 { 0x0003FFFF }, /* $fp, $sp, $r0 to $r13, ?fp */ \
145 { 0x00040000 }, /* $pc */ \
146 { 0x00080000 }, /* ?cc */ \
147 { 0x000FFFFF } /* All registers */ \
148 }
149
150 #define N_REG_CLASSES LIM_REG_CLASSES
151
152 #define REG_CLASS_NAMES {\
153 "NO_REGS", \
154 "GENERAL_REGS", \
155 "SPECIAL_REGS", \
156 "CC_REGS", \
157 "ALL_REGS" }
158
159 #define FIXED_REGISTERS { 1, 1, 0, 0, \
160 0, 0, 0, 0, \
161 0, 0, 0, 0, \
162 0, 0, 0, 1, \
163 1, 1, 1, 1 }
164
165 #define CALL_USED_REGISTERS { 1, 1, 1, 1, \
166 1, 1, 1, 1, \
167 0, 0, 0, 0, \
168 0, 0, 1, 1, \
169 1, 1, 1, 1 }
170
171 /* We can't copy to or from our CC register. */
172 #define AVOID_CCMODE_COPIES 1
173
174 /* A C expression whose value is a register class containing hard
175 register REGNO. */
176 #define REGNO_REG_CLASS(R) ((R < MOXIE_PC) ? GENERAL_REGS : \
177 (R == MOXIE_CC ? CC_REGS : SPECIAL_REGS))
178
179 /* The Overall Framework of an Assembler File */
180
181 #undef ASM_SPEC
182 #define ASM_SPEC "%{!mel:-EB} %{mel:-EL}"
183 #define ASM_COMMENT_START "#"
184 #define ASM_APP_ON ""
185 #define ASM_APP_OFF ""
186
187 #define FILE_ASM_OP "\t.file\n"
188
189 /* Switch to the text or data segment. */
190 #define TEXT_SECTION_ASM_OP "\t.text"
191 #define DATA_SECTION_ASM_OP "\t.data"
192
193 /* Assembler Commands for Alignment */
194
195 #define ASM_OUTPUT_ALIGN(STREAM,POWER) \
196 fprintf (STREAM, "\t.p2align\t%d\n", POWER);
197
198 /* Output and Generation of Labels */
199
200 #define GLOBAL_ASM_OP "\t.global\t"
201
202 /* Passing Arguments in Registers */
203
204 /* A C type for declaring a variable that is used as the first
205 argument of `FUNCTION_ARG' and other related values. */
206 #define CUMULATIVE_ARGS unsigned int
207
208 /* If defined, the maximum amount of space required for outgoing arguments
209 will be computed and placed into the variable
210 `current_function_outgoing_args_size'. No space will be pushed
211 onto the stack for each call; instead, the function prologue should
212 increase the stack frame size by this amount. */
213 #define ACCUMULATE_OUTGOING_ARGS 1
214
215 /* A C statement (sans semicolon) for initializing the variable CUM
216 for the state at the beginning of the argument list.
217 For moxie, the first arg is passed in register 2 (aka $r0). */
218 #define INIT_CUMULATIVE_ARGS(CUM,FNTYPE,LIBNAME,FNDECL,N_NAMED_ARGS) \
219 (CUM = MOXIE_R0)
220
221 /* How Scalar Function Values Are Returned */
222
223 /* STACK AND CALLING */
224
225 /* Define this macro if pushing a word onto the stack moves the stack
226 pointer to a smaller address. */
227 #define STACK_GROWS_DOWNWARD 1
228
229 /* Define this if the above stack space is to be considered part of the
230 space allocated by the caller. */
231 #define OUTGOING_REG_PARM_STACK_SPACE(FNTYPE) 1
232 #define STACK_PARMS_IN_REG_PARM_AREA
233
234 /* Define this if it is the responsibility of the caller to allocate
235 the area reserved for arguments passed in registers. */
236 #define REG_PARM_STACK_SPACE(FNDECL) (6 * UNITS_PER_WORD)
237
238 /* Offset from the argument pointer register to the first argument's
239 address. On some machines it may depend on the data type of the
240 function. */
241 #define FIRST_PARM_OFFSET(F) 12
242
243 /* Define this macro to nonzero value if the addresses of local variable slots
244 are at negative offsets from the frame pointer. */
245 #define FRAME_GROWS_DOWNWARD 1
246
247 /* Define this macro as a C expression that is nonzero for registers that are
248 used by the epilogue or the return pattern. The stack and frame
249 pointer registers are already assumed to be used as needed. */
250 #define EPILOGUE_USES(R) (R == MOXIE_R5)
251
252 /* A C expression whose value is RTL representing the location of the
253 incoming return address at the beginning of any function, before
254 the prologue. */
255 #define INCOMING_RETURN_ADDR_RTX \
256 gen_frame_mem (Pmode, \
257 plus_constant (Pmode, stack_pointer_rtx, UNITS_PER_WORD))
258
259 /* Describe how we implement __builtin_eh_return. */
260 #define EH_RETURN_DATA_REGNO(N) ((N) < 4 ? (N+2) : INVALID_REGNUM)
261
262 /* Store the return handler into the call frame. */
263 #define EH_RETURN_HANDLER_RTX \
264 gen_frame_mem (Pmode, \
265 plus_constant (Pmode, frame_pointer_rtx, UNITS_PER_WORD))
266
267 /* Storage Layout */
268
269 #define BITS_BIG_ENDIAN 0
270 #define BYTES_BIG_ENDIAN ( ! TARGET_LITTLE_ENDIAN )
271 #define WORDS_BIG_ENDIAN ( ! TARGET_LITTLE_ENDIAN )
272
273 /* Alignment required for a function entry point, in bits. */
274 #define FUNCTION_BOUNDARY 16
275
276 /* Define this macro as a C expression which is nonzero if accessing
277 less than a word of memory (i.e. a `char' or a `short') is no
278 faster than accessing a word of memory. */
279 #define SLOW_BYTE_ACCESS 1
280
281 /* Number of storage units in a word; normally the size of a
282 general-purpose register, a power of two from 1 or 8. */
283 #define UNITS_PER_WORD 4
284
285 /* Define this macro to the minimum alignment enforced by hardware
286 for the stack pointer on this machine. The definition is a C
287 expression for the desired alignment (measured in bits). */
288 #define STACK_BOUNDARY 32
289
290 /* Normal alignment required for function parameters on the stack, in
291 bits. All stack parameters receive at least this much alignment
292 regardless of data type. */
293 #define PARM_BOUNDARY 32
294
295 /* Alignment of field after `int : 0' in a structure. */
296 #define EMPTY_FIELD_BOUNDARY 32
297
298 /* No data type wants to be aligned rounder than this. */
299 #define BIGGEST_ALIGNMENT 32
300
301 /* The best alignment to use in cases where we have a choice. */
302 #define FASTEST_ALIGNMENT 32
303
304 /* Every structures size must be a multiple of 8 bits. */
305 #define STRUCTURE_SIZE_BOUNDARY 8
306
307 /* Look at the fundamental type that is used for a bit-field and use
308 that to impose alignment on the enclosing structure.
309 struct s {int a:8}; should have same alignment as "int", not "char". */
310 #define PCC_BITFIELD_TYPE_MATTERS 1
311
312 /* Largest integer machine mode for structures. If undefined, the default
313 is GET_MODE_SIZE(DImode). */
314 #define MAX_FIXED_MODE_SIZE 32
315
316 /* Make arrays of chars word-aligned for the same reasons. */
317 #define DATA_ALIGNMENT(TYPE, ALIGN) \
318 (TREE_CODE (TYPE) == ARRAY_TYPE \
319 && TYPE_MODE (TREE_TYPE (TYPE)) == QImode \
320 && (ALIGN) < FASTEST_ALIGNMENT ? FASTEST_ALIGNMENT : (ALIGN))
321
322 /* Set this nonzero if move instructions will actually fail to work
323 when given unaligned data. */
324 #define STRICT_ALIGNMENT 1
325
326 /* Generating Code for Profiling */
327 #define FUNCTION_PROFILER(FILE,LABELNO) (abort (), 0)
328
329 /* Trampolines for Nested Functions. */
330 #define TRAMPOLINE_SIZE (2 + 6 + 4 + 2 + 6)
331
332 /* Alignment required for trampolines, in bits. */
333 #define TRAMPOLINE_ALIGNMENT 32
334
335 /* An alias for the machine mode for pointers. */
336 #define Pmode SImode
337
338 /* An alias for the machine mode used for memory references to
339 functions being called, in `call' RTL expressions. */
340 #define FUNCTION_MODE QImode
341
342 /* The register number of the stack pointer register, which must also
343 be a fixed register according to `FIXED_REGISTERS'. */
344 #define STACK_POINTER_REGNUM MOXIE_SP
345
346 /* The register number of the frame pointer register, which is used to
347 access automatic variables in the stack frame. */
348 #define FRAME_POINTER_REGNUM MOXIE_QFP
349
350 /* The register number of the arg pointer register, which is used to
351 access the function's argument list. */
352 #define ARG_POINTER_REGNUM MOXIE_QAP
353
354 #define HARD_FRAME_POINTER_REGNUM MOXIE_FP
355
356 #define ELIMINABLE_REGS \
357 {{ FRAME_POINTER_REGNUM, HARD_FRAME_POINTER_REGNUM }, \
358 { ARG_POINTER_REGNUM, HARD_FRAME_POINTER_REGNUM }}
359
360 /* This macro returns the initial difference between the specified pair
361 of registers. */
362 #define INITIAL_ELIMINATION_OFFSET(FROM, TO, OFFSET) \
363 do { \
364 (OFFSET) = moxie_initial_elimination_offset ((FROM), (TO)); \
365 } while (0)
366
367 /* A C expression that is nonzero if REGNO is the number of a hard
368 register in which function arguments are sometimes passed. */
369 #define FUNCTION_ARG_REGNO_P(r) (r >= MOXIE_R0 && r <= MOXIE_R5)
370
371 /* A macro whose definition is the name of the class to which a valid
372 base register must belong. A base register is one used in an
373 address which is the register value plus a displacement. */
374 #define BASE_REG_CLASS GENERAL_REGS
375
376 #define INDEX_REG_CLASS NO_REGS
377
378 #define HARD_REGNO_OK_FOR_BASE_P(NUM) \
379 ((unsigned) (NUM) < FIRST_PSEUDO_REGISTER \
380 && (REGNO_REG_CLASS(NUM) == GENERAL_REGS \
381 || (NUM) == HARD_FRAME_POINTER_REGNUM))
382
383 /* A C expression which is nonzero if register number NUM is suitable
384 for use as a base register in operand addresses. */
385 #ifdef REG_OK_STRICT
386 #define REGNO_OK_FOR_BASE_P(NUM) \
387 (HARD_REGNO_OK_FOR_BASE_P(NUM) \
388 || HARD_REGNO_OK_FOR_BASE_P(reg_renumber[(NUM)]))
389 #else
390 #define REGNO_OK_FOR_BASE_P(NUM) \
391 ((NUM) >= FIRST_PSEUDO_REGISTER || HARD_REGNO_OK_FOR_BASE_P(NUM))
392 #endif
393
394 /* A C expression which is nonzero if register number NUM is suitable
395 for use as an index register in operand addresses. */
396 #define REGNO_OK_FOR_INDEX_P(NUM) MOXIE_FP
397
398 /* The maximum number of bytes that a single instruction can move
399 quickly between memory and registers or between two memory
400 locations. */
401 #define MOVE_MAX 4
402
403 /* All load operations zero extend. */
404 #define LOAD_EXTEND_OP(MEM) ZERO_EXTEND
405
406 /* A number, the maximum number of registers that can appear in a
407 valid memory address. */
408 #define MAX_REGS_PER_ADDRESS 1
409
410 /* An alias for a machine mode name. This is the machine mode that
411 elements of a jump-table should have. */
412 #define CASE_VECTOR_MODE SImode
413
414 /* Run-time Target Specification */
415
416 #define TARGET_CPU_CPP_BUILTINS() \
417 { \
418 builtin_define_std ("moxie"); \
419 builtin_define_std ("MOXIE"); \
420 if (TARGET_LITTLE_ENDIAN) \
421 builtin_define ("__MOXIE_LITTLE_ENDIAN__"); \
422 else \
423 builtin_define ("__MOXIE_BIG_ENDIAN__"); \
424 }
425
426 #define HAS_LONG_UNCOND_BRANCH true
427
428 #endif /* GCC_MOXIE_H */