1 /* Subroutines used for code generation on intel 80960.
2 Copyright (C) 1992, 1995 Free Software Foundation, Inc.
3 Contributed by Steven McGeady, Intel Corp.
4 Additional Work by Glenn Colon-Bonet, Jonathan Shapiro, Andy Wilson
5 Converted to GCC 2.0 by Jim Wilson and Michael Tiemann, Cygnus Support.
7 This file is part of GNU CC.
9 GNU CC is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 2, or (at your option)
14 GNU CC is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with GNU CC; see the file COPYING. If not, write to
21 the Free Software Foundation, 59 Temple Place - Suite 330,
22 Boston, MA 02111-1307, USA. */
29 #include "hard-reg-set.h"
31 #include "insn-config.h"
32 #include "conditions.h"
33 #include "insn-flags.h"
35 #include "insn-attr.h"
38 #include "insn-codes.h"
45 /* Save the operands last given to a compare for use when we
46 generate a scc or bcc insn. */
48 rtx i960_compare_op0
, i960_compare_op1
;
50 /* Used to implement #pragma align/noalign. Initialized by OVERRIDE_OPTIONS
53 static int i960_maxbitalignment
;
54 static int i960_last_maxbitalignment
;
56 /* Used to implement switching between MEM and ALU insn types, for better
57 C series performance. */
59 enum insn_types i960_last_insn_type
;
61 /* The leaf-procedure return register. Set only if this is a leaf routine. */
63 static int i960_leaf_ret_reg
;
65 /* True if replacing tail calls with jumps is OK. */
67 static int tail_call_ok
;
69 /* A string containing a list of insns to emit in the epilogue so as to
70 restore all registers saved by the prologue. Created by the prologue
71 code as it saves registers away. */
73 char epilogue_string
[1000];
75 /* A unique number (per function) for return labels. */
77 static int ret_label
= 0;
79 /* This is true if FNDECL is either a varargs or a stdarg function.
80 This is used to help identify functions that use an argument block. */
82 #define VARARGS_STDARG_FUNCTION(FNDECL) \
83 ((TYPE_ARG_TYPES (TREE_TYPE (FNDECL)) != 0 \
84 && (TREE_VALUE (tree_last (TYPE_ARG_TYPES (TREE_TYPE (FNDECL)))) != void_type_node)) \
85 || current_function_varargs)
87 /* Handle pragmas for compatibility with Intel's compilers. */
89 /* ??? This is incomplete, since it does not handle all pragmas that the
90 intel compilers understand. */
93 process_pragma (finput
)
100 while (c
== ' ' || c
== '\t')
104 && getc (finput
) == 'l'
105 && getc (finput
) == 'i'
106 && getc (finput
) == 'g'
107 && getc (finput
) == 'n'
108 && ((c
= getc (finput
)) == ' ' || c
== '\t' || c
== '\n'))
114 while (c
== ' ' || c
== '\t')
118 while (c
>= '0' && c
<= '9')
120 if (s
< buf
+ sizeof buf
- 1)
130 /* Return to last alignment. */
131 align
= i960_last_maxbitalignment
/ 8;
138 i960_last_maxbitalignment
= i960_maxbitalignment
;
139 i960_maxbitalignment
= align
* 8;
143 /* Silently ignore bad values. */
147 /* NOTE: ic960 R3.0 pragma align definition:
149 #pragma align [(size)] | (identifier=size[,...])
150 #pragma noalign [(identifier)[,...]]
152 (all parens are optional)
154 - size is [1,2,4,8,16]
155 - noalign means size==1
156 - applies only to component elements of a struct (and union?)
157 - identifier applies to structure tag (only)
158 - missing identifier means next struct
160 - alignment rules for bitfields need more investigation */
163 /* Should be pragma 'far' or equivalent for callx/balx here. */
168 /* Initialize variables before compiling any files. */
173 if (TARGET_IC_COMPAT2_0
)
175 i960_maxbitalignment
= 8;
176 i960_last_maxbitalignment
= 128;
180 i960_maxbitalignment
= 128;
181 i960_last_maxbitalignment
= 8;
185 /* Return true if OP can be used as the source of an fp move insn. */
188 fpmove_src_operand (op
, mode
)
190 enum machine_mode mode
;
192 return (GET_CODE (op
) == CONST_DOUBLE
|| general_operand (op
, mode
));
196 /* Return true if OP is a register or zero. */
199 reg_or_zero_operand (op
, mode
)
201 enum machine_mode mode
;
203 return register_operand (op
, mode
) || op
== const0_rtx
;
207 /* Return truth value of whether OP can be used as an operands in a three
208 address arithmetic insn (such as add %o1,7,%l2) of mode MODE. */
211 arith_operand (op
, mode
)
213 enum machine_mode mode
;
215 return (register_operand (op
, mode
) || literal (op
, mode
));
218 /* Return true if OP is a register or a valid floating point literal. */
221 fp_arith_operand (op
, mode
)
223 enum machine_mode mode
;
225 return (register_operand (op
, mode
) || fp_literal (op
, mode
));
228 /* Return true is OP is a register or a valid signed integer literal. */
231 signed_arith_operand (op
, mode
)
233 enum machine_mode mode
;
235 return (register_operand (op
, mode
) || signed_literal (op
, mode
));
238 /* Return truth value of whether OP is a integer which fits the
239 range constraining immediate operands in three-address insns. */
244 enum machine_mode mode
;
246 return ((GET_CODE (op
) == CONST_INT
) && INTVAL(op
) >= 0 && INTVAL(op
) < 32);
249 /* Return true if OP is a float constant of 1. */
252 fp_literal_one (op
, mode
)
254 enum machine_mode mode
;
256 return (TARGET_NUMERICS
&& mode
== GET_MODE (op
) && op
== CONST1_RTX (mode
));
259 /* Return true if OP is a float constant of 0. */
262 fp_literal_zero (op
, mode
)
264 enum machine_mode mode
;
266 return (TARGET_NUMERICS
&& mode
== GET_MODE (op
) && op
== CONST0_RTX (mode
));
269 /* Return true if OP is a valid floating point literal. */
274 enum machine_mode mode
;
276 return fp_literal_zero (op
, mode
) || fp_literal_one (op
, mode
);
279 /* Return true if OP is a valid signed immediate constant. */
282 signed_literal(op
, mode
)
284 enum machine_mode mode
;
286 return ((GET_CODE (op
) == CONST_INT
) && INTVAL(op
) > -32 && INTVAL(op
) < 32);
289 /* Return truth value of statement that OP is a symbolic memory
290 operand of mode MODE. */
293 symbolic_memory_operand (op
, mode
)
295 enum machine_mode mode
;
297 if (GET_CODE (op
) == SUBREG
)
298 op
= SUBREG_REG (op
);
299 if (GET_CODE (op
) != MEM
)
302 return (GET_CODE (op
) == SYMBOL_REF
|| GET_CODE (op
) == CONST
303 || GET_CODE (op
) == HIGH
|| GET_CODE (op
) == LABEL_REF
);
306 /* Return truth value of whether OP is EQ or NE. */
311 enum machine_mode mode
;
313 return (GET_CODE (op
) == EQ
|| GET_CODE (op
) == NE
);
316 /* OP is an integer register or a constant. */
319 arith32_operand (op
, mode
)
321 enum machine_mode mode
;
323 if (register_operand (op
, mode
))
325 return (CONSTANT_P (op
));
328 /* Return true if OP is an integer constant which is a power of 2. */
331 power2_operand (op
,mode
)
333 enum machine_mode mode
;
335 if (GET_CODE (op
) != CONST_INT
)
338 return exact_log2 (INTVAL (op
)) >= 0;
341 /* Return true if OP is an integer constant which is the complement of a
345 cmplpower2_operand (op
, mode
)
347 enum machine_mode mode
;
349 if (GET_CODE (op
) != CONST_INT
)
352 return exact_log2 (~ INTVAL (op
)) >= 0;
355 /* If VAL has only one bit set, return the index of that bit. Otherwise
364 for (i
= 0; val
!= 0; i
++, val
>>= 1)
376 /* Return non-zero if OP is a mask, i.e. all one bits are consecutive.
377 The return value indicates how many consecutive non-zero bits exist
378 if this is a mask. This is the same as the next function, except that
379 it does not indicate what the start and stop bit positions are. */
385 register int start
, end
, i
;
388 for (i
= 0; val
!= 0; val
>>= 1, i
++)
398 /* Still looking for the first bit. */
402 /* We've seen the start of a bit sequence, and now a zero. There
403 must be more one bits, otherwise we would have exited the loop.
404 Therefore, it is not a mask. */
409 /* The bit string has ones from START to END bit positions only. */
410 return end
- start
+ 1;
413 /* If VAL is a mask, then return nonzero, with S set to the starting bit
414 position and E set to the ending bit position of the mask. The return
415 value indicates how many consecutive bits exist in the mask. This is
416 the same as the previous function, except that it also indicates the
417 start and end bit positions of the mask. */
424 register int start
, end
, i
;
428 for (i
= 0; val
!= 0; val
>>= 1, i
++)
439 /* Still looking for the first bit. */
443 /* We've seen the start of a bit sequence, and now a zero. There
444 must be more one bits, otherwise we would have exited the loop.
445 Therefor, it is not a mask. */
454 /* The bit string has ones from START to END bit positions only. */
457 return ((start
< 0) ? 0 : end
- start
+ 1);
460 /* Return the machine mode to use for a comparison. */
463 select_cc_mode (op
, x
)
467 if (op
== GTU
|| op
== LTU
|| op
== GEU
|| op
== LEU
)
472 /* X and Y are two things to compare using CODE. Emit the compare insn and
473 return the rtx for register 36 in the proper mode. */
476 gen_compare_reg (code
, x
, y
)
481 enum machine_mode ccmode
= SELECT_CC_MODE (code
, x
, y
);
482 enum machine_mode mode
483 = GET_MODE (x
) == VOIDmode
? GET_MODE (y
) : GET_MODE (x
);
487 if (! arith_operand (x
, mode
))
488 x
= force_reg (SImode
, x
);
489 if (! arith_operand (y
, mode
))
490 y
= force_reg (SImode
, y
);
493 cc_reg
= gen_rtx (REG
, ccmode
, 36);
494 emit_insn (gen_rtx (SET
, VOIDmode
, cc_reg
,
495 gen_rtx (COMPARE
, ccmode
, x
, y
)));
500 /* For the i960, REG is cost 1, REG+immed CONST is cost 2, REG+REG is cost 2,
501 REG+nonimmed CONST is cost 4. REG+SYMBOL_REF, SYMBOL_REF, and similar
502 are 4. Indexed addresses are cost 6. */
504 /* ??? Try using just RTX_COST, i.e. not defining ADDRESS_COST. */
507 i960_address_cost (x
)
511 /* Handled before calling here. */
512 if (GET_CODE (x
) == REG
)
515 if (GET_CODE (x
) == PLUS
)
517 rtx base
= XEXP (x
, 0);
518 rtx offset
= XEXP (x
, 1);
520 if (GET_CODE (base
) == SUBREG
)
521 base
= SUBREG_REG (base
);
522 if (GET_CODE (offset
) == SUBREG
)
523 offset
= SUBREG_REG (offset
);
525 if (GET_CODE (base
) == REG
)
527 if (GET_CODE (offset
) == REG
)
529 if (GET_CODE (offset
) == CONST_INT
)
531 if ((unsigned)INTVAL (offset
) < 2047)
535 if (CONSTANT_P (offset
))
538 if (GET_CODE (base
) == PLUS
|| GET_CODE (base
) == MULT
)
541 /* This is an invalid address. The return value doesn't matter, but
542 for convenience we make this more expensive than anything else. */
545 if (GET_CODE (x
) == MULT
)
548 /* Symbol_refs and other unrecognized addresses are cost 4. */
552 /* Emit insns to move operands[1] into operands[0].
554 Return 1 if we have written out everything that needs to be done to
555 do the move. Otherwise, return 0 and the caller will emit the move
559 emit_move_sequence (operands
, mode
)
561 enum machine_mode mode
;
563 register rtx operand0
= operands
[0];
564 register rtx operand1
= operands
[1];
566 /* We can only store registers to memory. */
568 if (GET_CODE (operand0
) == MEM
&& GET_CODE (operand1
) != REG
)
569 operands
[1] = force_reg (mode
, operand1
);
574 /* Emit insns to load a constant to non-floating point registers.
575 Uses several strategies to try to use as few insns as possible. */
578 i960_output_ldconst (dst
, src
)
579 register rtx dst
, src
;
582 register unsigned rsrc2
;
583 enum machine_mode mode
= GET_MODE (dst
);
586 operands
[0] = operands
[2] = dst
;
587 operands
[1] = operands
[3] = src
;
589 /* Anything that isn't a compile time constant, such as a SYMBOL_REF,
590 must be a ldconst insn. */
592 if (GET_CODE (src
) != CONST_INT
&& GET_CODE (src
) != CONST_DOUBLE
)
594 output_asm_insn ("ldconst %1,%0", operands
);
597 else if (mode
== XFmode
)
603 if (fp_literal_zero (src
, XFmode
))
606 REAL_VALUE_FROM_CONST_DOUBLE (d
, src
);
607 REAL_VALUE_TO_TARGET_LONG_DOUBLE (d
, value_long
);
609 output_asm_insn ("# ldconst %1,%0",operands
);
611 for (i
= 0; i
< 3; i
++)
613 operands
[0] = gen_rtx (REG
, SImode
, REGNO (dst
) + i
);
614 operands
[1] = GEN_INT (value_long
[i
]);
615 output_asm_insn (i960_output_ldconst (operands
[0], operands
[1]),
621 else if (mode
== DFmode
)
625 if (fp_literal_zero (src
, DFmode
))
628 split_double (src
, &first
, &second
);
630 output_asm_insn ("# ldconst %1,%0",operands
);
632 operands
[0] = gen_rtx (REG
, SImode
, REGNO (dst
));
634 output_asm_insn (i960_output_ldconst (operands
[0], operands
[1]),
636 operands
[0] = gen_rtx (REG
, SImode
, REGNO (dst
) + 1);
637 operands
[1] = second
;
638 output_asm_insn (i960_output_ldconst (operands
[0], operands
[1]),
642 else if (mode
== SFmode
)
647 REAL_VALUE_FROM_CONST_DOUBLE (d
, src
);
648 REAL_VALUE_TO_TARGET_SINGLE (d
, value
);
650 output_asm_insn ("# ldconst %1,%0",operands
);
651 operands
[0] = gen_rtx (REG
, SImode
, REGNO (dst
));
652 operands
[1] = gen_rtx (CONST_INT
, VOIDmode
, value
);
653 output_asm_insn (i960_output_ldconst (operands
[0], operands
[1]),
657 else if (mode
== TImode
)
659 /* ??? This is currently not handled at all. */
662 /* Note: lowest order word goes in lowest numbered reg. */
663 rsrc1
= INTVAL (src
);
664 if (rsrc1
>= 0 && rsrc1
< 32)
667 output_asm_insn ("movq\t0,%0\t# ldconstq %1,%0",operands
);
668 /* Go pick up the low-order word. */
670 else if (mode
== DImode
)
672 rtx upperhalf
, lowerhalf
, xoperands
[2];
674 if (GET_CODE (src
) == CONST_DOUBLE
|| GET_CODE (src
) == CONST_INT
)
675 split_double (src
, &lowerhalf
, &upperhalf
);
680 /* Note: lowest order word goes in lowest numbered reg. */
681 /* Numbers from 0 to 31 can be handled with a single insn. */
682 rsrc1
= INTVAL (lowerhalf
);
683 if (upperhalf
== const0_rtx
&& rsrc1
>= 0 && rsrc1
< 32)
686 /* Output the upper half with a recursive call. */
687 xoperands
[0] = gen_rtx (REG
, SImode
, REGNO (dst
) + 1);
688 xoperands
[1] = upperhalf
;
689 output_asm_insn (i960_output_ldconst (xoperands
[0], xoperands
[1]),
691 /* The lower word is emitted as normally. */
695 rsrc1
= INTVAL (src
);
701 else if (mode
== HImode
)
710 /* ldconst 0..31,X -> mov 0..31,X */
713 if (i960_last_insn_type
== I_TYPE_REG
&& TARGET_C_SERIES
)
718 /* ldconst 32..63,X -> add 31,nn,X */
721 if (i960_last_insn_type
== I_TYPE_REG
&& TARGET_C_SERIES
)
723 operands
[1] = gen_rtx (CONST_INT
, VOIDmode
, rsrc1
- 31);
724 output_asm_insn ("addo\t31,%1,%0\t# ldconst %3,%0", operands
);
730 /* ldconst -1..-31 -> sub 0,0..31,X */
733 /* return 'sub -(%1),0,%0' */
734 operands
[1] = gen_rtx (CONST_INT
, VOIDmode
, - rsrc1
);
735 output_asm_insn ("subo\t%1,0,%0\t# ldconst %3,%0", operands
);
739 /* ldconst -32 -> not 31,X */
742 operands
[1] = gen_rtx (CONST_INT
, VOIDmode
, ~rsrc1
);
743 output_asm_insn ("not\t%1,%0 # ldconst %3,%0", operands
);
748 /* If const is a single bit. */
749 if (bitpos (rsrc1
) >= 0)
751 operands
[1] = gen_rtx (CONST_INT
, VOIDmode
, bitpos (rsrc1
));
752 output_asm_insn ("setbit\t%1,0,%0\t# ldconst %3,%0", operands
);
756 /* If const is a bit string of less than 6 bits (1..31 shifted). */
761 if (bitstr (rsrc1
, &s
, &e
) < 6)
763 rsrc2
= ((unsigned int) rsrc1
) >> s
;
764 operands
[1] = gen_rtx (CONST_INT
, VOIDmode
, rsrc2
);
765 operands
[2] = gen_rtx (CONST_INT
, VOIDmode
, s
);
766 output_asm_insn ("shlo\t%2,%1,%0\t# ldconst %3,%0", operands
);
771 /* Unimplemented cases:
772 const is in range 0..31 but rotated around end of word:
773 ror 31,3,g0 -> ldconst 0xe0000003,g0
775 and any 2 instruction cases that might be worthwhile */
777 output_asm_insn ("ldconst %1,%0", operands
);
781 /* Determine if there is an opportunity for a bypass optimization.
782 Bypass succeeds on the 960K* if the destination of the previous
783 instruction is the second operand of the current instruction.
784 Bypass always succeeds on the C*.
786 Return 1 if the pattern should interchange the operands.
788 CMPBR_FLAG is true if this is for a compare-and-branch insn.
789 OP1 and OP2 are the two source operands of a 3 operand insn. */
792 i960_bypass (insn
, op1
, op2
, cmpbr_flag
)
793 register rtx insn
, op1
, op2
;
796 register rtx prev_insn
, prev_dest
;
801 /* Can't do this if op1 isn't a register. */
805 /* Can't do this for a compare-and-branch if both ops aren't regs. */
806 if (cmpbr_flag
&& ! REG_P (op2
))
809 prev_insn
= prev_real_insn (insn
);
811 if (prev_insn
&& GET_CODE (prev_insn
) == INSN
812 && GET_CODE (PATTERN (prev_insn
)) == SET
)
814 prev_dest
= SET_DEST (PATTERN (prev_insn
));
815 if ((GET_CODE (prev_dest
) == REG
&& REGNO (prev_dest
) == REGNO (op1
))
816 || (GET_CODE (prev_dest
) == SUBREG
817 && GET_CODE (SUBREG_REG (prev_dest
)) == REG
818 && REGNO (SUBREG_REG (prev_dest
)) == REGNO (op1
)))
824 /* Output the code which declares the function name. This also handles
825 leaf routines, which have special requirements, and initializes some
829 i960_function_name_declare (file
, name
, fndecl
)
838 /* Increment global return label. */
842 /* Compute whether tail calls and leaf routine optimizations can be performed
843 for this function. */
855 /* Even if nobody uses extra parms, can't have leafproc or tail calls if
856 argblock, because argblock uses g14 implicitly. */
858 if (current_function_args_size
!= 0 || VARARGS_STDARG_FUNCTION (fndecl
))
864 /* See if caller passes in an address to return value. */
866 if (aggregate_value_p (DECL_RESULT (fndecl
)))
872 /* Can not use tail calls or make this a leaf routine if there is a non
875 if (get_frame_size () != 0)
878 /* I don't understand this condition, and do not think that it is correct.
879 Apparently this is just checking whether the frame pointer is used, and
880 we can't trust regs_ever_live[fp] since it is (almost?) always set. */
883 for (insn
= get_insns (); insn
; insn
= NEXT_INSN (insn
))
884 if (GET_CODE (insn
) == INSN
885 && reg_mentioned_p (frame_pointer_rtx
, insn
))
891 /* Check for CALL insns. Can not be a leaf routine if there are any. */
894 for (insn
= get_insns (); insn
; insn
= NEXT_INSN (insn
))
895 if (GET_CODE (insn
) == CALL_INSN
)
901 /* Can not be a leaf routine if any non-call clobbered registers are
902 used in this function. */
905 for (i
= 0, j
= 0; i
< FIRST_PSEUDO_REGISTER
; i
++)
906 if (regs_ever_live
[i
]
907 && ((! call_used_regs
[i
]) || (i
> 7 && i
< 12)))
909 /* Global registers. */
910 if (i
< 16 && i
> 7 && i
!= 13)
912 /* Local registers. */
917 /* Now choose a leaf return register, if we can find one, and if it is
918 OK for this to be a leaf routine. */
920 i960_leaf_ret_reg
= -1;
922 if (optimize
&& leaf_proc_ok
)
924 for (i960_leaf_ret_reg
= -1, i
= 0; i
< 8; i
++)
925 if (regs_ever_live
[i
] == 0)
927 i960_leaf_ret_reg
= i
;
928 regs_ever_live
[i
] = 1;
933 /* Do this after choosing the leaf return register, so it will be listed
934 if one was chosen. */
936 fprintf (file
, "\t# Function '%s'\n", (name
[0] == '*' ? &name
[1] : name
));
937 fprintf (file
, "\t# Registers used: ");
939 for (i
= 0, j
= 0; i
< FIRST_PSEUDO_REGISTER
; i
++)
941 if (regs_ever_live
[i
])
943 fprintf (file
, "%s%s ", reg_names
[i
], call_used_regs
[i
] ? "" : "*");
945 if (i
> 15 && j
== 0)
947 fprintf (file
,"\n\t#\t\t ");
953 fprintf (file
, "\n");
955 if (i960_leaf_ret_reg
>= 0)
957 /* Make it a leaf procedure. */
959 if (TREE_PUBLIC (fndecl
))
960 fprintf (file
,"\t.globl\t%s.lf\n", (name
[0] == '*' ? &name
[1] : name
));
962 fprintf (file
, "\t.leafproc\t");
963 assemble_name (file
, name
);
964 fprintf (file
, ",%s.lf\n", (name
[0] == '*' ? &name
[1] : name
));
965 ASM_OUTPUT_LABEL (file
, name
);
966 fprintf (file
, "\tlda LR%d,g14\n", ret_label
);
967 fprintf (file
, "%s.lf:\n", (name
[0] == '*' ? &name
[1] : name
));
968 fprintf (file
, "\tmov g14,g%d\n", i960_leaf_ret_reg
);
972 fprintf (file
, "\tlda 0,g14\n");
973 i960_last_insn_type
= I_TYPE_MEM
;
977 fprintf (file
, "\tmov 0,g14\n");
978 i960_last_insn_type
= I_TYPE_REG
;
983 ASM_OUTPUT_LABEL (file
, name
);
984 i960_last_insn_type
= I_TYPE_CTRL
;
988 /* Compute and return the frame size. */
991 compute_frame_size (size
)
995 int outgoing_args_size
= current_function_outgoing_args_size
;
997 /* The STARTING_FRAME_OFFSET is totally hidden to us as far
998 as size is concerned. */
999 actual_fsize
= (size
+ 15) & -16;
1000 actual_fsize
+= (outgoing_args_size
+ 15) & -16;
1002 return actual_fsize
;
1005 /* Output code for the function prologue. */
1008 i960_function_prologue (file
, size
)
1012 register int i
, j
, nr
;
1015 int actual_fsize
, offset
;
1017 /* -1 if reg must be saved on proc entry, 0 if available, 1 if saved
1019 int regs
[FIRST_PSEUDO_REGISTER
];
1021 for (i
= 0; i
< FIRST_PSEUDO_REGISTER
; i
++)
1022 if (regs_ever_live
[i
]
1023 && ((! call_used_regs
[i
]) || (i
> 7 && i
< 12)))
1026 /* Count global registers that need saving. */
1033 epilogue_string
[0] = '\0';
1035 if (profile_flag
|| profile_block_flag
)
1037 /* When profiling, we may use registers 20 to 27 to save arguments, so
1038 they can't be used here for saving globals. J is the number of
1039 argument registers the mcount call will save. */
1040 for (j
= 7; j
>= 0 && ! regs_ever_live
[j
]; j
--)
1043 for (i
= 20; i
<= j
+ 20; i
++)
1047 /* First look for local registers to save globals in. */
1048 for (i
= 0; i
< 16; i
++)
1053 /* Start at r4, not r3. */
1054 for (j
= 20; j
< 32; j
++)
1061 regs_ever_live
[j
] = 1;
1063 if (i
<= 14 && i
% 2 == 0 && j
<= 30 && j
% 2 == 0
1064 && regs
[i
+1] != 0 && regs
[j
+1] == 0)
1069 regs_ever_live
[j
+1] = 1;
1071 if (nr
== 2 && i
<= 12 && i
% 4 == 0 && j
<= 28 && j
% 4 == 0
1072 && regs
[i
+2] != 0 && regs
[j
+2] == 0)
1077 regs_ever_live
[j
+2] = 1;
1079 if (nr
== 3 && regs
[i
+3] != 0 && regs
[j
+3] == 0)
1084 regs_ever_live
[j
+3] = 1;
1087 fprintf (file
, "\tmov%s %s,%s\n",
1090 (nr
== 2) ? "l" : ""),
1091 reg_names
[i
], reg_names
[j
]);
1092 sprintf (tmpstr
, "\tmov%s %s,%s\n",
1095 (nr
== 2) ? "l" : ""),
1096 reg_names
[j
], reg_names
[i
]);
1097 strcat (epilogue_string
, tmpstr
);
1105 /* N_iregs is now the number of global registers that haven't been saved
1108 rsize
= (n_iregs
* 4);
1109 actual_fsize
= compute_frame_size (size
) + rsize
;
1111 /* ??? The 1.2.1 compiler does this also. This is meant to round the frame
1112 size up to the nearest multiple of 16. I don't know whether this is
1113 necessary, or even desirable.
1115 The frame pointer must be aligned, but the call instruction takes care of
1116 that. If we leave the stack pointer unaligned, we may save a little on
1117 dynamic stack allocation. And we don't lose, at least according to the
1119 actual_fsize
= (actual_fsize
+ 15) & ~0xF;
1122 /* Allocate space for register save and locals. */
1123 if (actual_fsize
> 0)
1125 if (actual_fsize
< 32)
1126 fprintf (file
, "\taddo %d,sp,sp\n", actual_fsize
);
1128 fprintf (file
, "\tlda\t%d(sp),sp\n", actual_fsize
);
1131 /* Take hardware register save area created by the call instruction
1132 into account, but store them before the argument block area. */
1133 offset
= 64 + actual_fsize
- compute_frame_size (0) - rsize
;
1134 /* Save registers on stack if needed. */
1135 for (i
= 0, j
= n_iregs
; j
> 0 && i
< 16; i
++)
1142 if (i
<= 14 && i
% 2 == 0 && regs
[i
+1] == -1 && offset
% 2 == 0)
1145 if (nr
== 2 && i
<= 12 && i
% 4 == 0 && regs
[i
+2] == -1
1149 if (nr
== 3 && regs
[i
+3] == -1)
1152 fprintf (file
,"\tst%s %s,%d(fp)\n",
1155 (nr
== 2) ? "l" : ""),
1156 reg_names
[i
], offset
);
1157 sprintf (tmpstr
,"\tld%s %d(fp),%s\n",
1160 (nr
== 2) ? "l" : ""),
1161 offset
, reg_names
[i
]);
1162 strcat (epilogue_string
, tmpstr
);
1168 if (actual_fsize
== 0 && size
== 0 && rsize
== 0)
1171 fprintf (file
, "\t#Prologue stats:\n");
1172 fprintf (file
, "\t# Total Frame Size: %d bytes\n", actual_fsize
);
1175 fprintf (file
, "\t# Local Variable Size: %d bytes\n", size
);
1177 fprintf (file
, "\t# Register Save Size: %d regs, %d bytes\n",
1179 fprintf (file
, "\t#End Prologue#\n");
1182 /* Output code for the function profiler. */
1185 output_function_profiler (file
, labelno
)
1189 /* The last used parameter register. */
1191 int i
, j
, increment
;
1192 int varargs_stdarg_function
1193 = VARARGS_STDARG_FUNCTION (current_function_decl
);
1195 /* Figure out the last used parameter register. The proper thing to do
1196 is to walk incoming args of the function. A function might have live
1197 parameter registers even if it has no incoming args. Note that we
1198 don't have to save parameter registers g8 to g11 because they are
1201 /* See also output_function_prologue, which tries to use local registers
1202 for preserved call-saved global registers. */
1204 for (last_parm_reg
= 7;
1205 last_parm_reg
>= 0 && ! regs_ever_live
[last_parm_reg
];
1209 /* Save parameter registers in regs r4 (20) to r11 (27). */
1211 for (i
= 0, j
= 4; i
<= last_parm_reg
; i
+= increment
, j
+= increment
)
1213 if (i
% 4 == 0 && (last_parm_reg
- i
) >= 3)
1215 else if (i
% 4 == 0 && (last_parm_reg
- i
) >= 2)
1217 else if (i
% 2 == 0 && (last_parm_reg
- i
) >= 1)
1222 fprintf (file
, "\tmov%s g%d,r%d\n",
1223 (increment
== 4 ? "q" : increment
== 3 ? "t"
1224 : increment
== 2 ? "l": ""), i
, j
);
1227 /* If this function uses the arg pointer, then save it in r3 and then
1230 if (current_function_args_size
!= 0 || varargs_stdarg_function
)
1231 fprintf (file
, "\tmov g14,r3\n\tmov 0,g14\n");
1233 /* Load location address into g0 and call mcount. */
1235 fprintf (file
, "\tlda\tLP%d,g0\n\tcallx\tmcount\n", labelno
);
1237 /* If this function uses the arg pointer, restore it. */
1239 if (current_function_args_size
!= 0 || varargs_stdarg_function
)
1240 fprintf (file
, "\tmov r3,g14\n");
1242 /* Restore parameter registers. */
1244 for (i
= 0, j
= 4; i
<= last_parm_reg
; i
+= increment
, j
+= increment
)
1246 if (i
% 4 == 0 && (last_parm_reg
- i
) >= 3)
1248 else if (i
% 4 == 0 && (last_parm_reg
- i
) >= 2)
1250 else if (i
% 2 == 0 && (last_parm_reg
- i
) >= 1)
1255 fprintf (file
, "\tmov%s r%d,g%d\n",
1256 (increment
== 4 ? "q" : increment
== 3 ? "t"
1257 : increment
== 2 ? "l": ""), j
, i
);
1261 /* Output code for the function epilogue. */
1264 i960_function_epilogue (file
, size
)
1268 if (i960_leaf_ret_reg
>= 0)
1270 fprintf (file
, "LR%d: ret\n", ret_label
);
1274 if (*epilogue_string
== 0)
1278 /* Emit a return insn, but only if control can fall through to here. */
1280 tmp
= get_last_insn ();
1283 if (GET_CODE (tmp
) == BARRIER
)
1285 if (GET_CODE (tmp
) == CODE_LABEL
)
1287 if (GET_CODE (tmp
) == JUMP_INSN
)
1289 if (GET_CODE (PATTERN (tmp
)) == RETURN
)
1293 if (GET_CODE (tmp
) == NOTE
)
1295 tmp
= PREV_INSN (tmp
);
1300 fprintf (file
, "LR%d: ret\n", ret_label
);
1304 fprintf (file
, "LR%d:\n", ret_label
);
1306 fprintf (file
, "\t#EPILOGUE#\n");
1308 /* Output the string created by the prologue which will restore all
1309 registers saved by the prologue. */
1311 if (epilogue_string
[0] != '\0')
1312 fprintf (file
, "%s", epilogue_string
);
1314 /* Must clear g14 on return if this function set it.
1315 Only varargs/stdarg functions modify g14. */
1317 if (VARARGS_STDARG_FUNCTION (current_function_decl
))
1318 fprintf (file
, "\tmov 0,g14\n");
1320 fprintf (file
, "\tret\n");
1321 fprintf (file
, "\t#End Epilogue#\n");
1324 /* Output code for a call insn. */
1327 i960_output_call_insn (target
, argsize_rtx
, arg_pointer
, insn
)
1328 register rtx target
, argsize_rtx
, arg_pointer
, insn
;
1330 int argsize
= INTVAL (argsize_rtx
);
1331 rtx nexti
= next_real_insn (insn
);
1333 int varargs_stdarg_function
1334 = VARARGS_STDARG_FUNCTION (current_function_decl
);
1336 operands
[0] = target
;
1337 operands
[1] = arg_pointer
;
1339 if (current_function_args_size
!= 0 || varargs_stdarg_function
)
1340 output_asm_insn ("mov g14,r3", operands
);
1343 output_asm_insn ("lda %a1,g14", operands
);
1344 else if (current_function_args_size
!= 0 || varargs_stdarg_function
)
1345 output_asm_insn ("mov 0,g14", operands
);
1347 /* The code used to assume that calls to SYMBOL_REFs could not be more
1348 than 24 bits away (b vs bx, callj vs callx). This is not true. This
1349 feature is now implemented by relaxing in the GNU linker. It can convert
1350 bx to b if in range, and callx to calls/call/balx/bal as appropriate. */
1352 /* Nexti could be zero if the called routine is volatile. */
1353 if (optimize
&& (*epilogue_string
== 0) && argsize
== 0 && tail_call_ok
1354 && (nexti
== 0 || GET_CODE (PATTERN (nexti
)) == RETURN
))
1356 /* Delete following return insn. */
1357 if (nexti
&& no_labels_between_p (insn
, nexti
))
1358 delete_insn (nexti
);
1359 output_asm_insn ("bx %0", operands
);
1360 return "# notreached";
1363 output_asm_insn ("callx %0", operands
);
1365 /* If the caller sets g14 to the address of the argblock, then the caller
1366 must clear it after the return. */
1368 if (current_function_args_size
!= 0 || varargs_stdarg_function
)
1369 output_asm_insn ("mov r3,g14", operands
);
1370 else if (argsize
> 48)
1371 output_asm_insn ("mov 0,g14", operands
);
1376 /* Output code for a return insn. */
1379 i960_output_ret_insn (insn
)
1382 static char lbuf
[20];
1384 if (*epilogue_string
!= 0)
1386 if (! TARGET_CODE_ALIGN
&& next_real_insn (insn
) == 0)
1389 sprintf (lbuf
, "b LR%d", ret_label
);
1393 /* Must clear g14 on return if this function set it.
1394 Only varargs/stdarg functions modify g14. */
1396 if (VARARGS_STDARG_FUNCTION (current_function_decl
))
1397 output_asm_insn ("mov 0,g14", 0);
1399 if (i960_leaf_ret_reg
>= 0)
1401 sprintf (lbuf
, "bx (%s)", reg_names
[i960_leaf_ret_reg
]);
1408 /* Return a character string representing the branch prediction
1409 opcode to be tacked on an instruction. This must at least
1410 return a null string. */
1413 i960_br_predict_opcode (lab_ref
, insn
)
1416 if (TARGET_BRANCH_PREDICT
)
1418 unsigned long label_uid
;
1420 if (GET_CODE (lab_ref
) == CODE_LABEL
)
1421 label_uid
= INSN_UID (lab_ref
);
1422 else if (GET_CODE (lab_ref
) == LABEL_REF
)
1423 label_uid
= INSN_UID (XEXP (lab_ref
, 0));
1427 /* If not optimizing, then the insn_addresses array will not be
1428 valid. In this case, always return ".t" since most branches
1429 are taken. If optimizing, return .t for backward branches
1430 and .f for forward branches. */
1432 || insn_addresses
[label_uid
] < insn_addresses
[INSN_UID (insn
)])
1441 /* Print the operand represented by rtx X formatted by code CODE. */
1444 i960_print_operand (file
, x
, code
)
1449 enum rtx_code rtxcode
= GET_CODE (x
);
1456 /* Second reg of a double. */
1457 fprintf (file
, "%s", reg_names
[REGNO (x
)+1]);
1461 fprintf (file
, "%s", reg_names
[REGNO (x
)]);
1469 else if (rtxcode
== MEM
)
1471 output_address (XEXP (x
, 0));
1474 else if (rtxcode
== CONST_INT
)
1476 if (INTVAL (x
) > 9999 || INTVAL (x
) < -999)
1477 fprintf (file
, "0x%x", INTVAL (x
));
1479 fprintf (file
, "%d", INTVAL (x
));
1482 else if (rtxcode
== CONST_DOUBLE
)
1487 if (x
== CONST0_RTX (GET_MODE (x
)))
1489 fprintf (file
, "0f0.0");
1492 else if (x
== CONST1_RTX (GET_MODE (x
)))
1494 fprintf (file
, "0f1.0");
1498 REAL_VALUE_FROM_CONST_DOUBLE (d
, x
);
1499 REAL_VALUE_TO_DECIMAL (d
, "%#g", dstr
);
1500 fprintf (file
, "0f%s", dstr
);
1507 /* Branch or jump, depending on assembler. */
1508 if (TARGET_ASM_COMPAT
)
1515 /* Sign of condition. */
1516 if ((rtxcode
== EQ
) || (rtxcode
== NE
) || (rtxcode
== GTU
)
1517 || (rtxcode
== LTU
) || (rtxcode
== GEU
) || (rtxcode
== LEU
))
1519 else if ((rtxcode
== GT
) || (rtxcode
== LT
)
1520 || (rtxcode
== GE
) || (rtxcode
== LE
))
1527 /* Inverted condition. */
1528 rtxcode
= reverse_condition (rtxcode
);
1532 /* Inverted condition w/ reversed operands. */
1533 rtxcode
= reverse_condition (rtxcode
);
1537 /* Reversed operand condition. */
1538 rtxcode
= swap_condition (rtxcode
);
1542 /* Normal condition. */
1544 if (rtxcode
== EQ
) { fputs ("e", file
); return; }
1545 else if (rtxcode
== NE
) { fputs ("ne", file
); return; }
1546 else if (rtxcode
== GT
) { fputs ("g", file
); return; }
1547 else if (rtxcode
== GTU
) { fputs ("g", file
); return; }
1548 else if (rtxcode
== LT
) { fputs ("l", file
); return; }
1549 else if (rtxcode
== LTU
) { fputs ("l", file
); return; }
1550 else if (rtxcode
== GE
) { fputs ("ge", file
); return; }
1551 else if (rtxcode
== GEU
) { fputs ("ge", file
); return; }
1552 else if (rtxcode
== LE
) { fputs ("le", file
); return; }
1553 else if (rtxcode
== LEU
) { fputs ("le", file
); return; }
1558 output_addr_const (file
, x
);
1568 /* Print a memory address as an operand to reference that memory location.
1570 This is exactly the same as legitimate_address_p, except that it the prints
1571 addresses instead of recognizing them. */
1574 i960_print_operand_addr (file
, addr
)
1586 if (GET_CODE (addr
) == REG
)
1588 else if (CONSTANT_P (addr
))
1590 else if (GET_CODE (addr
) == PLUS
)
1594 op0
= XEXP (addr
, 0);
1595 op1
= XEXP (addr
, 1);
1597 if (GET_CODE (op0
) == REG
)
1600 if (GET_CODE (op1
) == REG
)
1602 else if (CONSTANT_P (op1
))
1607 else if (GET_CODE (op0
) == PLUS
)
1609 if (GET_CODE (XEXP (op0
, 0)) == MULT
)
1611 ireg
= XEXP (XEXP (op0
, 0), 0);
1612 scale
= XEXP (XEXP (op0
, 0), 1);
1613 if (GET_CODE (XEXP (op0
, 1)) == REG
)
1615 breg
= XEXP (op0
, 1);
1621 else if (GET_CODE (XEXP (op0
, 0)) == REG
)
1623 breg
= XEXP (op0
, 0);
1624 if (GET_CODE (XEXP (op0
, 1)) == REG
)
1626 ireg
= XEXP (op0
, 1);
1635 else if (GET_CODE (op0
) == MULT
)
1637 ireg
= XEXP (op0
, 0);
1638 scale
= XEXP (op0
, 1);
1639 if (GET_CODE (op1
) == REG
)
1641 else if (CONSTANT_P (op1
))
1649 else if (GET_CODE (addr
) == MULT
)
1651 ireg
= XEXP (addr
, 0);
1652 scale
= XEXP (addr
, 1);
1658 output_addr_const (file
, offset
);
1660 fprintf (file
, "(%s)", reg_names
[REGNO (breg
)]);
1662 fprintf (file
, "[%s*%d]", reg_names
[REGNO (ireg
)], INTVAL (scale
));
1665 /* GO_IF_LEGITIMATE_ADDRESS recognizes an RTL expression
1666 that is a valid memory address for an instruction.
1667 The MODE argument is the machine mode for the MEM expression
1668 that wants to use this address.
1670 On 80960, legitimate addresses are:
1672 disp (12 or 32 bit) ld foo,r0
1673 base + index ld (g0)[g1*1],r0
1674 base + displ ld 0xf00(g0),r0
1675 base + index*scale + displ ld 0xf00(g0)[g1*4],r0
1676 index*scale + base ld (g0)[g1*4],r0
1677 index*scale + displ ld 0xf00[g1*4],r0
1678 index*scale ld [g1*4],r0
1679 index + base + displ ld 0xf00(g0)[g1*1],r0
1681 In each case, scale can be 1, 2, 4, 8, or 16. */
1683 /* This is exactly the same as i960_print_operand_addr, except that
1684 it recognizes addresses instead of printing them.
1686 It only recognizes address in canonical form. LEGITIMIZE_ADDRESS should
1687 convert common non-canonical forms to canonical form so that they will
1690 /* These two macros allow us to accept either a REG or a SUBREG anyplace
1691 where a register is valid. */
1693 #define RTX_OK_FOR_BASE_P(X, STRICT) \
1694 ((GET_CODE (X) == REG \
1695 && (STRICT ? REG_OK_FOR_BASE_P_STRICT (X) : REG_OK_FOR_BASE_P (X))) \
1696 || (GET_CODE (X) == SUBREG \
1697 && GET_CODE (SUBREG_REG (X)) == REG \
1698 && (STRICT ? REG_OK_FOR_BASE_P_STRICT (SUBREG_REG (X)) \
1699 : REG_OK_FOR_BASE_P (SUBREG_REG (X)))))
1701 #define RTX_OK_FOR_INDEX_P(X, STRICT) \
1702 ((GET_CODE (X) == REG \
1703 && (STRICT ? REG_OK_FOR_INDEX_P_STRICT (X) : REG_OK_FOR_INDEX_P (X)))\
1704 || (GET_CODE (X) == SUBREG \
1705 && GET_CODE (SUBREG_REG (X)) == REG \
1706 && (STRICT ? REG_OK_FOR_INDEX_P_STRICT (SUBREG_REG (X)) \
1707 : REG_OK_FOR_INDEX_P (SUBREG_REG (X)))))
1710 legitimate_address_p (mode
, addr
, strict
)
1711 enum machine_mode mode
;
1715 if (RTX_OK_FOR_BASE_P (addr
, strict
))
1717 else if (CONSTANT_P (addr
))
1719 else if (GET_CODE (addr
) == PLUS
)
1723 if (! TARGET_COMPLEX_ADDR
&& ! reload_completed
)
1726 op0
= XEXP (addr
, 0);
1727 op1
= XEXP (addr
, 1);
1729 if (RTX_OK_FOR_BASE_P (op0
, strict
))
1731 if (RTX_OK_FOR_INDEX_P (op1
, strict
))
1733 else if (CONSTANT_P (op1
))
1738 else if (GET_CODE (op0
) == PLUS
)
1740 if (GET_CODE (XEXP (op0
, 0)) == MULT
)
1742 if (! (RTX_OK_FOR_INDEX_P (XEXP (XEXP (op0
, 0), 0), strict
)
1743 && SCALE_TERM_P (XEXP (XEXP (op0
, 0), 1))))
1746 if (RTX_OK_FOR_BASE_P (XEXP (op0
, 1), strict
)
1747 && CONSTANT_P (op1
))
1752 else if (RTX_OK_FOR_BASE_P (XEXP (op0
, 0), strict
))
1754 if (RTX_OK_FOR_INDEX_P (XEXP (op0
, 1), strict
)
1755 && CONSTANT_P (op1
))
1763 else if (GET_CODE (op0
) == MULT
)
1765 if (! (RTX_OK_FOR_INDEX_P (XEXP (op0
, 0), strict
)
1766 && SCALE_TERM_P (XEXP (op0
, 1))))
1769 if (RTX_OK_FOR_BASE_P (op1
, strict
))
1771 else if (CONSTANT_P (op1
))
1779 else if (GET_CODE (addr
) == MULT
)
1781 if (! TARGET_COMPLEX_ADDR
&& ! reload_completed
)
1784 return (RTX_OK_FOR_INDEX_P (XEXP (addr
, 0), strict
)
1785 && SCALE_TERM_P (XEXP (addr
, 1)));
1791 /* Try machine-dependent ways of modifying an illegitimate address
1792 to be legitimate. If we find one, return the new, valid address.
1793 This macro is used in only one place: `memory_address' in explow.c.
1795 This converts some non-canonical addresses to canonical form so they
1796 can be recognized. */
1799 legitimize_address (x
, oldx
, mode
)
1802 enum machine_mode mode
;
1804 if (GET_CODE (x
) == SYMBOL_REF
)
1807 x
= copy_to_reg (x
);
1810 if (! TARGET_COMPLEX_ADDR
&& ! reload_completed
)
1813 /* Canonicalize (plus (mult (reg) (const)) (plus (reg) (const)))
1814 into (plus (plus (mult (reg) (const)) (reg)) (const)). This can be
1815 created by virtual register instantiation, register elimination, and
1816 similar optimizations. */
1817 if (GET_CODE (x
) == PLUS
&& GET_CODE (XEXP (x
, 0)) == MULT
1818 && GET_CODE (XEXP (x
, 1)) == PLUS
)
1819 x
= gen_rtx (PLUS
, Pmode
,
1820 gen_rtx (PLUS
, Pmode
, XEXP (x
, 0), XEXP (XEXP (x
, 1), 0)),
1821 XEXP (XEXP (x
, 1), 1));
1823 /* Canonicalize (plus (plus (mult (reg) (const)) (plus (reg) (const))) const)
1824 into (plus (plus (mult (reg) (const)) (reg)) (const)). */
1825 else if (GET_CODE (x
) == PLUS
&& GET_CODE (XEXP (x
, 0)) == PLUS
1826 && GET_CODE (XEXP (XEXP (x
, 0), 0)) == MULT
1827 && GET_CODE (XEXP (XEXP (x
, 0), 1)) == PLUS
1828 && CONSTANT_P (XEXP (x
, 1)))
1830 rtx constant
, other
;
1832 if (GET_CODE (XEXP (x
, 1)) == CONST_INT
)
1834 constant
= XEXP (x
, 1);
1835 other
= XEXP (XEXP (XEXP (x
, 0), 1), 1);
1837 else if (GET_CODE (XEXP (XEXP (XEXP (x
, 0), 1), 1)) == CONST_INT
)
1839 constant
= XEXP (XEXP (XEXP (x
, 0), 1), 1);
1840 other
= XEXP (x
, 1);
1846 x
= gen_rtx (PLUS
, Pmode
,
1847 gen_rtx (PLUS
, Pmode
, XEXP (XEXP (x
, 0), 0),
1848 XEXP (XEXP (XEXP (x
, 0), 1), 0)),
1849 plus_constant (other
, INTVAL (constant
)));
1856 /* Return the most stringent alignment that we are willing to consider
1857 objects of size SIZE and known alignment ALIGN as having. */
1860 i960_alignment (size
, align
)
1866 if (! TARGET_STRICT_ALIGN
)
1867 if (TARGET_IC_COMPAT2_0
|| align
>= 4)
1869 i
= i960_object_bytes_bitalign (size
) / BITS_PER_UNIT
;
1878 /* Modes for condition codes. */
1880 ((1 << (int) CCmode) | (1 << (int) CC_UNSmode) | (1<< (int) CC_CHKmode))
1882 /* Modes for single-word (and smaller) quantities. */
1885 & ~ ((1 << (int) DImode) | (1 << (int) TImode) \
1886 | (1 << (int) DFmode) | (1 << (int) XFmode)))
1888 /* Modes for double-word (and smaller) quantities. */
1891 & ~ ((1 << (int) TImode) | (1 << (int) XFmode)))
1893 /* Modes for quad-word quantities. */
1894 #define T_MODES (~C_MODES)
1896 /* Modes for single-float quantities. */
1897 #define SF_MODES ((1 << (int) SFmode))
1899 /* Modes for double-float quantities. */
1900 #define DF_MODES (SF_MODES | (1 << (int) DFmode) | (1 << (int) SCmode))
1902 /* Modes for quad-float quantities. */
1903 #define XF_MODES (DF_MODES | (1 << (int) XFmode) | (1 << (int) DCmode))
1905 unsigned int hard_regno_mode_ok
[FIRST_PSEUDO_REGISTER
] = {
1906 T_MODES
, S_MODES
, D_MODES
, S_MODES
, T_MODES
, S_MODES
, D_MODES
, S_MODES
,
1907 T_MODES
, S_MODES
, D_MODES
, S_MODES
, T_MODES
, S_MODES
, D_MODES
, S_MODES
,
1908 T_MODES
, S_MODES
, D_MODES
, S_MODES
, T_MODES
, S_MODES
, D_MODES
, S_MODES
,
1909 T_MODES
, S_MODES
, D_MODES
, S_MODES
, T_MODES
, S_MODES
, D_MODES
, S_MODES
,
1911 XF_MODES
, XF_MODES
, XF_MODES
, XF_MODES
, C_MODES
};
1914 /* Return the minimum alignment of an expression rtx X in bytes. This takes
1915 advantage of machine specific facts, such as knowing that the frame pointer
1916 is always 16 byte aligned. */
1919 i960_expr_alignment (x
, size
)
1928 switch (GET_CODE(x
))
1933 if ((align
& 0xf) == 0)
1935 else if ((align
& 0x7) == 0)
1937 else if ((align
& 0x3) == 0)
1939 else if ((align
& 0x1) == 0)
1946 align
= MIN (i960_expr_alignment (XEXP (x
, 0), size
),
1947 i960_expr_alignment (XEXP (x
, 1), size
));
1951 /* If this is a valid program, objects are guaranteed to be
1952 correctly aligned for whatever size the reference actually is. */
1953 align
= i960_object_bytes_bitalign (size
) / BITS_PER_UNIT
;
1957 if (REGNO (x
) == FRAME_POINTER_REGNUM
)
1962 align
= i960_expr_alignment (XEXP (x
, 0));
1964 if (GET_CODE (XEXP (x
, 1)) == CONST_INT
)
1966 align
= align
<< INTVAL (XEXP (x
, 1));
1967 align
= MIN (align
, 16);
1972 align
= (i960_expr_alignment (XEXP (x
, 0), size
) *
1973 i960_expr_alignment (XEXP (x
, 1), size
));
1975 align
= MIN (align
, 16);
1982 /* Return true if it is possible to reference both BASE and OFFSET, which
1983 have alignment at least as great as 4 byte, as if they had alignment valid
1984 for an object of size SIZE. */
1987 i960_improve_align (base
, offset
, size
)
1994 /* We have at least a word reference to the object, so we know it has to
1995 be aligned at least to 4 bytes. */
1997 i
= MIN (i960_expr_alignment (base
, 4),
1998 i960_expr_alignment (offset
, 4));
2002 /* We know the size of the request. If strict align is not enabled, we
2003 can guess that the alignment is OK for the requested size. */
2005 if (! TARGET_STRICT_ALIGN
)
2006 if ((j
= (i960_object_bytes_bitalign (size
) / BITS_PER_UNIT
)) > i
)
2012 /* Return true if it is possible to access BASE and OFFSET, which have 4 byte
2013 (SImode) alignment as if they had 16 byte (TImode) alignment. */
2016 i960_si_ti (base
, offset
)
2020 return i960_improve_align (base
, offset
, 16);
2023 /* Return true if it is possible to access BASE and OFFSET, which have 4 byte
2024 (SImode) alignment as if they had 8 byte (DImode) alignment. */
2027 i960_si_di (base
, offset
)
2031 return i960_improve_align (base
, offset
, 8);
2034 /* Return raw values of size and alignment (in words) for the data
2035 type being accessed. These values will be rounded by the caller. */
2038 i960_arg_size_and_align (mode
, type
, size_out
, align_out
)
2039 enum machine_mode mode
;
2046 /* Use formal alignment requirements of type being passed, except make
2047 it at least a word. If we don't have a type, this is a library call,
2048 and the parm has to be of scalar type. In this case, consider its
2049 formal alignment requirement to be its size in words. */
2051 if (mode
== BLKmode
)
2052 size
= (int_size_in_bytes (type
) + UNITS_PER_WORD
- 1) / UNITS_PER_WORD
;
2053 else if (mode
== VOIDmode
)
2055 /* End of parm list. */
2056 assert (type
!= 0 && TYPE_MODE (type
) == VOIDmode
);
2060 size
= (GET_MODE_SIZE (mode
) + UNITS_PER_WORD
- 1) / UNITS_PER_WORD
;
2064 /* ??? This is a hack to properly correct the alignment of XFmode
2065 values without affecting anything else. */
2071 else if (TYPE_ALIGN (type
) >= BITS_PER_WORD
)
2072 align
= TYPE_ALIGN (type
) / BITS_PER_WORD
;
2080 /* On the 80960 the first 12 args are in registers and the rest are pushed.
2081 Any arg that is bigger than 4 words is placed on the stack and all
2082 subsequent arguments are placed on the stack.
2084 Additionally, parameters with an alignment requirement stronger than
2085 a word must be aligned appropriately. Note that this means that a
2086 64 bit object with a 32 bit alignment is not 64 bit aligned and may be
2087 passed in an odd/even register pair. */
2089 /* Update CUM to advance past an argument described by MODE and TYPE. */
2092 i960_function_arg_advance (cum
, mode
, type
, named
)
2093 CUMULATIVE_ARGS
*cum
;
2094 enum machine_mode mode
;
2100 i960_arg_size_and_align (mode
, type
, &size
, &align
);
2102 if (size
> 4 || cum
->ca_nstackparms
!= 0
2103 || (size
+ ROUND_PARM (cum
->ca_nregparms
, align
)) > NPARM_REGS
2104 || MUST_PASS_IN_STACK (mode
, type
))
2106 /* Indicate that all the registers are in use, even if all are not,
2107 so va_start will compute the right value. */
2108 cum
->ca_nregparms
= NPARM_REGS
;
2109 cum
->ca_nstackparms
= ROUND_PARM (cum
->ca_nstackparms
, align
) + size
;
2112 cum
->ca_nregparms
= ROUND_PARM (cum
->ca_nregparms
, align
) + size
;
2115 /* Return the register that the argument described by MODE and TYPE is
2116 passed in, or else return 0 if it is passed on the stack. */
2119 i960_function_arg (cum
, mode
, type
, named
)
2120 CUMULATIVE_ARGS
*cum
;
2121 enum machine_mode mode
;
2128 i960_arg_size_and_align (mode
, type
, &size
, &align
);
2130 if (size
> 4 || cum
->ca_nstackparms
!= 0
2131 || (size
+ ROUND_PARM (cum
->ca_nregparms
, align
)) > NPARM_REGS
2132 || MUST_PASS_IN_STACK (mode
, type
))
2134 cum
->ca_nstackparms
= ROUND_PARM (cum
->ca_nstackparms
, align
);
2139 cum
->ca_nregparms
= ROUND_PARM (cum
->ca_nregparms
, align
);
2140 ret
= gen_rtx (REG
, mode
, cum
->ca_nregparms
);
2146 /* Floating-point support. */
2149 i960_output_long_double (file
, value
)
2151 REAL_VALUE_TYPE value
;
2156 REAL_VALUE_TO_TARGET_LONG_DOUBLE (value
, value_long
);
2157 REAL_VALUE_TO_DECIMAL (value
, "%.20g", dstr
);
2160 "\t.word\t0x%08lx\t\t# %s\n\t.word\t0x%08lx\n\t.word\t0x%08lx\n",
2161 value_long
[0], dstr
, value_long
[1], value_long
[2]);
2162 fprintf (file
, "\t.word\t0x0\n");
2166 i960_output_double (file
, value
)
2168 REAL_VALUE_TYPE value
;
2173 REAL_VALUE_TO_TARGET_DOUBLE (value
, value_long
);
2174 REAL_VALUE_TO_DECIMAL (value
, "%.20g", dstr
);
2176 fprintf (file
, "\t.word\t0x%08lx\t\t# %s\n\t.word\t0x%08lx\n",
2177 value_long
[0], dstr
, value_long
[1]);
2181 i960_output_float (file
, value
)
2183 REAL_VALUE_TYPE value
;
2188 REAL_VALUE_TO_TARGET_SINGLE (value
, value_long
);
2189 REAL_VALUE_TO_DECIMAL (value
, "%.12g", dstr
);
2191 fprintf (file
, "\t.word\t0x%08lx\t\t# %s (float)\n", value_long
, dstr
);
2194 /* Return the number of bits that an object of size N bytes is aligned to. */
2197 i960_object_bytes_bitalign (n
)
2201 else if (n
> 4) n
= 64;
2202 else if (n
> 2) n
= 32;
2203 else if (n
> 1) n
= 16;
2209 /* Compute the alignment for an aggregate type TSIZE.
2210 Alignment is MAX (greatest member alignment,
2211 MIN (pragma align, structure size alignment)). */
2214 i960_round_align (align
, tsize
)
2220 if (TREE_CODE (tsize
) != INTEGER_CST
)
2223 new_align
= i960_object_bytes_bitalign (TREE_INT_CST_LOW (tsize
)
2225 /* Handle #pragma align. */
2226 if (new_align
> i960_maxbitalignment
)
2227 new_align
= i960_maxbitalignment
;
2229 if (align
< new_align
)
2235 /* Do any needed setup for a varargs function. For the i960, we must
2236 create a register parameter block if one doesn't exist, and then copy
2237 all register parameters to memory. */
2240 i960_setup_incoming_varargs (cum
, mode
, type
, pretend_size
, no_rtl
)
2241 CUMULATIVE_ARGS
*cum
;
2242 enum machine_mode mode
;
2247 /* Note: for a varargs fn with only a va_alist argument, this is 0. */
2248 int first_reg
= cum
->ca_nregparms
;
2250 /* Copy only unnamed register arguments to memory. If there are
2251 any stack parms, there are no unnamed arguments in registers, and
2252 an argument block was already allocated by the caller.
2253 Remember that any arg bigger than 4 words is passed on the stack as
2254 are all subsequent args.
2256 If there are no stack arguments but there are exactly NPARM_REGS
2257 registers, either there were no extra arguments or the caller
2258 allocated an argument block. */
2260 if (cum
->ca_nstackparms
== 0 && first_reg
< NPARM_REGS
&& !no_rtl
)
2262 rtx label
= gen_label_rtx ();
2265 /* If arg_pointer_rtx == 0, no arguments were passed on the stack
2266 and we need to allocate a chunk to save the registers (if any
2267 arguments were passed on the stack the caller would allocate the
2268 48 bytes as well). We must allocate all 48 bytes (12*4) because
2269 va_start assumes it. */
2270 emit_insn (gen_cmpsi (arg_pointer_rtx
, const0_rtx
));
2271 emit_jump_insn (gen_bne (label
));
2272 emit_insn (gen_rtx (SET
, VOIDmode
, arg_pointer_rtx
,
2273 stack_pointer_rtx
));
2274 emit_insn (gen_rtx (SET
, VOIDmode
, stack_pointer_rtx
,
2275 memory_address (SImode
,
2276 plus_constant (stack_pointer_rtx
,
2280 /* ??? Note that we unnecessarily store one extra register for stdarg
2281 fns. We could optimize this, but it's kept as for now. */
2282 regblock
= gen_rtx (MEM
, BLKmode
,
2283 plus_constant (arg_pointer_rtx
,
2285 move_block_from_reg (first_reg
, regblock
,
2286 NPARM_REGS
- first_reg
,
2287 (NPARM_REGS
- first_reg
) * UNITS_PER_WORD
);
2291 /* Calculate the final size of the reg parm stack space for the current
2292 function, based on how many bytes would be allocated on the stack. */
2295 i960_final_reg_parm_stack_space (const_size
, var_size
)
2299 if (var_size
|| const_size
> 48)
2305 /* Calculate the size of the reg parm stack space. This is a bit complicated
2309 i960_reg_parm_stack_space (fndecl
)
2312 /* In this case, we are called from emit_library_call, and we don't need
2313 to pretend we have more space for parameters than what's apparent. */
2317 /* In this case, we are called from locate_and_pad_parms when we're
2318 not IN_REGS, so we have an arg block. */
2319 if (fndecl
!= current_function_decl
)
2322 /* Otherwise, we have an arg block if the current function has more than
2323 48 bytes of parameters. */
2324 if (current_function_args_size
!= 0 || VARARGS_STDARG_FUNCTION (fndecl
))
2330 /* Return the register class of a scratch register needed to copy IN into
2331 or out of a register in CLASS in MODE. If it can be done directly,
2332 NO_REGS is returned. */
2335 secondary_reload_class (class, mode
, in
)
2336 enum reg_class
class;
2337 enum machine_mode mode
;
2342 if (GET_CODE (in
) == REG
|| GET_CODE (in
) == SUBREG
)
2343 regno
= true_regnum (in
);
2345 /* We can place anything into LOCAL_OR_GLOBAL_REGS and can put
2346 LOCAL_OR_GLOBAL_REGS into anything. */
2347 if (class == LOCAL_OR_GLOBAL_REGS
|| class == LOCAL_REGS
2348 || class == GLOBAL_REGS
|| (regno
>= 0 && regno
< 32))
2351 /* We can place any hard register, 0.0, and 1.0 into FP_REGS. */
2352 if (class == FP_REGS
2353 && ((regno
>= 0 && regno
< FIRST_PSEUDO_REGISTER
)
2354 || in
== CONST0_RTX (mode
) || in
== CONST1_RTX (mode
)))
2357 return LOCAL_OR_GLOBAL_REGS
;
2360 /* Look at the opcode P, and set i96_last_insn_type to indicate which
2361 function unit it executed on. */
2363 /* ??? This would make more sense as an attribute. */
2366 i960_scan_opcode (p
)
2378 /* Ret is not actually of type REG, but it won't matter, because no
2379 insn will ever follow it. */
2382 i960_last_insn_type
= I_TYPE_REG
;
2386 if (p
[1] == 'x' || p
[3] == 'x')
2387 i960_last_insn_type
= I_TYPE_MEM
;
2388 i960_last_insn_type
= I_TYPE_CTRL
;
2393 i960_last_insn_type
= I_TYPE_CTRL
;
2400 i960_last_insn_type
= I_TYPE_MEM
;
2402 i960_last_insn_type
= I_TYPE_CTRL
;
2404 else if (p
[1] == 'm')
2407 i960_last_insn_type
= I_TYPE_REG
;
2408 else if (p
[4] == 'b' || p
[4] == 'j')
2409 i960_last_insn_type
= I_TYPE_CTRL
;
2411 i960_last_insn_type
= I_TYPE_REG
;
2414 i960_last_insn_type
= I_TYPE_REG
;
2418 i960_last_insn_type
= I_TYPE_MEM
;
2423 i960_last_insn_type
= I_TYPE_MEM
;
2425 i960_last_insn_type
= I_TYPE_REG
;