/* Definitions of target machine for GNU compiler, for the pdp-11
- Copyright (C) 1994, 1995, 1996, 1998 Free Software Foundation, Inc.
+ Copyright (C) 1994, 1995, 1996, 1998, 1999, 2000, 2001, 2002, 2004, 2005,
+ 2006, 2007, 2008 Free Software Foundation, Inc.
Contributed by Michael K. Gschwind (mike@vlsivie.tuwien.ac.at).
-This file is part of GNU CC.
+This file is part of GCC.
-GNU CC is free software; you can redistribute it and/or modify
+GCC is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
-the Free Software Foundation; either version 1, or (at your option)
+the Free Software Foundation; either version 3, or (at your option)
any later version.
-GNU CC is distributed in the hope that it will be useful,
+GCC is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
-along with GNU CC; see the file COPYING. If not, write to
-the Free Software Foundation, 59 Temple Place - Suite 330,
-Boston, MA 02111-1307, USA. */
+along with GCC; see the file COPYING3. If not see
+<http://www.gnu.org/licenses/>. */
-
-/* declarations */
-char *output_jump();
-char *output_move_double();
-char *output_move_quad();
-char *output_block_move();
+#define CONSTANT_POOL_BEFORE_FUNCTION 0
/* check whether load_fpu_reg or not */
#define LOAD_FPU_REG_P(x) ((x)>=8 && (x)<=11)
/* Names to predefine in the preprocessor for this target machine. */
-#define CPP_PREDEFINES "-Dpdp11"
+#define TARGET_CPU_CPP_BUILTINS() \
+ do \
+ { \
+ builtin_define_std ("pdp11"); \
+ } \
+ while (0)
/* Print subsidiary information on the compiler version in use. */
#define TARGET_VERSION fprintf (stderr, " (pdp11)");
/* #define DBX_DEBUGGING_INFO */
-/* Run-time compilation parameters selecting different hardware subsets.
-*/
-
-extern int target_flags;
-
-/* Macro to define tables used to set the flags.
- This is a list in braces of pairs in braces,
- each pair being { "NAME", VALUE }
- where VALUE is the bits to set or minus the bits to clear.
- An empty string NAME is used to identify the default VALUE. */
-
-#define TARGET_SWITCHES \
-{ { "fpu", 1}, \
- { "soft-float", -1}, \
-/* return float result in ac0 */\
- { "ac0", 2}, \
- { "no-ac0", -2}, \
-/* is 11/40 */ \
- { "40", 4}, \
- { "no-40", -4}, \
-/* is 11/45 */ \
- { "45", 8}, \
- { "no-45", -8}, \
-/* is 11/10 */ \
- { "10", -12}, \
-/* use movstrhi for bcopy */ \
- { "bcopy", 16}, \
- { "bcopy-builtin", -16}, \
-/* use 32 bit for int */ \
- { "int32", 32}, \
- { "no-int16", 32}, \
- { "int16", -32}, \
- { "no-int32", -32}, \
-/* use 32 bit for float */ \
- { "float32", 64}, \
- { "no-float64", 64}, \
- { "float64", -64}, \
- { "no-float32", -64}, \
-/* allow abshi pattern? - can trigger "optimizations" which make code SLOW! */\
- { "abshi", 128}, \
- { "no-abshi", -128}, \
-/* is branching expensive - on a PDP, it's actually really cheap */ \
-/* this is just to play around and check what code gcc generates */ \
- { "branch-expensive", 256}, \
- { "branch-cheap", -256}, \
-/* optimize for space instead of time - just in a couple of places */ \
- { "space", 512 }, \
- { "time", -512 }, \
-/* split instruction and data memory? */ \
- { "split", 1024 }, \
- { "no-split", -1024 }, \
-/* default */ \
- { "", TARGET_DEFAULT} \
-}
-
-#define TARGET_DEFAULT (1 | 8 | 128)
-
-#define TARGET_FPU (target_flags & 1)
-#define TARGET_SOFT_FLOAT (!TARGET_FPU)
-
-#define TARGET_AC0 ((target_flags & 2) && TARGET_FPU)
-#define TARGET_NO_AC0 (! TARGET_AC0)
-
-#define TARGET_45 (target_flags & 8)
-#define TARGET_40_PLUS ((target_flags & 4) || (target_flags))
+#define TARGET_40_PLUS (TARGET_40 || TARGET_45)
#define TARGET_10 (! TARGET_40_PLUS)
-#define TARGET_BCOPY_BUILTIN (! (target_flags & 16))
+#define TARGET_UNIX_ASM_DEFAULT 0
-#define TARGET_INT16 (! TARGET_INT32)
-#define TARGET_INT32 (target_flags & 32)
+#define ASSEMBLER_DIALECT (TARGET_UNIX_ASM ? 1 : 0)
-#define TARGET_FLOAT32 (target_flags & 64)
-#define TARGET_FLOAT64 (! TARGET_FLOAT32)
-
-#define TARGET_ABSHI_BUILTIN (target_flags & 128)
-
-#define TARGET_BRANCH_EXPENSIVE (target_flags & 256)
-#define TARGET_BRANCH_CHEAP (!TARGET_BRANCH_EXPENSIVE)
-
-#define TARGET_SPACE (target_flags & 512)
-#define TARGET_TIME (! TARGET_SPACE)
-
-#define TARGET_SPLIT (target_flags & 1024)
-#define TARGET_NOSPLIT (! TARGET_SPLIT)
\f
/* TYPE SIZES */
-#define CHAR_TYPE_SIZE 8
#define SHORT_TYPE_SIZE 16
#define INT_TYPE_SIZE (TARGET_INT16 ? 16 : 32)
#define LONG_TYPE_SIZE 32
/* machine types from ansi */
#define SIZE_TYPE "unsigned int" /* definition of size_t */
-
-/* is used in cexp.y - we don't have target_flags there,
- so just give default definition
-
- hope it does not come back to haunt us! */
#define WCHAR_TYPE "int" /* or long int???? */
#define WCHAR_TYPE_SIZE 16
/* Define this if most significant byte of a word is the lowest numbered. */
#define BYTES_BIG_ENDIAN 0
-/* Define this if most significant word of a multiword number is numbered. */
+/* Define this if most significant word of a multiword number is first. */
#define WORDS_BIG_ENDIAN 1
-/* number of bits in an addressable storage unit */
-#define BITS_PER_UNIT 8
-
-/* Width in bits of a "word", which is the contents of a machine register.
- Note that this is not necessarily the width of data type `int';
- if using 16-bit ints on a 68000, this would still be 32.
- But on a machine with 16-bit registers, this would be 16. */
-/* This is a machine with 16-bit registers */
-#define BITS_PER_WORD 16
+/* Define that floats are in VAX order, not high word first as for ints. */
+#define FLOAT_WORDS_BIG_ENDIAN 0
/* Width of a word, in units (bytes).
UNITS OR BYTES - seems like units */
#define UNITS_PER_WORD 2
+/* This machine doesn't use IEEE floats. */
+/* Because the pdp11 (at least Unix) convention for 32-bit ints is
+ big endian, opposite for what you need for float, the vax float
+ conversion routines aren't actually used directly. But the underlying
+ format is indeed the vax/pdp11 float format. */
+extern const struct real_format pdp11_f_format;
+extern const struct real_format pdp11_d_format;
+
/* Maximum sized of reasonable data type
DImode or Dfmode ...*/
#define MAX_FIXED_MODE_SIZE 64
-/* Width in bits of a pointer.
- See also the macro `Pmode' defined below. */
-#define POINTER_SIZE 16
-
/* Allocation boundary (in *bits*) for storing pointers in memory. */
#define POINTER_BOUNDARY 16
/* Allocation boundary (in *bits*) for storing arguments in argument list. */
#define PARM_BOUNDARY 16
+/* Boundary (in *bits*) on which stack pointer should be aligned. */
+#define STACK_BOUNDARY 16
+
/* Allocation boundary (in *bits*) for the code of a function. */
#define FUNCTION_BOUNDARY 16
/* Make sure everything's fine if we *don't* have an FPU.
This assumes that putting a register in fixed_regs will keep the
compiler's mitts completely off it. We don't bother to zero it out
- of register classes.
+ of register classes. Also fix incompatible register naming with
+ the UNIX assembler.
*/
#define CONDITIONAL_REGISTER_USAGE \
{ \
\
if (TARGET_AC0) \
call_used_regs[8] = 1; \
+ if (TARGET_UNIX_ASM) \
+ { \
+ /* Change names of FPU registers for the UNIX assembler. */ \
+ reg_names[8] = "fr0"; \
+ reg_names[9] = "fr1"; \
+ reg_names[10] = "fr2"; \
+ reg_names[11] = "fr3"; \
+ reg_names[12] = "fr4"; \
+ reg_names[13] = "fr5"; \
+ } \
}
/* Return number of consecutive hard regs needed starting at reg REGNO
FPU can only hold DF - simplifies life!
*/
#define HARD_REGNO_MODE_OK(REGNO, MODE) \
-((REGNO < 8)? \
+(((REGNO) < 8)? \
((GET_MODE_BITSIZE(MODE) <= 16) \
- || (GET_MODE_BITSIZE(MODE) == 32 && !(REGNO & 1))) \
+ || (GET_MODE_BITSIZE(MODE) == 32 && !((REGNO) & 1))) \
:(MODE) == DFmode)
/* Base register for access to local variables of the function. */
#define FRAME_POINTER_REGNUM 5
-/* Value should be nonzero if functions must have frame pointers.
- Zero means the frame pointer need not be set up (and parms
- may be accessed via the stack pointer) in functions that seem suitable.
- This is computed in `reload', in reload1.c.
- */
-
-#define FRAME_POINTER_REQUIRED 0
-
/* Base register for access to arguments of the function. */
#define ARG_POINTER_REGNUM 5
/* Register in which static-chain is passed to a function. */
/* ??? - i don't want to give up a reg for this! */
#define STATIC_CHAIN_REGNUM 4
-
-/* Register in which address to store a structure value
- is passed to a function.
- let's make it an invisible first argument!!! */
-
-#define STRUCT_VALUE 0
-
\f
/* Define the classes of registers for register constraints in the
machine description. Also define ranges of constants.
/* The pdp has a couple of classes:
-MUL_REGS are used for odd numbered regs, to use in 16 bit multiplication
- (even numbered do 32 bit multiply)
+MUL_REGS are used for odd numbered regs, to use in 16-bit multiplication
+ (even numbered do 32-bit multiply)
LMUL_REGS long multiply registers (even numbered regs )
- (don't need them, all 32 bit regs are even numbered!)
+ (don't need them, all 32-bit regs are even numbered!)
GENERAL_REGS is all cpu
LOAD_FPU_REGS is the first four cpu regs, they are easier to load
NO_LOAD_FPU_REGS is ac4 and ac5, currently - difficult to load them
/* #define GENERAL_REGS ALL_REGS */
-/* Give names of register classes as strings for dump file. */
+/* Give names of register classes as strings for dump file. */
#define REG_CLASS_NAMES {"NO_REGS", "MUL_REGS", "GENERAL_REGS", "LOAD_FPU_REGS", "NO_LOAD_FPU_REGS", "FPU_REGS", "ALL_REGS" }
This is an initializer for a vector of HARD_REG_SET
of length N_REG_CLASSES. */
-#define REG_CLASS_CONTENTS {0, 0x00aa, 0x00ff, 0x0f00, 0x3000, 0x3f00, 0x3fff}
+#define REG_CLASS_CONTENTS {{0}, {0x00aa}, {0x00ff}, {0x0f00}, {0x3000}, {0x3f00}, {0x3fff}}
/* The same information, inverted:
Return the class number of the smallest class containing
or could index an array. */
#define REGNO_REG_CLASS(REGNO) \
-((REGNO)>=8?((REGNO)<=11?LOAD_FPU_REGS:NO_LOAD_FPU_REGS):((REGNO&1)?MUL_REGS:GENERAL_REGS))
+((REGNO)>=8?((REGNO)<=11?LOAD_FPU_REGS:NO_LOAD_FPU_REGS):(((REGNO)&1)?MUL_REGS:GENERAL_REGS))
/* The class value for index registers, and the one for base regs. */
operand as its first argument and the constraint letter as its
second operand.
- `Q' is for memory references using take more than 1 instruction.
- `R' is for memory references which take 1 word for the instruction. */
+ `Q' is for memory references that require an extra word after the opcode.
+ `R' is for memory references which are encoded within the opcode. */
#define EXTRA_CONSTRAINT(OP,CODE) \
((GET_CODE (OP) != MEM) ? 0 \
- : !legitimate_address_p (GET_MODE (OP), XEXP (OP, 0)) ? 0 \
+ : !memory_address_p (GET_MODE (OP), XEXP (OP, 0)) ? 0 \
: ((CODE) == 'Q') ? !simple_memory_operand (OP, GET_MODE (OP)) \
: ((CODE) == 'R') ? simple_memory_operand (OP, GET_MODE (OP)) \
: 0)
makes the stack pointer a smaller address. */
#define STACK_GROWS_DOWNWARD
-/* Define this if the nominal address of the stack frame
+/* Define this to nonzero if the nominal address of the stack frame
is at the high-address end of the local variables;
that is, each additional local variable allocated
goes at a more negative offset in the frame.
*/
-#define FRAME_GROWS_DOWNWARD
+#define FRAME_GROWS_DOWNWARD 1
/* Offset within stack frame to start allocating local variables at.
If FRAME_GROWS_DOWNWARD, this is the offset to the END of the
extern int current_first_parm_offset;
/* Offset of first parameter from the argument pointer register value.
- For the pdp11, this is non-zero to account for the return address.
+ For the pdp11, this is nonzero to account for the return address.
1 - return address
2 - frame pointer (always saved, even when not used!!!!)
- -- chnage some day !!!:q!
+ -- change some day !!!:q!
*/
#define FIRST_PARM_OFFSET(FNDECL) 4
not without FPU!!!! ) */
#define FUNCTION_VALUE(VALTYPE, FUNC) \
- gen_rtx (REG, TYPE_MODE (VALTYPE), BASE_RETURN_VALUE_REG(TYPE_MODE(VALTYPE)))
+ gen_rtx_REG (TYPE_MODE (VALTYPE), BASE_RETURN_VALUE_REG(TYPE_MODE(VALTYPE)))
/* and the called function leaves it in the first register.
Difference only on machines with register windows. */
#define FUNCTION_OUTGOING_VALUE(VALTYPE, FUNC) \
- gen_rtx (REG, TYPE_MODE (VALTYPE), BASE_RETURN_VALUE_REG(TYPE_MODE(VALTYPE)))
+ gen_rtx_REG (TYPE_MODE (VALTYPE), BASE_RETURN_VALUE_REG(TYPE_MODE(VALTYPE)))
/* Define how to find the value returned by a library function
assuming the value has mode MODE. */
-#define LIBCALL_VALUE(MODE) gen_rtx (REG, MODE, BASE_RETURN_VALUE_REG(MODE))
+#define LIBCALL_VALUE(MODE) gen_rtx_REG (MODE, BASE_RETURN_VALUE_REG(MODE))
/* 1 if N is a possible register number for a function value
as seen by the caller.
#define FUNCTION_VALUE_REGNO_P(N) (((N) == 0) || (TARGET_AC0 && (N) == 8))
-/* should probably return DImode and DFmode in memory,lest
- we fill up all regs!
-
- have to, else we crash - exception: maybe return result in
- ac0 if DFmode and FPU present - compatibility problem with
- libraries for non-floating point ...
-*/
-
-#define RETURN_IN_MEMORY(TYPE) \
- (TYPE_MODE(TYPE) == DImode || (TYPE_MODE(TYPE) == DFmode && ! TARGET_AC0))
-
-
/* 1 if N is a possible register number for function argument passing.
- not used on pdp */
when the function gets a structure-value-address as an
invisible first argument. */
-#define INIT_CUMULATIVE_ARGS(CUM,FNTYPE,LIBNAME,INDIRECT) \
+#define INIT_CUMULATIVE_ARGS(CUM, FNTYPE, LIBNAME, INDIRECT, N_NAMED_ARGS) \
((CUM) = 0)
/* Update the data in CUM to advance over an argument
FUNCTION_ARG (CUM, MODE, TYPE, NAMED)
*/
-/* For an arg passed partly in registers and partly in memory,
- this is the number of registers used.
- For args passed entirely in registers or entirely in memory, zero. */
-
-#define FUNCTION_ARG_PARTIAL_NREGS(CUM, MODE, TYPE, NAMED) 0
-
-/* This macro generates the assembly code for function entry. */
-#define FUNCTION_PROLOGUE(FILE, SIZE) \
- output_function_prologue(FILE, SIZE);
-
/* Output assembler code to FILE to increment profiler label # LABELNO
for profiling a function entry. */
#define FUNCTION_PROFILER(FILE, LABELNO) \
- abort ();
+ gcc_unreachable ();
/* EXIT_IGNORE_STACK should be nonzero if, when returning from a function,
the stack pointer does not matter. The value is tested only in
No definition is equivalent to always zero. */
extern int may_call_alloca;
-extern int current_function_pretend_args_size;
#define EXIT_IGNORE_STACK 1
-/* This macro generates the assembly code for function exit,
- on machines that need it. If FUNCTION_EPILOGUE is not defined
- then individual return instructions are generated for each
- return statement. Args are same as for FUNCTION_PROLOGUE.
-*/
-
-#define FUNCTION_EPILOGUE(FILE, SIZE) \
- output_function_epilogue(FILE, SIZE);
-
#define INITIAL_FRAME_POINTER_OFFSET(DEPTH_VAR) \
{ \
int offset, regno; \
offset = get_frame_size(); \
for (regno = 0; regno < 8; regno++) \
- if (regs_ever_live[regno] && ! call_used_regs[regno]) \
+ if (df_regs_ever_live_p (regno) && ! call_used_regs[regno]) \
offset += 2; \
for (regno = 8; regno < 14; regno++) \
- if (regs_ever_live[regno] && ! call_used_regs[regno]) \
+ if (df_regs_ever_live_p (regno) && ! call_used_regs[regno]) \
offset += 8; \
/* offset -= 2; no fp on stack frame */ \
(DEPTH_VAR) = offset; \
\f
/* Addressing modes, and classification of registers for them. */
-#define HAVE_POST_INCREMENT
-/* #define HAVE_POST_DECREMENT */
+#define HAVE_POST_INCREMENT 1
-#define HAVE_PRE_DECREMENT
-/* #define HAVE_PRE_INCREMENT */
+#define HAVE_PRE_DECREMENT 1
/* Macros to check register numbers against specific register classes. */
\f
/* Maximum number of registers that can appear in a valid memory address. */
-#define MAX_REGS_PER_ADDRESS 2
-
-/* Recognize any constant value that is a valid address. */
-
-#define CONSTANT_ADDRESS_P(X) CONSTANT_P (X)
+#define MAX_REGS_PER_ADDRESS 1
/* Nonzero if the constant value X is a legitimate general operand.
It is given that X satisfies CONSTANT_P or is a CONST_DOUBLE. */
-#define LEGITIMATE_CONSTANT_P(X) (1)
+#define LEGITIMATE_CONSTANT_P(X) \
+ (GET_CODE (X) != CONST_DOUBLE || legitimate_const_double_p (X))
/* The macros REG_OK_FOR..._P assume that the arg is a REG rtx
and check its validity for a certain class.
&& GET_CODE (XEXP (operand, 0)) == REG \
&& REG_OK_FOR_BASE_P (XEXP (operand, 0))) \
goto ADDR; \
+ \
+ /* accept -(SP) -- which uses PRE_MODIFY for byte mode */ \
+ if (GET_CODE (operand) == PRE_MODIFY \
+ && GET_CODE (XEXP (operand, 0)) == REG \
+ && REGNO (XEXP (operand, 0)) == 6 \
+ && GET_CODE ((xfoob = XEXP (operand, 1))) == PLUS \
+ && GET_CODE (XEXP (xfoob, 0)) == REG \
+ && REGNO (XEXP (xfoob, 0)) == 6 \
+ && CONSTANT_P (XEXP (xfoob, 1)) \
+ && INTVAL (XEXP (xfoob,1)) == -2) \
+ goto ADDR; \
+ \
+ /* accept (SP)+ -- which uses POST_MODIFY for byte mode */ \
+ if (GET_CODE (operand) == POST_MODIFY \
+ && GET_CODE (XEXP (operand, 0)) == REG \
+ && REGNO (XEXP (operand, 0)) == 6 \
+ && GET_CODE ((xfoob = XEXP (operand, 1))) == PLUS \
+ && GET_CODE (XEXP (xfoob, 0)) == REG \
+ && REGNO (XEXP (xfoob, 0)) == 6 \
+ && CONSTANT_P (XEXP (xfoob, 1)) \
+ && INTVAL (XEXP (xfoob,1)) == 2) \
+ goto ADDR; \
+ \
\
/* handle another level of indirection ! */ \
if (GET_CODE(operand) != MEM) \
}
\f
-/* Try machine-dependent ways of modifying an illegitimate address
- to be legitimate. If we find one, return the new, valid address.
- This macro is used in only one place: `memory_address' in explow.c.
-
- OLDX is the address as it was before break_out_memory_refs was called.
- In some cases it is useful to look at this to decide what needs to be done.
-
- MODE and WIN are passed so that this macro can use
- GO_IF_LEGITIMATE_ADDRESS.
-
- It is always safe for this macro to do nothing. It exists to recognize
- opportunities to optimize the output. */
-
-#define LEGITIMIZE_ADDRESS(X,OLDX,MODE,WIN) {}
-
-
-/* Go to LABEL if ADDR (a legitimate address expression)
- has an effect that depends on the machine mode it is used for.
- On the pdp this is for predec/postinc */
-
-#define GO_IF_MODE_DEPENDENT_ADDRESS(ADDR,LABEL) \
- { if (GET_CODE (ADDR) == POST_INC || GET_CODE (ADDR) == PRE_DEC) \
- goto LABEL; \
- }
-
-\f
/* Specify the machine mode that this machine uses
for the index in the tablejump instruction. */
#define CASE_VECTOR_MODE HImode
`tablejump' insn. */
#define CASE_TAKES_INDEX_RAW
-/* Define as C expression which evaluates to nonzero if the tablejump
- instruction expects the table to contain offsets from the address of the
- table.
- Do not define this if the table should contain absolute addresses. */
-/* #define CASE_VECTOR_PC_RELATIVE 1 */
-
-/* Specify the tree operation to be used to convert reals to integers. */
-#define IMPLICIT_FIX_EXPR FIX_ROUND_EXPR
-
-/* This is the kind of divide that is easiest to do in the general case. */
-#define EASY_DIV_EXPR TRUNC_DIV_EXPR
-
/* Define this as 1 if `char' should by default be signed; else as 0. */
#define DEFAULT_SIGNED_CHAR 1
#define MOVE_MAX 2
-/* Zero extension is faster if the target is known to be zero */
-/* #define SLOW_ZERO_EXTEND */
-
/* Nonzero if access to memory by byte is slow and undesirable. -
*/
#define SLOW_BYTE_ACCESS 0
is done just by pretending it is already truncated. */
#define TRULY_NOOP_TRUNCATION(OUTPREC, INPREC) 1
-
-/* Add any extra modes needed to represent the condition code.
-
- CCFPmode is used for FPU, but should we use a separate reg? */
-#define EXTRA_CC_MODES CCFPmode
-
-/* the name for the mode above */
-#define EXTRA_CC_NAMES "CCFPmode"
-
/* Give a comparison code (EQ, NE etc) and the first operand of a COMPARE,
return the mode to be used for the comparison. For floating-point, CCFPmode
- should be used. */
+ should be used. */
#define SELECT_CC_MODE(OP,X,Y) \
(GET_MODE_CLASS(GET_MODE(X)) == MODE_FLOAT? CCFPmode : CCmode)
-/* We assume that the store-condition-codes instructions store 0 for false
- and some other value for true. This is the value stored for true. */
-
-/* #define STORE_FLAG_VALUE 1 */
-
/* Specify the machine mode that pointers have.
After generation of rtl, the compiler makes no further distinction
between pointers and any other objects of this machine mode. */
but a CALL with constant address is cheap. */
/* #define NO_FUNCTION_CSE */
-/* Compute the cost of computing a constant rtl expression RTX
- whose rtx-code is CODE. The body of this macro is a portion
- of a switch statement. If the code is computed here,
- return it with a return statement. Otherwise, break from the switch.
-
- -1, 0, 1 are cheaper for add, sub ...
-*/
-
-#define CONST_COSTS(RTX,CODE,OUTER_CODE) \
- case CONST_INT: \
- if (INTVAL(RTX) == 0 \
- || INTVAL(RTX) == -1 \
- || INTVAL(RTX) == 1) \
- return 0; \
- case CONST: \
- case LABEL_REF: \
- case SYMBOL_REF: \
- /* twice as expensive as REG */ \
- return 2; \
- case CONST_DOUBLE: \
- /* twice (or 4 times) as expensive as 16 bit */ \
- return 4;
\f
/* cost of moving one register class to another */
-#define REGISTER_MOVE_COST(CLASS1, CLASS2) register_move_cost(CLASS1, CLASS2)
+#define REGISTER_MOVE_COST(MODE, CLASS1, CLASS2) \
+ register_move_cost (CLASS1, CLASS2)
/* Tell emit-rtl.c how to initialize special values on a per-function base. */
extern int optimize;
{ /* all bets are off */ CC_STATUS_INIT; } \
if (cc_status.value1 && GET_CODE (cc_status.value1) == REG \
&& cc_status.value2 \
- && reg_overlap_mentioned_p (cc_status.value1, cc_status.value2)) \
- printf ("here!\n", cc_status.value2 = 0); \
+ && reg_overlap_mentioned_p (cc_status.value1, cc_status.value2)) \
+ { \
+ printf ("here!\n"); \
+ cc_status.value2 = 0; \
+ } \
}
\f
/* Control the assembler format that we output. */
-/* Output at beginning of assembler file. */
-
-#if 0
-#define ASM_FILE_START(FILE) \
-( \
-fprintf (FILE, "\t.data\n"), \
-fprintf (FILE, "$help$: . = .+8 ; space for tmp moves!\n") \
-/* do we need reg def's R0 = %0 etc ??? */ \
-)
-#else
-#define ASM_FILE_START(FILE) (0)
-#endif
-
-
/* Output to assembler file text saying following lines
may contain character constants, extra white space, comments, etc. */
This sequence is indexed by compiler's hard-register-number (see above). */
#define REGISTER_NAMES \
-{"r0", "r1", "r2", "r3", "r4", "fp", "sp", "pc", \
+{"r0", "r1", "r2", "r3", "r4", "r5", "sp", "pc", \
"ac0", "ac1", "ac2", "ac3", "ac4", "ac5" }
-/* How to renumber registers for dbx and gdb. */
-
-#define DBX_REGISTER_NUMBER(REGNO) (REGNO)
-
-/* This is how to output the definition of a user-level label named NAME,
- such as the label on a static function or variable NAME. */
+/* Globalizing directive for a label. */
+#define GLOBAL_ASM_OP "\t.globl "
-#define ASM_OUTPUT_LABEL(FILE,NAME) \
- do { assemble_name (FILE, NAME); fputs (":\n", FILE); } while (0)
-
-/* This is how to output a command to make the user-level label named NAME
- defined for reference from other files. */
-
-#define ASM_GLOBALIZE_LABEL(FILE,NAME) \
- do { fputs ("\t.globl ", FILE); assemble_name (FILE, NAME); fputs("\n", FILE); } while (0)
-
-/* The prefix to add to user-visible assembler symbols. */
+/* The prefix to add to user-visible assembler symbols. */
#define USER_LABEL_PREFIX "_"
-/* This is how to output an internal numbered label where
- PREFIX is the class of label and NUM is the number within the class. */
-
-#define ASM_OUTPUT_INTERNAL_LABEL(FILE,PREFIX,NUM) \
- fprintf (FILE, "%s_%d:\n", PREFIX, NUM)
-
/* This is how to store into the string LABEL
the symbol_ref name of an internal numbered label where
PREFIX is the class of label and NUM is the number within the class.
This is suitable for output with `assemble_name'. */
#define ASM_GENERATE_INTERNAL_LABEL(LABEL,PREFIX,NUM) \
- sprintf (LABEL, "*%s_%d", PREFIX, NUM)
-
-/* This is how to output an assembler line defining a `double' constant. */
-
-#define ASM_OUTPUT_DOUBLE(FILE,VALUE) \
- fprintf (FILE, "\tdouble %.20e\n", (VALUE))
-
-/* This is how to output an assembler line defining a `float' constant. */
-
-#define ASM_OUTPUT_FLOAT(FILE,VALUE) \
- fprintf (FILE, "\tfloat %.12e\n", (VALUE))
-
-/* This is how to output an assembler line defining an `int' constant. */
-
-#define ASM_OUTPUT_INT(FILE,VALUE) \
-( fprintf (FILE, "\t.word "), \
- output_addr_const (FILE, (VALUE)), \
- fprintf (FILE, "\n"))
-
-/* Likewise for `short' and `char' constants. */
-
-#define ASM_OUTPUT_SHORT(FILE,VALUE) \
-( fprintf (FILE, "\t.word "), \
- output_addr_const (FILE, (VALUE)), \
- fprintf (FILE, " /*short*/\n"))
-
-#define ASM_OUTPUT_CHAR(FILE,VALUE) \
-( fprintf (FILE, "\t.byte "), \
- output_addr_const (FILE, (VALUE)), \
- fprintf (FILE, " /* char */\n"))
-
-/* This is how to output an assembler line for a numeric constant byte.-
-
- do we really NEED it ? let's output it with a comment and grep the
- assembly source ;-)
-*/
-
-#define ASM_OUTPUT_BYTE(FILE,VALUE) \
- fprintf (FILE, "\t.byte 0x%x\n", (VALUE))
+ sprintf (LABEL, "*%s_%lu", PREFIX, (unsigned long)(NUM))
#define ASM_OUTPUT_ASCII(FILE, P, SIZE) \
output_ascii (FILE, P, SIZE)
-#define ASM_OUTPUT_ADDR_VEC_PROLOGUE(FILE, MODE, LEN) \
- fprintf (FILE, "\t/* HELP! */\n");
-
/* This is how to output an element of a case-vector that is absolute. */
#define ASM_OUTPUT_ADDR_VEC_ELT(FILE, VALUE) \
- fprintf (FILE, "\t.word L_%d\n", VALUE)
+ fprintf (FILE, "\t%sL_%d\n", TARGET_UNIX_ASM ? "" : ".word ", VALUE)
/* This is how to output an element of a case-vector that is relative.
- Don't define this if it is not supported. */
+ Don't define this if it is not supported. */
/* #define ASM_OUTPUT_ADDR_DIFF_ELT(FILE, VALUE, REL) */
*/
#define ASM_OUTPUT_ALIGN(FILE,LOG) \
- if ((LOG) != 0) \
- fprintf (FILE, "\t.align %d\n", 1<<(LOG))
+ switch (LOG) \
+ { \
+ case 0: \
+ break; \
+ case 1: \
+ fprintf (FILE, "\t.even\n"); \
+ break; \
+ default: \
+ gcc_unreachable (); \
+ }
#define ASM_OUTPUT_SKIP(FILE,SIZE) \
- fprintf (FILE, "\t.=.+ %d\n", (SIZE))
+ fprintf (FILE, "\t.=.+ %#ho\n", (unsigned short)(SIZE))
/* This says how to output an assembler line
to define a global common symbol. */
assemble_name ((FILE), (NAME)), \
fprintf ((FILE), "\n"), \
assemble_name ((FILE), (NAME)), \
- fprintf ((FILE), ": .=.+ %d\n", (ROUNDED)) \
+ fprintf ((FILE), ": .=.+ %#ho\n", (unsigned short)(ROUNDED)) \
)
/* This says how to output an assembler line
#define ASM_OUTPUT_LOCAL(FILE, NAME, SIZE, ROUNDED) \
( assemble_name ((FILE), (NAME)), \
- fprintf ((FILE), ":\t.=.+ %d\n", (ROUNDED)))
-
-/* Store in OUTPUT a string (made with alloca) containing
- an assembler-name for a local static variable named NAME.
- LABELNO is an integer which is different for each call. */
-
-#define ASM_FORMAT_PRIVATE_NAME(OUTPUT, NAME, LABELNO) \
-( (OUTPUT) = (char *) alloca (strlen ((NAME)) + 10), \
- sprintf ((OUTPUT), "%s.%d", (NAME), (LABELNO)))
-
-/* Define the parentheses used to group arithmetic operations
- in assembler code. */
-
-#define ASM_OPEN_PAREN "("
-#define ASM_CLOSE_PAREN ")"
-
-/* Define results of standard character escape sequences. */
-#define TARGET_BELL 007
-#define TARGET_BS 010
-#define TARGET_TAB 011
-#define TARGET_NEWLINE 012
-#define TARGET_VT 013
-#define TARGET_FF 014
-#define TARGET_CR 015
+ fprintf ((FILE), ":\t.=.+ %#ho\n", (unsigned short)(ROUNDED)))
/* Print operand X (an rtx) in assembler syntax to file FILE.
CODE is a letter or dot (`z' in `%z0') or 0 if no letter was specified.
else if (GET_CODE (X) == MEM) \
output_address (XEXP (X, 0)); \
else if (GET_CODE (X) == CONST_DOUBLE && GET_MODE (X) != SImode) \
- { union { double d; int i[2]; } u; \
- u.i[0] = CONST_DOUBLE_LOW (X); u.i[1] = CONST_DOUBLE_HIGH (X); \
- fprintf (FILE, "#%.20e", u.d); } \
- else { putc ('$', FILE); output_addr_const (FILE, X); }}
+ { REAL_VALUE_TYPE r; \
+ long sval[2]; \
+ REAL_VALUE_FROM_CONST_DOUBLE (r, X); \
+ REAL_VALUE_TO_TARGET_DOUBLE (r, sval); \
+ fprintf (FILE, "$%#lo", sval[0] >> 16); } \
+ else { putc ('$', FILE); output_addr_const_pdp11 (FILE, X); }}
\f
/* Print a memory address as an operand to reference that memory location. */
fprintf (FILE, "\tmov (sp)+, %s\n", reg_names[REGNO]) \
)
-
-#define ASM_IDENTIFY_GCC(FILE) \
- fprintf(FILE, "gcc_compiled:\n")
-
-#define ASM_OUTPUT_DOUBLE_INT(a,b) fprintf(a,"%d", b)
-
-/* trampoline - how should i do it in separate i+d ?
- have some allocate_trampoline magic???
-
- the following should work for shared I/D: */
-
-/* lets see whether this works as trampoline:
-MV #STATIC, $4 0x940Y 0x0000 <- STATIC; Y = STATIC_CHAIN_REGNUM
-JMP FUNCTION 0x0058 0x0000 <- FUNCTION
-*/
-
-#define TRAMPOLINE_TEMPLATE(FILE) \
-{ \
- if (TARGET_SPLIT) \
- abort(); \
- \
- ASM_OUTPUT_INT (FILE, GEN_INT (0x9400+STATIC_CHAIN_REGNUM)); \
- ASM_OUTPUT_INT (FILE, const0_rtx); \
- ASM_OUTPUT_INT (FILE, GEN_INT(0x0058)); \
- ASM_OUTPUT_INT (FILE, const0_rtx); \
-}
-
#define TRAMPOLINE_SIZE 8
-#define TRAMPOLINE_ALIGN 16
-
-/* Emit RTL insns to initialize the variable parts of a trampoline.
- FNADDR is an RTX for the address of the function's pure code.
- CXT is an RTX for the static chain value for the function. */
-
-#define INITIALIZE_TRAMPOLINE(TRAMP,FNADDR,CXT) \
-{ \
- if (TARGET_SPLIT) \
- abort(); \
- \
- emit_move_insn (gen_rtx (MEM, HImode, plus_constant (TRAMP, 2)), CXT); \
- emit_move_insn (gen_rtx (MEM, HImode, plus_constant (TRAMP, 6)), FNADDR); \
-}
-
+#define TRAMPOLINE_ALIGNMENT 16
/* Some machines may desire to change what optimizations are
performed for various optimization levels. This macro, if
#define OPTIMIZATION_OPTIONS(LEVEL,SIZE) \
{ \
+ flag_finite_math_only = 0; \
+ flag_trapping_math = 0; \
+ flag_signaling_nans = 0; \
if (LEVEL >= 3) \
{ \
- if (! SIZE) \
- flag_inline_functions = 1; \
flag_omit_frame_pointer = 1; \
/* flag_unroll_loops = 1; */ \
} \
}
-
-/* Provide the costs of a rtl expression. This is in the body of a
- switch on CODE.
-
- we don't say how expensive SImode is - pretty expensive!!!
-
- there is something wrong in MULT because MULT is not
- as cheap as total = 2 even if we can shift!
-
- if TARGET_SPACE make mult etc cheap, but not 1, so when
- in doubt the faster insn is chosen.
-*/
-
-#define RTX_COSTS(X,CODE,OUTER_CODE) \
- case MULT: \
- if (TARGET_SPACE) \
- total = COSTS_N_INSNS(2); \
- else \
- total = COSTS_N_INSNS (11); \
- break; \
- case DIV: \
- if (TARGET_SPACE) \
- total = COSTS_N_INSNS(2); \
- else \
- total = COSTS_N_INSNS (25); \
- break; \
- case MOD: \
- if (TARGET_SPACE) \
- total = COSTS_N_INSNS(2); \
- else \
- total = COSTS_N_INSNS (26); \
- break; \
- case ABS: \
- /* equivalent to length, so same for TARGET_SPACE */ \
- total = COSTS_N_INSNS (3); \
- break; \
- case ZERO_EXTEND: \
- /* only used for: qi->hi */ \
- total = COSTS_N_INSNS(1); \
- break; \
- case SIGN_EXTEND: \
- if (GET_MODE(X) == HImode) \
- total = COSTS_N_INSNS(1); \
- else if (GET_MODE(X) == SImode) \
- total = COSTS_N_INSNS(6); \
- else \
- total = COSTS_N_INSNS(2); \
- break; \
- /* case LSHIFT: */ \
- case ASHIFT: \
- case LSHIFTRT: \
- case ASHIFTRT: \
- if (TARGET_SPACE) \
- total = COSTS_N_INSNS(1); \
- else if (GET_MODE(X) == QImode) \
- { \
- if (GET_CODE(XEXP (X,1)) != CONST_INT) \
- total = COSTS_N_INSNS(8); /* worst case */ \
- else \
- total = COSTS_N_INSNS(INTVAL(XEXP (X,1))); \
- } \
- else if (GET_MODE(X) == HImode) \
- { \
- if (GET_CODE(XEXP (X,1)) == CONST_INT) \
- { \
- if (abs (INTVAL (XEXP (X, 1))) == 1) \
- total = COSTS_N_INSNS(1); \
- else \
- total = COSTS_N_INSNS(2.5 + 0.5 *INTVAL(XEXP(X,1))); \
- } \
- else /* worst case */ \
- total = COSTS_N_INSNS (10); \
- } \
- else if (GET_MODE(X) == SImode) \
- { \
- if (GET_CODE(XEXP (X,1)) == CONST_INT) \
- total = COSTS_N_INSNS(2.5 + 0.5 *INTVAL(XEXP(X,1))); \
- else /* worst case */ \
- total = COSTS_N_INSNS(18); \
- } \
- break;
-
-
/* there is no point in avoiding branches on a pdp,
since branches are really cheap - I just want to find out
how much difference the BRANCH_COST macro makes in code */
-#define BRANCH_COST (TARGET_BRANCH_CHEAP ? 0 : 1)
+#define BRANCH_COST(speed_p, predictable_p) (TARGET_BRANCH_CHEAP ? 0 : 1)
#define COMPARE_FLAG_MODE HImode
-
OSDN Git Service
