1 /* Definitions of target machine for GNU compiler, for MMIX.
2 Copyright (C) 2000, 2001, 2002 Free Software Foundation, Inc.
3 Contributed by Hans-Peter Nilsson (hp@bitrange.com)
5 This file is part of GNU CC.
7 GNU CC 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 2, or (at your option)
12 GNU CC 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 GNU CC; see the file COPYING. If not, write to
19 the Free Software Foundation, 59 Temple Place - Suite 330,
20 Boston, MA 02111-1307, USA. */
26 #include "hard-reg-set.h"
28 #include "insn-config.h"
40 #include "integrate.h"
42 #include "target-def.h"
45 /* First some local helper definitions. */
46 #define MMIX_FIRST_GLOBAL_REGNUM 32
48 /* We'd need a current_function_has_landing_pad. It's marked as such when
49 a nonlocal_goto_receiver is expanded. Not just a C++ thing, but
51 #define MMIX_CFUN_HAS_LANDING_PAD (cfun->machine->has_landing_pad != 0)
53 /* We have no means to tell DWARF 2 about the register stack, so we need
54 to store the return address on the stack if an exception can get into
55 this function. FIXME: Narrow condition. */
56 #define MMIX_CFUN_NEEDS_SAVED_EH_RETURN_ADDRESS \
57 (flag_exceptions && ! leaf_function_p ())
59 #define IS_MMIX_EH_RETURN_DATA_REG(REGNO) \
60 (current_function_calls_eh_return \
61 && (EH_RETURN_DATA_REGNO (0) == REGNO \
62 || EH_RETURN_DATA_REGNO (1) == REGNO \
63 || EH_RETURN_DATA_REGNO (2) == REGNO \
64 || EH_RETURN_DATA_REGNO (3) == REGNO))
66 /* For the default ABI, we rename registers at output-time to fill the gap
67 between the (statically partitioned) saved registers and call-clobbered
68 registers. In effect this makes unused call-saved registers to be used
69 as call-clobbered registers. The benefit comes from keeping the number
70 of local registers (value of rL) low, since there's a cost of
71 increasing rL and clearing unused (unset) registers with lower numbers. */
72 #define MMIX_OUTPUT_REGNO(N) \
74 || (int) (N) < MMIX_RETURN_VALUE_REGNUM \
75 || (int) (N) > MMIX_LAST_STACK_REGISTER_REGNUM \
76 ? (N) : ((N) - MMIX_RETURN_VALUE_REGNUM \
77 + cfun->machine->highest_saved_stack_register + 1))
79 /* The canonical saved comparison operands for non-cc0 machines, set in
80 the compare expander. */
84 /* We ignore some options with arguments. They are passed to the linker,
85 but also ends up here because they start with "-m". We tell the driver
86 to store them in a variable we don't inspect. */
87 const char *mmix_cc1_ignored_option
;
89 /* Declarations of locals. */
91 /* Intermediate for insn output. */
92 static int mmix_output_destination_register
;
94 static void mmix_output_shiftvalue_op_from_str
95 PARAMS ((FILE *, const char *, HOST_WIDEST_INT
));
96 static void mmix_output_shifted_value
PARAMS ((FILE *, HOST_WIDEST_INT
));
97 static void mmix_output_condition
PARAMS ((FILE *, rtx
, int));
98 static HOST_WIDEST_INT mmix_intval
PARAMS ((rtx
));
99 static void mmix_output_octa
PARAMS ((FILE *, HOST_WIDEST_INT
, int));
100 static bool mmix_assemble_integer
PARAMS ((rtx
, unsigned int, int));
101 static struct machine_function
* mmix_init_machine_status
PARAMS ((void));
102 static void mmix_encode_section_info
PARAMS ((tree
, int));
103 static const char *mmix_strip_name_encoding
PARAMS ((const char *));
105 extern void mmix_target_asm_function_prologue
106 PARAMS ((FILE *, HOST_WIDE_INT
));
107 extern void mmix_target_asm_function_epilogue
108 PARAMS ((FILE *, HOST_WIDE_INT
));
111 /* Target structure macros. Listed by node. See `Using and Porting GCC'
112 for a general description. */
114 /* Node: Function Entry */
116 #undef TARGET_ASM_BYTE_OP
117 #define TARGET_ASM_BYTE_OP NULL
118 #undef TARGET_ASM_ALIGNED_HI_OP
119 #define TARGET_ASM_ALIGNED_HI_OP NULL
120 #undef TARGET_ASM_ALIGNED_SI_OP
121 #define TARGET_ASM_ALIGNED_SI_OP NULL
122 #undef TARGET_ASM_ALIGNED_DI_OP
123 #define TARGET_ASM_ALIGNED_DI_OP NULL
124 #undef TARGET_ASM_INTEGER
125 #define TARGET_ASM_INTEGER mmix_assemble_integer
127 #undef TARGET_ASM_FUNCTION_PROLOGUE
128 #define TARGET_ASM_FUNCTION_PROLOGUE mmix_target_asm_function_prologue
130 #undef TARGET_ASM_FUNCTION_EPILOGUE
131 #define TARGET_ASM_FUNCTION_EPILOGUE mmix_target_asm_function_epilogue
133 #undef TARGET_ENCODE_SECTION_INFO
134 #define TARGET_ENCODE_SECTION_INFO mmix_encode_section_info
135 #undef TARGET_STRIP_NAME_ENCODING
136 #define TARGET_STRIP_NAME_ENCODING mmix_strip_name_encoding
138 struct gcc_target targetm
= TARGET_INITIALIZER
;
140 /* Functions that are expansions for target macros.
141 See Target Macros in `Using and Porting GCC'. */
143 /* OVERRIDE_OPTIONS. */
146 mmix_override_options ()
148 /* Should we err or should we warn? Hmm. At least we must neutralize
149 it. For example the wrong kind of case-tables will be generated with
150 PIC; we use absolute address items for mmixal compatibility. FIXME:
151 They could be relative if we just elide them to after all pertinent
155 warning ("-f%s not supported: ignored", (flag_pic
> 1) ? "PIC" : "pic");
160 /* INIT_EXPANDERS. */
163 mmix_init_expanders ()
165 init_machine_status
= mmix_init_machine_status
;
168 /* Set the per-function data. */
170 static struct machine_function
*
171 mmix_init_machine_status ()
173 return ggc_alloc_cleared (sizeof (struct machine_function
));
177 We have trouble getting the address of stuff that is located at other
178 than 32-bit alignments (GETA requirements), so try to give everything
179 at least 32-bit alignment. */
182 mmix_data_alignment (type
, basic_align
)
183 tree type ATTRIBUTE_UNUSED
;
186 if (basic_align
< 32)
192 /* CONSTANT_ALIGNMENT. */
195 mmix_constant_alignment (constant
, basic_align
)
196 tree constant ATTRIBUTE_UNUSED
;
199 if (basic_align
< 32)
205 /* LOCAL_ALIGNMENT. */
208 mmix_local_alignment (type
, basic_align
)
209 tree type ATTRIBUTE_UNUSED
;
212 if (basic_align
< 32)
218 /* CONDITIONAL_REGISTER_USAGE. */
221 mmix_conditional_register_usage ()
227 static const int gnu_abi_reg_alloc_order
[]
228 = MMIX_GNU_ABI_REG_ALLOC_ORDER
;
230 for (i
= 0; i
< FIRST_PSEUDO_REGISTER
; i
++)
231 reg_alloc_order
[i
] = gnu_abi_reg_alloc_order
[i
];
233 /* Change the default from the mmixware ABI. For the GNU ABI,
234 $15..$30 are call-saved just as $0..$14. There must be one
235 call-clobbered local register for the "hole" describing number of
236 saved local registers saved by PUSHJ/PUSHGO during the function
237 call, receiving the return value at return. So best is to use
238 the highest, $31. It's already marked call-clobbered for the
240 for (i
= 15; i
<= 30; i
++)
241 call_used_regs
[i
] = 0;
243 /* "Unfix" the parameter registers. */
244 for (i
= MMIX_RESERVED_GNU_ARG_0_REGNUM
;
245 i
< MMIX_RESERVED_GNU_ARG_0_REGNUM
+ MMIX_MAX_ARGS_IN_REGS
;
250 /* Step over the ":" in special register names. */
251 if (! TARGET_TOPLEVEL_SYMBOLS
)
252 for (i
= 0; i
< FIRST_PSEUDO_REGISTER
; i
++)
253 if (reg_names
[i
][0] == ':')
257 /* PREFERRED_RELOAD_CLASS.
258 We need to extend the reload class of REMAINDER_REG and HIMULT_REG. */
261 mmix_preferred_reload_class (x
, class)
262 rtx x ATTRIBUTE_UNUSED
;
263 enum reg_class
class;
265 /* FIXME: Revisit. */
266 return GET_CODE (x
) == MOD
&& GET_MODE (x
) == DImode
267 ? REMAINDER_REG
: class;
270 /* PREFERRED_OUTPUT_RELOAD_CLASS.
271 We need to extend the reload class of REMAINDER_REG and HIMULT_REG. */
274 mmix_preferred_output_reload_class (x
, class)
275 rtx x ATTRIBUTE_UNUSED
;
276 enum reg_class
class;
278 /* FIXME: Revisit. */
279 return GET_CODE (x
) == MOD
&& GET_MODE (x
) == DImode
280 ? REMAINDER_REG
: class;
283 /* SECONDARY_RELOAD_CLASS.
284 We need to reload regs of REMAINDER_REG and HIMULT_REG elsewhere. */
287 mmix_secondary_reload_class (class, mode
, x
, in_p
)
288 enum reg_class
class;
289 enum machine_mode mode ATTRIBUTE_UNUSED
;
290 rtx x ATTRIBUTE_UNUSED
;
291 int in_p ATTRIBUTE_UNUSED
;
293 if (class == REMAINDER_REG
294 || class == HIMULT_REG
295 || class == SYSTEM_REGS
)
301 /* CONST_OK_FOR_LETTER_P. */
304 mmix_const_ok_for_letter_p (value
, c
)
309 (c
== 'I' ? value
>= 0 && value
<= 255
310 : c
== 'J' ? value
>= 0 && value
<= 65535
311 : c
== 'K' ? value
<= 0 && value
>= -255
312 : c
== 'L' ? mmix_shiftable_wyde_value (value
)
313 : c
== 'M' ? value
== 0
314 : c
== 'N' ? mmix_shiftable_wyde_value (~value
)
315 : c
== 'O' ? (value
== 3 || value
== 5 || value
== 9
320 /* CONST_DOUBLE_OK_FOR_LETTER_P. */
323 mmix_const_double_ok_for_letter_p (value
, c
)
328 (c
== 'G' ? value
== CONST0_RTX (GET_MODE (value
))
333 We need this since our constants are not always expressible as
334 CONST_INT:s, but rather often as CONST_DOUBLE:s. */
337 mmix_extra_constraint (x
, c
, strict
)
342 HOST_WIDEST_INT value
;
344 /* When checking for an address, we need to handle strict vs. non-strict
345 register checks. Don't use address_operand, but instead its
346 equivalent (its callee, which it is just a wrapper for),
347 memory_operand_p and the strict-equivalent strict_memory_address_p. */
351 ? strict_memory_address_p (Pmode
, x
)
352 : memory_address_p (Pmode
, x
);
354 /* R asks whether x is to be loaded with GETA or something else. Right
355 now, only a SYMBOL_REF and LABEL_REF can fit for
356 TARGET_BASE_ADDRESSES.
358 Only constant symbolic addresses apply. With TARGET_BASE_ADDRESSES,
359 we just allow straight LABEL_REF or SYMBOL_REFs with SYMBOL_REF_FLAG
360 set right now; only function addresses and code labels. If we change
361 to let SYMBOL_REF_FLAG be set on other symbols, we have to check
362 inside CONST expressions. When TARGET_BASE_ADDRESSES is not in
363 effect, a "raw" constant check together with mmix_constant_address_p
364 is all that's needed; we want all constant addresses to be loaded
368 GET_CODE (x
) != CONST_INT
&& GET_CODE (x
) != CONST_DOUBLE
369 && mmix_constant_address_p (x
)
370 && (! TARGET_BASE_ADDRESSES
371 || (GET_CODE (x
) == LABEL_REF
372 || (GET_CODE (x
) == SYMBOL_REF
&& SYMBOL_REF_FLAG (x
))));
374 if (GET_CODE (x
) != CONST_DOUBLE
|| GET_MODE (x
) != VOIDmode
)
377 value
= mmix_intval (x
);
379 /* We used to map Q->J, R->K, S->L, T->N, U->O, but we don't have to any
380 more ('U' taken for address_operand, 'R' similarly). Some letters map
381 outside of CONST_INT, though; we still use 'S' and 'T'. */
383 return mmix_shiftable_wyde_value (value
);
385 return mmix_shiftable_wyde_value (~value
);
389 /* DYNAMIC_CHAIN_ADDRESS. */
392 mmix_dynamic_chain_address (frame
)
395 /* FIXME: the frame-pointer is stored at offset -8 from the current
396 frame-pointer. Unfortunately, the caller assumes that a
397 frame-pointer is present for *all* previous frames. There should be
398 a way to say that that cannot be done, like for RETURN_ADDR_RTX. */
399 return plus_constant (frame
, -8);
402 /* STARTING_FRAME_OFFSET. */
405 mmix_starting_frame_offset ()
407 /* The old frame pointer is in the slot below the new one, so
408 FIRST_PARM_OFFSET does not need to depend on whether the
409 frame-pointer is needed or not. We have to adjust for the register
410 stack pointer being located below the saved frame pointer.
411 Similarly, we store the return address on the stack too, for
412 exception handling, and always if we save the register stack pointer. */
415 + (MMIX_CFUN_HAS_LANDING_PAD
416 ? -16 : (MMIX_CFUN_NEEDS_SAVED_EH_RETURN_ADDRESS
? -8 : 0)));
419 /* RETURN_ADDR_RTX. */
422 mmix_return_addr_rtx (count
, frame
)
424 rtx frame ATTRIBUTE_UNUSED
;
427 ? (MMIX_CFUN_NEEDS_SAVED_EH_RETURN_ADDRESS
428 /* FIXME: Set frame_alias_set on the following. (Why?)
429 See mmix_initial_elimination_offset for the reason we can't use
430 get_hard_reg_initial_val for both. Always using a stack slot
431 and not a register would be suboptimal. */
432 ? validize_mem (gen_rtx_MEM (Pmode
, plus_constant (frame_pointer_rtx
, -16)))
433 : get_hard_reg_initial_val (Pmode
, MMIX_INCOMING_RETURN_ADDRESS_REGNUM
))
437 /* SETUP_FRAME_ADDRESSES. */
440 mmix_setup_frame_addresses ()
442 /* Nothing needed at the moment. */
445 /* The difference between the (imaginary) frame pointer and the stack
446 pointer. Used to eliminate the frame pointer. */
449 mmix_initial_elimination_offset (fromreg
, toreg
)
455 = (get_frame_size () + current_function_outgoing_args_size
+ 7) & ~7;
457 /* There is no actual offset between these two virtual values, but for
458 the frame-pointer, we have the old one in the stack position below
459 it, so the offset for the frame-pointer to the stack-pointer is one
461 if (fromreg
== MMIX_ARG_POINTER_REGNUM
462 && toreg
== MMIX_FRAME_POINTER_REGNUM
)
465 /* The difference is the size of local variables plus the size of
466 outgoing function arguments that would normally be passed as
467 registers but must be passed on stack because we're out of
468 function-argument registers. Only global saved registers are
469 counted; the others go on the register stack.
471 The frame-pointer is counted too if it is what is eliminated, as we
472 need to balance the offset for it from STARTING_FRAME_OFFSET.
474 Also add in the slot for the register stack pointer we save if we
477 Unfortunately, we can't access $0..$14, from unwinder code easily, so
478 store the return address in a frame slot too. FIXME: Only for
479 non-leaf functions. FIXME: Always with a landing pad, because it's
480 hard to know whether we need the other at the time we know we need
481 the offset for one (and have to state it). It's a kludge until we
482 can express the register stack in the EH frame info.
484 We have to do alignment here; get_frame_size will not return a
485 multiple of STACK_BOUNDARY. FIXME: Add note in manual. */
487 for (regno
= MMIX_FIRST_GLOBAL_REGNUM
;
490 if ((regs_ever_live
[regno
] && ! call_used_regs
[regno
])
491 || IS_MMIX_EH_RETURN_DATA_REG (regno
))
495 + (MMIX_CFUN_HAS_LANDING_PAD
496 ? 16 : (MMIX_CFUN_NEEDS_SAVED_EH_RETURN_ADDRESS
? 8 : 0))
497 + (fromreg
== MMIX_ARG_POINTER_REGNUM
? 0 : 8);
500 /* Return an rtx for a function argument to go in a register, and 0 for
501 one that must go on stack. */
504 mmix_function_arg (argsp
, mode
, type
, named
, incoming
)
505 const CUMULATIVE_ARGS
* argsp
;
506 enum machine_mode mode
;
508 int named ATTRIBUTE_UNUSED
;
511 /* Handling of the positional dummy parameter for varargs gets nasty.
512 Check execute/991216-3 and function.c:assign_params. We have to say
513 that the dummy parameter goes on stack in order to get the correct
514 offset when va_start and va_arg is applied. FIXME: Should do TRT by
515 itself in the gcc core. */
516 if ((! named
&& incoming
&& current_function_varargs
) || argsp
->now_varargs
)
519 /* Last-argument marker. */
520 if (type
== void_type_node
)
521 return (argsp
->regs
< MMIX_MAX_ARGS_IN_REGS
)
524 ? MMIX_FIRST_INCOMING_ARG_REGNUM
525 : MMIX_FIRST_ARG_REGNUM
) + argsp
->regs
)
528 return (argsp
->regs
< MMIX_MAX_ARGS_IN_REGS
529 && !MUST_PASS_IN_STACK (mode
, type
)
530 && (GET_MODE_BITSIZE (mode
) <= 64
535 ? MMIX_FIRST_INCOMING_ARG_REGNUM
536 : MMIX_FIRST_ARG_REGNUM
)
541 /* Returns nonzero for everything that goes by reference, 0 for
542 everything that goes by value. */
545 mmix_function_arg_pass_by_reference (argsp
, mode
, type
, named
)
546 const CUMULATIVE_ARGS
* argsp
;
547 enum machine_mode mode
;
549 int named ATTRIBUTE_UNUSED
;
551 /* FIXME: Check: I'm not sure the MUST_PASS_IN_STACK check is
554 MUST_PASS_IN_STACK (mode
, type
)
555 || (MMIX_FUNCTION_ARG_SIZE (mode
, type
) > 8
560 /* Return nonzero if regno is a register number where a parameter is
561 passed, and 0 otherwise. */
564 mmix_function_arg_regno_p (regno
, incoming
)
569 = incoming
? MMIX_FIRST_INCOMING_ARG_REGNUM
: MMIX_FIRST_ARG_REGNUM
;
571 return regno
>= first_arg_regnum
572 && regno
< first_arg_regnum
+ MMIX_MAX_ARGS_IN_REGS
;
575 /* FUNCTION_OUTGOING_VALUE. */
578 mmix_function_outgoing_value (valtype
, func
)
580 tree func ATTRIBUTE_UNUSED
;
582 enum machine_mode mode
= TYPE_MODE (valtype
);
583 enum machine_mode cmode
;
584 int first_val_regnum
= MMIX_OUTGOING_RETURN_VALUE_REGNUM
;
585 rtx vec
[MMIX_MAX_REGS_FOR_VALUE
];
589 /* Return values that fit in a register need no special handling.
590 There's no register hole when parameters are passed in global
593 || GET_MODE_BITSIZE (mode
) <= BITS_PER_WORD
)
595 gen_rtx_REG (mode
, MMIX_OUTGOING_RETURN_VALUE_REGNUM
);
597 /* A complex type, made up of components. */
598 cmode
= TYPE_MODE (TREE_TYPE (valtype
));
599 nregs
= ((GET_MODE_BITSIZE (mode
) + BITS_PER_WORD
- 1) / BITS_PER_WORD
);
601 /* We need to take care of the effect of the register hole on return
602 values of large sizes; the last register will appear as the first
603 register, with the rest shifted. (For complex modes, this is just
604 swapped registers.) */
606 if (nregs
> MMIX_MAX_REGS_FOR_VALUE
)
607 internal_error ("too large function value type, needs %d registers,\
608 have only %d registers for this", nregs
, MMIX_MAX_REGS_FOR_VALUE
);
610 /* FIXME: Maybe we should handle structure values like this too
611 (adjusted for BLKmode), perhaps for both ABI:s. */
612 for (i
= 0; i
< nregs
- 1; i
++)
614 = gen_rtx_EXPR_LIST (VOIDmode
,
615 gen_rtx_REG (cmode
, first_val_regnum
+ i
),
616 GEN_INT ((i
+ 1) * BITS_PER_UNIT
));
619 = gen_rtx_EXPR_LIST (VOIDmode
,
620 gen_rtx_REG (cmode
, first_val_regnum
+ nregs
- 1),
623 return gen_rtx_PARALLEL (VOIDmode
, gen_rtvec_v (nregs
, vec
));
626 /* EH_RETURN_DATA_REGNO. */
629 mmix_eh_return_data_regno (n
)
630 int n ATTRIBUTE_UNUSED
;
633 return MMIX_EH_RETURN_DATA_REGNO_START
+ n
;
635 return INVALID_REGNUM
;
638 /* EH_RETURN_STACKADJ_RTX. */
641 mmix_eh_return_stackadj_rtx ()
643 return gen_rtx_REG (Pmode
, MMIX_EH_RETURN_STACKADJ_REGNUM
);
646 /* EH_RETURN_HANDLER_RTX. */
649 mmix_eh_return_handler_rtx ()
652 gen_rtx_REG (Pmode
, MMIX_INCOMING_RETURN_ADDRESS_REGNUM
);
655 /* ASM_PREFERRED_EH_DATA_FORMAT. */
658 mmix_asm_preferred_eh_data_format (code
, global
)
659 int code ATTRIBUTE_UNUSED
;
660 int global ATTRIBUTE_UNUSED
;
662 /* This is the default (was at 2001-07-20). Revisit when needed. */
663 return DW_EH_PE_absptr
;
666 /* Emit the function prologue. For simplicity while the port is still
667 in a flux, we do it as text rather than the now preferred RTL way,
668 as (define_insn "function_prologue").
670 FIXME: Translate to RTL and/or optimize some of the DWARF 2 stuff. */
673 mmix_target_asm_function_prologue (stream
, locals_size
)
675 HOST_WIDE_INT locals_size
;
678 int stack_space_to_allocate
679 = (current_function_outgoing_args_size
680 + current_function_pretend_args_size
681 + (int) locals_size
+ 7) & ~7;
683 int doing_dwarf
= dwarf2out_do_frame ();
686 /* Guard our assumptions. Very low priority FIXME. */
687 if (locals_size
!= (int) locals_size
)
688 error ("stack frame too big");
690 /* Add room needed to save global non-register-stack registers. */
692 regno
>= MMIX_FIRST_GLOBAL_REGNUM
;
694 /* Note that we assume that the frame-pointer-register is one of these
695 registers, in which case we don't count it here. */
696 if ((((regno
!= MMIX_FRAME_POINTER_REGNUM
|| !frame_pointer_needed
)
697 && regs_ever_live
[regno
] && !call_used_regs
[regno
]))
698 || IS_MMIX_EH_RETURN_DATA_REG (regno
))
699 stack_space_to_allocate
+= 8;
701 /* If we do have a frame-pointer, add room for it. */
702 if (frame_pointer_needed
)
703 stack_space_to_allocate
+= 8;
705 /* If we have a non-local label, we need to be able to unwind to it, so
706 store the current register stack pointer. Also store the return
707 address if we do that. */
708 if (MMIX_CFUN_HAS_LANDING_PAD
)
709 stack_space_to_allocate
+= 16;
710 else if (MMIX_CFUN_NEEDS_SAVED_EH_RETURN_ADDRESS
)
711 /* If we do have a saved return-address slot, add room for it. */
712 stack_space_to_allocate
+= 8;
714 /* Make sure we don't get an unaligned stack. */
715 if ((stack_space_to_allocate
% 8) != 0)
716 internal_error ("stack frame not a multiple of 8 bytes: %d",
717 stack_space_to_allocate
);
719 if (current_function_pretend_args_size
)
721 int mmix_first_vararg_reg
722 = (MMIX_FIRST_INCOMING_ARG_REGNUM
723 + (MMIX_MAX_ARGS_IN_REGS
724 - current_function_pretend_args_size
/ 8));
727 = MMIX_FIRST_INCOMING_ARG_REGNUM
+ MMIX_MAX_ARGS_IN_REGS
- 1;
728 regno
>= mmix_first_vararg_reg
;
734 = stack_space_to_allocate
> (256 - 8)
735 ? (256 - 8) : stack_space_to_allocate
;
737 fprintf (stream
, "\tSUBU %s,%s,%d\n",
738 reg_names
[MMIX_STACK_POINTER_REGNUM
],
739 reg_names
[MMIX_STACK_POINTER_REGNUM
],
744 /* Each call to dwarf2out_def_cfa overrides the previous
745 setting; they don't accumulate. We must keep track
746 of the offset ourselves. */
747 cfa_offset
+= stack_chunk
;
748 if (!frame_pointer_needed
)
749 dwarf2out_def_cfa ("", MMIX_STACK_POINTER_REGNUM
,
752 offset
+= stack_chunk
;
753 stack_space_to_allocate
-= stack_chunk
;
756 fprintf (stream
, "\tSTOU %s,%s,%d\n", reg_names
[regno
],
757 reg_names
[MMIX_STACK_POINTER_REGNUM
],
760 /* These registers aren't actually saved (as in "will be
761 restored"), so don't tell DWARF2 they're saved. */
767 /* Store the frame-pointer. */
769 if (frame_pointer_needed
)
773 /* Get 8 less than otherwise, since we need to reach offset + 8. */
775 = stack_space_to_allocate
> (256 - 8 - 8)
776 ? (256 - 8 - 8) : stack_space_to_allocate
;
778 fprintf (stream
, "\tSUBU %s,%s,%d\n",
779 reg_names
[MMIX_STACK_POINTER_REGNUM
],
780 reg_names
[MMIX_STACK_POINTER_REGNUM
],
783 cfa_offset
+= stack_chunk
;
784 offset
+= stack_chunk
;
785 stack_space_to_allocate
-= stack_chunk
;
788 fprintf (stream
, "\tSTOU %s,%s,%d\n\tADDU %s,%s,%d\n",
789 reg_names
[MMIX_FRAME_POINTER_REGNUM
],
790 reg_names
[MMIX_STACK_POINTER_REGNUM
],
792 reg_names
[MMIX_FRAME_POINTER_REGNUM
],
793 reg_names
[MMIX_STACK_POINTER_REGNUM
],
797 /* If we're using the frame-pointer, then we just need this CFA
798 definition basing on that value (often equal to the CFA).
799 Further changes to the stack-pointer do not affect the
800 frame-pointer, so we conditionalize them below on
801 !frame_pointer_needed. */
802 dwarf2out_def_cfa ("", MMIX_FRAME_POINTER_REGNUM
,
803 -cfa_offset
+ offset
+ 8);
805 dwarf2out_reg_save ("", MMIX_FRAME_POINTER_REGNUM
,
806 -cfa_offset
+ offset
);
812 if (MMIX_CFUN_NEEDS_SAVED_EH_RETURN_ADDRESS
)
814 /* Store the return-address, if one is needed on the stack. We
815 usually store it in a register when needed, but that doesn't work
816 with -fexceptions. */
820 /* Get 8 less than otherwise, since we need to reach offset + 8. */
822 = stack_space_to_allocate
> (256 - 8 - 8)
823 ? (256 - 8 - 8) : stack_space_to_allocate
;
825 fprintf (stream
, "\tSUBU %s,%s,%d\n",
826 reg_names
[MMIX_STACK_POINTER_REGNUM
],
827 reg_names
[MMIX_STACK_POINTER_REGNUM
],
831 cfa_offset
+= stack_chunk
;
832 if (!frame_pointer_needed
)
833 dwarf2out_def_cfa ("", MMIX_STACK_POINTER_REGNUM
,
836 offset
+= stack_chunk
;
837 stack_space_to_allocate
-= stack_chunk
;
840 fprintf (stream
, "\tGET $255,rJ\n\tSTOU $255,%s,%d\n",
841 reg_names
[MMIX_STACK_POINTER_REGNUM
],
844 dwarf2out_return_save ("", -cfa_offset
+ offset
);
847 else if (MMIX_CFUN_HAS_LANDING_PAD
)
850 if (MMIX_CFUN_HAS_LANDING_PAD
)
852 /* Store the register defining the numbering of local registers, so
853 we know how long to unwind the register stack. */
857 /* Get 8 less than otherwise, since we need to reach offset + 8. */
859 = stack_space_to_allocate
> (256 - 8 - 8)
860 ? (256 - 8 - 8) : stack_space_to_allocate
;
862 fprintf (stream
, "\tSUBU %s,%s,%d\n",
863 reg_names
[MMIX_STACK_POINTER_REGNUM
],
864 reg_names
[MMIX_STACK_POINTER_REGNUM
],
866 offset
+= stack_chunk
;
867 stack_space_to_allocate
-= stack_chunk
;
871 cfa_offset
+= stack_chunk
;
872 if (!frame_pointer_needed
)
873 dwarf2out_def_cfa ("", MMIX_STACK_POINTER_REGNUM
,
878 /* We don't tell dwarf2 about this one; we just have it to unwind
879 the register stack at landing pads. FIXME: It's a kludge because
880 we can't describe the effect of the PUSHJ and PUSHGO insns on the
881 register stack at the moment. Best thing would be to handle it
882 like stack-pointer offsets. Better: some hook into dwarf2out.c
883 to produce DW_CFA_expression:s that specify the increment of rO,
884 and unwind it at eh_return (preferred) or at the landing pad.
885 Then saves to $0..$G-1 could be specified through that register. */
887 fprintf (stream
, "\tGET $255,rO\n\tSTOU $255,%s,%d\n",
888 reg_names
[MMIX_STACK_POINTER_REGNUM
], offset
);
893 /* After the return-address and the frame-pointer, we have the local
894 variables. They're the ones that may have an "unaligned" size. */
895 offset
-= (locals_size
+ 7) & ~7;
897 /* Now store all registers that are global, i.e. not saved by the
898 register file machinery.
900 It is assumed that the frame-pointer is one of these registers, so it
901 is explicitly excluded in the count. */
904 regno
>= MMIX_FIRST_GLOBAL_REGNUM
;
906 if (((regno
!= MMIX_FRAME_POINTER_REGNUM
|| !frame_pointer_needed
)
907 && regs_ever_live
[regno
] && ! call_used_regs
[regno
])
908 || IS_MMIX_EH_RETURN_DATA_REG (regno
))
914 /* Since the local variables go above, we may get a large
918 /* We're not going to access the locals area in the
919 prologue, so we'll just silently subtract the slab we
922 stack_space_to_allocate
> (256 - offset
- 8)
923 ? (256 - offset
- 8) : stack_space_to_allocate
;
925 mmix_output_register_setting (stream
, 255, stack_chunk
, 1);
926 fprintf (stream
, "\tSUBU %s,%s,$255\n",
927 reg_names
[MMIX_STACK_POINTER_REGNUM
],
928 reg_names
[MMIX_STACK_POINTER_REGNUM
]);
932 cfa_offset
+= stack_chunk
;
933 if (!frame_pointer_needed
)
934 dwarf2out_def_cfa ("", MMIX_STACK_POINTER_REGNUM
,
940 stack_chunk
= stack_space_to_allocate
> (256 - 8)
941 ? (256 - 8) : stack_space_to_allocate
;
943 fprintf (stream
, "\tSUBU %s,%s,%d\n",
944 reg_names
[MMIX_STACK_POINTER_REGNUM
],
945 reg_names
[MMIX_STACK_POINTER_REGNUM
], stack_chunk
);
948 cfa_offset
+= stack_chunk
;
949 if (!frame_pointer_needed
)
950 dwarf2out_def_cfa ("", MMIX_STACK_POINTER_REGNUM
,
955 offset
+= stack_chunk
;
956 stack_space_to_allocate
-= stack_chunk
;
959 fprintf (stream
, "\tSTOU %s,%s,%d\n", reg_names
[regno
],
960 reg_names
[MMIX_STACK_POINTER_REGNUM
], offset
);
962 dwarf2out_reg_save ("", regno
, -cfa_offset
+ offset
);
966 /* Finally, allocate room for outgoing args and local vars if room
967 wasn't allocated above. This might be any number of bytes (well, we
968 assume it fits in a host-int). */
969 if (stack_space_to_allocate
)
971 if (stack_space_to_allocate
< 256)
973 fprintf (stream
, "\tSUBU %s,%s,%d\n",
974 reg_names
[MMIX_STACK_POINTER_REGNUM
],
975 reg_names
[MMIX_STACK_POINTER_REGNUM
],
976 stack_space_to_allocate
);
980 mmix_output_register_setting (stream
, 255,
981 stack_space_to_allocate
, 1);
982 fprintf (stream
, "\tSUBU %s,%s,$255\n",
983 reg_names
[MMIX_STACK_POINTER_REGNUM
],
984 reg_names
[MMIX_STACK_POINTER_REGNUM
]);
989 cfa_offset
+= stack_space_to_allocate
;
990 if (!frame_pointer_needed
)
991 dwarf2out_def_cfa ("", MMIX_STACK_POINTER_REGNUM
,
997 /* MACHINE_DEPENDENT_REORG.
998 No actual rearrangements done here; just virtually by calculating the
999 highest saved stack register number used to modify the register numbers
1003 mmix_machine_dependent_reorg (first
)
1004 rtx first ATTRIBUTE_UNUSED
;
1008 /* We put the number of the highest saved register-file register in a
1009 location convenient for the call-patterns to output. Note that we
1010 don't tell dwarf2 about these registers, since it can't restore them
1012 for (regno
= MMIX_LAST_STACK_REGISTER_REGNUM
;
1015 if ((regs_ever_live
[regno
] && !call_used_regs
[regno
])
1016 || (regno
== MMIX_FRAME_POINTER_REGNUM
&& frame_pointer_needed
))
1019 /* Regardless of whether they're saved (they might be just read), we
1020 mustn't include registers that carry parameters. We could scan the
1021 insns to see whether they're actually used (and indeed do other less
1022 trivial register usage analysis and transformations), but it seems
1023 wasteful to optimize for unused parameter registers. As of
1024 2002-04-30, regs_ever_live[n] seems to be set for only-reads too, but
1025 that might change. */
1026 if (!TARGET_ABI_GNU
&& regno
< current_function_args_info
.regs
- 1)
1028 regno
= current_function_args_info
.regs
- 1;
1030 /* We don't want to let this cause us to go over the limit and make
1031 incoming parameter registers be misnumbered and treating the last
1032 parameter register and incoming return value register call-saved.
1033 Stop things at the unmodified scheme. */
1034 if (regno
> MMIX_RETURN_VALUE_REGNUM
- 1)
1035 regno
= MMIX_RETURN_VALUE_REGNUM
- 1;
1038 cfun
->machine
->highest_saved_stack_register
= regno
;
1041 /* TARGET_ASM_FUNCTION_EPILOGUE. */
1044 mmix_target_asm_function_epilogue (stream
, locals_size
)
1046 HOST_WIDE_INT locals_size
;
1050 int stack_space_to_deallocate
1051 = (current_function_outgoing_args_size
1052 + current_function_pretend_args_size
1053 + (int) locals_size
+ 7) & ~7;
1055 /* The assumption that locals_size fits in an int is asserted in
1056 mmix_target_asm_function_prologue. */
1058 /* The first address to access is beyond the outgoing_args area. */
1059 int offset
= current_function_outgoing_args_size
;
1061 /* Add the space for global non-register-stack registers.
1062 It is assumed that the frame-pointer register can be one of these
1063 registers, in which case it is excluded from the count when needed. */
1065 regno
>= MMIX_FIRST_GLOBAL_REGNUM
;
1067 if (((regno
!= MMIX_FRAME_POINTER_REGNUM
|| !frame_pointer_needed
)
1068 && regs_ever_live
[regno
] && !call_used_regs
[regno
])
1069 || IS_MMIX_EH_RETURN_DATA_REG (regno
))
1070 stack_space_to_deallocate
+= 8;
1072 /* Add in the space for register stack-pointer. If so, always add room
1073 for the saved PC. */
1074 if (MMIX_CFUN_HAS_LANDING_PAD
)
1075 stack_space_to_deallocate
+= 16;
1076 else if (MMIX_CFUN_NEEDS_SAVED_EH_RETURN_ADDRESS
)
1077 /* If we have a saved return-address slot, add it in. */
1078 stack_space_to_deallocate
+= 8;
1080 /* Add in the frame-pointer. */
1081 if (frame_pointer_needed
)
1082 stack_space_to_deallocate
+= 8;
1084 /* Make sure we don't get an unaligned stack. */
1085 if ((stack_space_to_deallocate
% 8) != 0)
1086 internal_error ("stack frame not a multiple of octabyte: %d",
1087 stack_space_to_deallocate
);
1089 /* We will add back small offsets to the stack pointer as we go.
1090 First, we restore all registers that are global, i.e. not saved by
1091 the register file machinery. */
1093 for (regno
= MMIX_FIRST_GLOBAL_REGNUM
;
1096 if (((regno
!= MMIX_FRAME_POINTER_REGNUM
|| !frame_pointer_needed
)
1097 && regs_ever_live
[regno
] && !call_used_regs
[regno
])
1098 || IS_MMIX_EH_RETURN_DATA_REG (regno
))
1104 /* There's better support for incrementing than
1105 decrementing, so we might be able to optimize this as
1107 mmix_output_register_setting (stream
, 255, offset
, 1);
1108 fprintf (stream
, "\tADDU %s,%s,$255\n",
1109 reg_names
[MMIX_STACK_POINTER_REGNUM
],
1110 reg_names
[MMIX_STACK_POINTER_REGNUM
]);
1113 fprintf (stream
, "\tINCL %s,%d\n",
1114 reg_names
[MMIX_STACK_POINTER_REGNUM
], offset
);
1116 stack_space_to_deallocate
-= offset
;
1120 fprintf (stream
, "\tLDOU %s,%s,%d\n",
1122 reg_names
[MMIX_STACK_POINTER_REGNUM
],
1127 /* Here is where the local variables were. As in the prologue, they
1128 might be of an unaligned size. */
1129 offset
+= (locals_size
+ 7) & ~7;
1132 /* The saved register stack pointer is just below the frame-pointer
1133 register. We don't need to restore it "manually"; the POP
1134 instruction does that. */
1135 if (MMIX_CFUN_HAS_LANDING_PAD
)
1137 else if (MMIX_CFUN_NEEDS_SAVED_EH_RETURN_ADDRESS
)
1138 /* The return-address slot is just below the frame-pointer register.
1139 We don't need to restore it because we don't really use it. */
1142 /* Get back the old frame-pointer-value. */
1143 if (frame_pointer_needed
)
1149 /* There's better support for incrementing than
1150 decrementing, so we might be able to optimize this as
1152 mmix_output_register_setting (stream
, 255, offset
, 1);
1153 fprintf (stream
, "\tADDU %s,%s,$255\n",
1154 reg_names
[MMIX_STACK_POINTER_REGNUM
],
1155 reg_names
[MMIX_STACK_POINTER_REGNUM
]);
1158 fprintf (stream
, "\tINCL %s,%d\n",
1159 reg_names
[MMIX_STACK_POINTER_REGNUM
], offset
);
1161 stack_space_to_deallocate
-= offset
;
1165 fprintf (stream
, "\tLDOU %s,%s,%d\n",
1166 reg_names
[MMIX_FRAME_POINTER_REGNUM
],
1167 reg_names
[MMIX_STACK_POINTER_REGNUM
],
1172 /* We do not need to restore pretended incoming args, just add back
1174 if (stack_space_to_deallocate
> 65535)
1176 /* There's better support for incrementing than decrementing, so
1177 we might be able to optimize this as we see a need. */
1178 mmix_output_register_setting (stream
, 255,
1179 stack_space_to_deallocate
, 1);
1180 fprintf (stream
, "\tADDU %s,%s,$255\n",
1181 reg_names
[MMIX_STACK_POINTER_REGNUM
],
1182 reg_names
[MMIX_STACK_POINTER_REGNUM
]);
1184 else if (stack_space_to_deallocate
!= 0)
1185 fprintf (stream
, "\tINCL %s,%d\n",
1186 reg_names
[MMIX_STACK_POINTER_REGNUM
],
1187 stack_space_to_deallocate
);
1189 if (current_function_calls_eh_return
)
1190 /* Adjustment the (normal) stack-pointer to that of the receiver.
1191 FIXME: It would be nice if we could also adjust the register stack
1192 here, but we need to express it through DWARF 2 too. */
1193 fprintf (stream
, "\tADDU %s,%s,%s\n",
1194 reg_names
[MMIX_STACK_POINTER_REGNUM
],
1195 reg_names
[MMIX_STACK_POINTER_REGNUM
],
1196 reg_names
[MMIX_EH_RETURN_STACKADJ_REGNUM
]);
1198 /* The extra \n is so we have a blank line between the assembly code of
1199 separate functions. */
1200 fprintf (stream
, "\tPOP %d,0\n\n",
1202 && current_function_return_rtx
!= NULL
1203 && ! current_function_returns_struct
)
1204 ? (GET_CODE (current_function_return_rtx
) == PARALLEL
1205 ? GET_NUM_ELEM (XVEC (current_function_return_rtx
, 0)) : 1)
1209 /* ASM_OUTPUT_MI_THUNK. */
1212 mmix_asm_output_mi_thunk (stream
, fndecl
, delta
, func
)
1214 tree fndecl ATTRIBUTE_UNUSED
;
1218 /* If you define STRUCT_VALUE to 0, rather than use STRUCT_VALUE_REGNUM,
1219 (i.e. pass location of structure to return as invisible first
1220 argument) you need to tweak this code too. */
1221 const char *regname
= reg_names
[MMIX_FIRST_INCOMING_ARG_REGNUM
];
1223 if (delta
>= 0 && delta
< 65536)
1224 asm_fprintf (stream
, "\tINCL %s,%d\n", delta
, regname
);
1225 else if (delta
< 0 && delta
>= -255)
1226 asm_fprintf (stream
, "\tSUBU %s,%s,%d\n", regname
, regname
, -delta
);
1229 mmix_output_register_setting (stream
, 255, delta
, 1);
1230 asm_fprintf (stream
, "\tADDU %s,%s,$255\n", regname
, regname
);
1233 fprintf (stream
, "\tJMP ");
1234 assemble_name (stream
, XSTR (XEXP (DECL_RTL (func
), 0), 0));
1235 fprintf (stream
, "\n");
1238 /* FUNCTION_PROFILER. */
1241 mmix_function_profiler (stream
, labelno
)
1242 FILE *stream ATTRIBUTE_UNUSED
;
1243 int labelno ATTRIBUTE_UNUSED
;
1245 sorry ("function_profiler support for MMIX");
1248 /* SETUP_INCOMING_VARARGS. */
1251 mmix_setup_incoming_varargs (args_so_farp
, mode
, vartype
, pretend_sizep
,
1253 CUMULATIVE_ARGS
* args_so_farp
;
1254 enum machine_mode mode
;
1256 int * pretend_sizep
;
1257 int second_time ATTRIBUTE_UNUSED
;
1259 /* For stdarg, the last named variable has been handled, but
1260 args_so_farp has not been advanced for it. For varargs, the current
1261 argument is to be counted to the anonymous ones. */
1262 if (current_function_stdarg
)
1264 if (args_so_farp
->regs
+ 1 < MMIX_MAX_ARGS_IN_REGS
)
1266 = (MMIX_MAX_ARGS_IN_REGS
- (args_so_farp
->regs
+ 1)) * 8;
1268 else if (current_function_varargs
)
1270 if (args_so_farp
->regs
< MMIX_MAX_ARGS_IN_REGS
)
1272 = (MMIX_MAX_ARGS_IN_REGS
- args_so_farp
->regs
) * 8;
1274 /* For varargs, we get here when we see the last named parameter,
1275 which will actually be passed on stack. So make the next call
1276 (there will be one) to FUNCTION_ARG return 0, to count it on
1277 stack, so va_arg for it will get right. FIXME: The GCC core
1278 should provide TRT. */
1279 args_so_farp
->now_varargs
= 1;
1282 internal_error ("neither varargs or stdarg in mmix_setup_incoming_varargs");
1285 /* We assume that one argument takes up one register here. That should
1286 be true until we start messing with multi-reg parameters. */
1287 if ((7 + (MMIX_FUNCTION_ARG_SIZE (mode
, vartype
))) / 8 != 1)
1288 internal_error ("MMIX Internal: Last named vararg would not fit in a register");
1291 /* EXPAND_BUILTIN_VA_ARG. */
1293 /* This is modified from the "standard" implementation of va_arg: read the
1294 value from the current (padded) address and increment by the (padded)
1295 size. The difference for MMIX is that if the type is
1296 pass-by-reference, then perform an indirection. */
1299 mmix_expand_builtin_va_arg (valist
, type
)
1303 tree ptr_size
= size_int (BITS_PER_WORD
/ BITS_PER_UNIT
);
1304 tree addr_tree
, type_size
= NULL
;
1305 tree align
, alignm1
;
1309 /* Compute the rounded size of the type. */
1313 align
= size_int (PARM_BOUNDARY
/ BITS_PER_UNIT
);
1314 alignm1
= size_int (PARM_BOUNDARY
/ BITS_PER_UNIT
- 1);
1315 if (type
== error_mark_node
1316 || (type_size
= TYPE_SIZE_UNIT (TYPE_MAIN_VARIANT (type
))) == NULL
1317 || TREE_OVERFLOW (type_size
))
1318 /* Presumably an error; the size isn't computable. A message has
1319 supposedly been emitted elsewhere. */
1320 rounded_size
= size_zero_node
;
1322 rounded_size
= fold (build (MULT_EXPR
, sizetype
,
1323 fold (build (TRUNC_DIV_EXPR
, sizetype
,
1324 fold (build (PLUS_EXPR
, sizetype
,
1325 type_size
, alignm1
)),
1329 if (AGGREGATE_TYPE_P (type
)
1330 && GET_MODE_UNIT_SIZE (TYPE_MODE (type
)) < 8
1331 && GET_MODE_UNIT_SIZE (TYPE_MODE (type
)) != 0)
1333 /* Adjust for big-endian the location of aggregates passed in a
1334 register, but where the aggregate is accessed in a shorter mode
1335 than the natural register mode (i.e. it is accessed as SFmode(?),
1336 SImode, HImode or QImode rather than DImode or DFmode(?)). FIXME:
1337 Or should we adjust the mode in which the aggregate is read, to be
1338 a register size mode? (Hum, nah, a small offset is generally
1339 cheaper than a wider memory access on MMIX.) */
1341 = build (PLUS_EXPR
, TREE_TYPE (addr_tree
), addr_tree
,
1342 size_int ((BITS_PER_WORD
/ BITS_PER_UNIT
)
1343 - GET_MODE_UNIT_SIZE (TYPE_MODE (type
))));
1345 else if (!integer_zerop (rounded_size
))
1347 if (!really_constant_p (type_size
))
1348 /* Varying-size types come in by reference. */
1350 = build1 (INDIRECT_REF
, build_pointer_type (type
), addr_tree
);
1353 /* If the size is less than a register, then we need to pad the
1354 address by adding the difference. */
1356 = fold (build (COND_EXPR
, sizetype
,
1357 fold (build (GT_EXPR
, sizetype
,
1361 fold (build (MINUS_EXPR
, sizetype
,
1365 = fold (build (PLUS_EXPR
, TREE_TYPE (addr_tree
), addr_tree
,
1368 /* If this type is larger than what fits in a register, then it
1369 is passed by reference. */
1371 = fold (build (COND_EXPR
, TREE_TYPE (addr_tree1
),
1372 fold (build (GT_EXPR
, sizetype
,
1375 build1 (INDIRECT_REF
, build_pointer_type (type
),
1381 addr
= expand_expr (addr_tree
, NULL_RTX
, Pmode
, EXPAND_NORMAL
);
1382 addr
= copy_to_reg (addr
);
1384 if (!integer_zerop (rounded_size
))
1386 /* Compute new value for AP. For MMIX, it is always advanced by the
1387 size of a register. */
1388 tree t
= build (MODIFY_EXPR
, TREE_TYPE (valist
), valist
,
1389 build (PLUS_EXPR
, TREE_TYPE (valist
), valist
,
1391 TREE_SIDE_EFFECTS (t
) = 1;
1392 expand_expr (t
, const0_rtx
, VOIDmode
, EXPAND_NORMAL
);
1398 /* TRAMPOLINE_SIZE. */
1399 /* Four 4-byte insns plus two 8-byte values. */
1400 int mmix_trampoline_size
= 32;
1403 /* TRAMPOLINE_TEMPLATE. */
1406 mmix_trampoline_template (stream
)
1409 /* Read a value into the static-chain register and jump somewhere. The
1410 static chain is stored at offset 16, and the function address is
1411 stored at offset 24. */
1412 /* FIXME: GCC copies this using *intsize* (tetra), when it should use
1413 register size (octa). */
1414 fprintf (stream
, "\tGETA $255,1F\n\t");
1415 fprintf (stream
, "LDOU %s,$255,0\n\t",
1416 reg_names
[MMIX_STATIC_CHAIN_REGNUM
]);
1417 fprintf (stream
, "LDOU $255,$255,8\n\t");
1418 fprintf (stream
, "GO $255,$255,0\n");
1419 fprintf (stream
, "1H\tOCTA 0\n\t");
1420 fprintf (stream
, "OCTA 0\n");
1423 /* INITIALIZE_TRAMPOLINE. */
1424 /* Set the static chain and function pointer field in the trampoline.
1425 We also SYNCID here to be sure (doesn't matter in the simulator, but
1426 some day it will). */
1429 mmix_initialize_trampoline (trampaddr
, fnaddr
, static_chain
)
1434 emit_move_insn (gen_rtx_MEM (DImode
, plus_constant (trampaddr
, 16)),
1436 emit_move_insn (gen_rtx_MEM (DImode
,
1437 plus_constant (trampaddr
, 24)),
1439 emit_insn (gen_sync_icache (validize_mem (gen_rtx_MEM (DImode
,
1441 GEN_INT (mmix_trampoline_size
- 1)));
1444 /* We must exclude constant addresses that have an increment that is not a
1445 multiple of four bytes because of restrictions of the GETA
1446 instruction, unless TARGET_BASE_ADDRESSES. */
1449 mmix_constant_address_p (x
)
1452 RTX_CODE code
= GET_CODE (x
);
1454 /* When using "base addresses", anything constant goes. */
1455 int constant_ok
= TARGET_BASE_ADDRESSES
!= 0;
1463 case CONSTANT_P_RTX
:
1465 /* FIXME: Don't know how to dissect these. Avoid them for now,
1466 except we know they're constants. */
1470 addend
= INTVAL (x
);
1474 if (GET_MODE (x
) != VOIDmode
)
1475 /* Strange that we got here. FIXME: Check if we do. */
1477 addend
= CONST_DOUBLE_LOW (x
);
1481 /* Note that expressions with arithmetic on forward references don't
1482 work in mmixal. People using gcc assembly code with mmixal might
1483 need to move arrays and such to before the point of use. */
1484 if (GET_CODE (XEXP (x
, 0)) == PLUS
)
1486 rtx x0
= XEXP (XEXP (x
, 0), 0);
1487 rtx x1
= XEXP (XEXP (x
, 0), 1);
1489 if ((GET_CODE (x0
) == SYMBOL_REF
1490 || GET_CODE (x0
) == LABEL_REF
)
1491 && (GET_CODE (x1
) == CONST_INT
1492 || (GET_CODE (x1
) == CONST_DOUBLE
1493 && GET_MODE (x1
) == VOIDmode
)))
1494 addend
= mmix_intval (x1
);
1506 return constant_ok
|| (addend
& 3) == 0;
1509 /* Return 1 if the address is OK, otherwise 0.
1510 Used by GO_IF_LEGITIMATE_ADDRESS. */
1513 mmix_legitimate_address (mode
, x
, strict_checking
)
1514 enum machine_mode mode ATTRIBUTE_UNUSED
;
1516 int strict_checking
;
1518 #define MMIX_REG_OK(X) \
1520 && (REGNO (X) <= MMIX_LAST_GENERAL_REGISTER \
1521 || (reg_renumber[REGNO (X)] > 0 \
1522 && reg_renumber[REGNO (X)] <= MMIX_LAST_GENERAL_REGISTER))) \
1523 || (!strict_checking \
1524 && (REGNO (X) <= MMIX_LAST_GENERAL_REGISTER \
1525 || REGNO (X) >= FIRST_PSEUDO_REGISTER \
1526 || REGNO (X) == ARG_POINTER_REGNUM)))
1530 (mem (plus reg reg))
1531 (mem (plus reg 0..255)).
1532 unless TARGET_BASE_ADDRESSES, in which case we accept all
1533 (mem constant_address) too. */
1537 if (REG_P (x
) && MMIX_REG_OK (x
))
1540 if (GET_CODE(x
) == PLUS
)
1542 rtx x1
= XEXP (x
, 0);
1543 rtx x2
= XEXP (x
, 1);
1545 /* Try swapping the order. FIXME: Do we need this? */
1553 /* (mem (plus (reg?) (?))) */
1554 if (!REG_P (x1
) || !MMIX_REG_OK (x1
))
1555 return TARGET_BASE_ADDRESSES
&& mmix_constant_address_p (x
);
1557 /* (mem (plus (reg) (reg?))) */
1558 if (REG_P (x2
) && MMIX_REG_OK (x2
))
1561 /* (mem (plus (reg) (0..255?))) */
1562 if (GET_CODE (x2
) == CONST_INT
1563 && CONST_OK_FOR_LETTER_P (INTVAL (x2
), 'I'))
1569 return TARGET_BASE_ADDRESSES
&& mmix_constant_address_p (x
);
1572 /* LEGITIMATE_CONSTANT_P. */
1575 mmix_legitimate_constant_p (x
)
1578 RTX_CODE code
= GET_CODE (x
);
1580 /* We must allow any number due to the way the cse passes works; if we
1581 do not allow any number here, general_operand will fail, and insns
1582 will fatally fail recognition instead of "softly". */
1583 if (code
== CONST_INT
|| code
== CONST_DOUBLE
)
1586 return CONSTANT_ADDRESS_P (x
);
1589 /* SELECT_CC_MODE. */
1592 mmix_select_cc_mode (op
, x
, y
)
1595 rtx y ATTRIBUTE_UNUSED
;
1597 /* We use CCmode, CC_UNSmode, CC_FPmode, CC_FPEQmode and CC_FUNmode to
1598 output different compare insns. Note that we do not check the
1599 validity of the comparison here. */
1601 if (GET_MODE_CLASS (GET_MODE (x
)) == MODE_FLOAT
)
1603 if (op
== ORDERED
|| op
== UNORDERED
|| op
== UNGE
1604 || op
== UNGT
|| op
== UNLE
|| op
== UNLT
)
1607 if (op
== EQ
|| op
== NE
)
1613 if (op
== GTU
|| op
== LTU
|| op
== GEU
|| op
== LEU
)
1619 /* REVERSIBLE_CC_MODE. */
1622 mmix_reversible_cc_mode (mode
)
1623 enum machine_mode mode
;
1625 /* That is, all integer and the EQ, NE, ORDERED and UNORDERED float
1627 return mode
!= CC_FPmode
;
1630 /* DEFAULT_RTX_COSTS. */
1633 mmix_rtx_cost_recalculated (x
, code
, outer_code
, costp
)
1634 rtx x ATTRIBUTE_UNUSED
;
1635 RTX_CODE code ATTRIBUTE_UNUSED
;
1636 RTX_CODE outer_code ATTRIBUTE_UNUSED
;
1637 int *costp ATTRIBUTE_UNUSED
;
1639 /* For the time being, this is just a stub and we'll accept the
1640 generic calculations, until we can do measurements, at least.
1641 Say we did not modify any calculated costs. */
1648 mmix_address_cost (addr
)
1649 rtx addr ATTRIBUTE_UNUSED
;
1651 /* There's no difference in the address costs and we have lots of
1652 registers. Some targets use constant 0, many others use 1 to say
1653 this. Let's start with 1. */
1657 /* REGISTER_MOVE_COST. */
1660 mmix_register_move_cost (mode
, from
, to
)
1661 enum machine_mode mode ATTRIBUTE_UNUSED
;
1662 enum reg_class from
;
1665 return (from
== GENERAL_REGS
&& from
== to
) ? 2 : 3;
1668 /* Note that we don't have a TEXT_SECTION_ASM_OP, because it has to be a
1669 compile-time constant; it's used in an asm in crtstuff.c, compiled for
1672 /* DATA_SECTION_ASM_OP. */
1675 mmix_data_section_asm_op ()
1677 return "\t.data ! mmixal:= 8H LOC 9B";
1681 mmix_encode_section_info (decl
, first
)
1685 /* Test for an external declaration, and do nothing if it is one. */
1686 if ((TREE_CODE (decl
) == VAR_DECL
1687 && (DECL_EXTERNAL (decl
) || TREE_PUBLIC (decl
)))
1688 || (TREE_CODE (decl
) == FUNCTION_DECL
&& TREE_PUBLIC (decl
)))
1690 else if (first
&& DECL_P (decl
))
1692 /* For non-visible declarations, add a "@" prefix, which we skip
1693 when the label is output. If the label does not have this
1694 prefix, a ":" is output if -mtoplevel-symbols.
1696 Note that this does not work for data that is declared extern and
1697 later defined as static. If there's code in between, that code
1698 will refer to the extern declaration, and vice versa. This just
1699 means that when -mtoplevel-symbols is in use, we can just handle
1700 well-behaved ISO-compliant code. */
1702 const char *str
= XSTR (XEXP (DECL_RTL (decl
), 0), 0);
1703 int len
= strlen (str
);
1706 /* Why is the return type of ggc_alloc_string const? */
1707 newstr
= (char *) ggc_alloc_string ("", len
+ 1);
1709 strcpy (newstr
+ 1, str
);
1711 XSTR (XEXP (DECL_RTL (decl
), 0), 0) = newstr
;
1714 /* Set SYMBOL_REF_FLAG for things that we want to access with GETA. We
1715 may need different options to reach for different things with GETA.
1716 For now, functions and things we know or have been told are constant. */
1717 if (TREE_CODE (decl
) == FUNCTION_DECL
1718 || TREE_CONSTANT (decl
)
1719 || (TREE_CODE (decl
) == VAR_DECL
1720 && TREE_READONLY (decl
)
1721 && !TREE_SIDE_EFFECTS (decl
)
1722 && (!DECL_INITIAL (decl
)
1723 || TREE_CONSTANT (DECL_INITIAL (decl
)))))
1725 rtx rtl
= (TREE_CODE_CLASS (TREE_CODE (decl
)) != 'd'
1726 ? TREE_CST_RTL (decl
) : DECL_RTL (decl
));
1727 SYMBOL_REF_FLAG (XEXP (rtl
, 0)) = 1;
1732 mmix_strip_name_encoding (name
)
1735 for (; (*name
== '@' || *name
== '*'); name
++)
1741 /* ASM_FILE_START. */
1744 mmix_asm_file_start (stream
)
1747 /* We just emit a little comment for the time being. FIXME: Perhaps add
1748 -mstandalone and some segment and prefix setup here. */
1749 ASM_OUTPUT_SOURCE_FILENAME (stream
, main_input_filename
);
1751 fprintf (stream
, "! mmixal:= 8H LOC Data_Section\n");
1753 /* Make sure each file starts with the text section. */
1760 mmix_asm_file_end (stream
)
1761 FILE * stream ATTRIBUTE_UNUSED
;
1763 /* Make sure each file ends with the data section. */
1767 /* ASM_OUTPUT_SOURCE_FILENAME. */
1770 mmix_asm_output_source_filename (stream
, name
)
1774 fprintf (stream
, "# 1 ");
1775 OUTPUT_QUOTED_STRING (stream
, name
);
1776 fprintf (stream
, "\n");
1779 /* OUTPUT_QUOTED_STRING. */
1782 mmix_output_quoted_string (stream
, string
, length
)
1784 const char * string
;
1787 const char * string_end
= string
+ length
;
1788 static const char *const unwanted_chars
= "\"[]\\";
1790 /* Output "any character except newline and double quote character". We
1791 play it safe and avoid all control characters too. We also do not
1792 want [] as characters, should input be passed through m4 with [] as
1793 quotes. Further, we avoid "\", because the GAS port handles it as a
1794 quoting character. */
1795 while (string
< string_end
)
1798 && (unsigned char) *string
< 128
1799 && !ISCNTRL (*string
)
1800 && strchr (unwanted_chars
, *string
) == NULL
)
1802 fputc ('"', stream
);
1804 && (unsigned char) *string
< 128
1805 && !ISCNTRL (*string
)
1806 && strchr (unwanted_chars
, *string
) == NULL
1807 && string
< string_end
)
1809 fputc (*string
, stream
);
1812 fputc ('"', stream
);
1813 if (string
< string_end
)
1814 fprintf (stream
, ",");
1816 if (string
< string_end
)
1818 fprintf (stream
, "#%x", *string
& 255);
1820 if (string
< string_end
)
1821 fprintf (stream
, ",");
1826 /* ASM_OUTPUT_SOURCE_LINE. */
1829 mmix_asm_output_source_line (stream
, lineno
)
1833 fprintf (stream
, "# %d ", lineno
);
1834 OUTPUT_QUOTED_STRING (stream
, main_input_filename
);
1835 fprintf (stream
, "\n");
1838 /* Target hook for assembling integer objects. Use mmix_print_operand
1839 for WYDE and TETRA. Use mmix_output_octa to output 8-byte
1843 mmix_assemble_integer (x
, size
, aligned_p
)
1851 /* We handle a limited number of types of operands in here. But
1852 that's ok, because we can punt to generic functions. We then
1853 pretend that aligned data isn't needed, so the usual .<pseudo>
1854 syntax is used (which works for aligned data too). We actually
1855 *must* do that, since we say we don't have simple aligned
1856 pseudos, causing this function to be called. We just try and
1857 keep as much compatibility as possible with mmixal syntax for
1858 normal cases (i.e. without GNU extensions and C only). */
1860 if (GET_CODE (x
) != CONST_INT
)
1865 fputs ("\tBYTE\t", asm_out_file
);
1866 mmix_print_operand (asm_out_file
, x
, 'B');
1867 fputc ('\n', asm_out_file
);
1871 if (GET_CODE (x
) != CONST_INT
)
1876 fputs ("\tWYDE\t", asm_out_file
);
1877 mmix_print_operand (asm_out_file
, x
, 'W');
1878 fputc ('\n', asm_out_file
);
1882 if (GET_CODE (x
) != CONST_INT
)
1887 fputs ("\tTETRA\t", asm_out_file
);
1888 mmix_print_operand (asm_out_file
, x
, 'L');
1889 fputc ('\n', asm_out_file
);
1893 if (GET_CODE (x
) == CONST_DOUBLE
)
1894 /* We don't get here anymore for CONST_DOUBLE, because DImode
1895 isn't expressed as CONST_DOUBLE, and DFmode is handled
1898 assemble_integer_with_op ("\tOCTA\t", x
);
1901 return default_assemble_integer (x
, size
, aligned_p
);
1904 /* ASM_OUTPUT_ASCII. */
1907 mmix_asm_output_ascii (stream
, string
, length
)
1914 int chunk_size
= length
> 60 ? 60 : length
;
1915 fprintf (stream
, "\tBYTE ");
1916 mmix_output_quoted_string (stream
, string
, chunk_size
);
1917 string
+= chunk_size
;
1918 length
-= chunk_size
;
1919 fprintf (stream
, "\n");
1923 /* ASM_OUTPUT_ALIGNED_COMMON. */
1926 mmix_asm_output_aligned_common (stream
, name
, size
, align
)
1932 /* This is mostly the elfos.h one. There doesn't seem to be a way to
1933 express this in a mmixal-compatible way. */
1934 fprintf (stream
, "\t.comm\t");
1935 assemble_name (stream
, name
);
1936 fprintf (stream
, ",%u,%u ! mmixal-incompatible COMMON\n",
1937 size
, align
/ BITS_PER_UNIT
);
1940 /* ASM_OUTPUT_ALIGNED_LOCAL. */
1943 mmix_asm_output_aligned_local (stream
, name
, size
, align
)
1951 ASM_OUTPUT_ALIGN (stream
, exact_log2 (align
/BITS_PER_UNIT
));
1952 assemble_name (stream
, name
);
1953 fprintf (stream
, "\tLOC @+%d\n", size
);
1956 /* ASM_OUTPUT_LABEL. */
1959 mmix_asm_output_label (stream
, name
)
1963 assemble_name (stream
, name
);
1964 fprintf (stream
, "\tIS @\n");
1967 /* ASM_DECLARE_REGISTER_GLOBAL. */
1970 mmix_asm_declare_register_global (stream
, decl
, regno
, name
)
1971 FILE *stream ATTRIBUTE_UNUSED
;
1972 tree decl ATTRIBUTE_UNUSED
;
1973 int regno ATTRIBUTE_UNUSED
;
1974 const char *name ATTRIBUTE_UNUSED
;
1976 /* Nothing to do here, but there *will* be, therefore the framework is
1980 /* ASM_GLOBALIZE_LABEL. */
1983 mmix_asm_globalize_label (stream
, name
)
1984 FILE * stream ATTRIBUTE_UNUSED
;
1985 const char * name ATTRIBUTE_UNUSED
;
1987 asm_fprintf (stream
, "\t.global ");
1988 assemble_name (stream
, name
);
1989 putc ('\n', stream
);
1992 /* ASM_WEAKEN_LABEL. */
1995 mmix_asm_weaken_label (stream
, name
)
1996 FILE * stream ATTRIBUTE_UNUSED
;
1997 const char * name ATTRIBUTE_UNUSED
;
1999 asm_fprintf (stream
, "\t.weak ");
2000 assemble_name (stream
, name
);
2001 asm_fprintf (stream
, " ! mmixal-incompatible\n");
2004 /* MAKE_DECL_ONE_ONLY. */
2007 mmix_make_decl_one_only (decl
)
2010 DECL_WEAK (decl
) = 1;
2013 /* ASM_OUTPUT_LABELREF.
2014 Strip GCC's '*' and our own '@'. No order is assumed. */
2017 mmix_asm_output_labelref (stream
, name
)
2023 for (; (*name
== '@' || *name
== '*'); name
++)
2027 asm_fprintf (stream
, "%s%U%s",
2028 is_extern
&& TARGET_TOPLEVEL_SYMBOLS
? ":" : "",
2032 /* ASM_OUTPUT_INTERNAL_LABEL. */
2035 mmix_asm_output_internal_label (stream
, name
, num
)
2040 fprintf (stream
, "%s:%d\tIS @\n", name
, num
);
2043 /* ASM_OUTPUT_DEF. */
2046 mmix_asm_output_def (stream
, name
, value
)
2051 assemble_name (stream
, name
);
2052 fprintf (stream
, "\tIS ");
2053 assemble_name (stream
, value
);
2054 fputc ('\n', stream
);
2057 /* ASM_OUTPUT_DEFINE_LABEL_DIFFERENCE_SYMBOL. */
2060 mmix_asm_output_define_label_difference_symbol (stream
, symbol
, hi
, lo
)
2066 assemble_name (stream
, symbol
);
2067 fprintf (stream
, "\tIS\t");
2068 assemble_name (stream
, hi
);
2069 fputc ('-', stream
);
2070 assemble_name (stream
, lo
);
2071 fprintf (stream
, "\n");
2074 /* PRINT_OPERAND. */
2077 mmix_print_operand (stream
, x
, code
)
2082 /* When we add support for different codes later, we can, when needed,
2083 drop through to the main handler with a modified operand. */
2085 int regno
= x
!= NULL_RTX
&& REG_P (x
) ? REGNO (x
) : 0;
2089 /* Unrelated codes are in alphabetic order. */
2092 /* For conditional branches, output "P" for a probable branch. */
2093 if (TARGET_BRANCH_PREDICT
)
2095 x
= find_reg_note (current_output_insn
, REG_BR_PROB
, 0);
2096 if (x
&& INTVAL (XEXP (x
, 0)) > REG_BR_PROB_BASE
/ 2)
2102 if (GET_CODE (x
) != CONST_INT
)
2103 fatal_insn ("MMIX Internal: Expected a CONST_INT, not this", x
);
2104 fprintf (stream
, "%d", (int) (INTVAL (x
) & 0xff));
2108 /* Highpart. Must be general register, and not the last one, as
2109 that one cannot be part of a consecutive register pair. */
2110 if (regno
> MMIX_LAST_GENERAL_REGISTER
- 1)
2111 internal_error ("MMIX Internal: Bad register: %d", regno
);
2113 /* This is big-endian, so the high-part is the first one. */
2114 fprintf (stream
, "%s", reg_names
[MMIX_OUTPUT_REGNO (regno
)]);
2118 /* Lowpart. Must be CONST_INT or general register, and not the last
2119 one, as that one cannot be part of a consecutive register pair. */
2120 if (GET_CODE (x
) == CONST_INT
)
2122 fprintf (stream
, "#%lx",
2123 (unsigned long) (INTVAL (x
)
2124 & ((unsigned int) 0x7fffffff * 2 + 1)));
2128 if (GET_CODE (x
) == SYMBOL_REF
)
2130 output_addr_const (stream
, x
);
2134 if (regno
> MMIX_LAST_GENERAL_REGISTER
- 1)
2135 internal_error ("MMIX Internal: Bad register: %d", regno
);
2137 /* This is big-endian, so the low-part is + 1. */
2138 fprintf (stream
, "%s", reg_names
[MMIX_OUTPUT_REGNO (regno
) + 1]);
2141 /* Can't use 'a' because that's a generic modifier for address
2144 mmix_output_shiftvalue_op_from_str (stream
, "ANDN",
2145 ~(unsigned HOST_WIDEST_INT
)
2150 mmix_output_shiftvalue_op_from_str (stream
, "INC",
2151 (unsigned HOST_WIDEST_INT
)
2156 mmix_output_shiftvalue_op_from_str (stream
, "OR",
2157 (unsigned HOST_WIDEST_INT
)
2162 mmix_output_shiftvalue_op_from_str (stream
, "SET",
2163 (unsigned HOST_WIDEST_INT
)
2169 mmix_output_condition (stream
, x
, (code
== 'D'));
2173 /* Output an extra "e" to make fcmpe, fune. */
2174 if (TARGET_FCMP_EPSILON
)
2175 fprintf (stream
, "e");
2179 /* Output the number minus 1. */
2180 if (GET_CODE (x
) != CONST_INT
)
2182 fatal_insn ("MMIX Internal: Bad value for 'm', not a CONST_INT",
2185 fprintf (stream
, HOST_WIDEST_INT_PRINT_DEC
,
2186 (HOST_WIDEST_INT
) (mmix_intval (x
) - 1));
2190 /* Store the number of registers we want to save. This was setup
2191 by the prologue. The actual operand contains the number of
2192 registers to pass, but we don't use it currently. Anyway, we
2193 need to output the number of saved registers here. */
2194 fprintf (stream
, "%d",
2195 cfun
->machine
->highest_saved_stack_register
+ 1);
2199 /* Store the register to output a constant to. */
2201 fatal_insn ("MMIX Internal: Expected a register, not this", x
);
2202 mmix_output_destination_register
= MMIX_OUTPUT_REGNO (regno
);
2206 /* Output the constant. Note that we use this for floats as well. */
2207 if (GET_CODE (x
) != CONST_INT
2208 && (GET_CODE (x
) != CONST_DOUBLE
2209 || (GET_MODE (x
) != VOIDmode
&& GET_MODE (x
) != DFmode
2210 && GET_MODE (x
) != SFmode
)))
2211 fatal_insn ("MMIX Internal: Expected a constant, not this", x
);
2212 mmix_output_register_setting (stream
,
2213 mmix_output_destination_register
,
2214 mmix_intval (x
), 0);
2218 /* An U for unsigned, if TARGET_ZERO_EXTEND. Ignore the operand. */
2219 if (TARGET_ZERO_EXTEND
)
2224 mmix_output_shifted_value (stream
, (HOST_WIDEST_INT
) mmix_intval (x
));
2228 mmix_output_shifted_value (stream
, (HOST_WIDEST_INT
) ~mmix_intval (x
));
2232 if (GET_CODE (x
) != CONST_INT
)
2233 fatal_insn ("MMIX Internal: Expected a CONST_INT, not this", x
);
2234 fprintf (stream
, "#%x", (int) (INTVAL (x
) & 0xffff));
2238 /* Nothing to do. */
2242 /* Presumably there's a missing case above if we get here. */
2243 internal_error ("MMIX Internal: Missing `%c' case in mmix_print_operand", code
);
2246 switch (GET_CODE (modified_x
))
2249 regno
= REGNO (modified_x
);
2250 if (regno
>= FIRST_PSEUDO_REGISTER
)
2251 internal_error ("MMIX Internal: Bad register: %d", regno
);
2252 fprintf (stream
, "%s", reg_names
[MMIX_OUTPUT_REGNO (regno
)]);
2256 output_address (XEXP (modified_x
, 0));
2260 /* For -2147483648, mmixal complains that the constant does not fit
2261 in 4 bytes, so let's output it as hex. Take care to handle hosts
2262 where HOST_WIDE_INT is longer than an int.
2264 Print small constants +-255 using decimal. */
2266 if (INTVAL (modified_x
) > -256 && INTVAL (modified_x
) < 256)
2267 fprintf (stream
, "%d", (int) (INTVAL (modified_x
)));
2269 fprintf (stream
, "#%x",
2270 (int) (INTVAL (modified_x
)) & (unsigned int) ~0);
2274 /* Do somewhat as CONST_INT. */
2275 mmix_output_octa (stream
, mmix_intval (modified_x
), 0);
2279 output_addr_const (stream
, modified_x
);
2283 /* No need to test for all strange things. Let output_addr_const do
2285 if (CONSTANT_P (modified_x
)
2286 /* Strangely enough, this is not included in CONSTANT_P.
2287 FIXME: Ask/check about sanity here. */
2288 || GET_CODE (modified_x
) == CODE_LABEL
)
2290 output_addr_const (stream
, modified_x
);
2294 /* We need the original here. */
2295 fatal_insn ("MMIX Internal: Cannot decode this operand", x
);
2299 /* PRINT_OPERAND_PUNCT_VALID_P. */
2302 mmix_print_operand_punct_valid_p (code
)
2303 int code ATTRIBUTE_UNUSED
;
2305 /* A '+' is used for branch prediction, similar to other ports. */
2309 /* PRINT_OPERAND_ADDRESS. */
2312 mmix_print_operand_address (stream
, x
)
2318 /* I find the generated assembly code harder to read without
2320 fprintf (stream
, "%s,0", reg_names
[MMIX_OUTPUT_REGNO (REGNO (x
))]);
2323 else if (GET_CODE (x
) == PLUS
)
2325 rtx x1
= XEXP (x
, 0);
2326 rtx x2
= XEXP (x
, 1);
2330 fprintf (stream
, "%s,", reg_names
[MMIX_OUTPUT_REGNO (REGNO (x1
))]);
2334 fprintf (stream
, "%s",
2335 reg_names
[MMIX_OUTPUT_REGNO (REGNO (x2
))]);
2338 else if (GET_CODE (x2
) == CONST_INT
2339 && CONST_OK_FOR_LETTER_P (INTVAL (x2
), 'I'))
2341 output_addr_const (stream
, x2
);
2347 if (TARGET_BASE_ADDRESSES
&& mmix_legitimate_constant_p (x
))
2349 output_addr_const (stream
, x
);
2353 fatal_insn ("MMIX Internal: This is not a recognized address", x
);
2356 /* ASM_OUTPUT_REG_PUSH. */
2359 mmix_asm_output_reg_push (stream
, regno
)
2363 fprintf (stream
, "\tSUBU %s,%s,8\n\tSTOU %s,%s,0\n",
2364 reg_names
[MMIX_STACK_POINTER_REGNUM
],
2365 reg_names
[MMIX_STACK_POINTER_REGNUM
],
2366 reg_names
[MMIX_OUTPUT_REGNO (regno
)],
2367 reg_names
[MMIX_STACK_POINTER_REGNUM
]);
2370 /* ASM_OUTPUT_REG_POP. */
2373 mmix_asm_output_reg_pop (stream
, regno
)
2377 fprintf (stream
, "\tLDOU %s,%s,0\n\tINCL %s,8\n",
2378 reg_names
[MMIX_OUTPUT_REGNO (regno
)],
2379 reg_names
[MMIX_STACK_POINTER_REGNUM
],
2380 reg_names
[MMIX_STACK_POINTER_REGNUM
]);
2383 /* ASM_OUTPUT_ADDR_DIFF_ELT. */
2386 mmix_asm_output_addr_diff_elt (stream
, body
, value
, rel
)
2388 rtx body ATTRIBUTE_UNUSED
;
2392 fprintf (stream
, "\tTETRA L%d-L%d\n", value
, rel
);
2395 /* ASM_OUTPUT_ADDR_VEC_ELT. */
2398 mmix_asm_output_addr_vec_elt (stream
, value
)
2402 fprintf (stream
, "\tOCTA L:%d\n", value
);
2405 /* ASM_OUTPUT_SKIP. */
2408 mmix_asm_output_skip (stream
, nbytes
)
2412 fprintf (stream
, "\tLOC @+%d\n", nbytes
);
2415 /* ASM_OUTPUT_ALIGN. */
2418 mmix_asm_output_align (stream
, power
)
2422 /* We need to record the needed alignment of this section in the object,
2423 so we have to output an alignment directive. Use a .p2align (not
2424 .align) so people will never have to wonder about whether the
2425 argument is in number of bytes or the log2 thereof. We do it in
2426 addition to the LOC directive, so nothing needs tweaking when
2427 copy-pasting assembly into mmixal. */
2428 fprintf (stream
, "\t.p2align %d\n", power
);
2429 fprintf (stream
, "\tLOC @+(%d-@)&%d\n", 1 << power
, (1 << power
) - 1);
2432 /* DBX_REGISTER_NUMBER. */
2435 mmix_dbx_register_number (regno
)
2438 /* Adjust the register number to the one it will be output as, dammit.
2439 It'd be nice if we could check the assumption that we're filling a
2440 gap, but every register between the last saved register and parameter
2441 registers might be a valid parameter register. */
2442 regno
= MMIX_OUTPUT_REGNO (regno
);
2444 /* We need to renumber registers to get the number of the return address
2445 register in the range 0..255. It is also space-saving if registers
2446 mentioned in the call-frame information (which uses this function by
2447 defaulting DWARF_FRAME_REGNUM to DBX_REGISTER_NUMBER) are numbered
2448 0 .. 63. So map 224 .. 256+15 -> 0 .. 47 and 0 .. 223 -> 48..223+48. */
2449 return regno
>= 224 ? (regno
- 224) : (regno
+ 48);
2452 /* End of target macro support functions.
2454 Now MMIX's own functions. First the exported ones. */
2456 /* Output an optimal sequence for setting a register to a specific
2457 constant. Used in an alternative for const_ints in movdi, and when
2458 using large stack-frame offsets.
2460 Use do_begin_end to say if a line-starting TAB and newline before the
2461 first insn and after the last insn is wanted. */
2464 mmix_output_register_setting (stream
, regno
, value
, do_begin_end
)
2467 HOST_WIDEST_INT value
;
2471 fprintf (stream
, "\t");
2473 if (mmix_shiftable_wyde_value ((unsigned HOST_WIDEST_INT
) value
))
2475 /* First, the one-insn cases. */
2476 mmix_output_shiftvalue_op_from_str (stream
, "SET",
2477 (unsigned HOST_WIDEST_INT
)
2479 fprintf (stream
, " %s,", reg_names
[regno
]);
2480 mmix_output_shifted_value (stream
, (unsigned HOST_WIDEST_INT
) value
);
2482 else if (mmix_shiftable_wyde_value (-(unsigned HOST_WIDEST_INT
) value
))
2484 /* We do this to get a bit more legible assembly code. The next
2485 alternative is mostly redundant with this. */
2487 mmix_output_shiftvalue_op_from_str (stream
, "SET",
2488 -(unsigned HOST_WIDEST_INT
)
2490 fprintf (stream
, " %s,", reg_names
[regno
]);
2491 mmix_output_shifted_value (stream
, -(unsigned HOST_WIDEST_INT
) value
);
2492 fprintf (stream
, "\n\tNEGU %s,0,%s", reg_names
[regno
],
2495 else if (mmix_shiftable_wyde_value (~(unsigned HOST_WIDEST_INT
) value
))
2497 /* Slightly more expensive, the two-insn cases. */
2499 /* FIXME: We could of course also test if 0..255-N or ~(N | 1..255)
2500 is shiftable, or any other one-insn transformation of the value.
2501 FIXME: Check first if the value is "shiftable" by two loading
2502 with two insns, since it makes more readable assembly code (if
2503 anyone else cares). */
2505 mmix_output_shiftvalue_op_from_str (stream
, "SET",
2506 ~(unsigned HOST_WIDEST_INT
)
2508 fprintf (stream
, " %s,", reg_names
[regno
]);
2509 mmix_output_shifted_value (stream
, ~(unsigned HOST_WIDEST_INT
) value
);
2510 fprintf (stream
, "\n\tNOR %s,%s,0", reg_names
[regno
],
2515 /* The generic case. 2..4 insns. */
2516 static const char *const higher_parts
[] = {"L", "ML", "MH", "H"};
2517 const char *op
= "SET";
2518 const char *line_begin
= "";
2521 HOST_WIDEST_INT tmpvalue
= value
;
2523 /* Compute the number of insns needed to output this constant. */
2524 for (i
= 0; i
< 4 && tmpvalue
!= 0; i
++)
2526 if (tmpvalue
& 65535)
2530 if (TARGET_BASE_ADDRESSES
&& insns
== 3)
2532 /* The number three is based on a static observation on
2533 ghostscript-6.52. Two and four are excluded because there
2534 are too many such constants, and each unique constant (maybe
2535 offset by 1..255) were used few times compared to other uses,
2538 We use base-plus-offset addressing to force it into a global
2539 register; we just use a "LDA reg,VALUE", which will cause the
2540 assembler and linker to DTRT (for constants as well as
2542 fprintf (stream
, "LDA %s,", reg_names
[regno
]);
2543 mmix_output_octa (stream
, value
, 0);
2547 /* Output pertinent parts of the 4-wyde sequence.
2548 Still more to do if we want this to be optimal, but hey...
2549 Note that the zero case has been handled above. */
2550 for (i
= 0; i
< 4 && value
!= 0; i
++)
2554 fprintf (stream
, "%s%s%s %s,#%x", line_begin
, op
,
2555 higher_parts
[i
], reg_names
[regno
],
2556 (int) (value
& 65535));
2557 /* The first one sets the rest of the bits to 0, the next
2558 ones add set bits. */
2560 line_begin
= "\n\t";
2569 fprintf (stream
, "\n");
2572 /* Return 1 if value is 0..65535*2**(16*N) for N=0..3.
2576 mmix_shiftable_wyde_value (value
)
2577 unsigned HOST_WIDEST_INT value
;
2579 /* Shift by 16 bits per group, stop when we've found two groups with
2582 int has_candidate
= 0;
2584 for (i
= 0; i
< 4; i
++)
2600 /* True if this is an address_operand or a symbolic operand. */
2603 mmix_symbolic_or_address_operand (op
, mode
)
2605 enum machine_mode mode
;
2607 switch (GET_CODE (op
))
2614 if ((GET_CODE (XEXP (op
, 0)) == SYMBOL_REF
2615 || GET_CODE (XEXP (op
, 0)) == LABEL_REF
)
2616 && (GET_CODE (XEXP (op
, 1)) == CONST_INT
2617 || (GET_CODE (XEXP (op
, 1)) == CONST_DOUBLE
2618 && GET_MODE (XEXP (op
, 1)) == VOIDmode
)))
2622 return address_operand (op
, mode
);
2626 /* True if this is a register or CONST_INT (or CONST_DOUBLE for DImode).
2627 We could narrow the value down with a couple of predicated, but that
2628 doesn't seem to be worth it at the moment. */
2631 mmix_reg_or_constant_operand (op
, mode
)
2633 enum machine_mode mode
;
2635 return register_operand (op
, mode
)
2636 || (GET_CODE (op
) == CONST_DOUBLE
&& GET_MODE (op
) == VOIDmode
)
2637 || GET_CODE (op
) == CONST_INT
;
2640 /* True if this is a register with a condition-code mode. */
2643 mmix_reg_cc_operand (op
, mode
)
2645 enum machine_mode mode
;
2647 if (mode
== VOIDmode
)
2648 mode
= GET_MODE (op
);
2650 return register_operand (op
, mode
)
2651 && (mode
== CCmode
|| mode
== CC_UNSmode
|| mode
== CC_FPmode
2652 || mode
== CC_FPEQmode
|| mode
== CC_FUNmode
);
2655 /* True if this is a foldable comparison operator
2656 - one where a the result of (compare:CC (reg) (const_int 0)) can be
2657 replaced by (reg). */
2660 mmix_foldable_comparison_operator (op
, mode
)
2662 enum machine_mode mode
;
2664 RTX_CODE code
= GET_CODE (op
);
2666 if (mode
== VOIDmode
)
2667 mode
= GET_MODE (op
);
2669 if (mode
== VOIDmode
&& GET_RTX_CLASS (GET_CODE (op
)) == '<')
2670 mode
= GET_MODE (XEXP (op
, 0));
2672 return ((mode
== CCmode
|| mode
== DImode
)
2673 && (code
== NE
|| code
== EQ
|| code
== GE
|| code
== GT
2675 /* FIXME: This may be a stupid trick. What happens when GCC wants to
2676 reverse the condition? Can it do that by itself? Maybe it can
2677 even reverse the condition to fit a foldable one in the first
2679 || (mode
== CC_UNSmode
&& (code
== GTU
|| code
== LEU
));
2682 /* Like comparison_operator, but only true if this comparison operator is
2683 applied to a valid mode. Needed to avoid jump.c generating invalid
2684 code with -ffast-math (gcc.dg/20001228-1.c). */
2687 mmix_comparison_operator (op
, mode
)
2689 enum machine_mode mode
;
2691 RTX_CODE code
= GET_CODE (op
);
2693 /* Comparison operators usually don't have a mode, but let's try and get
2694 one anyway for the day that changes. */
2695 if (mode
== VOIDmode
)
2696 mode
= GET_MODE (op
);
2698 /* Get the mode from the first operand if we don't have one. */
2699 if (mode
== VOIDmode
&& GET_RTX_CLASS (GET_CODE (op
)) == '<')
2700 mode
= GET_MODE (XEXP (op
, 0));
2702 /* FIXME: This needs to be kept in sync with the tables in
2703 mmix_output_condition. */
2705 (mode
== VOIDmode
&& GET_RTX_CLASS (GET_CODE (op
)) == '<')
2706 || (mode
== CC_FUNmode
2707 && (code
== ORDERED
|| code
== UNORDERED
))
2708 || (mode
== CC_FPmode
2709 && (code
== GT
|| code
== LT
))
2710 || (mode
== CC_FPEQmode
2711 && (code
== NE
|| code
== EQ
))
2712 || (mode
== CC_UNSmode
2713 && (code
== GEU
|| code
== GTU
|| code
== LEU
|| code
== LTU
))
2715 && (code
== NE
|| code
== EQ
|| code
== GE
|| code
== GT
2716 || code
== LE
|| code
== LT
))
2718 && (code
== NE
|| code
== EQ
|| code
== GE
|| code
== GT
2719 || code
== LE
|| code
== LT
|| code
== LEU
|| code
== GTU
));
2722 /* True if this is a register or 0 (int or float). */
2725 mmix_reg_or_0_operand (op
, mode
)
2727 enum machine_mode mode
;
2729 /* FIXME: Is mode calculation necessary and correct? */
2731 op
== CONST0_RTX (mode
== VOIDmode
? GET_MODE (op
) : mode
)
2732 || register_operand (op
, mode
);
2735 /* True if this is a register or an int 0..255. */
2738 mmix_reg_or_8bit_operand (op
, mode
)
2740 enum machine_mode mode
;
2742 return register_operand (op
, mode
)
2743 || (GET_CODE (op
) == CONST_INT
2744 && CONST_OK_FOR_LETTER_P (INTVAL (op
), 'I'));
2747 /* Returns zero if code and mode is not a valid condition from a
2748 compare-type insn. Nonzero if it is. The parameter op, if non-NULL,
2749 is the comparison of mode is CC-somethingmode. */
2752 mmix_valid_comparison (code
, mode
, op
)
2754 enum machine_mode mode
;
2757 if (mode
== VOIDmode
&& op
!= NULL_RTX
)
2758 mode
= GET_MODE (op
);
2760 /* We don't care to look at these, they should always be valid. */
2761 if (mode
== CCmode
|| mode
== CC_UNSmode
|| mode
== DImode
)
2764 if ((mode
== CC_FPmode
|| mode
== DFmode
)
2765 && (code
== GT
|| code
== LT
))
2768 if ((mode
== CC_FPEQmode
|| mode
== DFmode
)
2769 && (code
== EQ
|| code
== NE
))
2772 if ((mode
== CC_FUNmode
|| mode
== DFmode
)
2773 && (code
== ORDERED
|| code
== UNORDERED
))
2779 /* X and Y are two things to compare using CODE. Emit a compare insn if
2780 possible and return the rtx for the cc-reg in the proper mode, or
2781 NULL_RTX if this is not a valid comparison. */
2784 mmix_gen_compare_reg (code
, x
, y
)
2788 enum machine_mode ccmode
= SELECT_CC_MODE (code
, x
, y
);
2791 /* FIXME: Do we get constants here? Of double mode? */
2792 enum machine_mode mode
2793 = GET_MODE (x
) == VOIDmode
2795 : GET_MODE_CLASS (GET_MODE (x
)) == MODE_FLOAT
? DFmode
: DImode
;
2797 if (! mmix_valid_comparison (code
, mode
, x
))
2800 cc_reg
= gen_reg_rtx (ccmode
);
2802 /* FIXME: Can we avoid emitting a compare insn here? */
2803 if (! REG_P (x
) && ! REG_P (y
))
2804 x
= force_reg (mode
, x
);
2806 /* If it's not quite right yet, put y in a register. */
2808 && (GET_CODE (y
) != CONST_INT
2809 || ! CONST_OK_FOR_LETTER_P (INTVAL (y
), 'I')))
2810 y
= force_reg (mode
, y
);
2812 emit_insn (gen_rtx_SET (VOIDmode
, cc_reg
,
2813 gen_rtx_COMPARE (ccmode
, x
, y
)));
2818 /* Local (static) helper functions. */
2820 /* Print operator suitable for doing something with a shiftable
2821 wyde. The type of operator is passed as an asm output modifier. */
2824 mmix_output_shiftvalue_op_from_str (stream
, mainop
, value
)
2827 HOST_WIDEST_INT value
;
2829 static const char *const op_part
[] = {"L", "ML", "MH", "H"};
2832 if (! mmix_shiftable_wyde_value (value
))
2834 char s
[sizeof ("0xffffffffffffffff")];
2835 sprintf (s
, HOST_WIDEST_INT_PRINT_HEX
, value
);
2836 internal_error ("MMIX Internal: %s is not a shiftable int", s
);
2839 for (i
= 0; i
< 4; i
++)
2841 /* We know we're through when we find one-bits in the low
2845 fprintf (stream
, "%s%s", mainop
, op_part
[i
]);
2851 /* No bits set? Then it must have been zero. */
2852 fprintf (stream
, "%sL", mainop
);
2855 /* Print a 64-bit value, optionally prefixed by assembly pseudo. */
2858 mmix_output_octa (stream
, value
, do_begin_end
)
2860 HOST_WIDEST_INT value
;
2863 /* Snipped from final.c:output_addr_const. We need to avoid the
2864 presumed universal "0x" prefix. We can do it by replacing "0x" with
2865 "#0" here; we must avoid a space in the operands and no, the zero
2866 won't cause the number to be assumed in octal format. */
2867 char hex_format
[sizeof (HOST_WIDEST_INT_PRINT_HEX
)];
2870 fprintf (stream
, "\tOCTA ");
2872 strcpy (hex_format
, HOST_WIDEST_INT_PRINT_HEX
);
2873 hex_format
[0] = '#';
2874 hex_format
[1] = '0';
2876 /* Provide a few alternative output formats depending on the number, to
2877 improve legibility of assembler output. */
2878 if ((value
< (HOST_WIDEST_INT
) 0 && value
> (HOST_WIDEST_INT
) -10000)
2879 || (value
>= (HOST_WIDEST_INT
) 0 && value
<= (HOST_WIDEST_INT
) 16384))
2880 fprintf (stream
, "%d", (int) value
);
2881 else if (value
> (HOST_WIDEST_INT
) 0
2882 && value
< ((HOST_WIDEST_INT
) 1 << 31) * 2)
2883 fprintf (stream
, "#%x", (unsigned int) value
);
2885 fprintf (stream
, hex_format
, value
);
2888 fprintf (stream
, "\n");
2891 /* Print the presumed shiftable wyde argument shifted into place (to
2892 be output with an operand). */
2895 mmix_output_shifted_value (stream
, value
)
2897 HOST_WIDEST_INT value
;
2901 if (! mmix_shiftable_wyde_value (value
))
2904 sprintf (s
, HOST_WIDEST_INT_PRINT_HEX
, value
);
2905 internal_error ("MMIX Internal: %s is not a shiftable int", s
);
2908 for (i
= 0; i
< 4; i
++)
2910 /* We know we're through when we find one-bits in the low 16 bits. */
2913 fprintf (stream
, "#%x", (int) (value
& 0xffff));
2920 /* No bits set? Then it must have been zero. */
2921 fprintf (stream
, "0");
2924 /* Output an MMIX condition name corresponding to an operator
2926 (comparison_operator [(comparison_operator ...) (const_int 0)])
2927 which means we have to look at *two* operators.
2929 The argument "reversed" refers to reversal of the condition (not the
2930 same as swapping the arguments). */
2933 mmix_output_condition (stream
, x
, reversed
)
2942 /* The normal output cc-code. */
2943 const char *const normal
;
2945 /* The reversed cc-code, or NULL if invalid. */
2946 const char *const reversed
;
2951 enum machine_mode cc_mode
;
2953 /* Terminated with {NIL, NULL, NULL} */
2954 const struct cc_conv
*const convs
;
2958 #define CCEND {NIL, NULL, NULL}
2960 static const struct cc_conv cc_fun_convs
[]
2961 = {{ORDERED
, "Z", "P"},
2962 {UNORDERED
, "P", "Z"},
2964 static const struct cc_conv cc_fp_convs
[]
2968 static const struct cc_conv cc_fpeq_convs
[]
2972 static const struct cc_conv cc_uns_convs
[]
2973 = {{GEU
, "NN", "N"},
2978 static const struct cc_conv cc_signed_convs
[]
2986 static const struct cc_conv cc_di_convs
[]
2998 static const struct cc_type_conv cc_convs
[]
2999 = {{CC_FUNmode
, cc_fun_convs
},
3000 {CC_FPmode
, cc_fp_convs
},
3001 {CC_FPEQmode
, cc_fpeq_convs
},
3002 {CC_UNSmode
, cc_uns_convs
},
3003 {CCmode
, cc_signed_convs
},
3004 {DImode
, cc_di_convs
}};
3009 enum machine_mode mode
= GET_MODE (XEXP (x
, 0));
3010 RTX_CODE cc
= GET_CODE (x
);
3012 for (i
= 0; i
< ARRAY_SIZE (cc_convs
); i
++)
3014 if (mode
== cc_convs
[i
].cc_mode
)
3016 for (j
= 0; cc_convs
[i
].convs
[j
].cc
!= NIL
; j
++)
3017 if (cc
== cc_convs
[i
].convs
[j
].cc
)
3020 = (reversed
? cc_convs
[i
].convs
[j
].reversed
3021 : cc_convs
[i
].convs
[j
].normal
);
3023 if (mmix_cc
== NULL
)
3024 fatal_insn ("MMIX Internal: Trying to output invalidly\
3025 reversed condition:", x
);
3027 fprintf (stream
, "%s", mmix_cc
);
3031 fatal_insn ("MMIX Internal: What's the CC of this?", x
);
3035 fatal_insn ("MMIX Internal: What is the CC of this?", x
);
3038 /* Return the bit-value for a const_int or const_double. */
3040 static HOST_WIDEST_INT
3044 unsigned HOST_WIDEST_INT retval
;
3046 if (GET_CODE (x
) == CONST_INT
)
3049 /* We make a little song and dance because converting to long long in
3050 gcc-2.7.2 is broken. I still want people to be able to use it for
3051 cross-compilation to MMIX. */
3052 if (GET_CODE (x
) == CONST_DOUBLE
&& GET_MODE (x
) == VOIDmode
)
3054 if (sizeof (HOST_WIDE_INT
) < sizeof (HOST_WIDEST_INT
))
3056 retval
= (unsigned) CONST_DOUBLE_LOW (x
) / 2;
3058 retval
|= CONST_DOUBLE_LOW (x
) & 1;
3061 (unsigned HOST_WIDEST_INT
) CONST_DOUBLE_HIGH (x
)
3062 << (HOST_BITS_PER_LONG
);
3065 retval
= CONST_DOUBLE_HIGH (x
);
3070 if (GET_CODE (x
) == CONST_DOUBLE
)
3072 REAL_VALUE_TYPE value
;
3074 /* FIXME: This macro is not in the manual but should be. */
3075 REAL_VALUE_FROM_CONST_DOUBLE (value
, x
);
3077 if (GET_MODE (x
) == DFmode
)
3081 REAL_VALUE_TO_TARGET_DOUBLE (value
, bits
);
3083 if (sizeof (long) < sizeof (HOST_WIDEST_INT
))
3085 retval
= (unsigned long) bits
[1] / 2;
3087 retval
|= (unsigned long) bits
[1] & 1;
3089 |= (unsigned HOST_WIDEST_INT
) bits
[0]
3090 << (sizeof (bits
[0]) * 8);
3093 retval
= (unsigned long) bits
[1];
3097 else if (GET_MODE (x
) == SFmode
)
3100 REAL_VALUE_TO_TARGET_SINGLE (value
, bits
);
3102 return (unsigned long) bits
;
3106 fatal_insn ("MMIX Internal: This is not a constant:", x
);
3111 * eval: (c-set-style "gnu")
3112 * indent-tabs-mode: t