if (ch && GET_CODE (XEXP (X, 1)) == REG				\	  && GET_CODE (XEXP (X, 0)) == REG)				\	return X;							\      if (ch) { GO_IF_LEGITIMATE_ADDRESS (MODE, X, WIN); }		\      if (GET_CODE (XEXP (X, 0)) == REG                                 \	  || (GET_CODE (XEXP (X, 0)) == SIGN_EXTEND	        	\		   && GET_CODE (XEXP (XEXP (X, 0), 0)) == REG		\		   && GET_MODE (XEXP (XEXP (X, 0), 0)) == HImode))	\	{ register rtx temp = gen_reg_rtx (Pmode);			\	  register rtx val = force_operand (XEXP (X, 1), temp);		\	  if (val != temp) emit_move_insn (temp, val, 0);		\	  XEXP (X, 1) = temp;						\	  return X; }							\      else if (GET_CODE (XEXP (X, 1)) == REG				\	       || (GET_CODE (XEXP (X, 1)) == SIGN_EXTEND		\		   && GET_CODE (XEXP (XEXP (X, 1), 0)) == REG		\		   && GET_MODE (XEXP (XEXP (X, 1), 0)) == HImode))	\	{ register rtx temp = gen_reg_rtx (Pmode);			\	  register rtx val = force_operand (XEXP (X, 0), temp);		\	  if (val != temp) emit_move_insn (temp, val, 0);		\	  XEXP (X, 0) = temp;						\	  return X; }}}/* Go to LABEL if ADDR (a legitimate address expression)   has an effect that depends on the machine mode it is used for.   On the 80386, only postdecrement and postincrement address depend thus   (the amount of decrement or increment being the length of the operand).  */#define GO_IF_MODE_DEPENDENT_ADDRESS(ADDR,LABEL)	\ if (GET_CODE (ADDR) == POST_INC || GET_CODE (ADDR) == POST_DEC) goto LABEL/* Specify the machine mode that this machine uses   for the index in the tablejump instruction.  */#define CASE_VECTOR_MODE Pmode/* 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.   This should be changed to take advantage of fist --wfs ?? */#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/* Max number of bytes we can move from memory to memory   in one reasonably fast instruction.  */#define MOVE_MAX 4/* Define this if zero-extension is slow (more than one real instruction).  *//* #define SLOW_ZERO_EXTEND *//* Nonzero if access to memory by bytes is slow and undesirable.  */#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/* 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/* When a prototype says `char' or `short', really pass an `int'.   (The 386 can't easily push less than an int.)  */#define PROMOTE_PROTOTYPES/* 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/* Define this if addresses of constant functions   shouldn't be put through pseudo regs where they can be cse'd.   Desirable on the 386 because a CALL with a constant address is   not much slower than one with a register address.  */#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.  */#define CONST_COSTS(RTX,CODE) \  case CONST_INT:						\    if (RTX == const0_rtx) return 0;				\    if ((unsigned) INTVAL (RTX) < 077) return 1;		\  case CONST:							\  case LABEL_REF:						\  case SYMBOL_REF:						\    return 3;							\  case CONST_DOUBLE:						\    return 5;							\  case PLUS:							\    if (GET_CODE (XEXP (RTX, 0)) == REG				\        && GET_CODE (XEXP (RTX, 1)) == CONST_INT)		\      return 2;/* Tell final.c how to eliminate redundant test instructions.  *//* ??? Find a better place to put this.  */#if 0#define FINAL_PRESCAN_INSN(INSN, OPERANDS, NOPERANDS) \  fp_hook (INSN, OPERANDS, NOPERANDS)#endif/* Here we define machine-dependent flags and fields in cc_status   (see `conditions.h').  *//* Set if the cc value is actually in the 80387, so a floating point   conditional branch must be output.  */#define CC_IN_80387 04000/* 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.  */#define NOTICE_UPDATE_CC(EXP, INSN) \  notice_update_cc((EXP))/* Output a signed jump insn.  Use template NORMAL ordinarily, or   FLOAT following a floating point comparison.   Use NO_OV following an arithmetic insn that set the cc's   before a test insn that was deleted.   NO_OV may be zero, meaning final should reinsert the test insn   because the jump cannot be handled properly without it.  */#define OUTPUT_JUMP(NORMAL, FLOAT, NO_OV)			\{								\  if (cc_prev_status.flags & CC_IN_80387)				\    return FLOAT;						\  if (cc_prev_status.flags & CC_NO_OVERFLOW)				\    return NO_OV;						\  return NORMAL;						\}/* Control the assembler format that we output.  */#ifdef ATT#include <syms.h>#else #define FILNMLEN 14#endif/* How to refer to registers in assembler output.   This sequence is indexed by compiler's hard-register-number (see above). *//* In order to refer to the first 8 regs as 32 bit regs prefix an "e"   For non floating point regs, the following are the HImode names.   */#define HI_REGISTER_NAMES \{"ax","dx","cx","bx","si","di","bp","sp",          \ "st","st(1)"}/* ,"st(2)","st(3)","st(4)","st(5)" } */#define REGISTER_NAMES HI_REGISTER_NAMES/* Note we are omitting these since currently I don't know howto get gcc to use these, since they want the same but differentnumber as al, and ax.*//* note the last four are not really qi_registsers, but   the md will have to never output movb into one of them   only a movw .  There is no movb into the hardware reg   esi that I can find */#define QI_REGISTER_NAMES \{"al", "dl", "cl", "bl", "si", "di", "bp", "sp",}/*  Don't know how to use these, yet.   They overlap with ax,dx,cx,bx  and so would clobber al,dl,cl,bl #define QI_REGISTER_NAMES_TOP \{"ah", \ "dh", \ "ch", \ "bh", }*//* How to renumber registers for dbxand gdb.  *//* {0,2,1,3,6,7,4,5,12,13,14,15,16,17}  */#define DBX_REGISTER_NUMBER(n) \((n)==0?0 :(n)==1?2 :(n)==2?1 :(n)==3?3 :(n)==4?6 :(n)==5?7 :(n)==6?4 :(n)==7?5 :(n)==8?12 :(n)==9?12 :(n))/* 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.  */#define ASM_OUTPUT_LABEL(FILE,NAME)	\  (assemble_name (FILE, NAME), fputs (":\n", FILE))/* This is how to output an assembler line defining a `double' constant.  */#define ASM_OUTPUT_DOUBLE(FILE,VALUE)  \  fprintf (FILE, "%s%.22e\n",ASM_DOUBLE, (VALUE))/* This is how to output an assembler line defining a `float' constant.  */#define ASM_OUTPUT_FLOAT(FILE,VALUE)  \do { union { float f; long l;} tem;			\     tem.f = (VALUE); \     fputs(ASM_LONG,FILE); \     fprintf((FILE), "0x%x\n", tem.l); \   } while (0)/* 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)))/* This is how to output an assembler line defining an `int' constant.  */#define ASM_OUTPUT_INT(FILE,VALUE)  \( fprintf (FILE,ASM_LONG),			\   output_addr_const (FILE,(VALUE)),		\  putc('\n',FILE))/* Likewise for `char' and `short' constants.  *//* is this supposed to do align too?? */#define ASM_OUTPUT_SHORT(FILE,VALUE)  \( fprintf (FILE,ASM_SHORT),			\   output_addr_const (FILE,(VALUE)),		\  putc('\n',FILE))/*#define ASM_OUTPUT_SHORT(FILE,VALUE)  \( fputs (ASM_BYTE,FILE),			\   output_addr_const (FILE,(VALUE)),		\  fputs ( ",",FILE),			\   output_addr_const (FILE,(VALUE)),		\  fputs (" >> 8\n",FILE))*/#define ASM_OUTPUT_CHAR(FILE,VALUE)  \( fprintf (FILE, ASM_BYTE),			\   output_addr_const (FILE,(VALUE)),		\  putc('\n',FILE))/* This is how to output an assembler line for a numeric constant byte.  */#define ASM_OUTPUT_BYTE(FILE,VALUE)  \  fprintf ((FILE), "%s0x%x\n", ASM_BYTE, (VALUE))/* This is how to output an insn to push a register on the stack.   It need not be very fast code.  */#define ASM_OUTPUT_REG_PUSH(FILE,REGNO)  \  fprintf (FILE, "\tpushl e%s\n", reg_names[REGNO])/* This is how to output an insn to pop a register from the stack.   It need not be very fast code.  */#define ASM_OUTPUT_REG_POP(FILE,REGNO)  \  fprintf (FILE, "\tpopl e%s\n", reg_names[REGNO])/* This is how to output an element of a case-vector that is absolute.     */#define ASM_OUTPUT_ADDR_VEC_ELT(FILE, VALUE)  \  fprintf (FILE, "%s%s%d\n",ASM_LONG,LPREFIX, VALUE)/* This is how to output an element of a case-vector that is relative.   We don't use these on the 386 yet, because the ATT assembler can't do   forward reference the differences.   */#define ASM_OUTPUT_ADDR_DIFF_ELT(FILE, VALUE, REL)  abort(); \  fprintf (FILE, "\t.word %s%d-%s%d\n",LPREFIX, VALUE,LPREFIX, REL)/* 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 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.   The CODE z takes the size of operand from the following digit, and   outputs b,w,or l respectively.   On the 80386, we use several such letters:   f -- float insn (print a CONST_DOUBLE as a float rather than in hex).   L,W,B,Q,S -- print the opcode suffix for specified size of operand.   R -- print the prefix for register names.   z -- print the opcode suffix for the size of the current operand.   * -- print a star (in certain assembler syntax)   w -- print the operand as if it's a "word" (HImode) even if it isn't.   w -- print the operand as if it's a byte (QImode) even if it isn't.   c -- don't print special prefixes before constant operands.  */#define PRINT_OPERAND_PUNCT_VALID_P(CODE)				\  ((CODE) == '*')#define PRINT_OPERAND(FILE, X, CODE)  \  print_operand (FILE, X, CODE)#define PRINT_OPERAND_ADDRESS(FILE, ADDR)  \  print_operand_address (FILE, ADDR)/* Routines in gnulib that return floats must return them in an fp reg,   just as other functions do which return such values.   These macros make that happen.  */#define SFVALUE float#define INTIFY(FLOATVAL) FLOATVAL/* Nonzero if INSN magically clobbers register REGNO.  */#define INSN_CLOBBERS_REGNO_P(INSN, REGNO)	\  (FP_REGNO_P (REGNO)				\   && (GET_CODE (INSN) == JUMP_INSN || GET_CODE (INSN) == BARRIER))/* a letter which is not needed by the normal asm syntax, which   we can use for operand syntax in the extended asm */#define ASM_OPERAND_LETTER '#'/*Local variables:version-control: tEnd:*/