--- gcc/config/alpha/alpha.h	2018/04/24 18:16:16	1.1.1.2
+++ gcc/config/alpha/alpha.h	2018/04/24 18:22:29	1.1.1.3
@@ -1,6 +1,6 @@
 /* Definitions of target machine for GNU compiler, for DEC Alpha.
-   Copyright (C) 1992, 1993 Free Software Foundation, Inc.
-   Contributed by Richard Kenner (kenner@nyu.edu)
+   Copyright (C) 1992, 1993, 1994 Free Software Foundation, Inc.
+   Contributed by Richard Kenner (kenner@vlsi1.ultra.nyu.edu)
 
 This file is part of GNU CC.
 
@@ -44,14 +44,19 @@ the Free Software Foundation, 675 Mass A
 /* No point in running CPP on our assembler output.  */
 #define ASM_SPEC "-nocpp"
 
-/* Right now Alpha OSF/1 doesn't seem to have debugging libraries.  */
+/* Under OSF/1, -p and -pg require -lprof1.  */
 
-#define LIB_SPEC "%{p:-lprof1} -lc"
+#define LIB_SPEC "%{p:-lprof1} %{pg:-lprof1} %{a:-lprof2} -lc"
 
-/* Pass "-G 8" to ld because Alpha's CC does.  Pass -O3 if we are optimizing,
-   -O1 if we are not.  Pass -non_shared or -call_shared as appropriate.  */
+/* Pass "-G 8" to ld because Alpha's CC does.  Pass -O3 if we are
+   optimizing, -O1 if we are not.  Pass -shared, -non_shared or
+   -call_shared as appropriate.  Also pass -pg.  */
 #define LINK_SPEC  \
-  "-G 8 %{O*:-O3} %{!O*:-O1} %{static:-non_shared} %{!static:-call_shared}"
+  "-G 8 %{O*:-O3} %{!O*:-O1} %{!shared:-init __main} %{static:-non_shared} \
+   %{!static:%{shared:-shared} %{!shared:-call_shared}} %{pg}"
+
+#define STARTFILE_SPEC  \
+  "%{!shared:%{pg:gcrt0.o%s}%{!pg:%{p:mcrt0.o%s}%{!p:crt0.o%s}}}"
 
 /* Print subsidiary information on the compiler version in use.  */
 #define TARGET_VERSION
@@ -93,10 +98,14 @@ extern int target_flags;
     {"no-fp-regs", -3},			\
     {"alpha-as", -MASK_GAS},		\
     {"gas", MASK_GAS},			\
-    {"", TARGET_DEFAULT} }
+    {"", TARGET_DEFAULT | TARGET_CPU_DEFAULT} }
 
 #define TARGET_DEFAULT 3
 
+#ifndef TARGET_CPU_DEFAULT
+#define TARGET_CPU_DEFAULT 0
+#endif
+
 /* Define this macro to change register usage conditional on target flags.
 
    On the Alpha, we use this to disable the floating-point registers when
@@ -104,20 +113,11 @@ extern int target_flags;
 
 #define CONDITIONAL_REGISTER_USAGE	\
   if (! TARGET_FPREGS)			\
-    for (i = 32; i < 64; i++)		\
+    for (i = 32; i < 63; i++)		\
       fixed_regs[i] = call_used_regs[i] = 1;
 
-/* Define this to change the optimizations performed by default.  */
-
-#define OPTIMIZATION_OPTIONS(LEVEL)	\
-{					\
-  if ((LEVEL) > 0)			\
-    {					\
-      flag_force_addr = 1;		\
-      flag_force_mem = 1;		\
-      flag_omit_frame_pointer = 1;	\
-    }					\
-}
+/* Show we can debug even without a frame pointer.  */
+#define CAN_DEBUG_WITHOUT_FP
 
 /* target machine storage layout */
 
@@ -281,7 +281,11 @@ extern int target_flags;
    Since $31 is always zero, we will use register number 31 as the
    argument pointer.  It will never appear in the generated code
    because we will always be eliminating it in favor of the stack
-   poointer or frame pointer.  */
+   pointer or hardware frame pointer.
+
+   Likewise, we use $f31 for the frame pointer, which will always
+   be eliminated in favor of the hardware frame pointer or the
+   stack pointer.  */
 
 #define FIRST_PSEUDO_REGISTER 64
 
@@ -326,7 +330,7 @@ extern int target_flags;
    $26			(return PC)
    $15			(frame pointer)
    $29			(global pointer)
-   $30, $31, $f31	(stack pointer and always zero/ap)  */
+   $30, $31, $f31	(stack pointer and always zero/ap & fp)  */
 
 #define REG_ALLOC_ORDER		\
   {33,					\
@@ -381,7 +385,7 @@ extern int target_flags;
 #define STACK_POINTER_REGNUM 30
 
 /* Base register for access to local variables of the function.  */
-#define FRAME_POINTER_REGNUM 15
+#define HARD_FRAME_POINTER_REGNUM 15
 
 /* Value should be nonzero if functions must have frame pointers.
    Zero means the frame pointer need not be set up (and parms
@@ -392,6 +396,9 @@ extern int target_flags;
 /* Base register for access to arguments of the function.  */
 #define ARG_POINTER_REGNUM 31
 
+/* Base register for access to local variables of function.  */
+#define FRAME_POINTER_REGNUM 63
+
 /* Register in which static-chain is passed to a function. 
 
    For the Alpha, this is based on an example; the calling sequence
@@ -438,14 +445,15 @@ enum reg_class { NO_REGS, GENERAL_REGS,
    of length N_REG_CLASSES.  */
 
 #define REG_CLASS_CONTENTS	\
-  { {0, 0}, {~0, 0}, {0, ~0}, {~0, ~0} }
+  { {0, 0}, {~0, 0x80000000}, {0, 0x7fffffff}, {~0, ~0} }
 
 /* The same information, inverted:
    Return the class number of the smallest class containing
    reg number REGNO.  This could be a conditional expression
    or could index an array.  */
 
-#define REGNO_REG_CLASS(REGNO) ((REGNO) >= 32 ? FLOAT_REGS : GENERAL_REGS)
+#define REGNO_REG_CLASS(REGNO) \
+ ((REGNO) >= 32 && (REGNO) <= 62 ? FLOAT_REGS : GENERAL_REGS)
 
 /* The class value for index registers, and the one for base regs.  */
 #define INDEX_REG_CLASS NO_REGS
@@ -504,10 +512,13 @@ enum reg_class { NO_REGS, GENERAL_REGS,
 /* Optional extra constraints for this machine.
 
    For the Alpha, `Q' means that this is a memory operand but not a
-   reference to an unaligned location.  */
+   reference to an unaligned location.
+   `R' is a SYMBOL_REF that has SYMBOL_REF_FLAG set or is the current
+   function.  */
 
 #define EXTRA_CONSTRAINT(OP, C)				\
   ((C) == 'Q' ? GET_CODE (OP) == MEM && GET_CODE (XEXP (OP, 0)) != AND \
+   : (C) == 'R' ? current_file_function_operand (OP, Pmode)	\
    : 0)
 
 /* Given an rtx X being reloaded into a reg required to be
@@ -563,12 +574,26 @@ enum reg_class { NO_REGS, GENERAL_REGS,
 
 #define SECONDARY_MEMORY_NEEDED(CLASS1,CLASS2,MODE) ((CLASS1) != (CLASS2))
 
+/* Specify the mode to be used for memory when a secondary memory
+   location is needed.  If MODE is floating-point, use it.  Otherwise,
+   widen to a word like the default.  This is needed because we always
+   store integers in FP registers in quadword format.  This whole
+   area is very tricky! */
+#define SECONDARY_MEMORY_NEEDED_MODE(MODE)		\
+  (GET_MODE_CLASS (MODE) == MODE_FLOAT ? (MODE)		\
+   : mode_for_size (BITS_PER_WORD, GET_MODE_CLASS (MODE), 0))
+
 /* Return the maximum number of consecutive registers
    needed to represent mode MODE in a register of class CLASS.  */
 
 #define CLASS_MAX_NREGS(CLASS, MODE)				\
  ((GET_MODE_SIZE (MODE) + UNITS_PER_WORD - 1) / UNITS_PER_WORD)
 
+/* If defined, gives a class of registers that cannot be used as the
+   operand of a SUBREG that changes the size of the object.  */
+
+#define CLASS_CANNOT_CHANGE_SIZE	FLOAT_REGS
+
 /* Define the cost of moving between registers of various classes.  Moving
    between FLOAT_REGS and anything else except float regs is expensive. 
    In fact, we make it quite expensive because we really don't want to
@@ -611,7 +636,7 @@ enum reg_class { NO_REGS, GENERAL_REGS,
    first local allocated.  Otherwise, it is the offset to the BEGINNING
    of the first local allocated.  */
 
-#define STARTING_FRAME_OFFSET current_function_outgoing_args_size
+#define STARTING_FRAME_OFFSET 0
 
 /* If we generate an insn to push BYTES bytes,
    this says how many the stack pointer really advances by.
@@ -639,10 +664,11 @@ enum reg_class { NO_REGS, GENERAL_REGS,
    followed by "to".  Eliminations of the same "from" register are listed
    in order of preference.  */
 
-#define ELIMINABLE_REGS				\
-{{ ARG_POINTER_REGNUM, STACK_POINTER_REGNUM},	\
- { ARG_POINTER_REGNUM, FRAME_POINTER_REGNUM},   \
- { FRAME_POINTER_REGNUM, STACK_POINTER_REGNUM}}
+#define ELIMINABLE_REGS				     \
+{{ ARG_POINTER_REGNUM, STACK_POINTER_REGNUM},	     \
+ { ARG_POINTER_REGNUM, HARD_FRAME_POINTER_REGNUM},   \
+ { FRAME_POINTER_REGNUM, STACK_POINTER_REGNUM},	     \
+ { FRAME_POINTER_REGNUM, HARD_FRAME_POINTER_REGNUM}}
 
 /* Given FROM and TO register numbers, say whether this elimination is allowed.
    Frame pointer elimination is automatically handled.
@@ -652,20 +678,21 @@ enum reg_class { NO_REGS, GENERAL_REGS,
 
 #define CAN_ELIMINATE(FROM, TO) 1
 
+/* Round up to a multiple of 16 bytes.  */
+#define ALPHA_ROUND(X) (((X) + 15) & ~ 15)
+
 /* Define the offset between two registers, one to be eliminated, and the other
    its replacement, at the start of a routine.  */
 #define INITIAL_ELIMINATION_OFFSET(FROM, TO, OFFSET)			\
-{ if ((FROM) == FRAME_POINTER_REGNUM && (TO) == STACK_POINTER_REGNUM)	\
-    (OFFSET) = 0;							\
-  else									\
-    {									\
-      (OFFSET) = ((get_frame_size () + current_function_outgoing_args_size \
-		   + current_function_pretend_args_size			\
-		   + alpha_sa_size () + 15)				\
-		  & ~ 15);						\
-      if ((FROM) == ARG_POINTER_REGNUM)					\
-	(OFFSET) -= current_function_pretend_args_size;			\
-    }									\
+{ if ((FROM) == FRAME_POINTER_REGNUM)					\
+    (OFFSET) = (ALPHA_ROUND (current_function_outgoing_args_size)	\
+		+ alpha_sa_size ());					\
+  else if ((FROM) == ARG_POINTER_REGNUM)				\
+    (OFFSET) = (ALPHA_ROUND (current_function_outgoing_args_size)	\
+		+ alpha_sa_size ()					\
+		+ (ALPHA_ROUND (get_frame_size ()			\
+			       + current_function_pretend_args_size)	\
+		   - current_function_pretend_args_size));		\
 }
 
 /* Define this if stack space is still allocated for a parameter passed
@@ -783,8 +810,11 @@ enum reg_class { NO_REGS, GENERAL_REGS,
 #define FUNCTION_ARG(CUM, MODE, TYPE, NAMED)	\
 ((CUM) < 6 && ! MUST_PASS_IN_STACK (MODE, TYPE)	\
  ? gen_rtx(REG, (MODE),				\
-	   (CUM) + 16 + (TARGET_FPREGS		\
-			 && GET_MODE_CLASS (MODE) == MODE_FLOAT) * 32) : 0)
+	   (CUM) + 16 + ((TARGET_FPREGS		\
+			  && (GET_MODE_CLASS (MODE) == MODE_COMPLEX_FLOAT  \
+			      || GET_MODE_CLASS (MODE) == MODE_FLOAT)) \
+			 * 32))			\
+ : 0)
 
 /* Specify the padding direction of arguments.
 
@@ -885,9 +915,55 @@ extern char *alpha_function_name;
 #define FUNCTION_PROLOGUE(FILE, SIZE)  output_prolog (FILE, SIZE)
 
 /* Output assembler code to FILE to increment profiler label # LABELNO
-   for profiling a function entry.  */
+   for profiling a function entry.  Profiling for gprof does not
+   require LABELNO so we don't reference it at all.  This does,
+   however, mean that -p won't work.  But OSF/1 doesn't support the
+   traditional prof anyways, so there is no good reason to be
+   backwards compatible. */
+
+#define FUNCTION_PROFILER(FILE, LABELNO)			\
+    do {							\
+	fputs ("\tlda $28,_mcount\n", (FILE));			\
+	fputs ("\tjsr $28,($28),_mcount\n", (FILE));		\
+	fputs ("\tldgp $29,0($27)\n", (FILE));			\
+    } while (0);
+
+
+/* Output assembler code to FILE to initialize this source file's
+   basic block profiling info, if that has not already been done.
+   This assumes that __bb_init_func doesn't garble a1-a5. */
+
+#define FUNCTION_BLOCK_PROFILER(FILE, LABELNO)			\
+    do {							\
+	ASM_OUTPUT_REG_PUSH (FILE, 16);				\
+	fputs ("\tlda $16,$PBX32\n", (FILE));			\
+	fputs ("\tldq $26,0($16)\n", (FILE));			\
+	fputs ("\tbne $26,1f\n", (FILE));			\
+	fputs ("\tlda $27,__bb_init_func\n", (FILE));		\
+	fputs ("\tjsr $26,($27),__bb_init_func\n", (FILE));	\
+	fputs ("\tldgp $29,0($26)\n", (FILE));			\
+	fputs ("1:\n", (FILE));					\
+	ASM_OUTPUT_REG_POP (FILE, 16);				\
+    } while (0);
+
+/* Output assembler code to FILE to increment the entry-count for
+   the BLOCKNO'th basic block in this source file.  */
+
+#define BLOCK_PROFILER(FILE, BLOCKNO)				\
+    do {							\
+	int blockn = (BLOCKNO);					\
+	fputs ("\tsubq $30,16,$30\n", (FILE));			\
+	fputs ("\tstq $26,0($30)\n", (FILE));			\
+	fputs ("\tstq $27,8($30)\n", (FILE));			\
+	fputs ("\tlda $26,$PBX34\n", (FILE));			\
+	fprintf ((FILE), "\tldq $27,%d($26)\n", 8*blockn);	\
+	fputs ("\taddq $27,1,$27\n", (FILE));			\
+	fprintf ((FILE), "\tstq $27,%d($26)\n", 8*blockn);	\
+	fputs ("\tldq $26,0($30)\n", (FILE));			\
+	fputs ("\tldq $27,8($30)\n", (FILE));			\
+	fputs ("\taddq $30,16,$30\n", (FILE));			\
+    } while (0)
 
-#define FUNCTION_PROFILER(FILE, LABELNO)
 
 /* EXIT_IGNORE_STACK should be nonzero if, when returning from a function,
    the stack pointer does not matter.  The value is tested only in
@@ -1013,7 +1089,8 @@ __enable_execute_stack (addr)						\
 
 #define REGNO_OK_FOR_INDEX_P(REGNO) 0
 #define REGNO_OK_FOR_BASE_P(REGNO) \
-(((REGNO) < 32 || (unsigned) reg_renumber[REGNO] < 32))
+((REGNO) < 32 || (unsigned) reg_renumber[REGNO] < 32  \
+ || (REGNO) == 63 || reg_renumber[REGNO] == 63)
 
 /* Maximum number of registers that can appear in a valid memory address.  */
 #define MAX_REGS_PER_ADDRESS 1
@@ -1054,7 +1131,7 @@ __enable_execute_stack (addr)						\
 /* 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)  \
-  (REGNO (X) < 32 || REGNO (X) >= FIRST_PSEUDO_REGISTER)
+  (REGNO (X) < 32 || REGNO (X) == 63 || REGNO (X) >= FIRST_PSEUDO_REGISTER)
 
 #else
 
@@ -1211,8 +1288,11 @@ extern char *current_function_name;
 
 /* 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 */
+   Do not define this if the table should contain absolute addresses.
+   On the Alpha, the table is really GP-relative, not relative to the PC
+   of the table, but we pretend that it is PC-relative; this should be OK,
+   but we hsould try to find some better way sometime.  */
+#define CASE_VECTOR_PC_RELATIVE
 
 /* Specify the tree operation to be used to convert reals to integers.  */
 #define IMPLICIT_FIX_EXPR FIX_ROUND_EXPR
@@ -1275,6 +1355,26 @@ extern char *current_function_name;
 
 #define FLOAT_STORE_FLAG_VALUE 0.5
 
+/* Canonicalize a comparison from one we don't have to one we do have.  */
+
+#define CANONICALIZE_COMPARISON(CODE,OP0,OP1) \
+  do {									\
+    if (((CODE) == GE || (CODE) == GT || (CODE) == GEU || (CODE) == GTU) \
+	&& (GET_CODE (OP1) == REG || (OP1) == const0_rtx))		\
+      {									\
+	rtx tem = (OP0);						\
+	(OP0) = (OP1);							\
+	(OP1) = tem;							\
+	(CODE) = swap_condition (CODE);					\
+      }									\
+    if (((CODE) == LT || (CODE) == LTU)					\
+	&& GET_CODE (OP1) == CONST_INT && INTVAL (OP1) == 256)		\
+      {									\
+	(CODE) = (CODE) == LT ? LE : LEU;				\
+	(OP1) = GEN_INT (255);						\
+      }									\
+  } while (0)
+
 /* 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.  */
@@ -1309,17 +1409,28 @@ extern char *current_function_name;
    of a switch statement.  If the code is computed here,
    return it with a return statement.  Otherwise, break from the switch.
 
-   We only care about the cost if it is valid in an insn, so all constants
-   are cheap.  */
+   If this is an 8-bit constant, return zero since it can be used
+   nearly anywhere with no cost.  If it is a valid operand for an
+   ADD or AND, likewise return 0 if we know it will be used in that
+   context.  Otherwise, return 2 since it might be used there later.
+   All other constants take at least two insns.  */
 
 #define CONST_COSTS(RTX,CODE,OUTER_CODE) \
   case CONST_INT:						\
+    if (INTVAL (RTX) >= 0 && INTVAL (RTX) < 256)		\
+      return 0;							\
   case CONST_DOUBLE:						\
-    return 0;							\
+    if (((OUTER_CODE) == PLUS && add_operand (RTX, VOIDmode))	\
+	|| ((OUTER_CODE) == AND && and_operand (RTX, VOIDmode))) \
+      return 0;							\
+    else if (add_operand (RTX, VOIDmode) || and_operand (RTX, VOIDmode)) \
+      return 2;							\
+    else							\
+      return COSTS_N_INSNS (2);					\
   case CONST:							\
   case SYMBOL_REF:						\
   case LABEL_REF:						\
-    return 6;							\
+    return COSTS_N_INSNS (3);
     
 /* Provide the costs of a rtl expression.  This is in the body of a
    switch on CODE.  */
@@ -1337,12 +1448,7 @@ extern char *current_function_name;
   case MULT:						\
     if (GET_MODE_CLASS (GET_MODE (X)) == MODE_FLOAT)	\
       return COSTS_N_INSNS (6);				\
-    else if (GET_CODE (XEXP (X, 1)) != CONST_INT	\
-	     || exact_log2 (INTVAL (XEXP (X, 1))) < 0)	\
-      return COSTS_N_INSNS (21);			\
-    else if (const48_operand (XEXP (X, 1), VOIDmode))	\
-      break;						\
-    return COSTS_N_INSNS (2);				\
+    return COSTS_N_INSNS (23);				\
   case ASHIFT:						\
     if (GET_CODE (XEXP (X, 1)) == CONST_INT		\
 	&& INTVAL (XEXP (X, 1)) <= 3)			\
@@ -1371,6 +1477,7 @@ extern char *current_function_name;
 {								\
   alpha_write_verstamp (FILE);					\
   fprintf (FILE, "\t.set noreorder\n");				\
+  fprintf (FILE, "\t.set volatile\n");                                \
   fprintf (FILE, "\t.set noat\n");				\
   ASM_OUTPUT_SOURCE_FILENAME (FILE, main_input_filename);	\
 }
@@ -1413,14 +1520,14 @@ literal_section ()						\
 
 #define READONLY_DATA_SECTION	literal_section
 
-/* If we are referencing a function that is static or is known to be
-   in this file, make the SYMBOL_REF special.  We can use this to see
-   indicate that we can branch to this function without setting PV or
-   restoring GP.  */
+/* If we are referencing a function that is static, make the SYMBOL_REF
+   special.  We use this to see indicate we can branch to this function
+   without setting PV or restoring GP.  */
+/* For 2.6, don't do this if we're compiling C++.  */
 
 #define ENCODE_SECTION_INFO(DECL)  \
-  if (TREE_CODE (DECL) == FUNCTION_DECL			\
-      && (TREE_ASM_WRITTEN (DECL) || ! TREE_PUBLIC (DECL))) \
+  if (TREE_CODE (DECL) == FUNCTION_DECL && ! TREE_PUBLIC (DECL) \
+      && strcmp (lang_identify (), "cplusplus") != 0) \
     SYMBOL_REF_FLAG (XEXP (DECL_RTL (DECL), 0)) = 1;
 
 /* How to refer to registers in assembler output.
@@ -1434,7 +1541,7 @@ literal_section ()						\
  "$f0", "$f1", "$f2", "$f3", "$f4", "$f5", "$f6", "$f7", "$f8",	\
  "$f9", "$f10", "$f11", "$f12", "$f13", "$f14", "$f15",		\
  "$f16", "$f17", "$f18", "$f19", "$f20", "$f21", "$f22", "$f23",\
- "$f24", "$f25", "$f26", "$f27", "$f28", "$f29", "$f30", "$f31"}
+ "$f24", "$f25", "$f26", "$f27", "$f28", "$f29", "$f30", "FP"}
 
 /* How to renumber registers for dbx and gdb.  */
 
@@ -1596,6 +1703,7 @@ literal_section ()						\
     }									      \
   }									      \
   while (0)
+
 /* This is how to output an insn to push a register on the stack.
    It need not be very fast code.  */
 
@@ -1617,15 +1725,15 @@ literal_section ()						\
 #define ASM_OUTPUT_BYTE(FILE,VALUE)  \
   fprintf (FILE, "\t.byte 0x%x\n", (VALUE) & 0xff)
 
-/* This is how to output an element of a case-vector that is absolute.  */
+/* This is how to output an element of a case-vector that is absolute.
+   (Alpha does not use such vectors, but we must define this macro anyway.)  */
 
-#define ASM_OUTPUT_ADDR_VEC_ELT(FILE, VALUE)  \
-  fprintf (FILE, "\t.gprel32 $%d\n", (VALUE) + 32)
+#define ASM_OUTPUT_ADDR_VEC_ELT(FILE, VALUE) abort ()
 
-/* This is how to output an element of a case-vector that is relative.
-   (Alpha does not use such vectors, but we must define this macro anyway.)  */
+/* This is how to output an element of a case-vector that is relative.  */
 
-#define ASM_OUTPUT_ADDR_DIFF_ELT(FILE, VALUE, REL)  abort ()
+#define ASM_OUTPUT_ADDR_DIFF_ELT(FILE, VALUE, REL) \
+  fprintf (FILE, "\t.gprel32 $%d\n", (VALUE) + 32)
 
 /* This is how to output an assembler line
    that says to advance the location counter
@@ -1719,11 +1827,13 @@ literal_section ()						\
   {"reg_or_0_operand", {SUBREG, REG, CONST_INT}},	\
   {"reg_or_6bit_operand", {SUBREG, REG, CONST_INT}},	\
   {"reg_or_8bit_operand", {SUBREG, REG, CONST_INT}},	\
+  {"cint8_operand", {CONST_INT}},                       \
   {"reg_or_cint_operand", {SUBREG, REG, CONST_INT}},	\
   {"add_operand", {SUBREG, REG, CONST_INT}},		\
   {"sext_add_operand", {SUBREG, REG, CONST_INT}},	\
   {"const48_operand", {CONST_INT}},			\
   {"and_operand", {SUBREG, REG, CONST_INT}},		\
+  {"or_operand", {SUBREG, REG, CONST_INT}},		\
   {"mode_mask_operand", {CONST_INT}},			\
   {"mul8_operand", {CONST_INT}},			\
   {"mode_width_operand", {CONST_INT}},			\
@@ -1733,12 +1843,22 @@ literal_section ()						\
   {"divmod_operator", {DIV, MOD, UDIV, UMOD}},		\
   {"fp0_operand", {CONST_DOUBLE}},			\
   {"current_file_function_operand", {SYMBOL_REF}},	\
+  {"call_operand", {REG, SYMBOL_REF}},			\
   {"input_operand", {SUBREG, REG, MEM, CONST_INT, CONST_DOUBLE,	\
 		     SYMBOL_REF, CONST, LABEL_REF}},	\
+  {"some_operand", {SUBREG, REG, MEM, CONST_INT, CONST_DOUBLE, \
+		    SYMBOL_REF, CONST, LABEL_REF}},	\
   {"aligned_memory_operand", {MEM}},			\
   {"unaligned_memory_operand", {MEM}},			\
   {"any_memory_operand", {MEM}},
 
+/* Tell collect that the object format is ECOFF.  */
+#define OBJECT_FORMAT_COFF
+#define EXTENDED_COFF
+
+/* If we use NM, pass -g to it so it only lists globals.  */
+#define NM_FLAGS "-pg"
+
 /* Definitions for debugging.  */
 
 #define SDB_DEBUGGING_INFO		/* generate info for mips-tfile */
@@ -1746,7 +1866,8 @@ literal_section ()						\
 #define MIPS_DEBUGGING_INFO		/* MIPS specific debugging info */
 
 #ifndef PREFERRED_DEBUGGING_TYPE	/* assume SDB_DEBUGGING_INFO */
-#define PREFERRED_DEBUGGING_TYPE ((len > 1 && !strncmp (str, "ggdb", len)) ? DBX_DEBUG : SDB_DEBUG)
+#define PREFERRED_DEBUGGING_TYPE  \
+ ((len > 1 && !strncmp (str, "ggdb", len)) ? DBX_DEBUG : SDB_DEBUG)
 #endif
 
 
@@ -1859,7 +1980,7 @@ do {							\
    This is needed because the Alpha assembler provides no way
    of specifying such information in the assembly file.  */
 
-#if (TARGET_DEFAULT & MASK_GAS) != 0
+#if ((TARGET_DEFAULT | TARGET_CPU_DEFAULT) & MASK_GAS) != 0
 
 #define ASM_FINAL_SPEC "\
 %{malpha-as: %{!mno-mips-tfile: \
@@ -1895,3 +2016,15 @@ do {							\
 
 #define SHASH_SIZE 511
 #define THASH_SIZE 55
+
+/* Align ecoff symbol tables to avoid OSF1/1.3 nm complaints.  */
+
+#define ALIGN_SYMTABLE_OFFSET(OFFSET) (((OFFSET) + 7) & ~7)
+
+/* The system headers under OSF/1 are C++-aware.  */
+#define NO_IMPLICIT_EXTERN_C
+
+/* The linker will stick __main into the .init section.  */
+#define HAS_INIT_SECTION
+#define INIT_NAME_FORMAT "__init_%s"
+#define FINI_NAME_FORMAT "__fini_%s"