]>
Commit | Line | Data |
---|---|---|
cceb575c | 1 | /* Target Code for moxie |
23a5b65a | 2 | Copyright (C) 2008-2014 Free Software Foundation, Inc. |
cceb575c AG |
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 | #include "config.h" | |
22 | #include "system.h" | |
23 | #include "coretypes.h" | |
24 | #include "tm.h" | |
25 | #include "rtl.h" | |
26 | #include "regs.h" | |
27 | #include "hard-reg-set.h" | |
cceb575c AG |
28 | #include "insn-config.h" |
29 | #include "conditions.h" | |
30 | #include "insn-flags.h" | |
31 | #include "output.h" | |
32 | #include "insn-attr.h" | |
33 | #include "flags.h" | |
34 | #include "recog.h" | |
35 | #include "reload.h" | |
718f9c0f | 36 | #include "diagnostic-core.h" |
cceb575c AG |
37 | #include "obstack.h" |
38 | #include "tree.h" | |
d8a2d370 DN |
39 | #include "stor-layout.h" |
40 | #include "varasm.h" | |
41 | #include "calls.h" | |
cceb575c AG |
42 | #include "expr.h" |
43 | #include "optabs.h" | |
44 | #include "except.h" | |
45 | #include "function.h" | |
46 | #include "ggc.h" | |
47 | #include "target.h" | |
48 | #include "target-def.h" | |
49 | #include "tm_p.h" | |
50 | #include "langhooks.h" | |
51 | #include "df.h" | |
52 | ||
53 | #define LOSE_AND_RETURN(msgid, x) \ | |
54 | do \ | |
55 | { \ | |
56 | moxie_operand_lossage (msgid, x); \ | |
57 | return; \ | |
58 | } while (0) | |
59 | ||
60 | /* Worker function for TARGET_RETURN_IN_MEMORY. */ | |
61 | ||
62 | static bool | |
63 | moxie_return_in_memory (const_tree type, const_tree fntype ATTRIBUTE_UNUSED) | |
64 | { | |
65 | const HOST_WIDE_INT size = int_size_in_bytes (type); | |
66 | return (size == -1 || size > 2 * UNITS_PER_WORD); | |
67 | } | |
68 | ||
69 | /* Define how to find the value returned by a function. | |
70 | VALTYPE is the data type of the value (as a tree). | |
71 | If the precise function being called is known, FUNC is its | |
72 | FUNCTION_DECL; otherwise, FUNC is 0. | |
73 | ||
74 | We always return values in register $r0 for moxie. */ | |
75 | ||
feab9982 | 76 | static rtx |
9fb374d6 AG |
77 | moxie_function_value (const_tree valtype, |
78 | const_tree fntype_or_decl ATTRIBUTE_UNUSED, | |
cceb575c AG |
79 | bool outgoing ATTRIBUTE_UNUSED) |
80 | { | |
81 | return gen_rtx_REG (TYPE_MODE (valtype), MOXIE_R0); | |
82 | } | |
83 | ||
feab9982 AS |
84 | /* Define how to find the value returned by a library function. |
85 | ||
86 | We always return values in register $r0 for moxie. */ | |
87 | ||
88 | static rtx | |
89 | moxie_libcall_value (enum machine_mode mode, | |
90 | const_rtx fun ATTRIBUTE_UNUSED) | |
91 | { | |
92 | return gen_rtx_REG (mode, MOXIE_R0); | |
93 | } | |
94 | ||
95 | /* Handle TARGET_FUNCTION_VALUE_REGNO_P. | |
96 | ||
97 | We always return values in register $r0 for moxie. */ | |
98 | ||
99 | static bool | |
100 | moxie_function_value_regno_p (const unsigned int regno) | |
101 | { | |
102 | return (regno == MOXIE_R0); | |
103 | } | |
104 | ||
cceb575c AG |
105 | /* Emit an error message when we're in an asm, and a fatal error for |
106 | "normal" insns. Formatted output isn't easily implemented, since we | |
107 | use output_operand_lossage to output the actual message and handle the | |
108 | categorization of the error. */ | |
109 | ||
110 | static void | |
111 | moxie_operand_lossage (const char *msgid, rtx op) | |
112 | { | |
113 | debug_rtx (op); | |
114 | output_operand_lossage ("%s", msgid); | |
115 | } | |
116 | ||
117 | /* The PRINT_OPERAND_ADDRESS worker. */ | |
118 | ||
119 | void | |
120 | moxie_print_operand_address (FILE *file, rtx x) | |
121 | { | |
122 | switch (GET_CODE (x)) | |
123 | { | |
124 | case REG: | |
125 | fprintf (file, "(%s)", reg_names[REGNO (x)]); | |
126 | break; | |
127 | ||
128 | case PLUS: | |
129 | switch (GET_CODE (XEXP (x, 1))) | |
130 | { | |
131 | case CONST_INT: | |
132 | fprintf (file, "%ld(%s)", | |
133 | INTVAL(XEXP (x, 1)), reg_names[REGNO (XEXP (x, 0))]); | |
134 | break; | |
135 | case SYMBOL_REF: | |
136 | output_addr_const (file, XEXP (x, 1)); | |
137 | fprintf (file, "(%s)", reg_names[REGNO (XEXP (x, 0))]); | |
138 | break; | |
139 | case CONST: | |
140 | { | |
141 | rtx plus = XEXP (XEXP (x, 1), 0); | |
142 | if (GET_CODE (XEXP (plus, 0)) == SYMBOL_REF | |
143 | && CONST_INT_P (XEXP (plus, 1))) | |
144 | { | |
145 | output_addr_const(file, XEXP (plus, 0)); | |
146 | fprintf (file,"+%ld(%s)", INTVAL (XEXP (plus, 1)), | |
147 | reg_names[REGNO (XEXP (x, 0))]); | |
148 | } | |
149 | else | |
150 | abort(); | |
151 | } | |
152 | break; | |
153 | default: | |
154 | abort(); | |
155 | } | |
156 | break; | |
157 | ||
158 | default: | |
159 | output_addr_const (file, x); | |
160 | break; | |
161 | } | |
162 | } | |
163 | ||
164 | /* The PRINT_OPERAND worker. */ | |
165 | ||
166 | void | |
167 | moxie_print_operand (FILE *file, rtx x, int code) | |
168 | { | |
169 | rtx operand = x; | |
170 | ||
171 | /* New code entries should just be added to the switch below. If | |
172 | handling is finished, just return. If handling was just a | |
173 | modification of the operand, the modified operand should be put in | |
174 | "operand", and then do a break to let default handling | |
175 | (zero-modifier) output the operand. */ | |
176 | ||
177 | switch (code) | |
178 | { | |
179 | case 0: | |
180 | /* No code, print as usual. */ | |
181 | break; | |
182 | ||
183 | default: | |
184 | LOSE_AND_RETURN ("invalid operand modifier letter", x); | |
185 | } | |
186 | ||
187 | /* Print an operand as without a modifier letter. */ | |
188 | switch (GET_CODE (operand)) | |
189 | { | |
190 | case REG: | |
191 | if (REGNO (operand) > MOXIE_R13) | |
192 | internal_error ("internal error: bad register: %d", REGNO (operand)); | |
193 | fprintf (file, "%s", reg_names[REGNO (operand)]); | |
194 | return; | |
195 | ||
196 | case MEM: | |
197 | output_address (XEXP (operand, 0)); | |
198 | return; | |
199 | ||
200 | default: | |
201 | /* No need to handle all strange variants, let output_addr_const | |
202 | do it for us. */ | |
203 | if (CONSTANT_P (operand)) | |
204 | { | |
205 | output_addr_const (file, operand); | |
206 | return; | |
207 | } | |
208 | ||
209 | LOSE_AND_RETURN ("unexpected operand", x); | |
210 | } | |
211 | } | |
212 | ||
213 | /* Per-function machine data. */ | |
214 | struct GTY(()) machine_function | |
215 | { | |
216 | /* Number of bytes saved on the stack for callee saved registers. */ | |
217 | int callee_saved_reg_size; | |
218 | ||
219 | /* Number of bytes saved on the stack for local variables. */ | |
220 | int local_vars_size; | |
221 | ||
222 | /* The sum of 2 sizes: locals vars and padding byte for saving the | |
223 | * registers. Used in expand_prologue () and expand_epilogue(). */ | |
224 | int size_for_adjusting_sp; | |
225 | }; | |
226 | ||
227 | /* Zero initialization is OK for all current fields. */ | |
228 | ||
229 | static struct machine_function * | |
230 | moxie_init_machine_status (void) | |
231 | { | |
766090c2 | 232 | return ggc_cleared_alloc<machine_function> (); |
cceb575c AG |
233 | } |
234 | ||
235 | ||
c5387660 | 236 | /* The TARGET_OPTION_OVERRIDE worker. |
cceb575c | 237 | All this curently does is set init_machine_status. */ |
c5387660 JM |
238 | static void |
239 | moxie_option_override (void) | |
cceb575c AG |
240 | { |
241 | /* Set the per-function-data initializer. */ | |
242 | init_machine_status = moxie_init_machine_status; | |
243 | } | |
244 | ||
245 | /* Compute the size of the local area and the size to be adjusted by the | |
246 | * prologue and epilogue. */ | |
247 | ||
248 | static void | |
249 | moxie_compute_frame (void) | |
250 | { | |
251 | /* For aligning the local variables. */ | |
252 | int stack_alignment = STACK_BOUNDARY / BITS_PER_UNIT; | |
253 | int padding_locals; | |
254 | int regno; | |
255 | ||
256 | /* Padding needed for each element of the frame. */ | |
257 | cfun->machine->local_vars_size = get_frame_size (); | |
258 | ||
259 | /* Align to the stack alignment. */ | |
260 | padding_locals = cfun->machine->local_vars_size % stack_alignment; | |
261 | if (padding_locals) | |
262 | padding_locals = stack_alignment - padding_locals; | |
263 | ||
264 | cfun->machine->local_vars_size += padding_locals; | |
265 | ||
266 | cfun->machine->callee_saved_reg_size = 0; | |
267 | ||
268 | /* Save callee-saved registers. */ | |
269 | for (regno = 0; regno < FIRST_PSEUDO_REGISTER; regno++) | |
270 | if (df_regs_ever_live_p (regno) && (! call_used_regs[regno])) | |
271 | cfun->machine->callee_saved_reg_size += 4; | |
272 | ||
273 | cfun->machine->size_for_adjusting_sp = | |
274 | crtl->args.pretend_args_size | |
275 | + cfun->machine->local_vars_size | |
276 | + (ACCUMULATE_OUTGOING_ARGS ? crtl->outgoing_args_size : 0); | |
277 | } | |
278 | ||
279 | void | |
280 | moxie_expand_prologue (void) | |
281 | { | |
282 | int regno; | |
283 | rtx insn; | |
284 | ||
285 | moxie_compute_frame (); | |
286 | ||
650ae806 AG |
287 | if (flag_stack_usage_info) |
288 | current_function_static_stack_size = cfun->machine->size_for_adjusting_sp; | |
289 | ||
cceb575c AG |
290 | /* Save callee-saved registers. */ |
291 | for (regno = 0; regno < FIRST_PSEUDO_REGISTER; regno++) | |
292 | { | |
293 | if (!fixed_regs[regno] && df_regs_ever_live_p (regno) && !call_used_regs[regno]) | |
294 | { | |
295 | insn = emit_insn (gen_movsi_push (gen_rtx_REG (Pmode, regno))); | |
296 | RTX_FRAME_RELATED_P (insn) = 1; | |
297 | } | |
298 | } | |
299 | ||
300 | if (cfun->machine->size_for_adjusting_sp > 0) | |
301 | { | |
55a51460 AG |
302 | int i = cfun->machine->size_for_adjusting_sp; |
303 | while ((i >= 255) && (i <= 510)) | |
9df748c0 AG |
304 | { |
305 | insn = emit_insn (gen_subsi3 (stack_pointer_rtx, | |
306 | stack_pointer_rtx, | |
75cd1c8f | 307 | GEN_INT (255))); |
9df748c0 | 308 | RTX_FRAME_RELATED_P (insn) = 1; |
75cd1c8f | 309 | i -= 255; |
9df748c0 | 310 | } |
55a51460 | 311 | if (i <= 255) |
9df748c0 | 312 | { |
75cd1c8f | 313 | insn = emit_insn (gen_subsi3 (stack_pointer_rtx, |
9df748c0 | 314 | stack_pointer_rtx, |
75cd1c8f | 315 | GEN_INT (i))); |
9df748c0 | 316 | RTX_FRAME_RELATED_P (insn) = 1; |
75cd1c8f | 317 | } |
55a51460 AG |
318 | else |
319 | { | |
320 | rtx reg = gen_rtx_REG (SImode, MOXIE_R12); | |
321 | insn = emit_move_insn (reg, GEN_INT (i)); | |
322 | RTX_FRAME_RELATED_P (insn) = 1; | |
323 | insn = emit_insn (gen_subsi3 (stack_pointer_rtx, | |
324 | stack_pointer_rtx, | |
325 | reg)); | |
326 | RTX_FRAME_RELATED_P (insn) = 1; | |
327 | } | |
cceb575c AG |
328 | } |
329 | } | |
330 | ||
331 | void | |
332 | moxie_expand_epilogue (void) | |
333 | { | |
334 | int regno; | |
a8ea9484 | 335 | rtx reg; |
cceb575c AG |
336 | |
337 | if (cfun->machine->callee_saved_reg_size != 0) | |
338 | { | |
55a51460 | 339 | reg = gen_rtx_REG (Pmode, MOXIE_R12); |
9df748c0 AG |
340 | if (cfun->machine->callee_saved_reg_size <= 255) |
341 | { | |
342 | emit_move_insn (reg, hard_frame_pointer_rtx); | |
343 | emit_insn (gen_subsi3 | |
344 | (reg, reg, | |
345 | GEN_INT (cfun->machine->callee_saved_reg_size))); | |
346 | } | |
347 | else | |
348 | { | |
349 | emit_move_insn (reg, | |
350 | GEN_INT (-cfun->machine->callee_saved_reg_size)); | |
351 | emit_insn (gen_addsi3 (reg, reg, hard_frame_pointer_rtx)); | |
352 | } | |
cceb575c AG |
353 | for (regno = FIRST_PSEUDO_REGISTER; regno-- > 0; ) |
354 | if (!fixed_regs[regno] && !call_used_regs[regno] | |
355 | && df_regs_ever_live_p (regno)) | |
356 | { | |
9df748c0 | 357 | rtx preg = gen_rtx_REG (Pmode, regno); |
a8ea9484 | 358 | emit_insn (gen_movsi_pop (reg, preg)); |
cceb575c AG |
359 | } |
360 | } | |
361 | ||
362 | emit_jump_insn (gen_returner ()); | |
363 | } | |
364 | ||
365 | /* Implements the macro INITIAL_ELIMINATION_OFFSET, return the OFFSET. */ | |
366 | ||
367 | int | |
368 | moxie_initial_elimination_offset (int from, int to) | |
369 | { | |
370 | int ret; | |
371 | ||
372 | if ((from) == FRAME_POINTER_REGNUM && (to) == HARD_FRAME_POINTER_REGNUM) | |
373 | { | |
374 | /* Compute this since we need to use cfun->machine->local_vars_size. */ | |
375 | moxie_compute_frame (); | |
376 | ret = -cfun->machine->callee_saved_reg_size; | |
377 | } | |
378 | else if ((from) == ARG_POINTER_REGNUM && (to) == HARD_FRAME_POINTER_REGNUM) | |
379 | ret = 0x00; | |
380 | else | |
381 | abort (); | |
382 | ||
383 | return ret; | |
384 | } | |
385 | ||
386 | /* Worker function for TARGET_SETUP_INCOMING_VARARGS. */ | |
387 | ||
388 | static void | |
d5cc9181 | 389 | moxie_setup_incoming_varargs (cumulative_args_t cum_v, |
cceb575c AG |
390 | enum machine_mode mode ATTRIBUTE_UNUSED, |
391 | tree type ATTRIBUTE_UNUSED, | |
392 | int *pretend_size, int no_rtl) | |
393 | { | |
d5cc9181 | 394 | CUMULATIVE_ARGS *cum = get_cumulative_args (cum_v); |
cceb575c | 395 | int regno; |
75cd1c8f | 396 | int regs = 8 - *cum; |
cceb575c AG |
397 | |
398 | *pretend_size = regs < 0 ? 0 : GET_MODE_SIZE (SImode) * regs; | |
399 | ||
400 | if (no_rtl) | |
401 | return; | |
402 | ||
75cd1c8f | 403 | for (regno = *cum; regno < 8; regno++) |
cceb575c AG |
404 | { |
405 | rtx reg = gen_rtx_REG (SImode, regno); | |
406 | rtx slot = gen_rtx_PLUS (Pmode, | |
407 | gen_rtx_REG (SImode, ARG_POINTER_REGNUM), | |
408 | GEN_INT (UNITS_PER_WORD * (3 + (regno-2)))); | |
409 | ||
410 | emit_move_insn (gen_rtx_MEM (SImode, slot), reg); | |
411 | } | |
412 | } | |
413 | ||
414 | ||
415 | /* Return the fixed registers used for condition codes. */ | |
416 | ||
417 | static bool | |
418 | moxie_fixed_condition_code_regs (unsigned int *p1, unsigned int *p2) | |
419 | { | |
420 | *p1 = CC_REG; | |
421 | *p2 = INVALID_REGNUM; | |
422 | return true; | |
423 | } | |
424 | ||
425 | /* Return the next register to be used to hold a function argument or | |
426 | NULL_RTX if there's no more space. */ | |
427 | ||
4c05cbb2 | 428 | static rtx |
d5cc9181 | 429 | moxie_function_arg (cumulative_args_t cum_v, enum machine_mode mode, |
4c05cbb2 NF |
430 | const_tree type ATTRIBUTE_UNUSED, |
431 | bool named ATTRIBUTE_UNUSED) | |
cceb575c | 432 | { |
d5cc9181 JR |
433 | CUMULATIVE_ARGS *cum = get_cumulative_args (cum_v); |
434 | ||
4c05cbb2 NF |
435 | if (*cum < 8) |
436 | return gen_rtx_REG (mode, *cum); | |
cceb575c AG |
437 | else |
438 | return NULL_RTX; | |
439 | } | |
440 | ||
4c05cbb2 NF |
441 | #define MOXIE_FUNCTION_ARG_SIZE(MODE, TYPE) \ |
442 | ((MODE) != BLKmode ? GET_MODE_SIZE (MODE) \ | |
443 | : (unsigned) int_size_in_bytes (TYPE)) | |
444 | ||
445 | static void | |
d5cc9181 | 446 | moxie_function_arg_advance (cumulative_args_t cum_v, enum machine_mode mode, |
4c05cbb2 NF |
447 | const_tree type, bool named ATTRIBUTE_UNUSED) |
448 | { | |
d5cc9181 JR |
449 | CUMULATIVE_ARGS *cum = get_cumulative_args (cum_v); |
450 | ||
4c05cbb2 NF |
451 | *cum = (*cum < MOXIE_R6 |
452 | ? *cum + ((3 + MOXIE_FUNCTION_ARG_SIZE (mode, type)) / 4) | |
453 | : *cum); | |
454 | } | |
455 | ||
cceb575c AG |
456 | /* Return non-zero if the function argument described by TYPE is to be |
457 | passed by reference. */ | |
458 | ||
459 | static bool | |
d5cc9181 | 460 | moxie_pass_by_reference (cumulative_args_t cum ATTRIBUTE_UNUSED, |
cceb575c AG |
461 | enum machine_mode mode, const_tree type, |
462 | bool named ATTRIBUTE_UNUSED) | |
463 | { | |
464 | unsigned HOST_WIDE_INT size; | |
465 | ||
466 | if (type) | |
467 | { | |
468 | if (AGGREGATE_TYPE_P (type)) | |
469 | return true; | |
470 | size = int_size_in_bytes (type); | |
471 | } | |
472 | else | |
473 | size = GET_MODE_SIZE (mode); | |
474 | ||
75cd1c8f | 475 | return size > 4*6; |
cceb575c AG |
476 | } |
477 | ||
478 | /* Some function arguments will only partially fit in the registers | |
479 | that hold arguments. Given a new arg, return the number of bytes | |
480 | that fit in argument passing registers. */ | |
481 | ||
482 | static int | |
d5cc9181 | 483 | moxie_arg_partial_bytes (cumulative_args_t cum_v, |
cceb575c AG |
484 | enum machine_mode mode, |
485 | tree type, bool named) | |
486 | { | |
d5cc9181 | 487 | CUMULATIVE_ARGS *cum = get_cumulative_args (cum_v); |
cceb575c AG |
488 | int bytes_left, size; |
489 | ||
75cd1c8f | 490 | if (*cum >= 8) |
cceb575c AG |
491 | return 0; |
492 | ||
d5cc9181 | 493 | if (moxie_pass_by_reference (cum_v, mode, type, named)) |
cceb575c AG |
494 | size = 4; |
495 | else if (type) | |
496 | { | |
497 | if (AGGREGATE_TYPE_P (type)) | |
498 | return 0; | |
499 | size = int_size_in_bytes (type); | |
500 | } | |
501 | else | |
502 | size = GET_MODE_SIZE (mode); | |
503 | ||
75cd1c8f | 504 | bytes_left = (4 * 6) - ((*cum - 2) * 4); |
cceb575c AG |
505 | |
506 | if (size > bytes_left) | |
507 | return bytes_left; | |
508 | else | |
509 | return 0; | |
510 | } | |
511 | ||
4601494d RH |
512 | /* Worker function for TARGET_STATIC_CHAIN. */ |
513 | ||
514 | static rtx | |
515 | moxie_static_chain (const_tree fndecl, bool incoming_p) | |
516 | { | |
517 | rtx addr, mem; | |
518 | ||
9f62cb92 | 519 | if (!DECL_STATIC_CHAIN (fndecl)) |
4601494d RH |
520 | return NULL; |
521 | ||
522 | if (incoming_p) | |
0a81f074 | 523 | addr = plus_constant (Pmode, arg_pointer_rtx, 2 * UNITS_PER_WORD); |
4601494d | 524 | else |
0a81f074 | 525 | addr = plus_constant (Pmode, stack_pointer_rtx, -UNITS_PER_WORD); |
4601494d RH |
526 | |
527 | mem = gen_rtx_MEM (Pmode, addr); | |
528 | MEM_NOTRAP_P (mem) = 1; | |
529 | ||
530 | return mem; | |
531 | } | |
532 | ||
533 | /* Worker function for TARGET_ASM_TRAMPOLINE_TEMPLATE. */ | |
534 | ||
535 | static void | |
536 | moxie_asm_trampoline_template (FILE *f) | |
537 | { | |
538 | fprintf (f, "\tpush $sp, $r0\n"); | |
539 | fprintf (f, "\tldi.l $r0, 0x0\n"); | |
540 | fprintf (f, "\tsto.l 0x8($fp), $r0\n"); | |
541 | fprintf (f, "\tpop $sp, $r0\n"); | |
693ee8cf | 542 | fprintf (f, "\tnop\n"); |
4601494d RH |
543 | fprintf (f, "\tjmpa 0x0\n"); |
544 | } | |
545 | ||
546 | /* Worker function for TARGET_TRAMPOLINE_INIT. */ | |
547 | ||
548 | static void | |
549 | moxie_trampoline_init (rtx m_tramp, tree fndecl, rtx chain_value) | |
550 | { | |
551 | rtx mem, fnaddr = XEXP (DECL_RTL (fndecl), 0); | |
552 | ||
553 | emit_block_move (m_tramp, assemble_trampoline_template (), | |
554 | GEN_INT (TRAMPOLINE_SIZE), BLOCK_OP_NORMAL); | |
555 | ||
556 | mem = adjust_address (m_tramp, SImode, 4); | |
557 | emit_move_insn (mem, chain_value); | |
693ee8cf | 558 | mem = adjust_address (m_tramp, SImode, 20); |
4601494d RH |
559 | emit_move_insn (mem, fnaddr); |
560 | } | |
561 | ||
cceb575c AG |
562 | /* The Global `targetm' Variable. */ |
563 | ||
564 | /* Initialize the GCC target structure. */ | |
565 | ||
566 | #undef TARGET_PROMOTE_PROTOTYPES | |
567 | #define TARGET_PROMOTE_PROTOTYPES hook_bool_const_tree_true | |
568 | ||
569 | #undef TARGET_RETURN_IN_MEMORY | |
570 | #define TARGET_RETURN_IN_MEMORY moxie_return_in_memory | |
571 | #undef TARGET_MUST_PASS_IN_STACK | |
572 | #define TARGET_MUST_PASS_IN_STACK must_pass_in_stack_var_size | |
573 | #undef TARGET_PASS_BY_REFERENCE | |
574 | #define TARGET_PASS_BY_REFERENCE moxie_pass_by_reference | |
575 | #undef TARGET_ARG_PARTIAL_BYTES | |
576 | #define TARGET_ARG_PARTIAL_BYTES moxie_arg_partial_bytes | |
4c05cbb2 NF |
577 | #undef TARGET_FUNCTION_ARG |
578 | #define TARGET_FUNCTION_ARG moxie_function_arg | |
579 | #undef TARGET_FUNCTION_ARG_ADVANCE | |
580 | #define TARGET_FUNCTION_ARG_ADVANCE moxie_function_arg_advance | |
cceb575c AG |
581 | |
582 | ||
583 | #undef TARGET_SETUP_INCOMING_VARARGS | |
584 | #define TARGET_SETUP_INCOMING_VARARGS moxie_setup_incoming_varargs | |
585 | ||
586 | #undef TARGET_FIXED_CONDITION_CODE_REGS | |
587 | #define TARGET_FIXED_CONDITION_CODE_REGS moxie_fixed_condition_code_regs | |
588 | ||
589 | /* Define this to return an RTX representing the place where a | |
590 | function returns or receives a value of data type RET_TYPE, a tree | |
591 | node node representing a data type. */ | |
592 | #undef TARGET_FUNCTION_VALUE | |
593 | #define TARGET_FUNCTION_VALUE moxie_function_value | |
feab9982 AS |
594 | #undef TARGET_LIBCALL_VALUE |
595 | #define TARGET_LIBCALL_VALUE moxie_libcall_value | |
596 | #undef TARGET_FUNCTION_VALUE_REGNO_P | |
597 | #define TARGET_FUNCTION_VALUE_REGNO_P moxie_function_value_regno_p | |
cceb575c | 598 | |
b52b1749 AS |
599 | #undef TARGET_FRAME_POINTER_REQUIRED |
600 | #define TARGET_FRAME_POINTER_REQUIRED hook_bool_void_true | |
601 | ||
4601494d RH |
602 | #undef TARGET_STATIC_CHAIN |
603 | #define TARGET_STATIC_CHAIN moxie_static_chain | |
604 | #undef TARGET_ASM_TRAMPOLINE_TEMPLATE | |
605 | #define TARGET_ASM_TRAMPOLINE_TEMPLATE moxie_asm_trampoline_template | |
606 | #undef TARGET_TRAMPOLINE_INIT | |
607 | #define TARGET_TRAMPOLINE_INIT moxie_trampoline_init | |
608 | ||
c5387660 JM |
609 | #undef TARGET_OPTION_OVERRIDE |
610 | #define TARGET_OPTION_OVERRIDE moxie_option_override | |
611 | ||
cceb575c AG |
612 | struct gcc_target targetm = TARGET_INITIALIZER; |
613 | ||
614 | #include "gt-moxie.h" |