1 /* Subroutines for insn-output.c for Clipper
2 Copyright (C) 1987, 1988, 1991, 1997, 1998,
3 1999, 2000 Free Software Foundation, Inc.
4 Contributed by Holger Teutsch (holger@hotbso.rhein-main.de)
6 This file is part of GNU CC.
8 GNU CC is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 2, or (at your option)
13 GNU CC is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with GNU CC; see the file COPYING. If not, write to
20 the Free Software Foundation, 59 Temple Place - Suite 330,
21 Boston, MA 02111-1307, USA. */
27 #include "hard-reg-set.h"
29 #include "insn-config.h"
30 #include "conditions.h"
32 #include "insn-attr.h"
41 #include "target-def.h"
43 static void clipper_output_function_prologue PARAMS ((FILE *, HOST_WIDE_INT));
44 static void clipper_output_function_epilogue PARAMS ((FILE *, HOST_WIDE_INT));
46 extern char regs_ever_live[];
48 extern int frame_pointer_needed;
50 static int frame_size;
52 /* Initialize the GCC target structure. */
53 #undef TARGET_ASM_FUNCTION_PROLOGUE
54 #define TARGET_ASM_FUNCTION_PROLOGUE clipper_output_function_prologue
55 #undef TARGET_ASM_FUNCTION_EPILOGUE
56 #define TARGET_ASM_FUNCTION_EPILOGUE clipper_output_function_epilogue
58 struct gcc_target target = TARGET_INITIALIZER;
60 /* Compute size of a clipper stack frame where 'lsize' is the required
61 space for local variables. */
64 clipper_frame_size (lsize)
67 int i, size; /* total size of frame */
69 save_size = 0; /* compute size for reg saves */
71 for (i = 16; i < 32; i++)
72 if (regs_ever_live[i] && !call_used_regs[i])
75 for (i = 0; i < 16; i++)
76 if (regs_ever_live[i] && !call_used_regs[i])
79 size = lsize + save_size;
81 size = (size + 7) & ~7; /* align to 64 Bit */
85 /* Prologue and epilogue output
86 Function is entered with pc pushed, i.e. stack is 32 bit aligned
88 current_function_args_size == 0 means that the current function's args
89 are passed totally in registers i.e fp is not used as ap.
90 If frame_size is also 0 the current function does not push anything and
91 can run with misaligned stack -> subq $4,sp / add $4,sp on entry and exit
95 clipper_output_function_prologue (file, lsize)
97 HOST_WIDE_INT lsize; /* size for locals */
102 frame_size = size = clipper_frame_size (lsize);
104 if (frame_pointer_needed)
106 fputs ("\tpushw fp,sp\n", file);
107 fputs ("\tmovw sp,fp\n", file);
109 else if (size != 0 || current_function_args_size != 0)
111 size += 4; /* keep stack aligned */
112 frame_size = size; /* must push data or access args */
118 fprintf (file, "\tsubq $%d,sp\n", size);
120 fprintf (file, "\tsubi $%d,sp\n", size);
122 /* register save slots are relative to sp, because we have small positive
123 displacements and this works whether we have a frame pointer or not */
126 for (i = 16; i < 32; i++)
127 if (regs_ever_live[i] && !call_used_regs[i])
130 fprintf (file, "\tstord f%d,(sp)\n", i-16);
132 fprintf (file, "\tstord f%d,%d(sp)\n", i-16, offset);
136 for (i = 0; i < 16; i++)
137 if (regs_ever_live[i] && !call_used_regs[i])
140 fprintf (file, "\tstorw r%d,(sp)\n", i);
142 fprintf (file, "\tstorw r%d,%d(sp)\n", i, offset);
149 clipper_output_function_epilogue (file, size)
151 HOST_WIDE_INT size ATTRIBUTE_UNUSED;
155 if (frame_pointer_needed)
157 offset = -frame_size;
159 for (i = 16; i < 32; i++)
160 if (regs_ever_live[i] && !call_used_regs[i])
162 fprintf (file, "\tloadd %d(fp),f%d\n", offset, i-16);
166 for (i = 0; i < 16; i++)
167 if (regs_ever_live[i] && !call_used_regs[i])
169 fprintf (file, "\tloadw %d(fp),r%d\n", offset, i);
173 fputs ("\tmovw fp,sp\n\tpopw sp,fp\n\tret sp\n",
177 else /* no frame pointer */
181 for (i = 16; i < 32; i++)
182 if (regs_ever_live[i] && !call_used_regs[i])
185 fprintf (file, "\tloadd (sp),f%d\n", i-16);
187 fprintf (file, "\tloadd %d(sp),f%d\n", offset, i-16);
191 for (i = 0; i < 16; i++)
192 if (regs_ever_live[i] && !call_used_regs[i])
195 fprintf (file, "\tloadw (sp),r%d\n", i);
197 fprintf (file, "\tloadw %d(sp),r%d\n", offset, i);
204 fprintf (file, "\taddq $%d,sp\n", frame_size);
206 fprintf (file, "\taddi $%d,sp\n", frame_size);
209 fputs ("\tret sp\n", file);
219 clipper_movstr (operands)
222 rtx dst,src,cnt,tmp,top,bottom,xops[3];
226 extern FILE *asm_out_file;
230 /* don't change this operands[2]; gcc 2.3.3 doesn't honor clobber note */
231 align = INTVAL (operands[3]);
235 if (GET_CODE (operands[2]) == CONST_INT) /* fixed size move */
237 if ((fixed = INTVAL (operands[2])) <= 0)
241 output_asm_insn ("loadq %2,%5", operands);
243 output_asm_insn ("loadi %2,%5", operands);
248 bottom = (rtx)gen_label_rtx (); /* need a bottom label */
249 xops[0] = cnt; xops[1] = bottom;
250 output_asm_insn ("movw %2,%5", operands); /* count is scratch reg 5 */
251 output_asm_insn ("brle %l1", xops);
255 top = (rtx)gen_label_rtx (); /* top of loop label */
256 ASM_OUTPUT_INTERNAL_LABEL (asm_out_file, "L", CODE_LABEL_NUMBER (top));
259 xops[0] = src; xops[1] = tmp; xops[2] = dst;
261 if (fixed && (align & 0x3) == 0) /* word aligned move with known size */
267 "loadw %a0,%1\n\taddq $4,%0\n\tstorw %1,%a2\n\taddq $4,%2",
270 xops1[0] = cnt; xops1[1] = top;
271 output_asm_insn ("subq $4,%0\n\tbrgt %l1", xops1);
276 output_asm_insn ("loadh %a0,%1\n\tstorh %1,%a2", xops);
278 output_asm_insn ("loadb 2%a0,%1\n\tstorb %1,2%a2", xops);
282 output_asm_insn ("loadb %a0,%1\n\tstorb %1,%a2", xops);
287 "loadb %a0,%1\n\taddq $1,%0\n\tstorb %1,%a2\n\taddq $1,%2",
290 xops[0] = cnt; xops[1] = top;
291 output_asm_insn ("subq $1,%0\n\tbrgt %l1", xops);
295 ASM_OUTPUT_INTERNAL_LABEL (asm_out_file, "L", CODE_LABEL_NUMBER (bottom));
300 print_operand_address (file, addr)
306 switch (GET_CODE (addr))
309 fprintf (file, "(%s)", reg_names[REGNO (addr)]);
313 /* can be 'symbol + reg' or 'reg + reg' */
315 op0 = XEXP (addr, 0);
316 op1 = XEXP (addr, 1);
318 if (GET_CODE (op0) == REG && GET_CODE (op1) == REG)
320 fprintf (file, "[%s](%s)",
321 reg_names[REGNO (op0)], reg_names[REGNO (op1)]);
325 if (GET_CODE (op0) == REG && CONSTANT_ADDRESS_P (op1))
327 output_addr_const (file, op1);
328 fprintf (file, "(%s)", reg_names[REGNO (op0)]);
332 if (GET_CODE (op1) == REG && CONSTANT_ADDRESS_P (op0))
334 output_addr_const (file, op0);
335 fprintf (file, "(%s)", reg_names[REGNO (op1)]);
338 abort (); /* Oh no */
341 output_addr_const (file, addr);
350 switch (GET_CODE (op))
379 /* Dump the argument register to the stack; return the location
383 clipper_builtin_saveregs ()
385 rtx block, addr, r0_addr, r1_addr, f0_addr, f1_addr, mem;
386 int set = get_varargs_alias_set ();
388 /* Allocate the save area for r0,r1,f0,f1 */
390 block = assign_stack_local (BLKmode, 6 * UNITS_PER_WORD, 2 * BITS_PER_WORD);
392 RTX_UNCHANGING_P (block) = 1;
393 RTX_UNCHANGING_P (XEXP (block, 0)) = 1;
395 addr = XEXP (block, 0);
398 r1_addr = plus_constant (addr, 4);
399 f0_addr = plus_constant (addr, 8);
400 f1_addr = plus_constant (addr, 16);
404 mem = gen_rtx_MEM (SImode, r0_addr);
405 MEM_ALIAS_SET (mem) = set;
406 emit_move_insn (mem, gen_rtx_REG (SImode, 0));
408 mem = gen_rtx_MEM (SImode, r1_addr);
409 MEM_ALIAS_SET (mem) = set;
410 emit_move_insn (mem, gen_rtx_REG (SImode, 1));
412 /* Store float regs */
414 mem = gen_rtx_MEM (DFmode, f0_addr);
415 MEM_ALIAS_SET (mem) = set;
416 emit_move_insn (mem, gen_rtx_REG (DFmode, 16));
418 mem = gen_rtx_MEM (DFmode, f1_addr);
419 MEM_ALIAS_SET (mem) = set;
420 emit_move_insn (mem, gen_rtx_REG (DFmode, 17));
422 if (current_function_check_memory_usage)
424 emit_library_call (chkr_set_right_libfunc, 1, VOIDmode, 3,
426 GEN_INT (GET_MODE_SIZE (DFmode)),
427 TYPE_MODE (sizetype),
428 GEN_INT (MEMORY_USE_RW),
429 TYPE_MODE (integer_type_node));
430 emit_library_call (chkr_set_right_libfunc, 1, VOIDmode, 3,
432 GEN_INT (GET_MODE_SIZE (DFmode)),
433 TYPE_MODE (sizetype),
434 GEN_INT (MEMORY_USE_RW),
435 TYPE_MODE (integer_type_node));
436 emit_library_call (chkr_set_right_libfunc, 1, VOIDmode, 3,
438 GEN_INT (GET_MODE_SIZE (SImode)),
439 TYPE_MODE (sizetype),
440 GEN_INT (MEMORY_USE_RW),
441 TYPE_MODE (integer_type_node));
442 emit_library_call (chkr_set_right_libfunc, 1, VOIDmode, 3,
444 GEN_INT (GET_MODE_SIZE (SImode)),
445 TYPE_MODE (sizetype),
446 GEN_INT (MEMORY_USE_RW),
447 TYPE_MODE (integer_type_node));
454 clipper_build_va_list ()
456 tree record, ap, reg, num;
461 int __va_ap; // pointer to stack args
462 void *__va_reg[4]; // pointer to r0,f0,r1,f1
463 int __va_num; // number of args processed
467 record = make_node (RECORD_TYPE);
469 num = build_decl (FIELD_DECL, get_identifier ("__va_num"),
471 DECL_FIELD_CONTEXT (num) = record;
473 reg = build_decl (FIELD_DECL, get_identifier ("__va_reg"),
474 build_array_type (ptr_type_node,
475 build_index_type (build_int_2 (3, 0))));
476 DECL_FIELD_CONTEXT (reg) = record;
477 TREE_CHAIN (reg) = num;
479 ap = build_decl (FIELD_DECL, get_identifier ("__va_ap"),
481 DECL_FIELD_CONTEXT (ap) = record;
482 TREE_CHAIN (ap) = reg;
484 TYPE_FIELDS (record) = ap;
485 layout_type (record);
491 clipper_va_start (stdarg_p, valist, nextarg)
494 rtx nextarg ATTRIBUTE_UNUSED;
496 tree ap_field, reg_field, num_field;
497 tree t, u, save_area;
499 ap_field = TYPE_FIELDS (TREE_TYPE (valist));
500 reg_field = TREE_CHAIN (ap_field);
501 num_field = TREE_CHAIN (reg_field);
503 ap_field = build (COMPONENT_REF, TREE_TYPE (ap_field), valist, ap_field);
504 reg_field = build (COMPONENT_REF, TREE_TYPE (reg_field), valist, reg_field);
505 num_field = build (COMPONENT_REF, TREE_TYPE (num_field), valist, num_field);
507 /* Call __builtin_saveregs to save r0, r1, f0, and f1 in a block. */
509 save_area = make_tree (integer_type_node, expand_builtin_saveregs ());
513 t = make_tree (ptr_type_node, virtual_incoming_args_rtx);
514 if (stdarg_p && current_function_args_info.size != 0)
515 t = build (PLUS_EXPR, ptr_type_node, t,
516 build_int_2 (current_function_args_info.size, 0));
517 t = build (MODIFY_EXPR, TREE_TYPE (ap_field), ap_field, t);
518 TREE_SIDE_EFFECTS (t) = 1;
519 expand_expr (t, const0_rtx, VOIDmode, EXPAND_NORMAL);
521 /* Set the four entries of __va_reg. */
523 t = build1 (NOP_EXPR, ptr_type_node, save_area);
524 u = build (ARRAY_REF, ptr_type_node, reg_field, build_int_2 (0, 0));
525 t = build (MODIFY_EXPR, ptr_type_node, u, t);
526 TREE_SIDE_EFFECTS (t) = 1;
527 expand_expr (t, const0_rtx, VOIDmode, EXPAND_NORMAL);
529 t = fold (build (PLUS_EXPR, integer_type_node, save_area,
530 build_int_2 (8, 0)));
531 t = build1 (NOP_EXPR, ptr_type_node, save_area);
532 u = build (ARRAY_REF, ptr_type_node, reg_field, build_int_2 (1, 0));
533 t = build (MODIFY_EXPR, ptr_type_node, u, t);
534 TREE_SIDE_EFFECTS (t) = 1;
535 expand_expr (t, const0_rtx, VOIDmode, EXPAND_NORMAL);
537 t = fold (build (PLUS_EXPR, integer_type_node, save_area,
538 build_int_2 (4, 0)));
539 t = build1 (NOP_EXPR, ptr_type_node, save_area);
540 u = build (ARRAY_REF, ptr_type_node, reg_field, build_int_2 (2, 0));
541 t = build (MODIFY_EXPR, ptr_type_node, u, t);
542 TREE_SIDE_EFFECTS (t) = 1;
543 expand_expr (t, const0_rtx, VOIDmode, EXPAND_NORMAL);
545 t = fold (build (PLUS_EXPR, integer_type_node, save_area,
546 build_int_2 (16, 0)));
547 t = build1 (NOP_EXPR, ptr_type_node, save_area);
548 u = build (ARRAY_REF, ptr_type_node, reg_field, build_int_2 (3, 0));
549 t = build (MODIFY_EXPR, ptr_type_node, u, t);
550 TREE_SIDE_EFFECTS (t) = 1;
551 expand_expr (t, const0_rtx, VOIDmode, EXPAND_NORMAL);
555 t = build_int_2 (current_function_args_info.num, 0);
556 t = build (MODIFY_EXPR, TREE_TYPE (num_field), num_field, t);
557 TREE_SIDE_EFFECTS (t) = 1;
558 expand_expr (t, const0_rtx, VOIDmode, EXPAND_NORMAL);
562 clipper_va_arg (valist, type)
565 tree ap_field, reg_field, num_field;
568 rtx addr_rtx, over_label = NULL_RTX, tr;
574 addr = VA.__va_reg[2 * VA.__va_num];
576 addr = round(VA.__va_ap), VA.__va_ap = round(VA.__va_ap) + sizeof(TYPE);
582 addr = VA.__va_reg[2 * VA.__va_num + 1];
584 addr = round(VA.__va_ap), VA.__va_ap = round(VA.__va_ap) + sizeof(TYPE);
589 addr = round(VA.__va_ap), VA.__va_ap = round(VA.__va_ap) + sizeof(TYPE);
593 ap_field = TYPE_FIELDS (TREE_TYPE (valist));
594 reg_field = TREE_CHAIN (ap_field);
595 num_field = TREE_CHAIN (reg_field);
597 ap_field = build (COMPONENT_REF, TREE_TYPE (ap_field), valist, ap_field);
598 reg_field = build (COMPONENT_REF, TREE_TYPE (reg_field), valist, reg_field);
599 num_field = build (COMPONENT_REF, TREE_TYPE (num_field), valist, num_field);
601 addr_rtx = gen_reg_rtx (Pmode);
603 if (! AGGREGATE_TYPE_P (type))
608 over_label = gen_label_rtx ();
609 false_label = gen_label_rtx ();
611 emit_cmp_and_jump_insns (expand_expr (num_field, NULL_RTX, 0,
613 GEN_INT (2), GE, const0_rtx,
614 TYPE_MODE (TREE_TYPE (num_field)),
615 TREE_UNSIGNED (num_field), 0, false_label);
617 inreg = fold (build (MULT_EXPR, integer_type_node, num_field,
618 build_int_2 (2, 0)));
619 if (FLOAT_TYPE_P (type))
620 inreg = fold (build (PLUS_EXPR, integer_type_node, inreg,
621 build_int_2 (1, 0)));
622 inreg = fold (build (ARRAY_REF, ptr_type_node, reg_field, inreg));
624 tr = expand_expr (inreg, addr_rtx, VOIDmode, EXPAND_NORMAL);
626 emit_move_insn (addr_rtx, tr);
628 emit_jump_insn (gen_jump (over_label));
630 emit_label (false_label);
633 /* Round to alignment of `type', or at least integer alignment. */
635 align = TYPE_ALIGN (type);
636 if (align < TYPE_ALIGN (integer_type_node))
637 align = TYPE_ALIGN (integer_type_node);
638 align /= BITS_PER_UNIT;
640 addr = fold (build (PLUS_EXPR, ptr_type_node, ap_field,
641 build_int_2 (align-1, 0)));
642 addr = fold (build (BIT_AND_EXPR, ptr_type_node, addr,
643 build_int_2 (-align, -1)));
644 addr = save_expr (addr);
646 tr = expand_expr (addr, addr_rtx, Pmode, EXPAND_NORMAL);
648 emit_move_insn (addr_rtx, tr);
650 t = build (MODIFY_EXPR, TREE_TYPE (ap_field), ap_field,
651 build (PLUS_EXPR, TREE_TYPE (ap_field),
652 addr, build_int_2 (int_size_in_bytes (type), 0)));
653 TREE_SIDE_EFFECTS (t) = 1;
654 expand_expr (t, const0_rtx, VOIDmode, EXPAND_NORMAL);
657 emit_label (over_label);
659 t = build (MODIFY_EXPR, TREE_TYPE (num_field), num_field,
660 build (PLUS_EXPR, TREE_TYPE (num_field),
661 num_field, build_int_2 (1, 0)));
662 TREE_SIDE_EFFECTS (t) = 1;
663 expand_expr (t, const0_rtx, VOIDmode, EXPAND_NORMAL);
668 /* Return truth value of whether OP can be used as an word register
669 operand. Reject (SUBREG:SI (REG:SF )) */
672 int_reg_operand (op, mode)
674 enum machine_mode mode;
676 return (register_operand (op, mode) &&
677 (GET_CODE (op) != SUBREG ||
678 GET_MODE_CLASS (GET_MODE (SUBREG_REG (op))) == MODE_INT));
681 /* Return truth value of whether OP can be used as a float register
682 operand. Reject (SUBREG:SF (REG:SI )) )) */
685 fp_reg_operand (op, mode)
687 enum machine_mode mode;
689 return (register_operand (op, mode) &&
690 (GET_CODE (op) != SUBREG ||
691 GET_MODE_CLASS (GET_MODE (SUBREG_REG (op))) == MODE_FLOAT));