1 /* Definitions of target machine for GNU compiler, for MMIX.
2 Copyright (C) 2000-2014 Free Software Foundation, Inc.
3 Contributed by Hans-Peter Nilsson (hp@bitrange.com)
5 This file is part of GCC.
7 GCC is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3, or (at your option)
12 GCC is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
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/>. */
23 #include "coretypes.h"
27 #include "hard-reg-set.h"
29 #include "insn-config.h"
31 #include "basic-block.h"
35 #include "stor-layout.h"
39 #include "diagnostic-core.h"
46 #include "target-def.h"
48 #include "tm-constrs.h"
51 /* First some local helper definitions. */
52 #define MMIX_FIRST_GLOBAL_REGNUM 32
54 /* We'd need a current_function_has_landing_pad. It's marked as such when
55 a nonlocal_goto_receiver is expanded. Not just a C++ thing, but
57 #define MMIX_CFUN_HAS_LANDING_PAD (cfun->machine->has_landing_pad != 0)
59 /* We have no means to tell DWARF 2 about the register stack, so we need
60 to store the return address on the stack if an exception can get into
61 this function. FIXME: Narrow condition. Before any whole-function
62 analysis, df_regs_ever_live_p () isn't initialized. We know it's up-to-date
63 after reload_completed; it may contain incorrect information some time
64 before that. Within a RTL sequence (after a call to start_sequence,
65 such as in RTL expanders), leaf_function_p doesn't see all insns
66 (perhaps any insn). But regs_ever_live is up-to-date when
67 leaf_function_p () isn't, so we "or" them together to get accurate
68 information. FIXME: Some tweak to leaf_function_p might be
70 #define MMIX_CFUN_NEEDS_SAVED_EH_RETURN_ADDRESS \
72 && ((reload_completed && df_regs_ever_live_p (MMIX_rJ_REGNUM)) \
73 || !leaf_function_p ()))
75 #define IS_MMIX_EH_RETURN_DATA_REG(REGNO) \
76 (crtl->calls_eh_return \
77 && (EH_RETURN_DATA_REGNO (0) == REGNO \
78 || EH_RETURN_DATA_REGNO (1) == REGNO \
79 || EH_RETURN_DATA_REGNO (2) == REGNO \
80 || EH_RETURN_DATA_REGNO (3) == REGNO))
82 /* For the default ABI, we rename registers at output-time to fill the gap
83 between the (statically partitioned) saved registers and call-clobbered
84 registers. In effect this makes unused call-saved registers to be used
85 as call-clobbered registers. The benefit comes from keeping the number
86 of local registers (value of rL) low, since there's a cost of
87 increasing rL and clearing unused (unset) registers with lower numbers.
88 Don't translate while outputting the prologue. */
89 #define MMIX_OUTPUT_REGNO(N) \
91 || (int) (N) < MMIX_RETURN_VALUE_REGNUM \
92 || (int) (N) > MMIX_LAST_STACK_REGISTER_REGNUM \
94 || cfun->machine == NULL \
95 || cfun->machine->in_prologue \
96 ? (N) : ((N) - MMIX_RETURN_VALUE_REGNUM \
97 + cfun->machine->highest_saved_stack_register + 1))
99 /* The %d in "POP %d,0". */
100 #define MMIX_POP_ARGUMENT() \
102 && crtl->return_rtx != NULL \
103 && ! cfun->returns_struct) \
104 ? (GET_CODE (crtl->return_rtx) == PARALLEL \
105 ? GET_NUM_ELEM (XVEC (crtl->return_rtx, 0)) : 1) \
108 /* The canonical saved comparison operands for non-cc0 machines, set in
109 the compare expander. */
110 rtx mmix_compare_op0
;
111 rtx mmix_compare_op1
;
113 /* Declarations of locals. */
115 /* Intermediate for insn output. */
116 static int mmix_output_destination_register
;
118 static void mmix_option_override (void);
119 static void mmix_asm_output_source_filename (FILE *, const char *);
120 static void mmix_output_shiftvalue_op_from_str
121 (FILE *, const char *, int64_t);
122 static void mmix_output_shifted_value (FILE *, int64_t);
123 static void mmix_output_condition (FILE *, const_rtx
, int);
124 static void mmix_output_octa (FILE *, int64_t, int);
125 static bool mmix_assemble_integer (rtx
, unsigned int, int);
126 static struct machine_function
*mmix_init_machine_status (void);
127 static void mmix_encode_section_info (tree
, rtx
, int);
128 static const char *mmix_strip_name_encoding (const char *);
129 static void mmix_emit_sp_add (HOST_WIDE_INT offset
);
130 static void mmix_target_asm_function_prologue (FILE *, HOST_WIDE_INT
);
131 static void mmix_target_asm_function_end_prologue (FILE *);
132 static void mmix_target_asm_function_epilogue (FILE *, HOST_WIDE_INT
);
133 static reg_class_t
mmix_preferred_reload_class (rtx
, reg_class_t
);
134 static reg_class_t
mmix_preferred_output_reload_class (rtx
, reg_class_t
);
135 static bool mmix_legitimate_address_p (enum machine_mode
, rtx
, bool);
136 static bool mmix_legitimate_constant_p (enum machine_mode
, rtx
);
137 static void mmix_reorg (void);
138 static void mmix_asm_output_mi_thunk
139 (FILE *, tree
, HOST_WIDE_INT
, HOST_WIDE_INT
, tree
);
140 static void mmix_setup_incoming_varargs
141 (cumulative_args_t
, enum machine_mode
, tree
, int *, int);
142 static void mmix_file_start (void);
143 static void mmix_file_end (void);
144 static bool mmix_rtx_costs (rtx
, int, int, int, int *, bool);
145 static int mmix_register_move_cost (enum machine_mode
,
146 reg_class_t
, reg_class_t
);
147 static rtx
mmix_struct_value_rtx (tree
, int);
148 static enum machine_mode
mmix_promote_function_mode (const_tree
,
150 int *, const_tree
, int);
151 static void mmix_function_arg_advance (cumulative_args_t
, enum machine_mode
,
153 static rtx
mmix_function_arg_1 (const cumulative_args_t
, enum machine_mode
,
154 const_tree
, bool, bool);
155 static rtx
mmix_function_incoming_arg (cumulative_args_t
, enum machine_mode
,
157 static rtx
mmix_function_arg (cumulative_args_t
, enum machine_mode
,
159 static rtx
mmix_function_value (const_tree
, const_tree
, bool);
160 static rtx
mmix_libcall_value (enum machine_mode
, const_rtx
);
161 static bool mmix_function_value_regno_p (const unsigned int);
162 static bool mmix_pass_by_reference (cumulative_args_t
,
163 enum machine_mode
, const_tree
, bool);
164 static bool mmix_frame_pointer_required (void);
165 static void mmix_asm_trampoline_template (FILE *);
166 static void mmix_trampoline_init (rtx
, tree
, rtx
);
167 static void mmix_print_operand (FILE *, rtx
, int);
168 static void mmix_print_operand_address (FILE *, rtx
);
169 static bool mmix_print_operand_punct_valid_p (unsigned char);
170 static void mmix_conditional_register_usage (void);
172 /* Target structure macros. Listed by node. See `Using and Porting GCC'
173 for a general description. */
175 /* Node: Function Entry */
177 #undef TARGET_ASM_BYTE_OP
178 #define TARGET_ASM_BYTE_OP NULL
179 #undef TARGET_ASM_ALIGNED_HI_OP
180 #define TARGET_ASM_ALIGNED_HI_OP NULL
181 #undef TARGET_ASM_ALIGNED_SI_OP
182 #define TARGET_ASM_ALIGNED_SI_OP NULL
183 #undef TARGET_ASM_ALIGNED_DI_OP
184 #define TARGET_ASM_ALIGNED_DI_OP NULL
185 #undef TARGET_ASM_INTEGER
186 #define TARGET_ASM_INTEGER mmix_assemble_integer
188 #undef TARGET_ASM_FUNCTION_PROLOGUE
189 #define TARGET_ASM_FUNCTION_PROLOGUE mmix_target_asm_function_prologue
191 #undef TARGET_ASM_FUNCTION_END_PROLOGUE
192 #define TARGET_ASM_FUNCTION_END_PROLOGUE mmix_target_asm_function_end_prologue
194 #undef TARGET_ASM_FUNCTION_EPILOGUE
195 #define TARGET_ASM_FUNCTION_EPILOGUE mmix_target_asm_function_epilogue
197 #undef TARGET_PRINT_OPERAND
198 #define TARGET_PRINT_OPERAND mmix_print_operand
199 #undef TARGET_PRINT_OPERAND_ADDRESS
200 #define TARGET_PRINT_OPERAND_ADDRESS mmix_print_operand_address
201 #undef TARGET_PRINT_OPERAND_PUNCT_VALID_P
202 #define TARGET_PRINT_OPERAND_PUNCT_VALID_P mmix_print_operand_punct_valid_p
204 #undef TARGET_ENCODE_SECTION_INFO
205 #define TARGET_ENCODE_SECTION_INFO mmix_encode_section_info
206 #undef TARGET_STRIP_NAME_ENCODING
207 #define TARGET_STRIP_NAME_ENCODING mmix_strip_name_encoding
209 #undef TARGET_ASM_OUTPUT_MI_THUNK
210 #define TARGET_ASM_OUTPUT_MI_THUNK mmix_asm_output_mi_thunk
211 #undef TARGET_ASM_CAN_OUTPUT_MI_THUNK
212 #define TARGET_ASM_CAN_OUTPUT_MI_THUNK default_can_output_mi_thunk_no_vcall
213 #undef TARGET_ASM_FILE_START
214 #define TARGET_ASM_FILE_START mmix_file_start
215 #undef TARGET_ASM_FILE_START_FILE_DIRECTIVE
216 #define TARGET_ASM_FILE_START_FILE_DIRECTIVE true
217 #undef TARGET_ASM_FILE_END
218 #define TARGET_ASM_FILE_END mmix_file_end
219 #undef TARGET_ASM_OUTPUT_SOURCE_FILENAME
220 #define TARGET_ASM_OUTPUT_SOURCE_FILENAME mmix_asm_output_source_filename
222 #undef TARGET_CONDITIONAL_REGISTER_USAGE
223 #define TARGET_CONDITIONAL_REGISTER_USAGE mmix_conditional_register_usage
225 #undef TARGET_RTX_COSTS
226 #define TARGET_RTX_COSTS mmix_rtx_costs
227 #undef TARGET_ADDRESS_COST
228 #define TARGET_ADDRESS_COST hook_int_rtx_mode_as_bool_0
230 #undef TARGET_REGISTER_MOVE_COST
231 #define TARGET_REGISTER_MOVE_COST mmix_register_move_cost
233 #undef TARGET_MACHINE_DEPENDENT_REORG
234 #define TARGET_MACHINE_DEPENDENT_REORG mmix_reorg
236 #undef TARGET_PROMOTE_FUNCTION_MODE
237 #define TARGET_PROMOTE_FUNCTION_MODE mmix_promote_function_mode
239 #undef TARGET_FUNCTION_VALUE
240 #define TARGET_FUNCTION_VALUE mmix_function_value
241 #undef TARGET_LIBCALL_VALUE
242 #define TARGET_LIBCALL_VALUE mmix_libcall_value
243 #undef TARGET_FUNCTION_VALUE_REGNO_P
244 #define TARGET_FUNCTION_VALUE_REGNO_P mmix_function_value_regno_p
246 #undef TARGET_FUNCTION_ARG
247 #define TARGET_FUNCTION_ARG mmix_function_arg
248 #undef TARGET_FUNCTION_INCOMING_ARG
249 #define TARGET_FUNCTION_INCOMING_ARG mmix_function_incoming_arg
250 #undef TARGET_FUNCTION_ARG_ADVANCE
251 #define TARGET_FUNCTION_ARG_ADVANCE mmix_function_arg_advance
252 #undef TARGET_STRUCT_VALUE_RTX
253 #define TARGET_STRUCT_VALUE_RTX mmix_struct_value_rtx
254 #undef TARGET_SETUP_INCOMING_VARARGS
255 #define TARGET_SETUP_INCOMING_VARARGS mmix_setup_incoming_varargs
256 #undef TARGET_PASS_BY_REFERENCE
257 #define TARGET_PASS_BY_REFERENCE mmix_pass_by_reference
258 #undef TARGET_CALLEE_COPIES
259 #define TARGET_CALLEE_COPIES hook_bool_CUMULATIVE_ARGS_mode_tree_bool_true
261 #undef TARGET_PREFERRED_RELOAD_CLASS
262 #define TARGET_PREFERRED_RELOAD_CLASS mmix_preferred_reload_class
263 #undef TARGET_PREFERRED_OUTPUT_RELOAD_CLASS
264 #define TARGET_PREFERRED_OUTPUT_RELOAD_CLASS mmix_preferred_output_reload_class
266 #undef TARGET_LEGITIMATE_ADDRESS_P
267 #define TARGET_LEGITIMATE_ADDRESS_P mmix_legitimate_address_p
268 #undef TARGET_LEGITIMATE_CONSTANT_P
269 #define TARGET_LEGITIMATE_CONSTANT_P mmix_legitimate_constant_p
271 #undef TARGET_FRAME_POINTER_REQUIRED
272 #define TARGET_FRAME_POINTER_REQUIRED mmix_frame_pointer_required
274 #undef TARGET_ASM_TRAMPOLINE_TEMPLATE
275 #define TARGET_ASM_TRAMPOLINE_TEMPLATE mmix_asm_trampoline_template
276 #undef TARGET_TRAMPOLINE_INIT
277 #define TARGET_TRAMPOLINE_INIT mmix_trampoline_init
279 #undef TARGET_OPTION_OVERRIDE
280 #define TARGET_OPTION_OVERRIDE mmix_option_override
282 struct gcc_target targetm
= TARGET_INITIALIZER
;
284 /* Functions that are expansions for target macros.
285 See Target Macros in `Using and Porting GCC'. */
287 /* TARGET_OPTION_OVERRIDE. */
290 mmix_option_override (void)
292 /* Should we err or should we warn? Hmm. At least we must neutralize
293 it. For example the wrong kind of case-tables will be generated with
294 PIC; we use absolute address items for mmixal compatibility. FIXME:
295 They could be relative if we just elide them to after all pertinent
299 warning (0, "-f%s not supported: ignored", (flag_pic
> 1) ? "PIC" : "pic");
304 /* INIT_EXPANDERS. */
307 mmix_init_expanders (void)
309 init_machine_status
= mmix_init_machine_status
;
312 /* Set the per-function data. */
314 static struct machine_function
*
315 mmix_init_machine_status (void)
317 return ggc_cleared_alloc
<machine_function
> ();
320 /* DATA_ABI_ALIGNMENT.
321 We have trouble getting the address of stuff that is located at other
322 than 32-bit alignments (GETA requirements), so try to give everything
323 at least 32-bit alignment. */
326 mmix_data_alignment (tree type ATTRIBUTE_UNUSED
, int basic_align
)
328 if (basic_align
< 32)
334 /* CONSTANT_ALIGNMENT. */
337 mmix_constant_alignment (tree constant ATTRIBUTE_UNUSED
, int basic_align
)
339 if (basic_align
< 32)
345 /* LOCAL_ALIGNMENT. */
348 mmix_local_alignment (tree type ATTRIBUTE_UNUSED
, unsigned basic_align
)
350 if (basic_align
< 32)
356 /* TARGET_CONDITIONAL_REGISTER_USAGE. */
359 mmix_conditional_register_usage (void)
365 static const int gnu_abi_reg_alloc_order
[]
366 = MMIX_GNU_ABI_REG_ALLOC_ORDER
;
368 for (i
= 0; i
< FIRST_PSEUDO_REGISTER
; i
++)
369 reg_alloc_order
[i
] = gnu_abi_reg_alloc_order
[i
];
371 /* Change the default from the mmixware ABI. For the GNU ABI,
372 $15..$30 are call-saved just as $0..$14. There must be one
373 call-clobbered local register for the "hole" that holds the
374 number of saved local registers saved by PUSHJ/PUSHGO during the
375 function call, receiving the return value at return. So best is
376 to use the highest, $31. It's already marked call-clobbered for
378 for (i
= 15; i
<= 30; i
++)
379 call_used_regs
[i
] = 0;
381 /* "Unfix" the parameter registers. */
382 for (i
= MMIX_RESERVED_GNU_ARG_0_REGNUM
;
383 i
< MMIX_RESERVED_GNU_ARG_0_REGNUM
+ MMIX_MAX_ARGS_IN_REGS
;
388 /* Step over the ":" in special register names. */
389 if (! TARGET_TOPLEVEL_SYMBOLS
)
390 for (i
= 0; i
< FIRST_PSEUDO_REGISTER
; i
++)
391 if (reg_names
[i
][0] == ':')
395 /* INCOMING_REGNO and OUTGOING_REGNO worker function.
396 Those two macros must only be applied to function argument
397 registers and the function return value register for the opposite
398 use. FIXME: for their current use in gcc, it'd be better with an
399 explicit specific additional FUNCTION_INCOMING_ARG_REGNO_P a'la
400 TARGET_FUNCTION_ARG / TARGET_FUNCTION_INCOMING_ARG instead of
401 forcing the target to commit to a fixed mapping and for any
402 unspecified register use. Particularly when thinking about the
403 return-value, it is better to imagine INCOMING_REGNO and
404 OUTGOING_REGNO as named CALLEE_TO_CALLER_REGNO and INNER_REGNO as
405 named CALLER_TO_CALLEE_REGNO because the direction. The "incoming"
406 and "outgoing" is from the perspective of the parameter-registers,
407 but the same macro is (must be, lacking an alternative like
408 suggested above) used to map the return-value-register from the
409 same perspective. To make directions even more confusing, the macro
410 MMIX_OUTGOING_RETURN_VALUE_REGNUM holds the number of the register
411 in which to return a value, i.e. INCOMING_REGNO for the return-value-
412 register as received from a called function; the return-value on the
416 mmix_opposite_regno (int regno
, int incoming
)
418 if (incoming
&& regno
== MMIX_OUTGOING_RETURN_VALUE_REGNUM
)
419 return MMIX_RETURN_VALUE_REGNUM
;
421 if (!incoming
&& regno
== MMIX_RETURN_VALUE_REGNUM
)
422 return MMIX_OUTGOING_RETURN_VALUE_REGNUM
;
424 if (!mmix_function_arg_regno_p (regno
, incoming
))
429 ? MMIX_FIRST_INCOMING_ARG_REGNUM
- MMIX_FIRST_ARG_REGNUM
430 : MMIX_FIRST_ARG_REGNUM
- MMIX_FIRST_INCOMING_ARG_REGNUM
);
434 All registers that are part of the register stack and that will be
438 mmix_local_regno (int regno
)
440 return regno
<= MMIX_LAST_STACK_REGISTER_REGNUM
&& !call_used_regs
[regno
];
443 /* TARGET_PREFERRED_RELOAD_CLASS.
444 We need to extend the reload class of REMAINDER_REG and HIMULT_REG. */
447 mmix_preferred_reload_class (rtx x
, reg_class_t rclass
)
449 /* FIXME: Revisit. */
450 return GET_CODE (x
) == MOD
&& GET_MODE (x
) == DImode
451 ? REMAINDER_REG
: rclass
;
454 /* TARGET_PREFERRED_OUTPUT_RELOAD_CLASS.
455 We need to extend the reload class of REMAINDER_REG and HIMULT_REG. */
458 mmix_preferred_output_reload_class (rtx x
, reg_class_t rclass
)
460 /* FIXME: Revisit. */
461 return GET_CODE (x
) == MOD
&& GET_MODE (x
) == DImode
462 ? REMAINDER_REG
: rclass
;
465 /* SECONDARY_RELOAD_CLASS.
466 We need to reload regs of REMAINDER_REG and HIMULT_REG elsewhere. */
469 mmix_secondary_reload_class (enum reg_class rclass
,
470 enum machine_mode mode ATTRIBUTE_UNUSED
,
471 rtx x ATTRIBUTE_UNUSED
,
472 int in_p ATTRIBUTE_UNUSED
)
474 if (rclass
== REMAINDER_REG
475 || rclass
== HIMULT_REG
476 || rclass
== SYSTEM_REGS
)
482 /* DYNAMIC_CHAIN_ADDRESS. */
485 mmix_dynamic_chain_address (rtx frame
)
487 /* FIXME: the frame-pointer is stored at offset -8 from the current
488 frame-pointer. Unfortunately, the caller assumes that a
489 frame-pointer is present for *all* previous frames. There should be
490 a way to say that that cannot be done, like for RETURN_ADDR_RTX. */
491 return plus_constant (Pmode
, frame
, -8);
494 /* STARTING_FRAME_OFFSET. */
497 mmix_starting_frame_offset (void)
499 /* The old frame pointer is in the slot below the new one, so
500 FIRST_PARM_OFFSET does not need to depend on whether the
501 frame-pointer is needed or not. We have to adjust for the register
502 stack pointer being located below the saved frame pointer.
503 Similarly, we store the return address on the stack too, for
504 exception handling, and always if we save the register stack pointer. */
507 + (MMIX_CFUN_HAS_LANDING_PAD
508 ? -16 : (MMIX_CFUN_NEEDS_SAVED_EH_RETURN_ADDRESS
? -8 : 0)));
511 /* RETURN_ADDR_RTX. */
514 mmix_return_addr_rtx (int count
, rtx frame ATTRIBUTE_UNUSED
)
517 ? (MMIX_CFUN_NEEDS_SAVED_EH_RETURN_ADDRESS
518 /* FIXME: Set frame_alias_set on the following. (Why?)
519 See mmix_initial_elimination_offset for the reason we can't use
520 get_hard_reg_initial_val for both. Always using a stack slot
521 and not a register would be suboptimal. */
522 ? validize_mem (gen_rtx_MEM (Pmode
,
523 plus_constant (Pmode
,
524 frame_pointer_rtx
, -16)))
525 : get_hard_reg_initial_val (Pmode
, MMIX_INCOMING_RETURN_ADDRESS_REGNUM
))
529 /* SETUP_FRAME_ADDRESSES. */
532 mmix_setup_frame_addresses (void)
534 /* Nothing needed at the moment. */
537 /* The difference between the (imaginary) frame pointer and the stack
538 pointer. Used to eliminate the frame pointer. */
541 mmix_initial_elimination_offset (int fromreg
, int toreg
)
545 = (get_frame_size () + crtl
->outgoing_args_size
+ 7) & ~7;
547 /* There is no actual offset between these two virtual values, but for
548 the frame-pointer, we have the old one in the stack position below
549 it, so the offset for the frame-pointer to the stack-pointer is one
551 if (fromreg
== MMIX_ARG_POINTER_REGNUM
552 && toreg
== MMIX_FRAME_POINTER_REGNUM
)
555 /* The difference is the size of local variables plus the size of
556 outgoing function arguments that would normally be passed as
557 registers but must be passed on stack because we're out of
558 function-argument registers. Only global saved registers are
559 counted; the others go on the register stack.
561 The frame-pointer is counted too if it is what is eliminated, as we
562 need to balance the offset for it from STARTING_FRAME_OFFSET.
564 Also add in the slot for the register stack pointer we save if we
567 Unfortunately, we can't access $0..$14, from unwinder code easily, so
568 store the return address in a frame slot too. FIXME: Only for
569 non-leaf functions. FIXME: Always with a landing pad, because it's
570 hard to know whether we need the other at the time we know we need
571 the offset for one (and have to state it). It's a kludge until we
572 can express the register stack in the EH frame info.
574 We have to do alignment here; get_frame_size will not return a
575 multiple of STACK_BOUNDARY. FIXME: Add note in manual. */
577 for (regno
= MMIX_FIRST_GLOBAL_REGNUM
;
580 if ((df_regs_ever_live_p (regno
) && ! call_used_regs
[regno
])
581 || IS_MMIX_EH_RETURN_DATA_REG (regno
))
585 + (MMIX_CFUN_HAS_LANDING_PAD
586 ? 16 : (MMIX_CFUN_NEEDS_SAVED_EH_RETURN_ADDRESS
? 8 : 0))
587 + (fromreg
== MMIX_ARG_POINTER_REGNUM
? 0 : 8);
591 mmix_function_arg_advance (cumulative_args_t argsp_v
, enum machine_mode mode
,
592 const_tree type
, bool named ATTRIBUTE_UNUSED
)
594 CUMULATIVE_ARGS
*argsp
= get_cumulative_args (argsp_v
);
595 int arg_size
= MMIX_FUNCTION_ARG_SIZE (mode
, type
);
597 argsp
->regs
= ((targetm
.calls
.must_pass_in_stack (mode
, type
)
601 ? (MMIX_MAX_ARGS_IN_REGS
) + 1
602 : argsp
->regs
+ (7 + arg_size
) / 8);
605 /* Helper function for mmix_function_arg and mmix_function_incoming_arg. */
608 mmix_function_arg_1 (const cumulative_args_t argsp_v
,
609 enum machine_mode mode
,
611 bool named ATTRIBUTE_UNUSED
,
614 CUMULATIVE_ARGS
*argsp
= get_cumulative_args (argsp_v
);
616 /* Last-argument marker. */
617 if (type
== void_type_node
)
618 return (argsp
->regs
< MMIX_MAX_ARGS_IN_REGS
)
621 ? MMIX_FIRST_INCOMING_ARG_REGNUM
622 : MMIX_FIRST_ARG_REGNUM
) + argsp
->regs
)
625 return (argsp
->regs
< MMIX_MAX_ARGS_IN_REGS
626 && !targetm
.calls
.must_pass_in_stack (mode
, type
)
627 && (GET_MODE_BITSIZE (mode
) <= 64
632 ? MMIX_FIRST_INCOMING_ARG_REGNUM
633 : MMIX_FIRST_ARG_REGNUM
)
638 /* Return an rtx for a function argument to go in a register, and 0 for
639 one that must go on stack. */
642 mmix_function_arg (cumulative_args_t argsp
,
643 enum machine_mode mode
,
647 return mmix_function_arg_1 (argsp
, mode
, type
, named
, false);
651 mmix_function_incoming_arg (cumulative_args_t argsp
,
652 enum machine_mode mode
,
656 return mmix_function_arg_1 (argsp
, mode
, type
, named
, true);
659 /* Returns nonzero for everything that goes by reference, 0 for
660 everything that goes by value. */
663 mmix_pass_by_reference (cumulative_args_t argsp_v
, enum machine_mode mode
,
664 const_tree type
, bool named ATTRIBUTE_UNUSED
)
666 CUMULATIVE_ARGS
*argsp
= get_cumulative_args (argsp_v
);
668 /* FIXME: Check: I'm not sure the must_pass_in_stack check is
670 if (targetm
.calls
.must_pass_in_stack (mode
, type
))
673 if (MMIX_FUNCTION_ARG_SIZE (mode
, type
) > 8
675 && (!argsp
|| !argsp
->lib
))
681 /* Return nonzero if regno is a register number where a parameter is
682 passed, and 0 otherwise. */
685 mmix_function_arg_regno_p (int regno
, int incoming
)
688 = incoming
? MMIX_FIRST_INCOMING_ARG_REGNUM
: MMIX_FIRST_ARG_REGNUM
;
690 return regno
>= first_arg_regnum
691 && regno
< first_arg_regnum
+ MMIX_MAX_ARGS_IN_REGS
;
694 /* Implements TARGET_FUNCTION_VALUE. */
697 mmix_function_value (const_tree valtype
,
698 const_tree func ATTRIBUTE_UNUSED
,
701 enum machine_mode mode
= TYPE_MODE (valtype
);
702 enum machine_mode cmode
;
703 int first_val_regnum
= MMIX_OUTGOING_RETURN_VALUE_REGNUM
;
704 rtx vec
[MMIX_MAX_REGS_FOR_VALUE
];
709 return gen_rtx_REG (mode
, MMIX_RETURN_VALUE_REGNUM
);
711 /* Return values that fit in a register need no special handling.
712 There's no register hole when parameters are passed in global
715 || GET_MODE_BITSIZE (mode
) <= BITS_PER_WORD
)
717 gen_rtx_REG (mode
, MMIX_OUTGOING_RETURN_VALUE_REGNUM
);
719 if (COMPLEX_MODE_P (mode
))
720 /* A complex type, made up of components. */
721 cmode
= TYPE_MODE (TREE_TYPE (valtype
));
724 /* Of the other larger-than-register modes, we only support
725 scalar mode TImode. (At least, that's the only one that's
726 been rudimentally tested.) Make sure we're alerted for
729 sorry ("support for mode %qs", GET_MODE_NAME (mode
));
731 /* In any case, we will fill registers to the natural size. */
735 nregs
= ((GET_MODE_BITSIZE (mode
) + BITS_PER_WORD
- 1) / BITS_PER_WORD
);
737 /* We need to take care of the effect of the register hole on return
738 values of large sizes; the last register will appear as the first
739 register, with the rest shifted. (For complex modes, this is just
740 swapped registers.) */
742 if (nregs
> MMIX_MAX_REGS_FOR_VALUE
)
743 internal_error ("too large function value type, needs %d registers,\
744 have only %d registers for this", nregs
, MMIX_MAX_REGS_FOR_VALUE
);
746 /* FIXME: Maybe we should handle structure values like this too
747 (adjusted for BLKmode), perhaps for both ABI:s. */
748 for (i
= 0; i
< nregs
- 1; i
++)
750 = gen_rtx_EXPR_LIST (VOIDmode
,
751 gen_rtx_REG (cmode
, first_val_regnum
+ i
),
752 GEN_INT ((i
+ 1) * BITS_PER_UNIT
));
755 = gen_rtx_EXPR_LIST (VOIDmode
,
756 gen_rtx_REG (cmode
, first_val_regnum
+ nregs
- 1),
759 return gen_rtx_PARALLEL (mode
, gen_rtvec_v (nregs
, vec
));
762 /* Implements TARGET_LIBCALL_VALUE. */
765 mmix_libcall_value (enum machine_mode mode
,
766 const_rtx fun ATTRIBUTE_UNUSED
)
768 return gen_rtx_REG (mode
, MMIX_RETURN_VALUE_REGNUM
);
771 /* Implements TARGET_FUNCTION_VALUE_REGNO_P. */
774 mmix_function_value_regno_p (const unsigned int regno
)
776 return regno
== MMIX_RETURN_VALUE_REGNUM
;
779 /* EH_RETURN_DATA_REGNO. */
782 mmix_eh_return_data_regno (int n
)
785 return MMIX_EH_RETURN_DATA_REGNO_START
+ n
;
787 return INVALID_REGNUM
;
790 /* EH_RETURN_STACKADJ_RTX. */
793 mmix_eh_return_stackadj_rtx (void)
795 return gen_rtx_REG (Pmode
, MMIX_EH_RETURN_STACKADJ_REGNUM
);
798 /* EH_RETURN_HANDLER_RTX. */
801 mmix_eh_return_handler_rtx (void)
803 return gen_rtx_REG (Pmode
, MMIX_INCOMING_RETURN_ADDRESS_REGNUM
);
806 /* ASM_PREFERRED_EH_DATA_FORMAT. */
809 mmix_asm_preferred_eh_data_format (int code ATTRIBUTE_UNUSED
,
810 int global ATTRIBUTE_UNUSED
)
812 /* This is the default (was at 2001-07-20). Revisit when needed. */
813 return DW_EH_PE_absptr
;
816 /* Make a note that we've seen the beginning of the prologue. This
817 matters to whether we'll translate register numbers as calculated by
821 mmix_target_asm_function_prologue (FILE *stream ATTRIBUTE_UNUSED
,
822 HOST_WIDE_INT framesize ATTRIBUTE_UNUSED
)
824 cfun
->machine
->in_prologue
= 1;
827 /* Make a note that we've seen the end of the prologue. */
830 mmix_target_asm_function_end_prologue (FILE *stream ATTRIBUTE_UNUSED
)
832 cfun
->machine
->in_prologue
= 0;
835 /* Implement TARGET_MACHINE_DEPENDENT_REORG. No actual rearrangements
836 done here; just virtually by calculating the highest saved stack
837 register number used to modify the register numbers at output time. */
844 /* We put the number of the highest saved register-file register in a
845 location convenient for the call-patterns to output. Note that we
846 don't tell dwarf2 about these registers, since it can't restore them
848 for (regno
= MMIX_LAST_STACK_REGISTER_REGNUM
;
851 if ((df_regs_ever_live_p (regno
) && !call_used_regs
[regno
])
852 || (regno
== MMIX_FRAME_POINTER_REGNUM
&& frame_pointer_needed
))
855 /* Regardless of whether they're saved (they might be just read), we
856 mustn't include registers that carry parameters. We could scan the
857 insns to see whether they're actually used (and indeed do other less
858 trivial register usage analysis and transformations), but it seems
859 wasteful to optimize for unused parameter registers. As of
860 2002-04-30, df_regs_ever_live_p (n) seems to be set for only-reads too, but
861 that might change. */
862 if (!TARGET_ABI_GNU
&& regno
< crtl
->args
.info
.regs
- 1)
864 regno
= crtl
->args
.info
.regs
- 1;
866 /* We don't want to let this cause us to go over the limit and make
867 incoming parameter registers be misnumbered and treating the last
868 parameter register and incoming return value register call-saved.
869 Stop things at the unmodified scheme. */
870 if (regno
> MMIX_RETURN_VALUE_REGNUM
- 1)
871 regno
= MMIX_RETURN_VALUE_REGNUM
- 1;
874 cfun
->machine
->highest_saved_stack_register
= regno
;
877 /* TARGET_ASM_FUNCTION_EPILOGUE. */
880 mmix_target_asm_function_epilogue (FILE *stream
,
881 HOST_WIDE_INT locals_size ATTRIBUTE_UNUSED
)
883 /* Emit an \n for readability of the generated assembly. */
884 fputc ('\n', stream
);
887 /* TARGET_ASM_OUTPUT_MI_THUNK. */
890 mmix_asm_output_mi_thunk (FILE *stream
,
891 tree fndecl ATTRIBUTE_UNUSED
,
893 HOST_WIDE_INT vcall_offset ATTRIBUTE_UNUSED
,
896 /* If you define TARGET_STRUCT_VALUE_RTX that returns 0 (i.e. pass
897 location of structure to return as invisible first argument), you
898 need to tweak this code too. */
899 const char *regname
= reg_names
[MMIX_FIRST_INCOMING_ARG_REGNUM
];
901 if (delta
>= 0 && delta
< 65536)
902 fprintf (stream
, "\tINCL %s,%d\n", regname
, (int)delta
);
903 else if (delta
< 0 && delta
>= -255)
904 fprintf (stream
, "\tSUBU %s,%s,%d\n", regname
, regname
, (int)-delta
);
907 mmix_output_register_setting (stream
, 255, delta
, 1);
908 fprintf (stream
, "\tADDU %s,%s,$255\n", regname
, regname
);
911 fprintf (stream
, "\tJMP ");
912 assemble_name (stream
, XSTR (XEXP (DECL_RTL (func
), 0), 0));
913 fprintf (stream
, "\n");
916 /* FUNCTION_PROFILER. */
919 mmix_function_profiler (FILE *stream ATTRIBUTE_UNUSED
,
920 int labelno ATTRIBUTE_UNUSED
)
922 sorry ("function_profiler support for MMIX");
925 /* Worker function for TARGET_SETUP_INCOMING_VARARGS. For the moment,
926 let's stick to pushing argument registers on the stack. Later, we
927 can parse all arguments in registers, to improve performance. */
930 mmix_setup_incoming_varargs (cumulative_args_t args_so_farp_v
,
931 enum machine_mode mode
,
934 int second_time ATTRIBUTE_UNUSED
)
936 CUMULATIVE_ARGS
*args_so_farp
= get_cumulative_args (args_so_farp_v
);
938 /* The last named variable has been handled, but
939 args_so_farp has not been advanced for it. */
940 if (args_so_farp
->regs
+ 1 < MMIX_MAX_ARGS_IN_REGS
)
941 *pretend_sizep
= (MMIX_MAX_ARGS_IN_REGS
- (args_so_farp
->regs
+ 1)) * 8;
943 /* We assume that one argument takes up one register here. That should
944 be true until we start messing with multi-reg parameters. */
945 if ((7 + (MMIX_FUNCTION_ARG_SIZE (mode
, vartype
))) / 8 != 1)
946 internal_error ("MMIX Internal: Last named vararg would not fit in a register");
949 /* TARGET_ASM_TRAMPOLINE_TEMPLATE. */
952 mmix_asm_trampoline_template (FILE *stream
)
954 /* Read a value into the static-chain register and jump somewhere. The
955 static chain is stored at offset 16, and the function address is
956 stored at offset 24. */
958 fprintf (stream
, "\tGETA $255,1F\n\t");
959 fprintf (stream
, "LDOU %s,$255,0\n\t", reg_names
[MMIX_STATIC_CHAIN_REGNUM
]);
960 fprintf (stream
, "LDOU $255,$255,8\n\t");
961 fprintf (stream
, "GO $255,$255,0\n");
962 fprintf (stream
, "1H\tOCTA 0\n\t");
963 fprintf (stream
, "OCTA 0\n");
966 /* TARGET_TRAMPOLINE_INIT. */
967 /* Set the static chain and function pointer field in the trampoline.
968 We also SYNCID here to be sure (doesn't matter in the simulator, but
969 some day it will). */
972 mmix_trampoline_init (rtx m_tramp
, tree fndecl
, rtx static_chain
)
974 rtx fnaddr
= XEXP (DECL_RTL (fndecl
), 0);
977 emit_block_move (m_tramp
, assemble_trampoline_template (),
978 GEN_INT (2*UNITS_PER_WORD
), BLOCK_OP_NORMAL
);
980 mem
= adjust_address (m_tramp
, DImode
, 2*UNITS_PER_WORD
);
981 emit_move_insn (mem
, static_chain
);
982 mem
= adjust_address (m_tramp
, DImode
, 3*UNITS_PER_WORD
);
983 emit_move_insn (mem
, fnaddr
);
985 mem
= adjust_address (m_tramp
, DImode
, 0);
986 emit_insn (gen_sync_icache (mem
, GEN_INT (TRAMPOLINE_SIZE
- 1)));
989 /* We must exclude constant addresses that have an increment that is not a
990 multiple of four bytes because of restrictions of the GETA
991 instruction, unless TARGET_BASE_ADDRESSES. */
994 mmix_constant_address_p (rtx x
)
996 RTX_CODE code
= GET_CODE (x
);
998 /* When using "base addresses", anything constant goes. */
999 int constant_ok
= TARGET_BASE_ADDRESSES
!= 0;
1008 /* FIXME: Don't know how to dissect these. Avoid them for now,
1009 except we know they're constants. */
1013 addend
= INTVAL (x
);
1017 if (GET_MODE (x
) != VOIDmode
)
1018 /* Strange that we got here. FIXME: Check if we do. */
1020 addend
= CONST_DOUBLE_LOW (x
);
1024 /* Note that expressions with arithmetic on forward references don't
1025 work in mmixal. People using gcc assembly code with mmixal might
1026 need to move arrays and such to before the point of use. */
1027 if (GET_CODE (XEXP (x
, 0)) == PLUS
)
1029 rtx x0
= XEXP (XEXP (x
, 0), 0);
1030 rtx x1
= XEXP (XEXP (x
, 0), 1);
1032 if ((GET_CODE (x0
) == SYMBOL_REF
1033 || GET_CODE (x0
) == LABEL_REF
)
1034 && (GET_CODE (x1
) == CONST_INT
1035 || (GET_CODE (x1
) == CONST_DOUBLE
1036 && GET_MODE (x1
) == VOIDmode
)))
1037 addend
= mmix_intval (x1
);
1049 return constant_ok
|| (addend
& 3) == 0;
1052 /* Return 1 if the address is OK, otherwise 0. */
1055 mmix_legitimate_address_p (enum machine_mode mode ATTRIBUTE_UNUSED
,
1057 bool strict_checking
)
1059 #define MMIX_REG_OK(X) \
1061 && (REGNO (X) <= MMIX_LAST_GENERAL_REGISTER \
1062 || (reg_renumber[REGNO (X)] > 0 \
1063 && reg_renumber[REGNO (X)] <= MMIX_LAST_GENERAL_REGISTER))) \
1064 || (!strict_checking \
1065 && (REGNO (X) <= MMIX_LAST_GENERAL_REGISTER \
1066 || REGNO (X) >= FIRST_PSEUDO_REGISTER \
1067 || REGNO (X) == ARG_POINTER_REGNUM)))
1071 (mem (plus reg reg))
1072 (mem (plus reg 0..255)).
1073 unless TARGET_BASE_ADDRESSES, in which case we accept all
1074 (mem constant_address) too. */
1078 if (REG_P (x
) && MMIX_REG_OK (x
))
1081 if (GET_CODE(x
) == PLUS
)
1083 rtx x1
= XEXP (x
, 0);
1084 rtx x2
= XEXP (x
, 1);
1086 /* Try swapping the order. FIXME: Do we need this? */
1094 /* (mem (plus (reg?) (?))) */
1095 if (!REG_P (x1
) || !MMIX_REG_OK (x1
))
1096 return TARGET_BASE_ADDRESSES
&& mmix_constant_address_p (x
);
1098 /* (mem (plus (reg) (reg?))) */
1099 if (REG_P (x2
) && MMIX_REG_OK (x2
))
1102 /* (mem (plus (reg) (0..255?))) */
1103 if (satisfies_constraint_I (x2
))
1109 return TARGET_BASE_ADDRESSES
&& mmix_constant_address_p (x
);
1112 /* Implement TARGET_LEGITIMATE_CONSTANT_P. */
1115 mmix_legitimate_constant_p (enum machine_mode mode ATTRIBUTE_UNUSED
, rtx x
)
1117 RTX_CODE code
= GET_CODE (x
);
1119 /* We must allow any number due to the way the cse passes works; if we
1120 do not allow any number here, general_operand will fail, and insns
1121 will fatally fail recognition instead of "softly". */
1122 if (code
== CONST_INT
|| code
== CONST_DOUBLE
)
1125 return CONSTANT_ADDRESS_P (x
);
1128 /* SELECT_CC_MODE. */
1131 mmix_select_cc_mode (RTX_CODE op
, rtx x
, rtx y ATTRIBUTE_UNUSED
)
1133 /* We use CCmode, CC_UNSmode, CC_FPmode, CC_FPEQmode and CC_FUNmode to
1134 output different compare insns. Note that we do not check the
1135 validity of the comparison here. */
1137 if (GET_MODE_CLASS (GET_MODE (x
)) == MODE_FLOAT
)
1139 if (op
== ORDERED
|| op
== UNORDERED
|| op
== UNGE
1140 || op
== UNGT
|| op
== UNLE
|| op
== UNLT
)
1143 if (op
== EQ
|| op
== NE
)
1149 if (op
== GTU
|| op
== LTU
|| op
== GEU
|| op
== LEU
)
1155 /* REVERSIBLE_CC_MODE. */
1158 mmix_reversible_cc_mode (enum machine_mode mode
)
1160 /* That is, all integer and the EQ, NE, ORDERED and UNORDERED float
1162 return mode
!= CC_FPmode
;
1165 /* TARGET_RTX_COSTS. */
1168 mmix_rtx_costs (rtx x ATTRIBUTE_UNUSED
,
1169 int code ATTRIBUTE_UNUSED
,
1170 int outer_code ATTRIBUTE_UNUSED
,
1171 int opno ATTRIBUTE_UNUSED
,
1172 int *total ATTRIBUTE_UNUSED
,
1173 bool speed ATTRIBUTE_UNUSED
)
1175 /* For the time being, this is just a stub and we'll accept the
1176 generic calculations, until we can do measurements, at least.
1177 Say we did not modify any calculated costs. */
1181 /* TARGET_REGISTER_MOVE_COST.
1183 The special registers can only move to and from general regs, and we
1184 need to check that their constraints match, so say 3 for them. */
1187 mmix_register_move_cost (enum machine_mode mode ATTRIBUTE_UNUSED
,
1191 return (from
== GENERAL_REGS
&& from
== to
) ? 2 : 3;
1194 /* Note that we don't have a TEXT_SECTION_ASM_OP, because it has to be a
1195 compile-time constant; it's used in an asm in crtstuff.c, compiled for
1198 /* DATA_SECTION_ASM_OP. */
1201 mmix_data_section_asm_op (void)
1203 return "\t.data ! mmixal:= 8H LOC 9B";
1207 mmix_encode_section_info (tree decl
, rtx rtl
, int first
)
1209 /* Test for an external declaration, and do nothing if it is one. */
1210 if ((TREE_CODE (decl
) == VAR_DECL
1211 && (DECL_EXTERNAL (decl
) || TREE_PUBLIC (decl
)))
1212 || (TREE_CODE (decl
) == FUNCTION_DECL
&& TREE_PUBLIC (decl
)))
1214 else if (first
&& DECL_P (decl
))
1216 /* For non-visible declarations, add a "@" prefix, which we skip
1217 when the label is output. If the label does not have this
1218 prefix, a ":" is output if -mtoplevel-symbols.
1220 Note that this does not work for data that is declared extern and
1221 later defined as static. If there's code in between, that code
1222 will refer to the extern declaration, and vice versa. This just
1223 means that when -mtoplevel-symbols is in use, we can just handle
1224 well-behaved ISO-compliant code. */
1226 const char *str
= XSTR (XEXP (rtl
, 0), 0);
1227 int len
= strlen (str
);
1228 char *newstr
= XALLOCAVEC (char, len
+ 2);
1230 strcpy (newstr
+ 1, str
);
1231 XSTR (XEXP (rtl
, 0), 0) = ggc_alloc_string (newstr
, len
+ 1);
1234 /* Set SYMBOL_REF_FLAG for things that we want to access with GETA. We
1235 may need different options to reach for different things with GETA.
1236 For now, functions and things we know or have been told are constant. */
1237 if (TREE_CODE (decl
) == FUNCTION_DECL
1238 || TREE_CONSTANT (decl
)
1239 || (TREE_CODE (decl
) == VAR_DECL
1240 && TREE_READONLY (decl
)
1241 && !TREE_SIDE_EFFECTS (decl
)
1242 && (!DECL_INITIAL (decl
)
1243 || TREE_CONSTANT (DECL_INITIAL (decl
)))))
1244 SYMBOL_REF_FLAG (XEXP (rtl
, 0)) = 1;
1248 mmix_strip_name_encoding (const char *name
)
1250 for (; (*name
== '@' || *name
== '*'); name
++)
1256 /* TARGET_ASM_FILE_START.
1257 We just emit a little comment for the time being. */
1260 mmix_file_start (void)
1262 default_file_start ();
1264 fputs ("! mmixal:= 8H LOC Data_Section\n", asm_out_file
);
1266 /* Make sure each file starts with the text section. */
1267 switch_to_section (text_section
);
1270 /* TARGET_ASM_FILE_END. */
1273 mmix_file_end (void)
1275 /* Make sure each file ends with the data section. */
1276 switch_to_section (data_section
);
1279 /* TARGET_ASM_OUTPUT_SOURCE_FILENAME. */
1282 mmix_asm_output_source_filename (FILE *stream
, const char *name
)
1284 fprintf (stream
, "# 1 ");
1285 OUTPUT_QUOTED_STRING (stream
, name
);
1286 fprintf (stream
, "\n");
1289 /* OUTPUT_QUOTED_STRING. */
1292 mmix_output_quoted_string (FILE *stream
, const char *string
, int length
)
1294 const char * string_end
= string
+ length
;
1295 static const char *const unwanted_chars
= "\"[]\\";
1297 /* Output "any character except newline and double quote character". We
1298 play it safe and avoid all control characters too. We also do not
1299 want [] as characters, should input be passed through m4 with [] as
1300 quotes. Further, we avoid "\", because the GAS port handles it as a
1301 quoting character. */
1302 while (string
< string_end
)
1305 && (unsigned char) *string
< 128
1306 && !ISCNTRL (*string
)
1307 && strchr (unwanted_chars
, *string
) == NULL
)
1309 fputc ('"', stream
);
1311 && (unsigned char) *string
< 128
1312 && !ISCNTRL (*string
)
1313 && strchr (unwanted_chars
, *string
) == NULL
1314 && string
< string_end
)
1316 fputc (*string
, stream
);
1319 fputc ('"', stream
);
1320 if (string
< string_end
)
1321 fprintf (stream
, ",");
1323 if (string
< string_end
)
1325 fprintf (stream
, "#%x", *string
& 255);
1327 if (string
< string_end
)
1328 fprintf (stream
, ",");
1333 /* Target hook for assembling integer objects. Use mmix_print_operand
1334 for WYDE and TETRA. Use mmix_output_octa to output 8-byte
1338 mmix_assemble_integer (rtx x
, unsigned int size
, int aligned_p
)
1343 /* We handle a limited number of types of operands in here. But
1344 that's ok, because we can punt to generic functions. We then
1345 pretend that aligned data isn't needed, so the usual .<pseudo>
1346 syntax is used (which works for aligned data too). We actually
1347 *must* do that, since we say we don't have simple aligned
1348 pseudos, causing this function to be called. We just try and
1349 keep as much compatibility as possible with mmixal syntax for
1350 normal cases (i.e. without GNU extensions and C only). */
1352 if (GET_CODE (x
) != CONST_INT
)
1357 fputs ("\tBYTE\t", asm_out_file
);
1358 mmix_print_operand (asm_out_file
, x
, 'B');
1359 fputc ('\n', asm_out_file
);
1363 if (GET_CODE (x
) != CONST_INT
)
1368 fputs ("\tWYDE\t", asm_out_file
);
1369 mmix_print_operand (asm_out_file
, x
, 'W');
1370 fputc ('\n', asm_out_file
);
1374 if (GET_CODE (x
) != CONST_INT
)
1379 fputs ("\tTETRA\t", asm_out_file
);
1380 mmix_print_operand (asm_out_file
, x
, 'L');
1381 fputc ('\n', asm_out_file
);
1385 /* We don't get here anymore for CONST_DOUBLE, because DImode
1386 isn't expressed as CONST_DOUBLE, and DFmode is handled
1388 gcc_assert (GET_CODE (x
) != CONST_DOUBLE
);
1389 assemble_integer_with_op ("\tOCTA\t", x
);
1392 return default_assemble_integer (x
, size
, aligned_p
);
1395 /* ASM_OUTPUT_ASCII. */
1398 mmix_asm_output_ascii (FILE *stream
, const char *string
, int length
)
1402 int chunk_size
= length
> 60 ? 60 : length
;
1403 fprintf (stream
, "\tBYTE ");
1404 mmix_output_quoted_string (stream
, string
, chunk_size
);
1405 string
+= chunk_size
;
1406 length
-= chunk_size
;
1407 fprintf (stream
, "\n");
1411 /* ASM_OUTPUT_ALIGNED_COMMON. */
1414 mmix_asm_output_aligned_common (FILE *stream
,
1419 /* This is mostly the elfos.h one. There doesn't seem to be a way to
1420 express this in a mmixal-compatible way. */
1421 fprintf (stream
, "\t.comm\t");
1422 assemble_name (stream
, name
);
1423 fprintf (stream
, ",%u,%u ! mmixal-incompatible COMMON\n",
1424 size
, align
/ BITS_PER_UNIT
);
1427 /* ASM_OUTPUT_ALIGNED_LOCAL. */
1430 mmix_asm_output_aligned_local (FILE *stream
,
1435 switch_to_section (data_section
);
1437 ASM_OUTPUT_ALIGN (stream
, exact_log2 (align
/BITS_PER_UNIT
));
1438 assemble_name (stream
, name
);
1439 fprintf (stream
, "\tLOC @+%d\n", size
);
1442 /* ASM_OUTPUT_LABEL. */
1445 mmix_asm_output_label (FILE *stream
, const char *name
)
1447 assemble_name (stream
, name
);
1448 fprintf (stream
, "\tIS @\n");
1451 /* ASM_OUTPUT_INTERNAL_LABEL. */
1454 mmix_asm_output_internal_label (FILE *stream
, const char *name
)
1456 assemble_name_raw (stream
, name
);
1457 fprintf (stream
, "\tIS @\n");
1460 /* ASM_DECLARE_REGISTER_GLOBAL. */
1463 mmix_asm_declare_register_global (FILE *stream ATTRIBUTE_UNUSED
,
1464 tree decl ATTRIBUTE_UNUSED
,
1465 int regno ATTRIBUTE_UNUSED
,
1466 const char *name ATTRIBUTE_UNUSED
)
1468 /* Nothing to do here, but there *will* be, therefore the framework is
1472 /* ASM_WEAKEN_LABEL. */
1475 mmix_asm_weaken_label (FILE *stream ATTRIBUTE_UNUSED
,
1476 const char *name ATTRIBUTE_UNUSED
)
1478 fprintf (stream
, "\t.weak ");
1479 assemble_name (stream
, name
);
1480 fprintf (stream
, " ! mmixal-incompatible\n");
1483 /* MAKE_DECL_ONE_ONLY. */
1486 mmix_make_decl_one_only (tree decl
)
1488 DECL_WEAK (decl
) = 1;
1491 /* ASM_OUTPUT_LABELREF.
1492 Strip GCC's '*' and our own '@'. No order is assumed. */
1495 mmix_asm_output_labelref (FILE *stream
, const char *name
)
1499 for (; (*name
== '@' || *name
== '*'); name
++)
1503 asm_fprintf (stream
, "%s%U%s",
1504 is_extern
&& TARGET_TOPLEVEL_SYMBOLS
? ":" : "",
1508 /* ASM_OUTPUT_DEF. */
1511 mmix_asm_output_def (FILE *stream
, const char *name
, const char *value
)
1513 assemble_name (stream
, name
);
1514 fprintf (stream
, "\tIS ");
1515 assemble_name (stream
, value
);
1516 fputc ('\n', stream
);
1519 /* TARGET_PRINT_OPERAND. */
1522 mmix_print_operand (FILE *stream
, rtx x
, int code
)
1524 /* When we add support for different codes later, we can, when needed,
1525 drop through to the main handler with a modified operand. */
1527 int regno
= x
!= NULL_RTX
&& REG_P (x
) ? REGNO (x
) : 0;
1531 /* Unrelated codes are in alphabetic order. */
1534 /* For conditional branches, output "P" for a probable branch. */
1535 if (TARGET_BRANCH_PREDICT
)
1537 x
= find_reg_note (current_output_insn
, REG_BR_PROB
, 0);
1538 if (x
&& XINT (x
, 0) > REG_BR_PROB_BASE
/ 2)
1544 /* For the %d in POP %d,0. */
1545 fprintf (stream
, "%d", MMIX_POP_ARGUMENT ());
1549 if (GET_CODE (x
) != CONST_INT
)
1550 fatal_insn ("MMIX Internal: Expected a CONST_INT, not this", x
);
1551 fprintf (stream
, "%d", (int) (INTVAL (x
) & 0xff));
1555 /* Highpart. Must be general register, and not the last one, as
1556 that one cannot be part of a consecutive register pair. */
1557 if (regno
> MMIX_LAST_GENERAL_REGISTER
- 1)
1558 internal_error ("MMIX Internal: Bad register: %d", regno
);
1560 /* This is big-endian, so the high-part is the first one. */
1561 fprintf (stream
, "%s", reg_names
[MMIX_OUTPUT_REGNO (regno
)]);
1565 /* Lowpart. Must be CONST_INT or general register, and not the last
1566 one, as that one cannot be part of a consecutive register pair. */
1567 if (GET_CODE (x
) == CONST_INT
)
1569 fprintf (stream
, "#%lx",
1570 (unsigned long) (INTVAL (x
)
1571 & ((unsigned int) 0x7fffffff * 2 + 1)));
1575 if (GET_CODE (x
) == SYMBOL_REF
)
1577 output_addr_const (stream
, x
);
1581 if (regno
> MMIX_LAST_GENERAL_REGISTER
- 1)
1582 internal_error ("MMIX Internal: Bad register: %d", regno
);
1584 /* This is big-endian, so the low-part is + 1. */
1585 fprintf (stream
, "%s", reg_names
[MMIX_OUTPUT_REGNO (regno
) + 1]);
1588 /* Can't use 'a' because that's a generic modifier for address
1591 mmix_output_shiftvalue_op_from_str (stream
, "ANDN",
1597 mmix_output_shiftvalue_op_from_str (stream
, "INC",
1603 mmix_output_shiftvalue_op_from_str (stream
, "OR",
1609 mmix_output_shiftvalue_op_from_str (stream
, "SET",
1616 mmix_output_condition (stream
, x
, (code
== 'D'));
1620 /* Output an extra "e" to make fcmpe, fune. */
1621 if (TARGET_FCMP_EPSILON
)
1622 fprintf (stream
, "e");
1626 /* Output the number minus 1. */
1627 if (GET_CODE (x
) != CONST_INT
)
1629 fatal_insn ("MMIX Internal: Bad value for 'm', not a CONST_INT",
1632 fprintf (stream
, "%"PRId64
,
1633 (int64_t) (mmix_intval (x
) - 1));
1637 /* Store the number of registers we want to save. This was setup
1638 by the prologue. The actual operand contains the number of
1639 registers to pass, but we don't use it currently. Anyway, we
1640 need to output the number of saved registers here. */
1641 fprintf (stream
, "%d",
1642 cfun
->machine
->highest_saved_stack_register
+ 1);
1646 /* Store the register to output a constant to. */
1648 fatal_insn ("MMIX Internal: Expected a register, not this", x
);
1649 mmix_output_destination_register
= MMIX_OUTPUT_REGNO (regno
);
1653 /* Output the constant. Note that we use this for floats as well. */
1654 if (GET_CODE (x
) != CONST_INT
1655 && (GET_CODE (x
) != CONST_DOUBLE
1656 || (GET_MODE (x
) != VOIDmode
&& GET_MODE (x
) != DFmode
1657 && GET_MODE (x
) != SFmode
)))
1658 fatal_insn ("MMIX Internal: Expected a constant, not this", x
);
1659 mmix_output_register_setting (stream
,
1660 mmix_output_destination_register
,
1661 mmix_intval (x
), 0);
1665 /* An U for unsigned, if TARGET_ZERO_EXTEND. Ignore the operand. */
1666 if (TARGET_ZERO_EXTEND
)
1671 mmix_output_shifted_value (stream
, (int64_t) mmix_intval (x
));
1675 mmix_output_shifted_value (stream
, (int64_t) ~mmix_intval (x
));
1679 if (GET_CODE (x
) != CONST_INT
)
1680 fatal_insn ("MMIX Internal: Expected a CONST_INT, not this", x
);
1681 fprintf (stream
, "#%x", (int) (INTVAL (x
) & 0xffff));
1685 /* Nothing to do. */
1689 /* Presumably there's a missing case above if we get here. */
1690 internal_error ("MMIX Internal: Missing %qc case in mmix_print_operand", code
);
1693 switch (GET_CODE (modified_x
))
1696 regno
= REGNO (modified_x
);
1697 if (regno
>= FIRST_PSEUDO_REGISTER
)
1698 internal_error ("MMIX Internal: Bad register: %d", regno
);
1699 fprintf (stream
, "%s", reg_names
[MMIX_OUTPUT_REGNO (regno
)]);
1703 output_address (XEXP (modified_x
, 0));
1707 /* For -2147483648, mmixal complains that the constant does not fit
1708 in 4 bytes, so let's output it as hex. Take care to handle hosts
1709 where HOST_WIDE_INT is longer than an int.
1711 Print small constants +-255 using decimal. */
1713 if (INTVAL (modified_x
) > -256 && INTVAL (modified_x
) < 256)
1714 fprintf (stream
, "%d", (int) (INTVAL (modified_x
)));
1716 fprintf (stream
, "#%x",
1717 (int) (INTVAL (modified_x
)) & (unsigned int) ~0);
1721 /* Do somewhat as CONST_INT. */
1722 mmix_output_octa (stream
, mmix_intval (modified_x
), 0);
1726 output_addr_const (stream
, modified_x
);
1730 /* No need to test for all strange things. Let output_addr_const do
1732 if (CONSTANT_P (modified_x
)
1733 /* Strangely enough, this is not included in CONSTANT_P.
1734 FIXME: Ask/check about sanity here. */
1735 || LABEL_P (modified_x
))
1737 output_addr_const (stream
, modified_x
);
1741 /* We need the original here. */
1742 fatal_insn ("MMIX Internal: Cannot decode this operand", x
);
1746 /* TARGET_PRINT_OPERAND_PUNCT_VALID_P. */
1749 mmix_print_operand_punct_valid_p (unsigned char code
)
1751 /* A '+' is used for branch prediction, similar to other ports. */
1753 /* A '.' is used for the %d in the POP %d,0 return insn. */
1757 /* TARGET_PRINT_OPERAND_ADDRESS. */
1760 mmix_print_operand_address (FILE *stream
, rtx x
)
1764 /* I find the generated assembly code harder to read without
1766 fprintf (stream
, "%s,0", reg_names
[MMIX_OUTPUT_REGNO (REGNO (x
))]);
1769 else if (GET_CODE (x
) == PLUS
)
1771 rtx x1
= XEXP (x
, 0);
1772 rtx x2
= XEXP (x
, 1);
1776 fprintf (stream
, "%s,", reg_names
[MMIX_OUTPUT_REGNO (REGNO (x1
))]);
1780 fprintf (stream
, "%s",
1781 reg_names
[MMIX_OUTPUT_REGNO (REGNO (x2
))]);
1784 else if (satisfies_constraint_I (x2
))
1786 output_addr_const (stream
, x2
);
1792 if (TARGET_BASE_ADDRESSES
&& mmix_legitimate_constant_p (Pmode
, x
))
1794 output_addr_const (stream
, x
);
1798 fatal_insn ("MMIX Internal: This is not a recognized address", x
);
1801 /* ASM_OUTPUT_REG_PUSH. */
1804 mmix_asm_output_reg_push (FILE *stream
, int regno
)
1806 fprintf (stream
, "\tSUBU %s,%s,8\n\tSTOU %s,%s,0\n",
1807 reg_names
[MMIX_STACK_POINTER_REGNUM
],
1808 reg_names
[MMIX_STACK_POINTER_REGNUM
],
1809 reg_names
[MMIX_OUTPUT_REGNO (regno
)],
1810 reg_names
[MMIX_STACK_POINTER_REGNUM
]);
1813 /* ASM_OUTPUT_REG_POP. */
1816 mmix_asm_output_reg_pop (FILE *stream
, int regno
)
1818 fprintf (stream
, "\tLDOU %s,%s,0\n\tINCL %s,8\n",
1819 reg_names
[MMIX_OUTPUT_REGNO (regno
)],
1820 reg_names
[MMIX_STACK_POINTER_REGNUM
],
1821 reg_names
[MMIX_STACK_POINTER_REGNUM
]);
1824 /* ASM_OUTPUT_ADDR_DIFF_ELT. */
1827 mmix_asm_output_addr_diff_elt (FILE *stream
,
1828 rtx body ATTRIBUTE_UNUSED
,
1832 fprintf (stream
, "\tTETRA L%d-L%d\n", value
, rel
);
1835 /* ASM_OUTPUT_ADDR_VEC_ELT. */
1838 mmix_asm_output_addr_vec_elt (FILE *stream
, int value
)
1840 fprintf (stream
, "\tOCTA L:%d\n", value
);
1843 /* ASM_OUTPUT_SKIP. */
1846 mmix_asm_output_skip (FILE *stream
, int nbytes
)
1848 fprintf (stream
, "\tLOC @+%d\n", nbytes
);
1851 /* ASM_OUTPUT_ALIGN. */
1854 mmix_asm_output_align (FILE *stream
, int power
)
1856 /* We need to record the needed alignment of this section in the object,
1857 so we have to output an alignment directive. Use a .p2align (not
1858 .align) so people will never have to wonder about whether the
1859 argument is in number of bytes or the log2 thereof. We do it in
1860 addition to the LOC directive, so nothing needs tweaking when
1861 copy-pasting assembly into mmixal. */
1862 fprintf (stream
, "\t.p2align %d\n", power
);
1863 fprintf (stream
, "\tLOC @+(%d-@)&%d\n", 1 << power
, (1 << power
) - 1);
1866 /* DBX_REGISTER_NUMBER. */
1869 mmix_dbx_register_number (unsigned regno
)
1871 /* Adjust the register number to the one it will be output as, dammit.
1872 It'd be nice if we could check the assumption that we're filling a
1873 gap, but every register between the last saved register and parameter
1874 registers might be a valid parameter register. */
1875 regno
= MMIX_OUTPUT_REGNO (regno
);
1877 /* We need to renumber registers to get the number of the return address
1878 register in the range 0..255. It is also space-saving if registers
1879 mentioned in the call-frame information (which uses this function by
1880 defaulting DWARF_FRAME_REGNUM to DBX_REGISTER_NUMBER) are numbered
1881 0 .. 63. So map 224 .. 256+15 -> 0 .. 47 and 0 .. 223 -> 48..223+48. */
1882 return regno
>= 224 ? (regno
- 224) : (regno
+ 48);
1885 /* End of target macro support functions.
1887 Now the MMIX port's own functions. First the exported ones. */
1889 /* Wrapper for get_hard_reg_initial_val since integrate.h isn't included
1890 from insn-emit.c. */
1893 mmix_get_hard_reg_initial_val (enum machine_mode mode
, int regno
)
1895 return get_hard_reg_initial_val (mode
, regno
);
1898 /* Nonzero when the function epilogue is simple enough that a single
1899 "POP %d,0" should be used even within the function. */
1902 mmix_use_simple_return (void)
1906 int stack_space_to_allocate
1907 = (crtl
->outgoing_args_size
1908 + crtl
->args
.pretend_args_size
1909 + get_frame_size () + 7) & ~7;
1911 if (!TARGET_USE_RETURN_INSN
|| !reload_completed
)
1915 regno
>= MMIX_FIRST_GLOBAL_REGNUM
;
1917 /* Note that we assume that the frame-pointer-register is one of these
1918 registers, in which case we don't count it here. */
1919 if ((((regno
!= MMIX_FRAME_POINTER_REGNUM
|| !frame_pointer_needed
)
1920 && df_regs_ever_live_p (regno
) && !call_used_regs
[regno
]))
1921 || IS_MMIX_EH_RETURN_DATA_REG (regno
))
1924 if (frame_pointer_needed
)
1925 stack_space_to_allocate
+= 8;
1927 if (MMIX_CFUN_HAS_LANDING_PAD
)
1928 stack_space_to_allocate
+= 16;
1929 else if (MMIX_CFUN_NEEDS_SAVED_EH_RETURN_ADDRESS
)
1930 stack_space_to_allocate
+= 8;
1932 return stack_space_to_allocate
== 0;
1936 /* Expands the function prologue into RTX. */
1939 mmix_expand_prologue (void)
1941 HOST_WIDE_INT locals_size
= get_frame_size ();
1943 HOST_WIDE_INT stack_space_to_allocate
1944 = (crtl
->outgoing_args_size
1945 + crtl
->args
.pretend_args_size
1946 + locals_size
+ 7) & ~7;
1947 HOST_WIDE_INT offset
= -8;
1949 /* Add room needed to save global non-register-stack registers. */
1951 regno
>= MMIX_FIRST_GLOBAL_REGNUM
;
1953 /* Note that we assume that the frame-pointer-register is one of these
1954 registers, in which case we don't count it here. */
1955 if ((((regno
!= MMIX_FRAME_POINTER_REGNUM
|| !frame_pointer_needed
)
1956 && df_regs_ever_live_p (regno
) && !call_used_regs
[regno
]))
1957 || IS_MMIX_EH_RETURN_DATA_REG (regno
))
1958 stack_space_to_allocate
+= 8;
1960 /* If we do have a frame-pointer, add room for it. */
1961 if (frame_pointer_needed
)
1962 stack_space_to_allocate
+= 8;
1964 /* If we have a non-local label, we need to be able to unwind to it, so
1965 store the current register stack pointer. Also store the return
1966 address if we do that. */
1967 if (MMIX_CFUN_HAS_LANDING_PAD
)
1968 stack_space_to_allocate
+= 16;
1969 else if (MMIX_CFUN_NEEDS_SAVED_EH_RETURN_ADDRESS
)
1970 /* If we do have a saved return-address slot, add room for it. */
1971 stack_space_to_allocate
+= 8;
1973 /* Make sure we don't get an unaligned stack. */
1974 if ((stack_space_to_allocate
% 8) != 0)
1975 internal_error ("stack frame not a multiple of 8 bytes: %wd",
1976 stack_space_to_allocate
);
1978 if (crtl
->args
.pretend_args_size
)
1980 int mmix_first_vararg_reg
1981 = (MMIX_FIRST_INCOMING_ARG_REGNUM
1982 + (MMIX_MAX_ARGS_IN_REGS
1983 - crtl
->args
.pretend_args_size
/ 8));
1986 = MMIX_FIRST_INCOMING_ARG_REGNUM
+ MMIX_MAX_ARGS_IN_REGS
- 1;
1987 regno
>= mmix_first_vararg_reg
;
1992 HOST_WIDE_INT stack_chunk
1993 = stack_space_to_allocate
> (256 - 8)
1994 ? (256 - 8) : stack_space_to_allocate
;
1996 mmix_emit_sp_add (-stack_chunk
);
1997 offset
+= stack_chunk
;
1998 stack_space_to_allocate
-= stack_chunk
;
2001 /* These registers aren't actually saved (as in "will be
2002 restored"), so don't tell DWARF2 they're saved. */
2003 emit_move_insn (gen_rtx_MEM (DImode
,
2004 plus_constant (Pmode
, stack_pointer_rtx
,
2006 gen_rtx_REG (DImode
, regno
));
2011 /* Store the frame-pointer. */
2013 if (frame_pointer_needed
)
2019 /* Get 8 less than otherwise, since we need to reach offset + 8. */
2020 HOST_WIDE_INT stack_chunk
2021 = stack_space_to_allocate
> (256 - 8 - 8)
2022 ? (256 - 8 - 8) : stack_space_to_allocate
;
2024 mmix_emit_sp_add (-stack_chunk
);
2026 offset
+= stack_chunk
;
2027 stack_space_to_allocate
-= stack_chunk
;
2030 insn
= emit_move_insn (gen_rtx_MEM (DImode
,
2031 plus_constant (Pmode
,
2034 hard_frame_pointer_rtx
);
2035 RTX_FRAME_RELATED_P (insn
) = 1;
2036 insn
= emit_insn (gen_adddi3 (hard_frame_pointer_rtx
,
2038 GEN_INT (offset
+ 8)));
2039 RTX_FRAME_RELATED_P (insn
) = 1;
2043 if (MMIX_CFUN_NEEDS_SAVED_EH_RETURN_ADDRESS
)
2048 /* Store the return-address, if one is needed on the stack. We
2049 usually store it in a register when needed, but that doesn't work
2050 with -fexceptions. */
2054 /* Get 8 less than otherwise, since we need to reach offset + 8. */
2055 HOST_WIDE_INT stack_chunk
2056 = stack_space_to_allocate
> (256 - 8 - 8)
2057 ? (256 - 8 - 8) : stack_space_to_allocate
;
2059 mmix_emit_sp_add (-stack_chunk
);
2061 offset
+= stack_chunk
;
2062 stack_space_to_allocate
-= stack_chunk
;
2065 tmpreg
= gen_rtx_REG (DImode
, 255);
2066 retreg
= gen_rtx_REG (DImode
, MMIX_rJ_REGNUM
);
2068 /* Dwarf2 code is confused by the use of a temporary register for
2069 storing the return address, so we have to express it as a note,
2070 which we attach to the actual store insn. */
2071 emit_move_insn (tmpreg
, retreg
);
2073 insn
= emit_move_insn (gen_rtx_MEM (DImode
,
2074 plus_constant (Pmode
,
2078 RTX_FRAME_RELATED_P (insn
) = 1;
2079 add_reg_note (insn
, REG_FRAME_RELATED_EXPR
,
2080 gen_rtx_SET (VOIDmode
,
2081 gen_rtx_MEM (DImode
,
2082 plus_constant (Pmode
,
2089 else if (MMIX_CFUN_HAS_LANDING_PAD
)
2092 if (MMIX_CFUN_HAS_LANDING_PAD
)
2094 /* Store the register defining the numbering of local registers, so
2095 we know how long to unwind the register stack. */
2099 /* Get 8 less than otherwise, since we need to reach offset + 8. */
2100 HOST_WIDE_INT stack_chunk
2101 = stack_space_to_allocate
> (256 - 8 - 8)
2102 ? (256 - 8 - 8) : stack_space_to_allocate
;
2104 mmix_emit_sp_add (-stack_chunk
);
2106 offset
+= stack_chunk
;
2107 stack_space_to_allocate
-= stack_chunk
;
2110 /* We don't tell dwarf2 about this one; we just have it to unwind
2111 the register stack at landing pads. FIXME: It's a kludge because
2112 we can't describe the effect of the PUSHJ and PUSHGO insns on the
2113 register stack at the moment. Best thing would be to handle it
2114 like stack-pointer offsets. Better: some hook into dwarf2out.c
2115 to produce DW_CFA_expression:s that specify the increment of rO,
2116 and unwind it at eh_return (preferred) or at the landing pad.
2117 Then saves to $0..$G-1 could be specified through that register. */
2119 emit_move_insn (gen_rtx_REG (DImode
, 255),
2120 gen_rtx_REG (DImode
,
2122 emit_move_insn (gen_rtx_MEM (DImode
,
2123 plus_constant (Pmode
, stack_pointer_rtx
,
2125 gen_rtx_REG (DImode
, 255));
2129 /* After the return-address and the frame-pointer, we have the local
2130 variables. They're the ones that may have an "unaligned" size. */
2131 offset
-= (locals_size
+ 7) & ~7;
2133 /* Now store all registers that are global, i.e. not saved by the
2134 register file machinery.
2136 It is assumed that the frame-pointer is one of these registers, so it
2137 is explicitly excluded in the count. */
2140 regno
>= MMIX_FIRST_GLOBAL_REGNUM
;
2142 if (((regno
!= MMIX_FRAME_POINTER_REGNUM
|| !frame_pointer_needed
)
2143 && df_regs_ever_live_p (regno
) && ! call_used_regs
[regno
])
2144 || IS_MMIX_EH_RETURN_DATA_REG (regno
))
2150 HOST_WIDE_INT stack_chunk
2151 = (stack_space_to_allocate
> (256 - offset
- 8)
2152 ? (256 - offset
- 8) : stack_space_to_allocate
);
2154 mmix_emit_sp_add (-stack_chunk
);
2155 offset
+= stack_chunk
;
2156 stack_space_to_allocate
-= stack_chunk
;
2159 insn
= emit_move_insn (gen_rtx_MEM (DImode
,
2160 plus_constant (Pmode
,
2163 gen_rtx_REG (DImode
, regno
));
2164 RTX_FRAME_RELATED_P (insn
) = 1;
2168 /* Finally, allocate room for outgoing args and local vars if room
2169 wasn't allocated above. */
2170 if (stack_space_to_allocate
)
2171 mmix_emit_sp_add (-stack_space_to_allocate
);
2174 /* Expands the function epilogue into RTX. */
2177 mmix_expand_epilogue (void)
2179 HOST_WIDE_INT locals_size
= get_frame_size ();
2181 HOST_WIDE_INT stack_space_to_deallocate
2182 = (crtl
->outgoing_args_size
2183 + crtl
->args
.pretend_args_size
2184 + locals_size
+ 7) & ~7;
2186 /* The first address to access is beyond the outgoing_args area. */
2187 HOST_WIDE_INT offset
= crtl
->outgoing_args_size
;
2189 /* Add the space for global non-register-stack registers.
2190 It is assumed that the frame-pointer register can be one of these
2191 registers, in which case it is excluded from the count when needed. */
2193 regno
>= MMIX_FIRST_GLOBAL_REGNUM
;
2195 if (((regno
!= MMIX_FRAME_POINTER_REGNUM
|| !frame_pointer_needed
)
2196 && df_regs_ever_live_p (regno
) && !call_used_regs
[regno
])
2197 || IS_MMIX_EH_RETURN_DATA_REG (regno
))
2198 stack_space_to_deallocate
+= 8;
2200 /* Add in the space for register stack-pointer. If so, always add room
2201 for the saved PC. */
2202 if (MMIX_CFUN_HAS_LANDING_PAD
)
2203 stack_space_to_deallocate
+= 16;
2204 else if (MMIX_CFUN_NEEDS_SAVED_EH_RETURN_ADDRESS
)
2205 /* If we have a saved return-address slot, add it in. */
2206 stack_space_to_deallocate
+= 8;
2208 /* Add in the frame-pointer. */
2209 if (frame_pointer_needed
)
2210 stack_space_to_deallocate
+= 8;
2212 /* Make sure we don't get an unaligned stack. */
2213 if ((stack_space_to_deallocate
% 8) != 0)
2214 internal_error ("stack frame not a multiple of octabyte: %wd",
2215 stack_space_to_deallocate
);
2217 /* We will add back small offsets to the stack pointer as we go.
2218 First, we restore all registers that are global, i.e. not saved by
2219 the register file machinery. */
2221 for (regno
= MMIX_FIRST_GLOBAL_REGNUM
;
2224 if (((regno
!= MMIX_FRAME_POINTER_REGNUM
|| !frame_pointer_needed
)
2225 && df_regs_ever_live_p (regno
) && !call_used_regs
[regno
])
2226 || IS_MMIX_EH_RETURN_DATA_REG (regno
))
2230 mmix_emit_sp_add (offset
);
2231 stack_space_to_deallocate
-= offset
;
2235 emit_move_insn (gen_rtx_REG (DImode
, regno
),
2236 gen_rtx_MEM (DImode
,
2237 plus_constant (Pmode
, stack_pointer_rtx
,
2242 /* Here is where the local variables were. As in the prologue, they
2243 might be of an unaligned size. */
2244 offset
+= (locals_size
+ 7) & ~7;
2246 /* The saved register stack pointer is just below the frame-pointer
2247 register. We don't need to restore it "manually"; the POP
2248 instruction does that. */
2249 if (MMIX_CFUN_HAS_LANDING_PAD
)
2251 else if (MMIX_CFUN_NEEDS_SAVED_EH_RETURN_ADDRESS
)
2252 /* The return-address slot is just below the frame-pointer register.
2253 We don't need to restore it because we don't really use it. */
2256 /* Get back the old frame-pointer-value. */
2257 if (frame_pointer_needed
)
2261 mmix_emit_sp_add (offset
);
2263 stack_space_to_deallocate
-= offset
;
2267 emit_move_insn (hard_frame_pointer_rtx
,
2268 gen_rtx_MEM (DImode
,
2269 plus_constant (Pmode
, stack_pointer_rtx
,
2274 /* We do not need to restore pretended incoming args, just add back
2276 if (stack_space_to_deallocate
!= 0)
2277 mmix_emit_sp_add (stack_space_to_deallocate
);
2279 if (crtl
->calls_eh_return
)
2280 /* Adjust the (normal) stack-pointer to that of the receiver.
2281 FIXME: It would be nice if we could also adjust the register stack
2282 here, but we need to express it through DWARF 2 too. */
2283 emit_insn (gen_adddi3 (stack_pointer_rtx
, stack_pointer_rtx
,
2284 gen_rtx_REG (DImode
,
2285 MMIX_EH_RETURN_STACKADJ_REGNUM
)));
2288 /* Output an optimal sequence for setting a register to a specific
2289 constant. Used in an alternative for const_ints in movdi, and when
2290 using large stack-frame offsets.
2292 Use do_begin_end to say if a line-starting TAB and newline before the
2293 first insn and after the last insn is wanted. */
2296 mmix_output_register_setting (FILE *stream
,
2302 fprintf (stream
, "\t");
2304 if (insn_const_int_ok_for_constraint (value
, CONSTRAINT_K
))
2305 fprintf (stream
, "NEGU %s,0,%"PRId64
, reg_names
[regno
], -value
);
2306 else if (mmix_shiftable_wyde_value ((uint64_t) value
))
2308 /* First, the one-insn cases. */
2309 mmix_output_shiftvalue_op_from_str (stream
, "SET",
2312 fprintf (stream
, " %s,", reg_names
[regno
]);
2313 mmix_output_shifted_value (stream
, (uint64_t) value
);
2315 else if (mmix_shiftable_wyde_value (-(uint64_t) value
))
2317 /* We do this to get a bit more legible assembly code. The next
2318 alternative is mostly redundant with this. */
2320 mmix_output_shiftvalue_op_from_str (stream
, "SET",
2323 fprintf (stream
, " %s,", reg_names
[regno
]);
2324 mmix_output_shifted_value (stream
, -(uint64_t) value
);
2325 fprintf (stream
, "\n\tNEGU %s,0,%s", reg_names
[regno
],
2328 else if (mmix_shiftable_wyde_value (~(uint64_t) value
))
2330 /* Slightly more expensive, the two-insn cases. */
2332 /* FIXME: We could of course also test if 0..255-N or ~(N | 1..255)
2333 is shiftable, or any other one-insn transformation of the value.
2334 FIXME: Check first if the value is "shiftable" by two loading
2335 with two insns, since it makes more readable assembly code (if
2336 anyone else cares). */
2338 mmix_output_shiftvalue_op_from_str (stream
, "SET",
2341 fprintf (stream
, " %s,", reg_names
[regno
]);
2342 mmix_output_shifted_value (stream
, ~(uint64_t) value
);
2343 fprintf (stream
, "\n\tNOR %s,%s,0", reg_names
[regno
],
2348 /* The generic case. 2..4 insns. */
2349 static const char *const higher_parts
[] = {"L", "ML", "MH", "H"};
2350 const char *op
= "SET";
2351 const char *line_begin
= "";
2354 int64_t tmpvalue
= value
;
2356 /* Compute the number of insns needed to output this constant. */
2357 for (i
= 0; i
< 4 && tmpvalue
!= 0; i
++)
2359 if (tmpvalue
& 65535)
2363 if (TARGET_BASE_ADDRESSES
&& insns
== 3)
2365 /* The number three is based on a static observation on
2366 ghostscript-6.52. Two and four are excluded because there
2367 are too many such constants, and each unique constant (maybe
2368 offset by 1..255) were used few times compared to other uses,
2371 We use base-plus-offset addressing to force it into a global
2372 register; we just use a "LDA reg,VALUE", which will cause the
2373 assembler and linker to DTRT (for constants as well as
2375 fprintf (stream
, "LDA %s,", reg_names
[regno
]);
2376 mmix_output_octa (stream
, value
, 0);
2380 /* Output pertinent parts of the 4-wyde sequence.
2381 Still more to do if we want this to be optimal, but hey...
2382 Note that the zero case has been handled above. */
2383 for (i
= 0; i
< 4 && value
!= 0; i
++)
2387 fprintf (stream
, "%s%s%s %s,#%x", line_begin
, op
,
2388 higher_parts
[i
], reg_names
[regno
],
2389 (int) (value
& 65535));
2390 /* The first one sets the rest of the bits to 0, the next
2391 ones add set bits. */
2393 line_begin
= "\n\t";
2402 fprintf (stream
, "\n");
2405 /* Return 1 if value is 0..65535*2**(16*N) for N=0..3.
2409 mmix_shiftable_wyde_value (uint64_t value
)
2411 /* Shift by 16 bits per group, stop when we've found two groups with
2414 int has_candidate
= 0;
2416 for (i
= 0; i
< 4; i
++)
2432 /* X and Y are two things to compare using CODE. Return the rtx for
2433 the cc-reg in the proper mode. */
2436 mmix_gen_compare_reg (RTX_CODE code
, rtx x
, rtx y
)
2438 enum machine_mode ccmode
= SELECT_CC_MODE (code
, x
, y
);
2439 return gen_reg_rtx (ccmode
);
2442 /* Local (static) helper functions. */
2445 mmix_emit_sp_add (HOST_WIDE_INT offset
)
2451 /* Negative stack-pointer adjustments are allocations and appear in
2452 the prologue only. We mark them as frame-related so unwind and
2453 debug info is properly emitted for them. */
2455 insn
= emit_insn (gen_adddi3 (stack_pointer_rtx
,
2460 rtx tmpr
= gen_rtx_REG (DImode
, 255);
2461 RTX_FRAME_RELATED_P (emit_move_insn (tmpr
, GEN_INT (offset
))) = 1;
2462 insn
= emit_insn (gen_adddi3 (stack_pointer_rtx
,
2463 stack_pointer_rtx
, tmpr
));
2465 RTX_FRAME_RELATED_P (insn
) = 1;
2469 /* Positive adjustments are in the epilogue only. Don't mark them
2470 as "frame-related" for unwind info. */
2471 if (insn_const_int_ok_for_constraint (offset
, CONSTRAINT_L
))
2472 emit_insn (gen_adddi3 (stack_pointer_rtx
,
2477 rtx tmpr
= gen_rtx_REG (DImode
, 255);
2478 emit_move_insn (tmpr
, GEN_INT (offset
));
2479 insn
= emit_insn (gen_adddi3 (stack_pointer_rtx
,
2480 stack_pointer_rtx
, tmpr
));
2485 /* Print operator suitable for doing something with a shiftable
2486 wyde. The type of operator is passed as an asm output modifier. */
2489 mmix_output_shiftvalue_op_from_str (FILE *stream
,
2493 static const char *const op_part
[] = {"L", "ML", "MH", "H"};
2496 if (! mmix_shiftable_wyde_value (value
))
2498 char s
[sizeof ("0xffffffffffffffff")];
2499 sprintf (s
, "%#"PRIx64
, value
);
2500 internal_error ("MMIX Internal: %s is not a shiftable int", s
);
2503 for (i
= 0; i
< 4; i
++)
2505 /* We know we're through when we find one-bits in the low
2509 fprintf (stream
, "%s%s", mainop
, op_part
[i
]);
2515 /* No bits set? Then it must have been zero. */
2516 fprintf (stream
, "%sL", mainop
);
2519 /* Print a 64-bit value, optionally prefixed by assembly pseudo. */
2522 mmix_output_octa (FILE *stream
, int64_t value
, int do_begin_end
)
2525 fprintf (stream
, "\tOCTA ");
2527 /* Provide a few alternative output formats depending on the number, to
2528 improve legibility of assembler output. */
2529 if ((value
< (int64_t) 0 && value
> (int64_t) -10000)
2530 || (value
>= (int64_t) 0 && value
<= (int64_t) 16384))
2531 fprintf (stream
, "%d", (int) value
);
2532 else if (value
> (int64_t) 0
2533 && value
< ((int64_t) 1 << 31) * 2)
2534 fprintf (stream
, "#%x", (unsigned int) value
);
2535 else if (sizeof (HOST_WIDE_INT
) == sizeof (int64_t))
2536 /* We need to avoid the not-so-universal "0x" prefix; we need the
2537 pure hex-digits together with the mmixal "#" hex prefix. */
2538 fprintf (stream
, "#" HOST_WIDE_INT_PRINT_HEX_PURE
,
2539 (HOST_WIDE_INT
) value
);
2540 else /* Need to avoid the hex output; there's no ...WIDEST...HEX_PURE. */
2541 fprintf (stream
, "%"PRIu64
, value
);
2544 fprintf (stream
, "\n");
2547 /* Print the presumed shiftable wyde argument shifted into place (to
2548 be output with an operand). */
2551 mmix_output_shifted_value (FILE *stream
, int64_t value
)
2555 if (! mmix_shiftable_wyde_value (value
))
2558 sprintf (s
, "%#"PRIx64
, value
);
2559 internal_error ("MMIX Internal: %s is not a shiftable int", s
);
2562 for (i
= 0; i
< 4; i
++)
2564 /* We know we're through when we find one-bits in the low 16 bits. */
2567 fprintf (stream
, "#%x", (int) (value
& 0xffff));
2574 /* No bits set? Then it must have been zero. */
2575 fprintf (stream
, "0");
2578 /* Output an MMIX condition name corresponding to an operator
2580 (comparison_operator [(comparison_operator ...) (const_int 0)])
2581 which means we have to look at *two* operators.
2583 The argument "reversed" refers to reversal of the condition (not the
2584 same as swapping the arguments). */
2587 mmix_output_condition (FILE *stream
, const_rtx x
, int reversed
)
2593 /* The normal output cc-code. */
2594 const char *const normal
;
2596 /* The reversed cc-code, or NULL if invalid. */
2597 const char *const reversed
;
2602 enum machine_mode cc_mode
;
2604 /* Terminated with {UNKNOWN, NULL, NULL} */
2605 const struct cc_conv
*const convs
;
2609 #define CCEND {UNKNOWN, NULL, NULL}
2611 static const struct cc_conv cc_fun_convs
[]
2612 = {{ORDERED
, "Z", "P"},
2613 {UNORDERED
, "P", "Z"},
2615 static const struct cc_conv cc_fp_convs
[]
2619 static const struct cc_conv cc_fpeq_convs
[]
2623 static const struct cc_conv cc_uns_convs
[]
2624 = {{GEU
, "NN", "N"},
2629 static const struct cc_conv cc_signed_convs
[]
2637 static const struct cc_conv cc_di_convs
[]
2649 static const struct cc_type_conv cc_convs
[]
2650 = {{CC_FUNmode
, cc_fun_convs
},
2651 {CC_FPmode
, cc_fp_convs
},
2652 {CC_FPEQmode
, cc_fpeq_convs
},
2653 {CC_UNSmode
, cc_uns_convs
},
2654 {CCmode
, cc_signed_convs
},
2655 {DImode
, cc_di_convs
}};
2660 enum machine_mode mode
= GET_MODE (XEXP (x
, 0));
2661 RTX_CODE cc
= GET_CODE (x
);
2663 for (i
= 0; i
< ARRAY_SIZE (cc_convs
); i
++)
2665 if (mode
== cc_convs
[i
].cc_mode
)
2667 for (j
= 0; cc_convs
[i
].convs
[j
].cc
!= UNKNOWN
; j
++)
2668 if (cc
== cc_convs
[i
].convs
[j
].cc
)
2671 = (reversed
? cc_convs
[i
].convs
[j
].reversed
2672 : cc_convs
[i
].convs
[j
].normal
);
2674 if (mmix_cc
== NULL
)
2675 fatal_insn ("MMIX Internal: Trying to output invalidly\
2676 reversed condition:", x
);
2678 fprintf (stream
, "%s", mmix_cc
);
2682 fatal_insn ("MMIX Internal: What's the CC of this?", x
);
2686 fatal_insn ("MMIX Internal: What is the CC of this?", x
);
2689 /* Return the bit-value for a const_int or const_double. */
2692 mmix_intval (const_rtx x
)
2694 if (GET_CODE (x
) == CONST_INT
)
2697 /* We make a little song and dance because converting to long long in
2698 gcc-2.7.2 is broken. I still want people to be able to use it for
2699 cross-compilation to MMIX. */
2700 if (GET_CODE (x
) == CONST_DOUBLE
&& GET_MODE (x
) == VOIDmode
)
2701 return CONST_DOUBLE_HIGH (x
);
2703 if (GET_CODE (x
) == CONST_DOUBLE
)
2705 REAL_VALUE_TYPE value
;
2707 /* FIXME: This macro is not in the manual but should be. */
2708 REAL_VALUE_FROM_CONST_DOUBLE (value
, x
);
2710 if (GET_MODE (x
) == DFmode
)
2714 REAL_VALUE_TO_TARGET_DOUBLE (value
, bits
);
2716 /* The double cast is necessary to avoid getting the long
2717 sign-extended to unsigned long long(!) when they're of
2718 different size (usually 32-bit hosts). */
2720 ((uint64_t) (unsigned long) bits
[0]
2722 | (uint64_t) (unsigned long) bits
[1];
2724 else if (GET_MODE (x
) == SFmode
)
2727 REAL_VALUE_TO_TARGET_SINGLE (value
, bits
);
2729 return (unsigned long) bits
;
2733 fatal_insn ("MMIX Internal: This is not a constant:", x
);
2736 /* Worker function for TARGET_PROMOTE_FUNCTION_MODE. */
2739 mmix_promote_function_mode (const_tree type ATTRIBUTE_UNUSED
,
2740 enum machine_mode mode
,
2741 int *punsignedp ATTRIBUTE_UNUSED
,
2742 const_tree fntype ATTRIBUTE_UNUSED
,
2745 /* Apparently not doing TRT if int < register-size. FIXME: Perhaps
2746 FUNCTION_VALUE and LIBCALL_VALUE needs tweaking as some ports say. */
2747 if (for_return
== 1)
2750 /* Promotion of modes currently generates slow code, extending before
2751 operation, so we do it only for arguments. */
2752 if (GET_MODE_CLASS (mode
) == MODE_INT
2753 && GET_MODE_SIZE (mode
) < 8)
2758 /* Worker function for TARGET_STRUCT_VALUE_RTX. */
2761 mmix_struct_value_rtx (tree fntype ATTRIBUTE_UNUSED
,
2762 int incoming ATTRIBUTE_UNUSED
)
2764 return gen_rtx_REG (Pmode
, MMIX_STRUCT_VALUE_REGNUM
);
2767 /* Worker function for TARGET_FRAME_POINTER_REQUIRED.
2769 FIXME: Is this requirement built-in? Anyway, we should try to get rid
2770 of it; we can deduce the value. */
2773 mmix_frame_pointer_required (void)
2775 return (cfun
->has_nonlocal_label
);
2780 * eval: (c-set-style "gnu")
2781 * indent-tabs-mode: t