pyr.h

gcc-2.95.3 Linux下最常用的C编译器

				     gen_rtx (SYMBOL_REF, Pmode,	\
					      "__enable_execute_stack")), \
			    const0_rtx));				\
}

/* Output assembler code to FILE to increment profiler label # LABELNO
   for profiling a function entry.  */
#define FUNCTION_PROFILER(FILE, LABELNO)  \
   fprintf (FILE, "\tmova LP%d,tr0\n\tcall mcount\n", (LABELNO));

/* Output assembler code to FILE to initialize this source file's
   basic block profiling info, if that has not already been done.
   Don't know if this works on Pyrs. */

#if 0 /* don't do basic_block profiling yet */
#define FUNCTION_BLOCK_PROFILER(FILE, LABELNO)  \
  fprintf (FILE, \
           "\tmtstw LPBX0,tr0\n\tbne LPI%d\n\tmova LP%d,TR0\n\tcall __bb_init_func\nLPI%d:\n", \
           LABELNO, LABELNO);

/* Output assembler code to increment the count associated with
   the basic block number BLOCKNO.  Not sure how to do this on pyrs. */
#define BLOCK_PROFILER(FILE, BLOCKNO)  \
    fprintf (FILE, "\taddw", 4 * BLOCKNO)
#endif /* don't do basic_block profiling yet */

/* When returning from a function, the stack pointer does not matter
   (as long as there is a frame pointer).  */

/* This should return non-zero when we really set up a frame pointer.
   Otherwise, GCC is directed to preserve sp by returning zero.  */
extern int current_function_pretend_args_size;
extern int current_function_args_size;
extern int current_function_calls_alloca;
#define EXIT_IGNORE_STACK \
  (get_frame_size () + current_function_pretend_args_size		\
   + current_function_args_size != 0					\
   || current_function_calls_alloca)					\

/* Store in the variable DEPTH the initial difference between the
   frame pointer reg contents and the stack pointer reg contents,
   as of the start of the function body.  This depends on the layout
   of the fixed parts of the stack frame and on how registers are saved.

   On the Pyramid, FRAME_POINTER_REQUIRED is always 1, so the definition
   of this macro doesn't matter.  But it must be defined.  */

#define INITIAL_FRAME_POINTER_OFFSET(DEPTH) (DEPTH) = 0;

/*** Addressing modes, and classification of registers for them.  ***/

/* #define HAVE_POST_INCREMENT 0 */	/* pyramid has none of these */
/* #define HAVE_POST_DECREMENT 0 */

/* #define HAVE_PRE_DECREMENT 0 */
/* #define HAVE_PRE_INCREMENT 0 */

/* 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) \
((regno) < FIRST_PSEUDO_REGISTER || reg_renumber[regno] >= 0)

#define REGNO_OK_FOR_INDEX_P(regno)  \
((unsigned) (regno) - 1 < FIRST_PSEUDO_REGISTER - 1 \
 || 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)   \
  (GET_CODE (X) == LABEL_REF || GET_CODE (X) == SYMBOL_REF		\
   || GET_CODE (X) == CONST_INT || GET_CODE (X) == CONST		\
   || GET_CODE (X) == HIGH)

/* 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) (REGNO (X) > 0)
/* 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 -- i.e., neither indexed nor 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 (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 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.
   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 this to be nonzero if shift instructions ignore all but the low-order
   few bits. */
#define SHIFT_COUNT_TRUNCATED 1

/* 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,OUTER_CODE) \
  case CONST_INT:						\
    if (CONST_OK_FOR_LETTER_P (INTVAL (RTX),'I')) return 0;	\
  case CONST:							\
  case LABEL_REF:						\
  case SYMBOL_REF:						\
    return 4;							\
  case CONST_DOUBLE:						\
    return 6;

/* A flag which says to swap the operands of certain insns
   when they are output.  */
extern int swap_operands;

/*** 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"