diff options
Diffstat (limited to 'gcc/config/tahoe/tahoe.h')
| -rw-r--r-- | gcc/config/tahoe/tahoe.h | 1017 |
1 files changed, 0 insertions, 1017 deletions
diff --git a/gcc/config/tahoe/tahoe.h b/gcc/config/tahoe/tahoe.h deleted file mode 100644 index 240f399..0000000 --- a/gcc/config/tahoe/tahoe.h +++ /dev/null @@ -1,1017 +0,0 @@ -/* Definitions of target machine for GNU compiler. Tahoe version. - Copyright (C) 1989, 93, 94, 95, 96, 1998, 1999, 2000 Free Software Foundation, Inc. - -This file is part of GNU CC. - -GNU CC 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 2, or (at your option) -any later version. - -GNU CC 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. */ - -/* - * Original port made at the University of Buffalo by Devon Bowen, - * Dale Wiles and Kevin Zachmann. - * - * HCX/UX version by Piet van Oostrum (piet@cs.ruu.nl) - * - * Performance hacking by Michael Tiemann (tiemann@cygnus.com) - */ - -/* define this for the HCX/UX version */ - -/* #define HCX_UX */ - -/* - * Run-time Target Specification - */ - -#ifdef HCX_UX -/* no predefines, see Makefile and hcx-universe.c */ -/* have cc1 print that this is the hcx version */ -#define TARGET_VERSION printf (" (hcx)"); -#else -/* we want "tahoe" and "unix" defined for all future compilations */ -#define CPP_PREDEFINES "-Dtahoe -Dunix -Asystem(unix) -Acpu(tahoe) -Amachine(tahoe)" -/* have cc1 print that this is the tahoe version */ -#define TARGET_VERSION printf (" (tahoe)"); -#endif - -/* this is required in all tm files to hold flags */ - -extern int target_flags; - -/* Zero if it is safe to output .dfloat and .float pseudos. */ -#define TARGET_HEX_FLOAT (target_flags & 1) - -#define TARGET_DEFAULT 1 - -#define TARGET_SWITCHES \ - { {"hex-float", 1}, \ - {"no-hex-float", -1}, \ - { "", TARGET_DEFAULT} } - - -/* - * Storage Layout - */ - -/* This symbol was previously not mentioned, so apparently the tahoe - is little-endian for bits, or else doesn't care. */ -#define BITS_BIG_ENDIAN 0 - -/* tahoe uses a big endian byte order */ - -#define BYTES_BIG_ENDIAN 1 - -/* tahoe uses a big endian word order */ - -#define WORDS_BIG_ENDIAN 1 - -/* standard byte size is usable on tahoe */ - -#define BITS_PER_UNIT 8 - -/* longs on the tahoe are 4 byte groups */ - -#define BITS_PER_WORD 32 - -/* from the last two params we get 4 bytes per word */ - -#define UNITS_PER_WORD 4 - -/* addresses are 32 bits (one word) */ - -#define POINTER_SIZE 32 - -/* all parameters line up on 32 boundaries */ - -#define PARM_BOUNDARY 32 - -/* stack should line up on 32 boundaries */ - -#define STACK_BOUNDARY 32 - -/* line functions up on 32 bits */ - -#define FUNCTION_BOUNDARY 32 - -/* the biggest alignment the tahoe needs in 32 bits */ - -#define BIGGEST_ALIGNMENT 32 - -/* we have to align after an 'int : 0' in a structure */ - -#define EMPTY_FIELD_BOUNDARY 32 - -#ifdef HCX_UX -/* structures must be made of full words */ - -#define STRUCTURE_SIZE_BOUNDARY 32 -#else -/* structures must be made of full bytes */ - -#define STRUCTURE_SIZE_BOUNDARY 8 -#endif - -/* tahoe is picky about data alignment */ - -#define STRICT_ALIGNMENT 1 - -/* keep things standard with pcc */ - -#define PCC_BITFIELD_TYPE_MATTERS 1 - -/* this section is borrowed from the vax version since the */ -/* formats are the same in both of the architectures */ - -#define CHECK_FLOAT_VALUE(MODE, D, OVERFLOW) \ - if (OVERFLOW) \ - (D) = 1.7014117331926443e+38; \ - else if ((MODE) == SFmode) \ - { \ - if ((D) > 1.7014117331926443e+38) \ - (OVERFLOW) = 1, (D) = 1.7014117331926443e+38; \ - else if ((D) < -1.7014117331926443e+38) \ - (OVERFLOW) = 1, (D) = -1.7014117331926443e+38; \ - else if (((D) > 0) && ((D) < 2.9387358770557188e-39)) \ - (OVERFLOW) = 1, (D) = 0.0; \ - else if (((D) < 0) && ((D) > -2.9387358770557188e-39)) \ - (OVERFLOW) = 1, (D) = 0.0; \ - } - - -/* - * Register Usage - */ - -/* define 15 general regs plus one for the floating point reg (FPP) */ - -#define FIRST_PSEUDO_REGISTER 17 - -/* let the compiler know what the fp, sp and pc are */ - -#define FIXED_REGISTERS {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 0} - -/* lots of regs aren't guaranteed to return from a call. The FPP reg */ -/* must be included in these since it can't be saved by the reg mask */ - -#define CALL_USED_REGISTERS {1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1} - -/* A single fp reg can handle any type of float. - CPU regs hold just 32 bits. */ - -#define HARD_REGNO_NREGS(REGNO, MODE) \ - (REGNO != 16 ? ((GET_MODE_SIZE(MODE)+UNITS_PER_WORD-1) / UNITS_PER_WORD) \ - : GET_MODE_NUNITS ((MODE))) - -/* any mode greater than 4 bytes (doubles) can only go in an even regs */ -/* and the FPP can only hold SFmode and DFmode */ - -#define HARD_REGNO_MODE_OK(REGNO, MODE) \ - (REGNO != 16 \ - ? (GET_MODE_UNIT_SIZE (MODE) <= 4 ? 1 : (REGNO % 2 - 1)) \ - : ((MODE) == SFmode || (MODE) == DFmode \ - || (MODE) == SCmode || (MODE) == DCmode)) - -/* if mode1 or mode2, but not both, are doubles then modes cannot be tied */ - -#define MODES_TIEABLE_P(MODE1, MODE2) \ - (((MODE1) == DFmode || (MODE1) == DCmode) \ - == ((MODE2) == DFmode || (MODE2) == DCmode)) - -/* return nonzero if register variable of mode MODE is not - a priori a bad idea. Used only if defined. */ -#define MODE_OK_FOR_USERVAR(MODE) \ - ((MODE) == SImode) - -/* the program counter is reg 15 */ - -#define PC_REGNUM 15 - -/* the stack pointer is reg 14 */ - -#define STACK_POINTER_REGNUM 14 - -/* the frame pointer is reg 13 */ - -#define FRAME_POINTER_REGNUM 13 - -/* tahoe does require an fp */ - -#define FRAME_POINTER_REQUIRED 1 - -/* since tahoe doesn't have a argument pointer, make it the fp */ - -#define ARG_POINTER_REGNUM 13 - -/* this isn't currently used since C doesn't support this feature */ - -#define STATIC_CHAIN_REGNUM 0 - -/* we'll use reg 1 for structure passing cause the destination */ -/* of the eventual movblk requires it to be there anyway. */ - -#define STRUCT_VALUE_REGNUM 1 - - -/* - * Register Classes - */ - -/* tahoe has two types of regs. GENERAL_REGS are all the regs up */ -/* to number 15. FPP_REG is the special floating point processor */ -/* register class (only one reg). */ - -enum reg_class {NO_REGS,GENERAL_REGS,FPP_REG,ALL_REGS,LIM_REG_CLASSES}; - -/* defines the number of reg classes. */ - -#define N_REG_CLASSES (int) LIM_REG_CLASSES - -/* this defines what the classes are officially named for debugging */ - -#define REG_CLASS_NAMES \ - {"NO_REGS","GENERAL_REGS","FPP_REG","ALL_REGS"} - -/* set general regs to be the first 16 regs and the fpp reg to be 17th */ - -#define REG_CLASS_CONTENTS {0,0xffff,0x10000,0x1ffff} - -/* register class for the fpp reg is FPP_REG, all others are GENERAL_REGS */ - -#define REGNO_REG_CLASS(REGNO) (REGNO == 16 ? FPP_REG : GENERAL_REGS) - -/* only general registers can be used as a base reg */ - -#define BASE_REG_CLASS GENERAL_REGS - -/* only general registers can be used to index */ - -#define INDEX_REG_CLASS GENERAL_REGS - -/* 'a' as a constraint in the md file means the FFP_REG class */ - -#define REG_CLASS_FROM_LETTER(C) (C == 'a' ? FPP_REG : NO_REGS) - -/* any general reg but the fpp can be a base reg */ - -#define REGNO_OK_FOR_BASE_P(regno) \ -((regno) < FIRST_PSEUDO_REGISTER - 1 || reg_renumber[regno] >= 0) - -/* any general reg except the pc and fpp can be an index reg */ - -#define REGNO_OK_FOR_INDEX_P(regno) \ -((regno) < FIRST_PSEUDO_REGISTER - 2 || reg_renumber[regno] >= 0) - -/* if your loading a floating point constant, it can't be done */ -/* through a register. Force it to be a memory constant. */ - -#define PREFERRED_RELOAD_CLASS(X,CLASS) \ - ((GET_CODE (X) == CONST_DOUBLE) ? NO_REGS : CLASS) - -/* for the fpp reg, all modes fit; for any others, you need two for doubles */ - -#define CLASS_MAX_NREGS(CLASS, MODE) \ - (CLASS != FPP_REG ? ((GET_MODE_SIZE (MODE) + UNITS_PER_WORD - 1) / UNITS_PER_WORD) : 1) - -/* we don't define any special constant sizes so all should fail */ - -#define CONST_OK_FOR_LETTER_P(VALUE, C) 0 - -/* we don't define any special double sizes so all should fail */ - -#define CONST_DOUBLE_OK_FOR_LETTER_P(VALUE, C) 0 - - -/* - * Describing Stack Layout - */ - -/* tahoe stack grows from high to low memory */ - -#define STACK_GROWS_DOWNWARD - -/* Define this if longjmp restores from saved registers - rather than from what setjmp saved. */ -#define LONGJMP_RESTORE_FROM_STACK - -/* tahoe call frames grow from high to low memory on the stack */ - -#define FRAME_GROWS_DOWNWARD - -/* the tahoe fp points to the *top* of the frame instead of the */ -/* bottom, so we have to make this offset a constant large enough */ -/* to jump over the biggest frame possible. */ - -#define STARTING_FRAME_OFFSET -52 - -/* tahoe always pushes 4 bytes unless it's a double in which case */ -/* it pushes a full 8 bytes. */ - -#define PUSH_ROUNDING(BYTES) (BYTES <= 4 ? 4 : 8) - -/* the first parameter in a function is at the fp + 4 */ - -#define FIRST_PARM_OFFSET(FNDECL) 4 - -/* the tahoe return function takes care of everything on the stack */ - -#define RETURN_POPS_ARGS(FUNDECL,FUNTYPE,SIZE) (SIZE) - -/* function values for all types are returned in register 0 */ - -#define FUNCTION_VALUE(VALTYPE, FUNC) \ - gen_rtx_REG (TYPE_MODE (VALTYPE), 0) - -/* library routines also return things in reg 0 */ - -#define LIBCALL_VALUE(MODE) gen_rtx_REG (MODE, 0) - -/* Tahoe doesn't return structures in a reentrant way */ - -#define PCC_STATIC_STRUCT_RETURN - -/* we only return values from a function in reg 0 */ - -#define FUNCTION_VALUE_REGNO_P(N) ((N) == 0) - -/* we never pass args through a register */ - -#define FUNCTION_ARG(CUM, MODE, TYPE, NAMED) 0 - -/* int is fine to hold the argument summary in FUNCTION_ARG */ - -#define CUMULATIVE_ARGS int - -/* we just set CUM to 0 before the FUNCTION_ARG call. No matter what */ -/* we make it, FUNCTION_ARG will return 0 anyway */ - -#define INIT_CUMULATIVE_ARGS(CUM,FNTYPE,LIBNAME,INDIRECT) \ - ((CUM) = 0) - -/* all modes push their size rounded to the nearest word boundary */ -/* except block which is the size of the block rounded up */ - -#define FUNCTION_ARG_ADVANCE(CUM, MODE, TYPE, NAMED) \ - ((CUM) += ((MODE) != BLKmode \ - ? (GET_MODE_SIZE (MODE) + 3) & ~3 \ - : (int_size_in_bytes (TYPE) + 3) & ~3)) - -/* this is always false since we never pass params in regs */ - -#define FUNCTION_ARG_REGNO_P(N) 0 - -/* this code calculates the register entry mask and sets up */ -/* the stack pointer for the function. The stack is set down */ -/* far enough from the fp to jump over any push regs and local */ -/* vars. This is a problem since the tahoe has the fp pointing */ -/* to the top of the frame and the compiler must know the off- */ -/* set off the fp to the local vars. */ - -#define FUNCTION_PROLOGUE(FILE, SIZE) \ -{ register int regno; \ - register int mask = 0; \ - extern char call_used_regs[]; \ - for (regno = 0; regno < FIRST_PSEUDO_REGISTER-1; regno++) \ - if (regs_ever_live[regno] && !call_used_regs[regno]) \ - mask |= 1 << regno; \ - fprintf (FILE, "\t.word 0x%x\n", mask); \ - if (SIZE != 0) fprintf (FILE, "\tsubl3 $%d,fp,sp\n", (SIZE) - STARTING_FRAME_OFFSET); } - -/* Zero out global variable in case it was used in this function. */ -#define FUNCTION_EPILOGUE(FILE, SIZE) \ -{ extern rtx tahoe_reg_conversion_loc; \ - tahoe_reg_conversion_loc = 0; \ -} - -#ifdef HCX_UX - -/* to call the profiler, the address of the counter var is placed */ -/* on the stack and then passed into mcount this way */ - -#define FUNCTION_PROFILER(FILE, LABELNO) \ - fprintf (FILE, "\tpushal LP%d\n\tcallf $8,mcount\n", (LABELNO)); - -#else - -/* to call the profiler, push the variable value onto the stack */ -/* and call mcount like a regular function. */ - -#define FUNCTION_PROFILER(FILE, LABELNO) \ - fprintf (FILE, "\tpushl $LP%d\n\tcallf $8,mcount\n", (LABELNO)); - -#endif - -/* all stack handling at the end of a function is handled by the */ -/* return command. */ - -#define EXIT_IGNORE_STACK 1 - -/* - * Library Subroutine Names - */ - -/* udiv is a valid C library routine in libc.a, so we call that */ - -#define UDIVSI3_LIBCALL "*udiv" - -/* urem is a valid C library routine in libc.a, so we call that */ -/* but not so on hcx/ux */ - -#ifdef HCX_UX -#undef UMODSI3_LIBCALL -#else -#define UMODSI3_LIBCALL "*urem" -#endif - - -/* - * Addressing Modes - */ - -/* constant addresses can be treated exactly the same as normal constants */ - -#define CONSTANT_ADDRESS_P(X) \ - (GET_CODE (X) == LABEL_REF || GET_CODE (X) == SYMBOL_REF \ - || GET_CODE (X) == CONST_INT || GET_CODE (X) == CONST \ - || GET_CODE (X) == HIGH) - -/* we can have as many as two regs in any given address */ - -#define MAX_REGS_PER_ADDRESS 2 - -/* The following is all the code for GO_IF_LEGITIMATE_ADDRESS */ -/* most of this taken directly from the vax tm file since the */ -/* tahoe and vax addressing modes are nearly identical. */ - -/* Is x an indirectable address? */ - -#define INDIRECTABLE_ADDRESS_P(X) \ - (CONSTANT_ADDRESS_P (X) \ - || (GET_CODE (X) == REG && REG_OK_FOR_BASE_P (X)) \ - || (GET_CODE (X) == PLUS \ - && GET_CODE (XEXP (X, 0)) == REG \ - && REG_OK_FOR_BASE_P (XEXP (X, 0)) \ - && CONSTANT_ADDRESS_P (XEXP (X, 1)))) - -/* If x is a non-indexed-address, go to ADDR. */ - -#define GO_IF_NONINDEXED_ADDRESS(X, ADDR) \ -{ register rtx xfoob = (X); \ - if (GET_CODE (xfoob) == REG) goto ADDR; \ - if (INDIRECTABLE_ADDRESS_P (xfoob)) goto ADDR; \ - xfoob = XEXP (X, 0); \ - if (GET_CODE (X) == MEM && INDIRECTABLE_ADDRESS_P (xfoob)) \ - goto ADDR; \ - if ((GET_CODE (X) == PRE_DEC || GET_CODE (X) == POST_INC) \ - && GET_CODE (xfoob) == REG && REGNO (xfoob) == 14) \ - goto ADDR; } - -/* Is PROD an index term in mode MODE. */ - -#define INDEX_TERM_P(PROD, MODE) \ -(GET_MODE_SIZE (MODE) == 1 \ - ? (GET_CODE (PROD) == REG && REG_OK_FOR_BASE_P (PROD)) \ - : (GET_CODE (PROD) == MULT \ - && \ - (xfoo0 = XEXP (PROD, 0), xfoo1 = XEXP (PROD, 1), \ - ((GET_CODE (xfoo0) == CONST_INT \ - && INTVAL (xfoo0) == GET_MODE_SIZE (MODE) \ - && GET_CODE (xfoo1) == REG \ - && REG_OK_FOR_INDEX_P (xfoo1)) \ - || \ - (GET_CODE (xfoo1) == CONST_INT \ - && INTVAL (xfoo1) == GET_MODE_SIZE (MODE) \ - && GET_CODE (xfoo0) == REG \ - && REG_OK_FOR_INDEX_P (xfoo0)))))) - -/* Is the addition to the index a reg? */ - -#define GO_IF_REG_PLUS_INDEX(X, MODE, ADDR) \ -{ register rtx xfooa; \ - if (GET_CODE (X) == PLUS) \ - { if (GET_CODE (XEXP (X, 0)) == REG \ - && REG_OK_FOR_BASE_P (XEXP (X, 0)) \ - && (xfooa = XEXP (X, 1), \ - INDEX_TERM_P (xfooa, MODE))) \ - goto ADDR; \ - if (GET_CODE (XEXP (X, 1)) == REG \ - && REG_OK_FOR_BASE_P (XEXP (X, 1)) \ - && (xfooa = XEXP (X, 0), \ - INDEX_TERM_P (xfooa, MODE))) \ - goto ADDR; } } - -/* Is the rtx X a valid memory address for operand of mode MODE? */ -/* If it is, go to ADDR */ - -#define GO_IF_LEGITIMATE_ADDRESS(MODE, X, ADDR) \ -{ register rtx xfoo, xfoo0, xfoo1; \ - GO_IF_NONINDEXED_ADDRESS (X, ADDR); \ - if (GET_CODE (X) == PLUS) \ - { xfoo = XEXP (X, 0); \ - if (INDEX_TERM_P (xfoo, MODE)) \ - { GO_IF_NONINDEXED_ADDRESS (XEXP (X, 1), ADDR); } \ - xfoo = XEXP (X, 1); \ - if (INDEX_TERM_P (xfoo, MODE)) \ - { GO_IF_NONINDEXED_ADDRESS (XEXP (X, 0), ADDR); } \ - if (CONSTANT_ADDRESS_P (XEXP (X, 0))) \ - { if (GET_CODE (XEXP (X, 1)) == REG \ - && REG_OK_FOR_BASE_P (XEXP (X, 1))) \ - goto ADDR; \ - GO_IF_REG_PLUS_INDEX (XEXP (X, 1), MODE, ADDR); } \ - if (CONSTANT_ADDRESS_P (XEXP (X, 1))) \ - { if (GET_CODE (XEXP (X, 0)) == REG \ - && REG_OK_FOR_BASE_P (XEXP (X, 0))) \ - goto ADDR; \ - GO_IF_REG_PLUS_INDEX (XEXP (X, 0), MODE, ADDR); } } } - -/* Register 16 can never be used for index or base */ - -#ifndef REG_OK_STRICT -#define REG_OK_FOR_INDEX_P(X) (REGNO(X) != 16) -#define REG_OK_FOR_BASE_P(X) (REGNO(X) != 16) -#else -#define REG_OK_FOR_INDEX_P(X) REGNO_OK_FOR_INDEX_P (REGNO (X)) -#define REG_OK_FOR_BASE_P(X) REGNO_OK_FOR_BASE_P (REGNO (X)) -#endif - -/* Addressing is too simple to allow optimizing here */ - -#define LEGITIMIZE_ADDRESS(X,OLDX,MODE,WIN) {} - -/* Post_inc and pre_dec always adds 4 */ - -#define GO_IF_MODE_DEPENDENT_ADDRESS(ADDR,LABEL) \ - { if (GET_CODE(ADDR) == POST_INC || GET_CODE(ADDR) == PRE_DEC) \ - goto LABEL; \ - if (GET_CODE (ADDR) == PLUS) \ - { if (CONSTANT_ADDRESS_P (XEXP (ADDR, 0)) \ - && GET_CODE (XEXP (ADDR, 1)) == REG); \ - else if (CONSTANT_ADDRESS_P (XEXP (ADDR, 1)) \ - && GET_CODE (XEXP (ADDR, 0)) == REG); \ - else goto LABEL; }} - -/* Double's are not legitimate as immediate operands */ - -#define LEGITIMATE_CONSTANT_P(X) \ - (GET_CODE (X) != CONST_DOUBLE) - - -/* - * Miscellaneous Parameters - */ - -/* the elements in the case jump table are all words */ - -#define CASE_VECTOR_MODE HImode - -/* 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 - -/* tahoe case instructions just fall through to the next instruction */ -/* if not satisfied. It doesn't support a default action */ - -#define CASE_DROPS_THROUGH - -/* the standard answer is given here and work ok */ - -#define IMPLICIT_FIX_EXPR FIX_ROUND_EXPR - -/* in a general div case, it's easiest to use TRUNC_DIV_EXPR */ - -#define EASY_DIV_EXPR TRUNC_DIV_EXPR - -/* the standard seems to be leaving char's as signed so we left it */ -/* this way even though we think they should be unsigned! */ - -#define DEFAULT_SIGNED_CHAR 1 - -/* the most we can move without cutting down speed is 4 bytes */ - -#define MOVE_MAX 4 - -/* our int is 32 bits */ - -#define INT_TYPE_SIZE 32 - -/* byte access isn't really slower than anything else */ - -#define SLOW_BYTE_ACCESS 0 - -/* zero extension is more than one instruction so try to avoid it */ - -#define SLOW_ZERO_EXTEND - -/* any bits higher than the low 4 are ignored in the shift count */ -/* so don't bother zero extending or sign extending them */ - -#define SHIFT_COUNT_TRUNCATED 1 - -/* we don't need to officially convert from one fixed type to another */ -/* in order to use it as that type. We can just assume it's the same */ - -#define TRULY_NOOP_TRUNCATION(OUTPREC, INPREC) 1 - -/* pass chars as ints */ - -#define PROMOTE_PROTOTYPES 1 - -/* pointers can be represented by an si mode expression */ - -#define Pmode SImode - -/* function addresses are made by specifying a byte address */ - -#define FUNCTION_MODE QImode - -/* Define this if addresses of constant functions - shouldn't be put through pseudo regs where they can be cse'd. - On the tahoe a call with a constant address is much faster than one with a - register. */ - -#define NO_FUNCTION_CSE - -/* specify the costs of various sorts of constants, - and also indicate that multiplication is cheap on this machine. */ - -#define CONST_COSTS(RTX,CODE,OUTER_CODE) \ - case CONST_INT: \ - /* Constant zero is super cheap due to clr instruction. */ \ - if (RTX == const0_rtx) return 0; \ - if ((unsigned) INTVAL (RTX) < 077) return 1; \ - if (INTVAL (RTX) <= 127 && INTVAL (RTX) >= -128) return 2; \ - case CONST: \ - case LABEL_REF: \ - case SYMBOL_REF: \ - return 3; \ - case CONST_DOUBLE: \ - return 5; \ - case MULT: \ - total = 2; - - -/* - * Condition Code Information - */ - -/* Nonzero if the results of the previous comparison are - in the floating point condition code register. */ - -#define CC_UNCHANGED 04000 - - -#define NOTICE_UPDATE_CC(EXP, INSN) \ -{ if (cc_status.flags & CC_UNCHANGED) \ - /* Happens for cvtld and a few other insns. */ \ - cc_status.flags &= ~CC_UNCHANGED; \ - else if (GET_CODE (EXP) == SET) \ - { if (GET_CODE (SET_SRC (EXP)) == CALL) \ - CC_STATUS_INIT; \ - else if (GET_CODE (SET_DEST (EXP)) != PC) \ - { cc_status.flags = 0; \ - cc_status.value1 = SET_DEST (EXP); \ - cc_status.value2 = SET_SRC (EXP); } } \ - else if (GET_CODE (EXP) == PARALLEL \ - && GET_CODE (XVECEXP (EXP, 0, 0)) == SET \ - && GET_CODE (SET_DEST (XVECEXP (EXP, 0, 0))) != PC) \ - { cc_status.flags = 0; \ - cc_status.value1 = SET_DEST (XVECEXP (EXP, 0, 0)); \ - cc_status.value2 = SET_SRC (XVECEXP (EXP, 0, 0)); } \ - /* PARALLELs whose first element sets the PC are aob, sob insns. \ - They do change the cc's. So drop through and forget the cc's. */ \ - else 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)) \ - cc_status.value2 = 0; \ - if (cc_status.value1 && GET_CODE (cc_status.value1) == MEM \ - && cc_status.value2 \ - && GET_CODE (cc_status.value2) == MEM) \ - cc_status.value2 = 0; } -/* Actual condition, one line up, should be that value2's address - depends on value1, but that is too much of a pain. */ - - -/* - * Output of Assembler Code - */ - -/* print which tahoe version compiled this code and print a directive */ -/* to the gnu assembler to say that the following is normal assembly */ - -#ifdef HCX_UX -#define ASM_FILE_START(FILE) \ -{ fprintf (FILE, "#gcc hcx 1.0\n\n"); \ - output_file_directive ((FILE), main_input_filename);} while (0) -#else -#define ASM_FILE_START(FILE) fprintf (FILE, "#gcc tahoe 1.0\n#NO_APP\n"); -#endif - -/* the instruction that turns on the APP for the gnu assembler */ - -#define ASM_APP_ON "#APP\n" - -/* the instruction that turns off the APP for the gnu assembler */ - -#define ASM_APP_OFF "#NO_APP\n" - -/* what to output before read-only data. */ - -#define TEXT_SECTION_ASM_OP "\t.text" - -/* what to output before writable data. */ - -#define DATA_SECTION_ASM_OP "\t.data" - -/* this is what we call each of the regs. notice that the FPP reg is */ -/* called "ac". This should never get used due to the way we've set */ -/* up FPP instructions in the md file. But we call it "ac" here to */ -/* fill the list. */ - -#define REGISTER_NAMES \ -{"r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7", "r8", \ - "r9", "r10", "r11", "r12", "fp", "sp", "pc", "ac"} - -#ifdef HCX_UX -/* allow generation of sdb info in the assembly */ -#define SDB_DEBUGGING_INFO -#else -/* allow generation of dbx info in the assembly */ - -#define DBX_DEBUGGING_INFO - -/* our dbx doesn't support this */ - -#define DBX_NO_XREFS - -/* we don't want symbols broken up */ - -#define DBX_CONTIN_LENGTH 0 - -/* this'll really never be used, but we'll leave it at this */ - -#define DBX_CONTIN_CHAR '?' - -#endif /* HCX_UX */ - -/* registers are called the same thing in dbx anything else */ -/* This is necessary even if we generate SDB output */ - -#define DBX_REGISTER_NUMBER(REGNO) (REGNO) - -/* labels are the label followed by a colon and a newline */ -/* must be a statement, so surround it in a null loop */ - -#define ASM_OUTPUT_LABEL(FILE,NAME) \ - do { assemble_name (FILE, NAME); fputs (":\n", FILE); } while (0) - -/* use the .globl directive to make labels global for the linker */ - -#define ASM_GLOBALIZE_LABEL(FILE,NAME) \ - do { fputs (".globl ", FILE); assemble_name (FILE, NAME); fputs ("\n", FILE);} while (0) - -/* The prefix to add to user-visible assembler symbols. */ - -#define USER_LABEL_PREFIX "_" - -/* use the standard format for printing internal labels */ - -#define ASM_OUTPUT_INTERNAL_LABEL(FILE,PREFIX,NUM) \ - fprintf (FILE, "%s%d:\n", PREFIX, NUM) - -/* a * is used for label indirection in unix assembly */ - -#define ASM_GENERATE_INTERNAL_LABEL(LABEL,PREFIX,NUM) \ - sprintf (LABEL, "*%s%d", PREFIX, NUM) - -/* outputting a double is easy cause we only have one kind */ - -#ifdef HCX_UX -#define ASM_OUTPUT_DOUBLE(FILE,VALUE) \ - fprintf (FILE, "\t.double 0d%.20e\n", (VALUE)) -#else -#define ASM_OUTPUT_DOUBLE(FILE,VALUE) \ -{ \ - union { int i[2]; double d;} temp; \ - temp.d = (VALUE); \ - if (TARGET_HEX_FLOAT) \ - fprintf ((FILE), "\t.long 0x%x,0x%x # %.20e\n", \ - temp.i[0], temp.i[1], temp.d); \ - else \ - fprintf (FILE, "\t.dfloat 0d%.20e\n", temp.d); \ -} -#endif - -/* This is how to output an assembler line defining a `float' constant. */ - -#ifdef HCX_UX -#define ASM_OUTPUT_FLOAT(FILE,VALUE) \ - fprintf (FILE, "\t.float 0f%.20e\n", (VALUE)) -#else -#define ASM_OUTPUT_FLOAT(FILE,VALUE) \ -{ \ - union { int i; float f;} temp; \ - temp.f = (float) (VALUE); \ - if (TARGET_HEX_FLOAT) \ - fprintf ((FILE), "\t.long 0x%x # %.20e\n", \ - temp.i, temp.f); \ - else \ - fprintf (FILE, "\t.float 0f%.20e\n", temp.f); \ -} -#endif - -/* This is how to output an assembler line defining an `int' constant. */ - -#define ASM_OUTPUT_INT(FILE,VALUE) \ -( fprintf (FILE, "\t.long "), \ - output_addr_const (FILE, (VALUE)), \ - fprintf (FILE, "\n")) - -/* Likewise for `char' and `short' constants. */ - -#define ASM_OUTPUT_SHORT(FILE,VALUE) \ -( fprintf (FILE, "\t.word "), \ - output_addr_const (FILE, (VALUE)), \ - fprintf (FILE, "\n")) - -#define ASM_OUTPUT_CHAR(FILE,VALUE) \ -( fprintf (FILE, "\t.byte "), \ - output_addr_const (FILE, (VALUE)), \ - fprintf (FILE, "\n")) - -#ifdef HCX_UX -/* This is how to output an assembler line for an ASCII string. */ - -#define ASM_OUTPUT_ASCII(FILE, p, size) \ -do { register int i; \ - fprintf ((FILE), "\t.ascii \""); \ - for (i = 0; i < (size); i++) \ - { \ - register int c = (p)[i]; \ - if (c == '\'' || c == '\\') \ - putc ('\\', (FILE)); \ - if (c >= ' ' && c < 0177 && c != '\"') \ - putc (c, (FILE)); \ - else \ - { \ - fprintf ((FILE), "\\%03o", c); \ - } \ - } \ - fprintf ((FILE), "\"\n"); } while (0) -#endif - -/* This is how to output an assembler line for a numeric constant byte. */ - -#define ASM_OUTPUT_BYTE(FILE,VALUE) \ - fprintf (FILE, "\t.byte 0x%x\n", (VALUE)) - -/* this is the insn to push a register onto the stack */ - -#define ASM_OUTPUT_REG_PUSH(FILE,REGNO) \ - fprintf (FILE, "\tpushl %s\n", reg_names[REGNO]) - -/* this is the insn to pop a register from the stack */ - -#define ASM_OUTPUT_REG_POP(FILE,REGNO) \ - fprintf (FILE, "\tmovl (sp)+,%s\n", reg_names[REGNO]) - -/* this is required even thought tahoe doesn't support it */ -/* cause the C code expects it to be defined */ - -#define ASM_OUTPUT_ADDR_VEC_ELT(FILE, VALUE) \ - fprintf (FILE, "\t.long L%d\n", VALUE) - -/* This is how to output an element of a case-vector that is relative. */ - -#define ASM_OUTPUT_ADDR_DIFF_ELT(FILE, BODY, VALUE, REL) \ - fprintf (FILE, "\t.word L%d-L%d\n", VALUE, REL) - -/* This is how to output an assembler line - that says to advance the location counter - to a multiple of 2**LOG bytes. */ - -#ifdef HCX_UX -#define CASE_ALIGNMENT 2 -#define ASM_OUTPUT_ALIGN(FILE,LOG) \ - if ((LOG)!=0) fprintf ((FILE), "\t.align %d\n", 1<<(LOG)) -#else -#define CASE_ALIGNMENT 1 -#define ASM_OUTPUT_ALIGN(FILE,LOG) \ - LOG ? fprintf (FILE, "\t.align %d\n", (LOG)) : 0 -#endif - -/* This is how to skip over some space */ - -#define ASM_OUTPUT_SKIP(FILE,SIZE) \ - fprintf (FILE, "\t.space %u\n", (SIZE)) - -/* This defines common variables across files */ - -#ifdef HCX_UX -#define ASM_OUTPUT_COMMON(FILE, NAME, SIZE, ROUNDED) \ -( fputs (".comm ", (FILE)), \ - assemble_name ((FILE), (NAME)), \ - fprintf ((FILE), ",%u\n", (SIZE))) -#else -#define ASM_OUTPUT_COMMON(FILE, NAME, SIZE, ROUNDED) \ -( fputs (".comm ", (FILE)), \ - assemble_name ((FILE), (NAME)), \ - fprintf ((FILE), ",%u\n", (ROUNDED))) -#endif - -/* This says how to output an assembler line - to define a local common symbol. */ - -#ifdef HCX_UX -#define ASM_OUTPUT_LOCAL(FILE, NAME, SIZE, ROUNDED) \ -( fputs ("\t.bss ", (FILE)), \ - assemble_name ((FILE), (NAME)), \ - fprintf ((FILE), ",%u,4\n", (SIZE),(ROUNDED))) -#else -#define ASM_OUTPUT_LOCAL(FILE, NAME, SIZE, ROUNDED) \ -( fputs (".lcomm ", (FILE)), \ - assemble_name ((FILE), (NAME)), \ - fprintf ((FILE), ",%u\n", (ROUNDED))) -#endif - -/* code to generate a label */ - -#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 - -/* Print an instruction operand X on file FILE. - CODE is the code from the %-spec that requested printing this operand; - if `%z3' was used to print operand 3, then CODE is 'z'. - On the Vax, the only code used is `#', indicating that either - `d' or `g' should be printed, depending on whether we're using dfloat - or gfloat. */ -/* Print an operand. Some difference from the vax code, - since the tahoe can't support immediate floats and doubles. - - %@ means print the proper alignment operand for aligning after a casesi. - This depends on the assembler syntax. - This is 1 for our assembler, since .align is logarithmic. - - %s means the number given is supposed to be a shift value, but on - the tahoe it should be converted to a number that can be used as a - multiplicative constant (cause multiplication is a whole lot faster - than shifting). So make the number 2^n instead. */ - -#define PRINT_OPERAND_PUNCT_VALID_P(CODE) \ - ((CODE) == '@') - -#define PRINT_OPERAND(FILE, X, CODE) \ -{ if (CODE == '@') \ - putc ('0' + CASE_ALIGNMENT, FILE); \ - else if (CODE == 's') \ - fprintf (FILE, "$%d", 1 << INTVAL(X)); \ - else if (GET_CODE (X) == REG) \ - fprintf (FILE, "%s", reg_names[REGNO (X)]); \ - else if (GET_CODE (X) == MEM) \ - output_address (XEXP (X, 0)); \ - else { putc ('$', FILE); output_addr_const (FILE, X); }} - -/* When the operand is an address, call print_operand_address to */ -/* do the work from output-tahoe.c. */ - -#define PRINT_OPERAND_ADDRESS(FILE, ADDR) \ - print_operand_address (FILE, ADDR) - -/* This is for G++ */ - -#define CRT0_DUMMIES -#define DOT_GLOBAL_START -#ifdef HCX_UX -#define NO_GNU_LD /* because of COFF format */ -#define LINK_SPEC "-L/usr/staff/lib" -#endif |