/* ---> Since we always have a frame pointer, it is safe for this   to not work.   */#define FIX_FRAME_POINTER_ADDRESS(ADDR,DEPTH) \	fatal ("compiler error, Pyramid call without frame ptr!\n")/*** Addressing modes, and classification of registers for them.  ***//* #define HAVE_POST_INCREMENT */	/* pyramid has none of these *//* #define HAVE_POST_DECREMENT *//* #define HAVE_PRE_DECREMENT *//* #define HAVE_PRE_INCREMENT *//* Macros to check register numbers against specific register classes.  *//* These assume that REGNO is a hard or pseudo reg number.   They give nonzero only if REGNO is a hard reg of the suitable class   or a pseudo reg currently allocated to a suitable hard reg.   Since they use reg_renumber, they are safe only once reg_renumber   has been allocated, which happens in local-alloc.c.  *//* All registers except gr0 OK as index or base registers.  */#define REGNO_OK_FOR_BASE_P(regno) \((0 < (regno) && (regno) < FIRST_PSEUDO_REGISTER) || reg_renumber[regno] > 0)#define REGNO_OK_FOR_INDEX_P(regno)  \((0 < (regno) && (regno) < FIRST_PSEUDO_REGISTER) || reg_renumber[regno] > 0)/* Maximum number of registers that can appear in a valid memory address.  */#define MAX_REGS_PER_ADDRESS 2     /* check MAX_REGS_PER_ADDRESS *//* 1 if X is an rtx for a constant that is a valid address.  */#define CONSTANT_ADDRESS_P(X) CONSTANT_P (X)/* 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/* The macros REG_OK_FOR..._P assume that the arg is a REG rtx   and check its validity for a certain class.   We have two alternate definitions for each of them.   The usual definition accepts all pseudo regs; the other rejects   them unless they have been allocated suitable hard regs.   The symbol REG_OK_STRICT causes the latter definition to be used.   Most source files want to accept pseudo regs in the hope that   they will get allocated to the class that the insn wants them to be in.   Source files for reload pass need to be strict.   After reload, it makes no difference, since pseudo regs have   been eliminated by then.  */#ifndef REG_OK_STRICT/* Nonzero if X is a hard reg that can be used as an index   or if it is a pseudo reg.  */#define REG_OK_FOR_INDEX_P(X) 1/* Nonzero if X is a hard reg that can be used as a base reg   or if it is a pseudo reg.  */#define REG_OK_FOR_BASE_P(X) 1#else/* Nonzero if X is a hard reg that can be used as an index.  */#define REG_OK_FOR_INDEX_P(X) REGNO_OK_FOR_INDEX_P (REGNO (X))/* Nonzero if X is a hard reg that can be used as a base reg.  */#define REG_OK_FOR_BASE_P(X) REGNO_OK_FOR_BASE_P (REGNO (X))#endif/* GO_IF_LEGITIMATE_ADDRESS recognizes an RTL expression   that is a valid memory address for an instruction.   The MODE argument is the machine mode for the MEM expression   that wants to use this address.   The other macros defined here are used only in GO_IF_LEGITIMATE_ADDRESS,   except for CONSTANT_ADDRESS_P which is actually machine-independent.  *//* Go to ADDR if X is indexable -- ie, neither indexed nor offset.   Note that X is indexable iff x is offset.  */#define GO_IF_INDEXABLE_ADDRESS(X, ADDR)  \{ register rtx xfoob = (X);						\  if ((CONSTANT_ADDRESS_P (xfoob))					\      || (GET_CODE (xfoob) == REG && (REG_OK_FOR_BASE_P (xfoob))))	\	  goto ADDR;							\ }/* Go to label ADDR if X is a valid address that doesn't use indexing.   This is so if X is either a simple address, or the contents of a register   plus an offset.   This macro also gets used in output-pyramid.h in the function that   recognizes non-indexed operands.  */#define GO_IF_NONINDEXED_ADDRESS(X, ADDR)  \{									\  if (GET_CODE (X) == REG)						\      goto ADDR;							\  GO_IF_INDEXABLE_ADDRESS (X, ADDR);					\  if (GET_CODE (X) == PLUS)						\    { /* Handle offset(reg) represented with offset on left */		\      if (CONSTANT_ADDRESS_P (XEXP (X, 0)))				\	{ if (GET_CODE (XEXP (X, 1)) == REG				\	      && REG_OK_FOR_BASE_P (XEXP (X, 1)))			\	    goto ADDR;							\	 }								\      /* Handle offset(reg) represented with offset on right */		\      if (CONSTANT_ADDRESS_P (XEXP (X, 1)))				\	{ if (GET_CODE (XEXP (X, 0)) == REG				\	      && REG_OK_FOR_BASE_P (XEXP (X, 0)))			\	    goto ADDR;							\	 }								\     }									\}/* 1 if PROD is either a reg or a reg times a valid offset multiplier   (ie, 2, 4, or 8).   This macro's expansion uses the temporary variables xfoo0 and xfoo1   that must be declared in the surrounding context.  */#define INDEX_TERM_P(PROD, MODE)   \((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) == 1					\	     || INTVAL (xfoo0) == 2					\	     || INTVAL (xfoo0) == 4					\	     || INTVAL (xfoo0) == 8)					\         && GET_CODE (xfoo1) == REG					\         && REG_OK_FOR_INDEX_P (xfoo1))					\        ||								\        (GET_CODE (xfoo1) == CONST_INT					\	 && (INTVAL (xfoo1) == 1					\	     || INTVAL (xfoo1) == 2					\	     || INTVAL (xfoo1) == 4					\	     || INTVAL (xfoo1) == 8)					\        && GET_CODE (xfoo0) == REG					\        && REG_OK_FOR_INDEX_P (xfoo0))))))#define GO_IF_LEGITIMATE_ADDRESS(MODE, X, ADDR)  \{ register rtx xone, xtwo, xfoo0, xfoo1;				\  GO_IF_NONINDEXED_ADDRESS (X, ADDR);					\  if (TARGET_INDEX && GET_CODE (X) == PLUS)				\    {									\      /* Handle <address>[index] represented with index-sum outermost */\      xone = XEXP (X, 0);						\      xtwo = XEXP (X, 1);						\      if (INDEX_TERM_P (xone, MODE))					\	{ GO_IF_INDEXABLE_ADDRESS (xtwo, ADDR); }			\      /* Handle <address>[index] represented with index-sum innermost */\      if (INDEX_TERM_P (xtwo, MODE))					\	{ GO_IF_INDEXABLE_ADDRESS (xone, ADDR); }			\    }									\}/* 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.   --> FIXME: We haven't yet figured out what optimizations are useful   --> on Pyramids.   */#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.   There don't seem to be any such modes on pyramids. */#define GO_IF_MODE_DEPENDENT_ADDRESS(ADDR,LABEL)/*** Miscellaneous Parameters ***//* Specify the machine mode that this machine uses   for the index in the tablejump instruction.  */#define CASE_VECTOR_MODE SImode/* Define this 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*//* 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.   It's just a guess. I have no idea of insn cost on pyrs. */#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/* This flag, if defined, says the same insns that convert to a signed fixnum   also convert validly to an unsigned one.  *//* This is untrue for pyramid.  The cvtdw instruction generates a trap   for input operands that are out-of-range for a signed int.  *//* #define FIXUNS_TRUNC_LIKE_FIX_TRUNC *//* Define this macro if the preprocessor should silently ignore  '#sccs' directives. *//* #define SCCS_DIRECTIVE *//* Define this macro if the preprocessor should silently ignore  '#ident' directives. *//* #define IDENT_DIRECTIVE *//* Max number of bytes we can move from memory to memory   in one reasonably fast instruction.  */#define MOVE_MAX 8/* Define this if zero-extension is slow (more than one real instruction).  *//* #define SLOW_ZERO_EXTEND *//* number of bits in an 'int' on target machine */#define INT_TYPE_SIZE 32/* 1 if byte access requires more than one instruction */#define SLOW_BYTE_ACCESS 0/* Define if shifts truncate the shift count   which implies one can omit a sign-extension or zero-extension   of a shift count.  */#define SHIFT_COUNT_TRUNCATED/* Value is 1 if truncating an integer of INPREC bits to OUTPREC bits   is done just by pretending it is already truncated.  */#define TRULY_NOOP_TRUNCATION(OUTPREC, INPREC) 1/* Define this macro if it is as good or better to call a constant   function address than to call an address kept in a register./* #define NO_FUNCTION_CSE *//* When a prototype says `char' or `short', really pass an `int'.  */#define PROMOTE_PROTOTYPES/* There are no flag store insns on a pyr. *//* #define STORE_FLAG_VALUE *//* 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.  */#define Pmode SImode/* A function address in a call instruction   is a byte address (for indexing purposes)   so give the MEM rtx a byte's mode.  */#define FUNCTION_MODE QImode/* 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.  */#define CONST_COSTS(RTX,CODE) \  case CONST_INT:						\    if (CONST_OK_FOR_LETTER_P (INTVAL (RTX),'I')) return 0;	\  case CONST:							\  case LABEL_REF:						\  case SYMBOL_REF:						\    return 2;							\  case CONST_DOUBLE:						\    return 4;/*** Condition Code Information ***//* Tell final.c how to eliminate redundant test instructions.  *//* Here we define machine-dependent flags and fields in cc_status   (see `conditions.h').  No extra ones are needed for the pyr.  *//* Store in cc_status the expressions   that the condition codes will describe   after execution of an instruction whose pattern is EXP.   Do not alter them if the instruction would not alter the cc's.  *//* This is a very simple definition of NOTICE_UPDATE_CC.   Many cases can be optimized, to improve condition code usage.   Maybe we should handle this entirely in the md, since it complicated   to describe the way pyr sets cc.  */#define TRULY_UNSIGNED_COMPARE_P(X) \  (X == GEU || X == GTU || X == LEU || X == LTU)#define CC_VALID_FOR_UNSIGNED 2#define CC_STATUS_MDEP_INIT cc_status.mdep = 0#define NOTICE_UPDATE_CC(EXP, INSN) \  notice_update_cc(EXP, INSN)/*** Output of Assembler Code ***//* Output at beginning of assembler file.  */#define ASM_FILE_START(FILE) \  fprintf (FILE, ((TARGET_UNIX_ASM)? "" : "#NO_APP\n"));/* Output to assembler file text saying following lines   may contain character constants, extra white space, comments, etc.  */#define ASM_APP_ON ((TARGET_UNIX_ASM) ? "" : "#APP\n")/* Output to assembler file text saying following lines   no longer contain unusual constructs.  */#define ASM_APP_OFF ((TARGET_UNIX_ASM) ? "" : "#NO_APP\n")/* Output before read-only data.  */#define TEXT_SECTION_ASM_OP ".text"/* Output before writable data.  */#define DATA_SECTION_ASM_OP ".data"/* How to refer to registers in assembler output.   This sequence is indexed by compiler's hard-register-number (see above).  */#define REGISTER_NAMES \{"gr0", "gr1", "gr2", "gr3", "gr4", "gr5", "gr6", "gr7", "gr8", \ "gr9", "gr10", "gr11", "logpsw", "cfp", "sp", "pc", \ "pr0", "pr1", "pr2", "pr3", "pr4", "pr5", "pr6", "pr7", \ "pr8", "pr9", "pr10", "pr11", "pr12", "pr13", "pr14", "pr15", \ "lr0", "lr1", "lr2", "lr3", "lr4", "lr5", "lr6", "lr7", \ "lr8", "lr9", "lr10", "lr11", "lr12", "lr13", "lr14", "lr15", \ "tr0", "tr1", "tr2", "tr3", "tr4", "tr5", "tr6", "tr7", \ "tr8", "tr9", "tr10", "tr11", "tr12", "tr13", "tr14", "tr15"}/* How to renumber registers for dbx and gdb.  */#define DBX_REGISTER_NUMBER(REGNO) (REGNO)/* Our preference is for dbx rather than sdb.   Yours may be different. */#define DBX_DEBUGGING_INFO/* #define SDB_DEBUGGING_INFO *//* Don't use the `xsfoo;' construct in DBX output; this system   doesn't support it.  */