X-Git-Url: http://drtracing.org/?a=blobdiff_plain;f=gas%2Fconfig%2Ftc-ia64.c;h=c0eb593f02b11422eaba4561d281169fd147d6f4;hb=3d207518c117df7a6c58f20bc2693171b7690650;hp=e4470213b8aeeb570ee64137626ecd63ca5ffed0;hpb=db0bc2846c03b3b1a281d424299fec1dc9a9c706;p=deliverable%2Fbinutils-gdb.git

diff --git a/gas/config/tc-ia64.c b/gas/config/tc-ia64.c
index e4470213b8..c0eb593f02 100644
--- a/gas/config/tc-ia64.c
+++ b/gas/config/tc-ia64.c
@@ -1,6 +1,5 @@
 /* tc-ia64.c -- Assembler for the HP/Intel IA-64 architecture.
-   Copyright 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008
-   Free Software Foundation, Inc.
+   Copyright (C) 1998-2016 Free Software Foundation, Inc.
    Contributed by David Mosberger-Tang <davidm@hpl.hp.com>
 
    This file is part of GAS, the GNU Assembler.
@@ -50,6 +49,8 @@
 #include "opcode/ia64.h"
 
 #include "elf/ia64.h"
+#include "bfdver.h"
+#include <time.h>
 
 #ifdef HAVE_LIMITS_H
 #include <limits.h>
@@ -101,6 +102,9 @@ enum reloc_func
     FUNC_LT_DTP_RELATIVE,
     FUNC_LT_TP_RELATIVE,
     FUNC_IPLT_RELOC,
+#ifdef TE_VMS
+    FUNC_SLOTCOUNT_RELOC,
+#endif
   };
 
 enum reg_symbol
@@ -109,7 +113,8 @@ enum reg_symbol
     REG_FR	= (REG_GR + 128),
     REG_AR	= (REG_FR + 128),
     REG_CR	= (REG_AR + 128),
-    REG_P	= (REG_CR + 128),
+    REG_DAHR	= (REG_CR + 128),
+    REG_P	= (REG_DAHR + 8),
     REG_BR	= (REG_P  + 64),
     REG_IP	= (REG_BR + 8),
     REG_CFM,
@@ -128,6 +133,7 @@ enum reg_symbol
     IND_PKR,
     IND_PMC,
     IND_PMD,
+    IND_DAHR,
     IND_RR,
     /* The following pseudo-registers are used for unwind directives only:  */
     REG_PSP,
@@ -161,20 +167,23 @@ struct label_fix
   bfd_boolean dw2_mark_labels;
 };
 
+#ifdef TE_VMS
+/* An internally used relocation.  */
+#define DUMMY_RELOC_IA64_SLOTCOUNT	(BFD_RELOC_UNUSED + 1)
+#endif
+
 /* This is the endianness of the current section.  */
 extern int target_big_endian;
 
 /* This is the default endianness.  */
 static int default_big_endian = TARGET_BYTES_BIG_ENDIAN;
 
-void (*ia64_number_to_chars) PARAMS ((char *, valueT, int));
+void (*ia64_number_to_chars) (char *, valueT, int);
 
-static void ia64_float_to_chars_bigendian
-  PARAMS ((char *, LITTLENUM_TYPE *, int));
-static void ia64_float_to_chars_littleendian
-  PARAMS ((char *, LITTLENUM_TYPE *, int));
-static void (*ia64_float_to_chars)
-  PARAMS ((char *, LITTLENUM_TYPE *, int));
+static void ia64_float_to_chars_bigendian (char *, LITTLENUM_TYPE *, int);
+static void ia64_float_to_chars_littleendian (char *, LITTLENUM_TYPE *, int);
+
+static void (*ia64_float_to_chars) (char *, LITTLENUM_TYPE *, int);
 
 static struct hash_control *alias_hash;
 static struct hash_control *alias_name_hash;
@@ -293,7 +302,7 @@ static struct
 	struct label_fix *tag_fixups;
 	struct unw_rec_list *unwind_record;	/* Unwind directive.  */
 	expressionS opnd[6];
-	char *src_file;
+	const char *src_file;
 	unsigned int src_line;
 	struct dwarf2_line_info debug_line;
       }
@@ -410,6 +419,8 @@ ar[] =
 #define CR_IFS          23
 #define CR_IIM          24
 #define CR_IHA          25
+#define CR_IIB0         26
+#define CR_IIB1         27
 #define CR_LID          64
 #define CR_IVR          65
 #define CR_TPR          66
@@ -443,6 +454,8 @@ cr[] =
     {"cr.ifs",	CR_IFS},
     {"cr.iim",	CR_IIM},
     {"cr.iha",	CR_IHA},
+    {"cr.iib0",	CR_IIB0},
+    {"cr.iib1",	CR_IIB1},
     {"cr.lid",	CR_LID},
     {"cr.ivr",	CR_IVR},
     {"cr.tpr",	CR_TPR},
@@ -527,6 +540,7 @@ indirect_reg[] =
     { "pkr",	IND_PKR },
     { "pmc",	IND_PMC },
     { "pmd",	IND_PMD },
+    { "dahr",	IND_DAHR },
     { "rr",	IND_RR },
   };
 
@@ -571,6 +585,9 @@ pseudo_func[] =
     { NULL, 0, { 0 } },	/* placeholder for FUNC_LT_DTP_RELATIVE */
     { NULL, 0, { 0 } },	/* placeholder for FUNC_LT_TP_RELATIVE */
     { "iplt",	PSEUDO_FUNC_RELOC, { 0 } },
+#ifdef TE_VMS
+    { "slotcount", PSEUDO_FUNC_RELOC, { 0 } },
+#endif
 
     /* mbtype4 constants:  */
     { "alt",	PSEUDO_FUNC_CONST, { 0xa } },
@@ -594,12 +611,18 @@ pseudo_func[] =
 
     /* hint constants: */
     { "pause",	PSEUDO_FUNC_CONST, { 0x0 } },
+    { "priority", PSEUDO_FUNC_CONST, { 0x1 } },
+
+    /* tf constants: */
+    { "clz",	PSEUDO_FUNC_CONST, {  32 } },
+    { "mpy",	PSEUDO_FUNC_CONST, {  33 } },
+    { "datahints",	PSEUDO_FUNC_CONST, {  34 } },
 
     /* unwind-related constants:  */
     { "svr4",	PSEUDO_FUNC_CONST,	{ ELFOSABI_NONE } },
     { "hpux",	PSEUDO_FUNC_CONST,	{ ELFOSABI_HPUX } },
     { "nt",	PSEUDO_FUNC_CONST,	{ 2 } },		/* conflicts w/ELFOSABI_NETBSD */
-    { "linux",	PSEUDO_FUNC_CONST,	{ ELFOSABI_LINUX } },
+    { "linux",	PSEUDO_FUNC_CONST,	{ ELFOSABI_GNU } },
     { "freebsd", PSEUDO_FUNC_CONST,	{ ELFOSABI_FREEBSD } },
     { "openvms", PSEUDO_FUNC_CONST,	{ ELFOSABI_OPENVMS } },
     { "nsk",	PSEUDO_FUNC_CONST,	{ ELFOSABI_NSK } },
@@ -649,7 +672,7 @@ static struct rsrc {
   int insn_srlz;                    /* current insn serialization state */
   int data_srlz;                    /* current data serialization state */
   int qp_regno;                     /* qualifying predicate for this usage */
-  char *file;                       /* what file marked this dependency */
+  const char *file;                       /* what file marked this dependency */
   unsigned int line;                /* what line marked this dependency */
   struct mem_offset mem_offset;     /* optional memory offset hint */
   enum { CMP_NONE, CMP_OR, CMP_AND } cmp_type; /* OR or AND compare? */
@@ -776,211 +799,26 @@ static struct
 
 #define ENCODED_PSP_OFFSET(OFFSET) (((OFFSET) + 16) / 4)
 
-typedef void (*vbyte_func) PARAMS ((int, char *, char *));
+typedef void (*vbyte_func) (int, char *, char *);
 
 /* Forward declarations:  */
-static void set_section PARAMS ((char *name));
-static unsigned int set_regstack PARAMS ((unsigned int, unsigned int,
-					  unsigned int, unsigned int));
-static void dot_align (int);
-static void dot_radix PARAMS ((int));
-static void dot_special_section PARAMS ((int));
-static void dot_proc PARAMS ((int));
-static void dot_fframe PARAMS ((int));
-static void dot_vframe PARAMS ((int));
-static void dot_vframesp PARAMS ((int));
-static void dot_save PARAMS ((int));
-static void dot_restore PARAMS ((int));
-static void dot_restorereg PARAMS ((int));
-static void dot_handlerdata  PARAMS ((int));
-static void dot_unwentry PARAMS ((int));
-static void dot_altrp PARAMS ((int));
-static void dot_savemem PARAMS ((int));
-static void dot_saveg PARAMS ((int));
-static void dot_savef PARAMS ((int));
-static void dot_saveb PARAMS ((int));
-static void dot_savegf PARAMS ((int));
-static void dot_spill PARAMS ((int));
-static void dot_spillreg PARAMS ((int));
-static void dot_spillmem PARAMS ((int));
-static void dot_label_state PARAMS ((int));
-static void dot_copy_state PARAMS ((int));
-static void dot_unwabi PARAMS ((int));
-static void dot_personality PARAMS ((int));
-static void dot_body PARAMS ((int));
-static void dot_prologue PARAMS ((int));
-static void dot_endp PARAMS ((int));
-static void dot_template PARAMS ((int));
-static void dot_regstk PARAMS ((int));
-static void dot_rot PARAMS ((int));
-static void dot_byteorder PARAMS ((int));
-static void dot_psr PARAMS ((int));
-static void dot_alias PARAMS ((int));
-static void dot_ln PARAMS ((int));
-static void cross_section PARAMS ((int ref, void (*cons) PARAMS((int)), int ua));
-static void dot_xdata PARAMS ((int));
-static void stmt_float_cons PARAMS ((int));
-static void stmt_cons_ua PARAMS ((int));
-static void dot_xfloat_cons PARAMS ((int));
-static void dot_xstringer PARAMS ((int));
-static void dot_xdata_ua PARAMS ((int));
-static void dot_xfloat_cons_ua PARAMS ((int));
-static void print_prmask PARAMS ((valueT mask));
-static void dot_pred_rel PARAMS ((int));
-static void dot_reg_val PARAMS ((int));
-static void dot_serialize PARAMS ((int));
-static void dot_dv_mode PARAMS ((int));
-static void dot_entry PARAMS ((int));
-static void dot_mem_offset PARAMS ((int));
-static void add_unwind_entry PARAMS((unw_rec_list *, int));
-static symbolS *declare_register PARAMS ((const char *name, unsigned int regnum));
-static void declare_register_set PARAMS ((const char *, unsigned int, unsigned int));
-static unsigned int operand_width PARAMS ((enum ia64_opnd));
-static enum operand_match_result operand_match PARAMS ((const struct ia64_opcode *idesc,
-							int index,
-							expressionS *e));
-static int parse_operand PARAMS ((expressionS *, int));
-static struct ia64_opcode * parse_operands PARAMS ((struct ia64_opcode *));
-static void build_insn PARAMS ((struct slot *, bfd_vma *));
-static void emit_one_bundle PARAMS ((void));
-static void fix_insn PARAMS ((fixS *, const struct ia64_operand *, valueT));
-static bfd_reloc_code_real_type ia64_gen_real_reloc_type PARAMS ((struct symbol *sym,
-								  bfd_reloc_code_real_type r_type));
-static void insn_group_break PARAMS ((int, int, int));
-static void mark_resource PARAMS ((struct ia64_opcode *, const struct ia64_dependency *,
-				   struct rsrc *, int depind, int path));
-static void add_qp_mutex PARAMS((valueT mask));
-static void add_qp_imply PARAMS((int p1, int p2));
-static void clear_qp_branch_flag PARAMS((valueT mask));
-static void clear_qp_mutex PARAMS((valueT mask));
-static void clear_qp_implies PARAMS((valueT p1_mask, valueT p2_mask));
-static int has_suffix_p PARAMS((const char *, const char *));
-static void clear_register_values PARAMS ((void));
-static void print_dependency PARAMS ((const char *action, int depind));
-static void instruction_serialization PARAMS ((void));
-static void data_serialization PARAMS ((void));
-static void remove_marked_resource PARAMS ((struct rsrc *));
-static int is_conditional_branch PARAMS ((struct ia64_opcode *));
-static int is_taken_branch PARAMS ((struct ia64_opcode *));
-static int is_interruption_or_rfi PARAMS ((struct ia64_opcode *));
-static int depends_on PARAMS ((int, struct ia64_opcode *));
-static int specify_resource PARAMS ((const struct ia64_dependency *,
-				     struct ia64_opcode *, int, struct rsrc [], int, int));
-static int check_dv PARAMS((struct ia64_opcode *idesc));
-static void check_dependencies PARAMS((struct ia64_opcode *));
-static void mark_resources PARAMS((struct ia64_opcode *));
-static void update_dependencies PARAMS((struct ia64_opcode *));
-static void note_register_values PARAMS((struct ia64_opcode *));
-static int qp_mutex PARAMS ((int, int, int));
-static int resources_match PARAMS ((struct rsrc *, struct ia64_opcode *, int, int, int));
-static void output_vbyte_mem PARAMS ((int, char *, char *));
-static void count_output PARAMS ((int, char *, char *));
-static void output_R1_format PARAMS ((vbyte_func, unw_record_type, int));
-static void output_R2_format PARAMS ((vbyte_func, int, int, unsigned long));
-static void output_R3_format PARAMS ((vbyte_func, unw_record_type, unsigned long));
-static void output_P1_format PARAMS ((vbyte_func, int));
-static void output_P2_format PARAMS ((vbyte_func, int, int));
-static void output_P3_format PARAMS ((vbyte_func, unw_record_type, int));
-static void output_P4_format PARAMS ((vbyte_func, unsigned char *, unsigned long));
-static void output_P5_format PARAMS ((vbyte_func, int, unsigned long));
-static void output_P6_format PARAMS ((vbyte_func, unw_record_type, int));
-static void output_P7_format PARAMS ((vbyte_func, unw_record_type, unsigned long, unsigned long));
-static void output_P8_format PARAMS ((vbyte_func, unw_record_type, unsigned long));
-static void output_P9_format PARAMS ((vbyte_func, int, int));
-static void output_P10_format PARAMS ((vbyte_func, int, int));
-static void output_B1_format PARAMS ((vbyte_func, unw_record_type, unsigned long));
-static void output_B2_format PARAMS ((vbyte_func, unsigned long, unsigned long));
-static void output_B3_format PARAMS ((vbyte_func, unsigned long, unsigned long));
-static void output_B4_format PARAMS ((vbyte_func, unw_record_type, unsigned long));
-static char format_ab_reg PARAMS ((int, int));
-static void output_X1_format PARAMS ((vbyte_func, unw_record_type, int, int, unsigned long,
-				      unsigned long));
-static void output_X2_format PARAMS ((vbyte_func, int, int, int, int, int, unsigned long));
-static void output_X3_format PARAMS ((vbyte_func, unw_record_type, int, int, int, unsigned long,
-				      unsigned long));
-static void output_X4_format PARAMS ((vbyte_func, int, int, int, int, int, int, unsigned long));
-static unw_rec_list *output_endp PARAMS ((void));
-static unw_rec_list *output_prologue PARAMS ((void));
-static unw_rec_list *output_prologue_gr PARAMS ((unsigned int, unsigned int));
-static unw_rec_list *output_body PARAMS ((void));
-static unw_rec_list *output_mem_stack_f PARAMS ((unsigned int));
-static unw_rec_list *output_mem_stack_v PARAMS ((void));
-static unw_rec_list *output_psp_gr PARAMS ((unsigned int));
-static unw_rec_list *output_psp_sprel PARAMS ((unsigned int));
-static unw_rec_list *output_rp_when PARAMS ((void));
-static unw_rec_list *output_rp_gr PARAMS ((unsigned int));
-static unw_rec_list *output_rp_br PARAMS ((unsigned int));
-static unw_rec_list *output_rp_psprel PARAMS ((unsigned int));
-static unw_rec_list *output_rp_sprel PARAMS ((unsigned int));
-static unw_rec_list *output_pfs_when PARAMS ((void));
-static unw_rec_list *output_pfs_gr PARAMS ((unsigned int));
-static unw_rec_list *output_pfs_psprel PARAMS ((unsigned int));
-static unw_rec_list *output_pfs_sprel PARAMS ((unsigned int));
-static unw_rec_list *output_preds_when PARAMS ((void));
-static unw_rec_list *output_preds_gr PARAMS ((unsigned int));
-static unw_rec_list *output_preds_psprel PARAMS ((unsigned int));
-static unw_rec_list *output_preds_sprel PARAMS ((unsigned int));
-static unw_rec_list *output_fr_mem PARAMS ((unsigned int));
-static unw_rec_list *output_frgr_mem PARAMS ((unsigned int, unsigned int));
-static unw_rec_list *output_gr_gr PARAMS ((unsigned int, unsigned int));
-static unw_rec_list *output_gr_mem PARAMS ((unsigned int));
-static unw_rec_list *output_br_mem PARAMS ((unsigned int));
-static unw_rec_list *output_br_gr PARAMS ((unsigned int, unsigned int));
-static unw_rec_list *output_spill_base PARAMS ((unsigned int));
-static unw_rec_list *output_unat_when PARAMS ((void));
-static unw_rec_list *output_unat_gr PARAMS ((unsigned int));
-static unw_rec_list *output_unat_psprel PARAMS ((unsigned int));
-static unw_rec_list *output_unat_sprel PARAMS ((unsigned int));
-static unw_rec_list *output_lc_when PARAMS ((void));
-static unw_rec_list *output_lc_gr PARAMS ((unsigned int));
-static unw_rec_list *output_lc_psprel PARAMS ((unsigned int));
-static unw_rec_list *output_lc_sprel PARAMS ((unsigned int));
-static unw_rec_list *output_fpsr_when PARAMS ((void));
-static unw_rec_list *output_fpsr_gr PARAMS ((unsigned int));
-static unw_rec_list *output_fpsr_psprel PARAMS ((unsigned int));
-static unw_rec_list *output_fpsr_sprel PARAMS ((unsigned int));
-static unw_rec_list *output_priunat_when_gr PARAMS ((void));
-static unw_rec_list *output_priunat_when_mem PARAMS ((void));
-static unw_rec_list *output_priunat_gr PARAMS ((unsigned int));
-static unw_rec_list *output_priunat_psprel PARAMS ((unsigned int));
-static unw_rec_list *output_priunat_sprel PARAMS ((unsigned int));
-static unw_rec_list *output_bsp_when PARAMS ((void));
-static unw_rec_list *output_bsp_gr PARAMS ((unsigned int));
-static unw_rec_list *output_bsp_psprel PARAMS ((unsigned int));
-static unw_rec_list *output_bsp_sprel PARAMS ((unsigned int));
-static unw_rec_list *output_bspstore_when PARAMS ((void));
-static unw_rec_list *output_bspstore_gr PARAMS ((unsigned int));
-static unw_rec_list *output_bspstore_psprel PARAMS ((unsigned int));
-static unw_rec_list *output_bspstore_sprel PARAMS ((unsigned int));
-static unw_rec_list *output_rnat_when PARAMS ((void));
-static unw_rec_list *output_rnat_gr PARAMS ((unsigned int));
-static unw_rec_list *output_rnat_psprel PARAMS ((unsigned int));
-static unw_rec_list *output_rnat_sprel PARAMS ((unsigned int));
-static unw_rec_list *output_unwabi PARAMS ((unsigned long, unsigned long));
-static unw_rec_list *output_epilogue PARAMS ((unsigned long));
-static unw_rec_list *output_label_state PARAMS ((unsigned long));
-static unw_rec_list *output_copy_state PARAMS ((unsigned long));
-static unw_rec_list *output_spill_psprel PARAMS ((unsigned int, unsigned int, unsigned int,
-						    unsigned int));
-static unw_rec_list *output_spill_sprel PARAMS ((unsigned int, unsigned int, unsigned int,
-						   unsigned int));
-static unw_rec_list *output_spill_reg PARAMS ((unsigned int, unsigned int, unsigned int,
-						 unsigned int, unsigned int));
-static void process_one_record PARAMS ((unw_rec_list *, vbyte_func));
-static void process_unw_records PARAMS ((unw_rec_list *, vbyte_func));
-static int calc_record_size PARAMS ((unw_rec_list *));
-static void set_imask PARAMS ((unw_rec_list *, unsigned long, unsigned long, unsigned int));
-static unsigned long slot_index PARAMS ((unsigned long, fragS *,
-					 unsigned long, fragS *,
-					 int));
-static unw_rec_list *optimize_unw_records PARAMS ((unw_rec_list *));
-static void fixup_unw_records PARAMS ((unw_rec_list *, int));
-static int parse_predicate_and_operand PARAMS ((expressionS *, unsigned *, const char *));
-static void convert_expr_to_ab_reg PARAMS ((const expressionS *, unsigned int *, unsigned int *, const char *, int));
-static void convert_expr_to_xy_reg PARAMS ((const expressionS *, unsigned int *, unsigned int *, const char *, int));
-static unsigned int get_saved_prologue_count PARAMS ((unsigned long));
-static void save_prologue_count PARAMS ((unsigned long, unsigned int));
-static void free_saved_prologue_counts PARAMS ((void));
+static void dot_alias (int);
+static int parse_operand_and_eval (expressionS *, int);
+static void emit_one_bundle (void);
+static bfd_reloc_code_real_type ia64_gen_real_reloc_type (struct symbol *,
+							  bfd_reloc_code_real_type);
+static void insn_group_break (int, int, int);
+static void add_qp_mutex (valueT);
+static void add_qp_imply (int, int);
+static void clear_qp_mutex (valueT);
+static void clear_qp_implies (valueT, valueT);
+static void print_dependency (const char *, int);
+static void instruction_serialization (void);
+static void data_serialization (void);
+static void output_R3_format (vbyte_func, unw_record_type, unsigned long);
+static void output_B3_format (vbyte_func, unsigned long, unsigned long);
+static void output_B4_format (vbyte_func, unw_record_type, unsigned long);
+static void free_saved_prologue_counts (void);
 
 /* Determine if application register REGNUM resides only in the integer
    unit (as opposed to the memory unit).  */
@@ -991,7 +829,7 @@ ar_is_only_in_integer_unit (int reg)
   return reg >= 64 && reg <= 111;
 }
 
-/* Determine if application register REGNUM resides only in the memory 
+/* Determine if application register REGNUM resides only in the memory
    unit (as opposed to the integer unit).  */
 static int
 ar_is_only_in_memory_unit (int reg)
@@ -1005,8 +843,7 @@ ar_is_only_in_memory_unit (int reg)
    don't see any other way to accomplish the same thing without
    changing obj-elf.c (which may be the Right Thing, in the end).  */
 static void
-set_section (name)
-     char *name;
+set_section (char *name)
 {
   char *saved_input_line_pointer;
 
@@ -1018,26 +855,30 @@ set_section (name)
 
 /* Map 's' to SHF_IA_64_SHORT.  */
 
-int
-ia64_elf_section_letter (letter, ptr_msg)
-     int letter;
-     char **ptr_msg;
+bfd_vma
+ia64_elf_section_letter (int letter, const char **ptr_msg)
 {
   if (letter == 's')
     return SHF_IA_64_SHORT;
   else if (letter == 'o')
     return SHF_LINK_ORDER;
+#ifdef TE_VMS
+  else if (letter == 'O')
+    return SHF_IA_64_VMS_OVERLAID;
+  else if (letter == 'g')
+    return SHF_IA_64_VMS_GLOBAL;
+#endif
 
-  *ptr_msg = _("Bad .section directive: want a,o,s,w,x,M,S,G,T in string");
+  *ptr_msg = _("bad .section directive: want a,o,s,w,x,M,S,G,T in string");
   return -1;
 }
 
 /* Map SHF_IA_64_SHORT to SEC_SMALL_DATA.  */
 
 flagword
-ia64_elf_section_flags (flags, attr, type)
-     flagword flags;
-     int attr, type ATTRIBUTE_UNUSED;
+ia64_elf_section_flags (flagword flags,
+			bfd_vma attr,
+			int type ATTRIBUTE_UNUSED)
 {
   if (attr & SHF_IA_64_SHORT)
     flags |= SEC_SMALL_DATA;
@@ -1045,9 +886,7 @@ ia64_elf_section_flags (flags, attr, type)
 }
 
 int
-ia64_elf_section_type (str, len)
-     const char *str;
-     size_t len;
+ia64_elf_section_type (const char *str, size_t len)
 {
 #define STREQ(s) ((len == sizeof (s) - 1) && (strncmp (str, s, sizeof (s) - 1) == 0))
 
@@ -1071,8 +910,10 @@ ia64_elf_section_type (str, len)
 }
 
 static unsigned int
-set_regstack (ins, locs, outs, rots)
-     unsigned int ins, locs, outs, rots;
+set_regstack (unsigned int ins,
+	      unsigned int locs,
+	      unsigned int outs,
+	      unsigned int rots)
 {
   /* Size of frame.  */
   unsigned int sof;
@@ -1100,7 +941,7 @@ set_regstack (ins, locs, outs, rots)
 }
 
 void
-ia64_flush_insns ()
+ia64_flush_insns (void)
 {
   struct label_fix *lfix;
   segT saved_seg;
@@ -1184,37 +1025,158 @@ ia64_flush_insns ()
     as_bad (_("qualifying predicate not followed by instruction"));
 }
 
-static void
-ia64_do_align (int nbytes)
+void
+ia64_cons_align (int nbytes)
 {
-  char *saved_input_line_pointer = input_line_pointer;
+  if (md.auto_align)
+    {
+      int log;
+      for (log = 0; (nbytes & 1) != 1; nbytes >>= 1)
+	log++;
 
-  input_line_pointer = "";
-  s_align_bytes (nbytes);
-  input_line_pointer = saved_input_line_pointer;
+      do_align (log, NULL, 0, 0);
+    }
 }
 
-void
-ia64_cons_align (nbytes)
-     int nbytes;
-{
-  if (md.auto_align)
+#ifdef TE_VMS
+
+/* .vms_common section, symbol, size, alignment  */
+
+static void
+obj_elf_vms_common (int ignore ATTRIBUTE_UNUSED)
+{
+  const char *sec_name;
+  char *sym_name;
+  char c;
+  offsetT size;
+  offsetT cur_size;
+  offsetT temp;
+  symbolS *symbolP;
+  segT current_seg = now_seg;
+  subsegT current_subseg = now_subseg;
+  offsetT log_align;
+
+  /* Section name.  */
+  sec_name = obj_elf_section_name ();
+  if (sec_name == NULL)
+    return;
+
+  /* Symbol name.  */
+  SKIP_WHITESPACE ();
+  if (*input_line_pointer == ',')
+    {
+      input_line_pointer++;
+      SKIP_WHITESPACE ();
+    }
+  else
+    {
+      as_bad (_("expected ',' after section name"));
+      ignore_rest_of_line ();
+      return;
+    }
+
+  c = get_symbol_name (&sym_name);
+
+  if (input_line_pointer == sym_name)
+    {
+      (void) restore_line_pointer (c);
+      as_bad (_("expected symbol name"));
+      ignore_rest_of_line ();
+      return;
+    }
+
+  symbolP = symbol_find_or_make (sym_name);
+  (void) restore_line_pointer (c);
+
+  if ((S_IS_DEFINED (symbolP) || symbol_equated_p (symbolP))
+      && !S_IS_COMMON (symbolP))
+    {
+      as_bad (_("Ignoring attempt to re-define symbol"));
+      ignore_rest_of_line ();
+      return;
+    }
+
+  /* Symbol size.  */
+  SKIP_WHITESPACE ();
+  if (*input_line_pointer == ',')
+    {
+      input_line_pointer++;
+      SKIP_WHITESPACE ();
+    }
+  else
+    {
+      as_bad (_("expected ',' after symbol name"));
+      ignore_rest_of_line ();
+      return;
+    }
+
+  temp = get_absolute_expression ();
+  size = temp;
+  size &= ((offsetT) 2 << (stdoutput->arch_info->bits_per_address - 1)) - 1;
+  if (temp != size)
+    {
+      as_warn (_("size (%ld) out of range, ignored"), (long) temp);
+      ignore_rest_of_line ();
+      return;
+    }
+
+  /* Alignment.  */
+  SKIP_WHITESPACE ();
+  if (*input_line_pointer == ',')
+    {
+      input_line_pointer++;
+      SKIP_WHITESPACE ();
+    }
+  else
+    {
+      as_bad (_("expected ',' after symbol size"));
+      ignore_rest_of_line ();
+      return;
+    }
+
+  log_align = get_absolute_expression ();
+
+  demand_empty_rest_of_line ();
+
+  obj_elf_change_section
+    (sec_name, SHT_NOBITS,
+     SHF_ALLOC | SHF_WRITE | SHF_IA_64_VMS_OVERLAID | SHF_IA_64_VMS_GLOBAL,
+     0, NULL, 1, 0);
+
+  S_SET_VALUE (symbolP, 0);
+  S_SET_SIZE (symbolP, size);
+  S_SET_EXTERNAL (symbolP);
+  S_SET_SEGMENT (symbolP, now_seg);
+
+  symbol_get_bfdsym (symbolP)->flags |= BSF_OBJECT;
+
+  record_alignment (now_seg, log_align);
+
+  cur_size = bfd_section_size (stdoutput, now_seg);
+  if ((int) size > cur_size)
     {
-      char *saved_input_line_pointer = input_line_pointer;
-      input_line_pointer = "";
-      s_align_bytes (nbytes);
-      input_line_pointer = saved_input_line_pointer;
+      char *pfrag
+        = frag_var (rs_fill, 1, 1, (relax_substateT)0, NULL,
+                    (valueT)size - (valueT)cur_size, NULL);
+      *pfrag = 0;
+      bfd_section_size (stdoutput, now_seg) = size;
     }
+
+  /* Switch back to current segment.  */
+  subseg_set (current_seg, current_subseg);
+
+#ifdef md_elf_section_change_hook
+  md_elf_section_change_hook ();
+#endif
 }
 
+#endif /* TE_VMS */
+
 /* Output COUNT bytes to a memory location.  */
 static char *vbyte_mem_ptr = NULL;
 
-void
-output_vbyte_mem (count, ptr, comment)
-     int count;
-     char *ptr;
-     char *comment ATTRIBUTE_UNUSED;
+static void
+output_vbyte_mem (int count, char *ptr, char *comment ATTRIBUTE_UNUSED)
 {
   int x;
   if (vbyte_mem_ptr == NULL)
@@ -1228,20 +1190,16 @@ output_vbyte_mem (count, ptr, comment)
 
 /* Count the number of bytes required for records.  */
 static int vbyte_count = 0;
-void
-count_output (count, ptr, comment)
-     int count;
-     char *ptr ATTRIBUTE_UNUSED;
-     char *comment ATTRIBUTE_UNUSED;
+static void
+count_output (int count,
+	      char *ptr ATTRIBUTE_UNUSED,
+	      char *comment ATTRIBUTE_UNUSED)
 {
   vbyte_count += count;
 }
 
 static void
-output_R1_format (f, rtype, rlen)
-     vbyte_func f;
-     unw_record_type rtype;
-     int rlen;
+output_R1_format (vbyte_func f, unw_record_type rtype, int rlen)
 {
   int r = 0;
   char byte;
@@ -1261,10 +1219,7 @@ output_R1_format (f, rtype, rlen)
 }
 
 static void
-output_R2_format (f, mask, grsave, rlen)
-     vbyte_func f;
-     int mask, grsave;
-     unsigned long rlen;
+output_R2_format (vbyte_func f, int mask, int grsave, unsigned long rlen)
 {
   char bytes[20];
   int count = 2;
@@ -1278,10 +1233,7 @@ output_R2_format (f, mask, grsave, rlen)
 }
 
 static void
-output_R3_format (f, rtype, rlen)
-     vbyte_func f;
-     unw_record_type rtype;
-     unsigned long rlen;
+output_R3_format (vbyte_func f, unw_record_type rtype, unsigned long rlen)
 {
   int r = 0, count;
   char bytes[20];
@@ -1301,9 +1253,7 @@ output_R3_format (f, rtype, rlen)
 }
 
 static void
-output_P1_format (f, brmask)
-     vbyte_func f;
-     int brmask;
+output_P1_format (vbyte_func f, int brmask)
 {
   char byte;
   byte = UNW_P1 | (brmask & 0x1f);
@@ -1311,10 +1261,7 @@ output_P1_format (f, brmask)
 }
 
 static void
-output_P2_format (f, brmask, gr)
-     vbyte_func f;
-     int brmask;
-     int gr;
+output_P2_format (vbyte_func f, int brmask, int gr)
 {
   char bytes[2];
   brmask = (brmask & 0x1f);
@@ -1324,10 +1271,7 @@ output_P2_format (f, brmask, gr)
 }
 
 static void
-output_P3_format (f, rtype, reg)
-     vbyte_func f;
-     unw_record_type rtype;
-     int reg;
+output_P3_format (vbyte_func f, unw_record_type rtype, int reg)
 {
   char bytes[2];
   int r = 0;
@@ -1379,20 +1323,14 @@ output_P3_format (f, rtype, reg)
 }
 
 static void
-output_P4_format (f, imask, imask_size)
-     vbyte_func f;
-     unsigned char *imask;
-     unsigned long imask_size;
+output_P4_format (vbyte_func f, unsigned char *imask, unsigned long imask_size)
 {
   imask[0] = UNW_P4;
   (*f) (imask_size, (char *) imask, NULL);
 }
 
 static void
-output_P5_format (f, grmask, frmask)
-     vbyte_func f;
-     int grmask;
-     unsigned long frmask;
+output_P5_format (vbyte_func f, int grmask, unsigned long frmask)
 {
   char bytes[4];
   grmask = (grmask & 0x0f);
@@ -1405,10 +1343,7 @@ output_P5_format (f, grmask, frmask)
 }
 
 static void
-output_P6_format (f, rtype, rmask)
-     vbyte_func f;
-     unw_record_type rtype;
-     int rmask;
+output_P6_format (vbyte_func f, unw_record_type rtype, int rmask)
 {
   char byte;
   int r = 0;
@@ -1422,11 +1357,10 @@ output_P6_format (f, rtype, rmask)
 }
 
 static void
-output_P7_format (f, rtype, w1, w2)
-     vbyte_func f;
-     unw_record_type rtype;
-     unsigned long w1;
-     unsigned long w2;
+output_P7_format (vbyte_func f,
+		  unw_record_type rtype,
+		  unsigned long w1,
+		  unsigned long w2)
 {
   char bytes[20];
   int count = 1;
@@ -1491,10 +1425,7 @@ output_P7_format (f, rtype, w1, w2)
 }
 
 static void
-output_P8_format (f, rtype, t)
-     vbyte_func f;
-     unw_record_type rtype;
-     unsigned long t;
+output_P8_format (vbyte_func f, unw_record_type rtype, unsigned long t)
 {
   char bytes[20];
   int r = 0;
@@ -1568,10 +1499,7 @@ output_P8_format (f, rtype, t)
 }
 
 static void
-output_P9_format (f, grmask, gr)
-     vbyte_func f;
-     int grmask;
-     int gr;
+output_P9_format (vbyte_func f, int grmask, int gr)
 {
   char bytes[3];
   bytes[0] = UNW_P9;
@@ -1581,10 +1509,7 @@ output_P9_format (f, grmask, gr)
 }
 
 static void
-output_P10_format (f, abi, context)
-     vbyte_func f;
-     int abi;
-     int context;
+output_P10_format (vbyte_func f, int abi, int context)
 {
   char bytes[3];
   bytes[0] = UNW_P10;
@@ -1594,10 +1519,7 @@ output_P10_format (f, abi, context)
 }
 
 static void
-output_B1_format (f, rtype, label)
-     vbyte_func f;
-     unw_record_type rtype;
-     unsigned long label;
+output_B1_format (vbyte_func f, unw_record_type rtype, unsigned long label)
 {
   char byte;
   int r = 0;
@@ -1616,10 +1538,7 @@ output_B1_format (f, rtype, label)
 }
 
 static void
-output_B2_format (f, ecount, t)
-     vbyte_func f;
-     unsigned long ecount;
-     unsigned long t;
+output_B2_format (vbyte_func f, unsigned long ecount, unsigned long t)
 {
   char bytes[20];
   int count = 1;
@@ -1634,10 +1553,7 @@ output_B2_format (f, ecount, t)
 }
 
 static void
-output_B3_format (f, ecount, t)
-     vbyte_func f;
-     unsigned long ecount;
-     unsigned long t;
+output_B3_format (vbyte_func f, unsigned long ecount, unsigned long t)
 {
   char bytes[20];
   int count = 1;
@@ -1653,10 +1569,7 @@ output_B3_format (f, ecount, t)
 }
 
 static void
-output_B4_format (f, rtype, label)
-     vbyte_func f;
-     unw_record_type rtype;
-     unsigned long label;
+output_B4_format (vbyte_func f, unw_record_type rtype, unsigned long label)
 {
   char bytes[20];
   int r = 0;
@@ -1678,9 +1591,7 @@ output_B4_format (f, rtype, label)
 }
 
 static char
-format_ab_reg (ab, reg)
-     int ab;
-     int reg;
+format_ab_reg (int ab, int reg)
 {
   int ret;
   ab = (ab & 3);
@@ -1690,12 +1601,12 @@ format_ab_reg (ab, reg)
 }
 
 static void
-output_X1_format (f, rtype, ab, reg, t, w1)
-     vbyte_func f;
-     unw_record_type rtype;
-     int ab, reg;
-     unsigned long t;
-     unsigned long w1;
+output_X1_format (vbyte_func f,
+		  unw_record_type rtype,
+		  int ab,
+		  int reg,
+		  unsigned long t,
+		  unsigned long w1)
 {
   char bytes[20];
   int r = 0;
@@ -1713,11 +1624,13 @@ output_X1_format (f, rtype, ab, reg, t, w1)
 }
 
 static void
-output_X2_format (f, ab, reg, x, y, treg, t)
-     vbyte_func f;
-     int ab, reg;
-     int x, y, treg;
-     unsigned long t;
+output_X2_format (vbyte_func f,
+		  int ab,
+		  int reg,
+		  int x,
+		  int y,
+		  int treg,
+		  unsigned long t)
 {
   char bytes[20];
   int count = 3;
@@ -1729,13 +1642,13 @@ output_X2_format (f, ab, reg, x, y, treg, t)
 }
 
 static void
-output_X3_format (f, rtype, qp, ab, reg, t, w1)
-     vbyte_func f;
-     unw_record_type rtype;
-     int qp;
-     int ab, reg;
-     unsigned long t;
-     unsigned long w1;
+output_X3_format (vbyte_func f,
+		  unw_record_type rtype,
+		  int qp,
+		  int ab,
+		  int reg,
+		  unsigned long t,
+		  unsigned long w1)
 {
   char bytes[20];
   int r = 0;
@@ -1754,12 +1667,14 @@ output_X3_format (f, rtype, qp, ab, reg, t, w1)
 }
 
 static void
-output_X4_format (f, qp, ab, reg, x, y, treg, t)
-     vbyte_func f;
-     int qp;
-     int ab, reg;
-     int x, y, treg;
-     unsigned long t;
+output_X4_format (vbyte_func f,
+		  int qp,
+		  int ab,
+		  int reg,
+		  int x,
+		  int y,
+		  int treg,
+		  unsigned long t)
 {
   char bytes[20];
   int count = 4;
@@ -1826,7 +1741,7 @@ static unw_rec_list *
 alloc_record (unw_record_type t)
 {
   unw_rec_list *ptr;
-  ptr = xmalloc (sizeof (*ptr));
+  ptr = XNEW (unw_rec_list);
   memset (ptr, 0, sizeof (*ptr));
   ptr->slot_number = SLOT_NUM_NOT_SET;
   ptr->r.type = t;
@@ -1837,14 +1752,14 @@ alloc_record (unw_record_type t)
    body region.  */
 
 static unw_rec_list *
-output_endp ()
+output_endp (void)
 {
   unw_rec_list *ptr = alloc_record (endp);
   return ptr;
 }
 
 static unw_rec_list *
-output_prologue ()
+output_prologue (void)
 {
   unw_rec_list *ptr = alloc_record (prologue);
   memset (&ptr->r.record.r.mask, 0, sizeof (ptr->r.record.r.mask));
@@ -1852,9 +1767,7 @@ output_prologue ()
 }
 
 static unw_rec_list *
-output_prologue_gr (saved_mask, reg)
-     unsigned int saved_mask;
-     unsigned int reg;
+output_prologue_gr (unsigned int saved_mask, unsigned int reg)
 {
   unw_rec_list *ptr = alloc_record (prologue_gr);
   memset (&ptr->r.record.r.mask, 0, sizeof (ptr->r.record.r.mask));
@@ -1864,15 +1777,14 @@ output_prologue_gr (saved_mask, reg)
 }
 
 static unw_rec_list *
-output_body ()
+output_body (void)
 {
   unw_rec_list *ptr = alloc_record (body);
   return ptr;
 }
 
 static unw_rec_list *
-output_mem_stack_f (size)
-     unsigned int size;
+output_mem_stack_f (unsigned int size)
 {
   unw_rec_list *ptr = alloc_record (mem_stack_f);
   ptr->r.record.p.size = size;
@@ -1880,15 +1792,14 @@ output_mem_stack_f (size)
 }
 
 static unw_rec_list *
-output_mem_stack_v ()
+output_mem_stack_v (void)
 {
   unw_rec_list *ptr = alloc_record (mem_stack_v);
   return ptr;
 }
 
 static unw_rec_list *
-output_psp_gr (gr)
-     unsigned int gr;
+output_psp_gr (unsigned int gr)
 {
   unw_rec_list *ptr = alloc_record (psp_gr);
   ptr->r.record.p.r.gr = gr;
@@ -1896,8 +1807,7 @@ output_psp_gr (gr)
 }
 
 static unw_rec_list *
-output_psp_sprel (offset)
-     unsigned int offset;
+output_psp_sprel (unsigned int offset)
 {
   unw_rec_list *ptr = alloc_record (psp_sprel);
   ptr->r.record.p.off.sp = offset / 4;
@@ -1905,15 +1815,14 @@ output_psp_sprel (offset)
 }
 
 static unw_rec_list *
-output_rp_when ()
+output_rp_when (void)
 {
   unw_rec_list *ptr = alloc_record (rp_when);
   return ptr;
 }
 
 static unw_rec_list *
-output_rp_gr (gr)
-     unsigned int gr;
+output_rp_gr (unsigned int gr)
 {
   unw_rec_list *ptr = alloc_record (rp_gr);
   ptr->r.record.p.r.gr = gr;
@@ -1921,8 +1830,7 @@ output_rp_gr (gr)
 }
 
 static unw_rec_list *
-output_rp_br (br)
-     unsigned int br;
+output_rp_br (unsigned int br)
 {
   unw_rec_list *ptr = alloc_record (rp_br);
   ptr->r.record.p.r.br = br;
@@ -1930,8 +1838,7 @@ output_rp_br (br)
 }
 
 static unw_rec_list *
-output_rp_psprel (offset)
-     unsigned int offset;
+output_rp_psprel (unsigned int offset)
 {
   unw_rec_list *ptr = alloc_record (rp_psprel);
   ptr->r.record.p.off.psp = ENCODED_PSP_OFFSET (offset);
@@ -1939,8 +1846,7 @@ output_rp_psprel (offset)
 }
 
 static unw_rec_list *
-output_rp_sprel (offset)
-     unsigned int offset;
+output_rp_sprel (unsigned int offset)
 {
   unw_rec_list *ptr = alloc_record (rp_sprel);
   ptr->r.record.p.off.sp = offset / 4;
@@ -1948,15 +1854,14 @@ output_rp_sprel (offset)
 }
 
 static unw_rec_list *
-output_pfs_when ()
+output_pfs_when (void)
 {
   unw_rec_list *ptr = alloc_record (pfs_when);
   return ptr;
 }
 
 static unw_rec_list *
-output_pfs_gr (gr)
-     unsigned int gr;
+output_pfs_gr (unsigned int gr)
 {
   unw_rec_list *ptr = alloc_record (pfs_gr);
   ptr->r.record.p.r.gr = gr;
@@ -1964,8 +1869,7 @@ output_pfs_gr (gr)
 }
 
 static unw_rec_list *
-output_pfs_psprel (offset)
-     unsigned int offset;
+output_pfs_psprel (unsigned int offset)
 {
   unw_rec_list *ptr = alloc_record (pfs_psprel);
   ptr->r.record.p.off.psp = ENCODED_PSP_OFFSET (offset);
@@ -1973,8 +1877,7 @@ output_pfs_psprel (offset)
 }
 
 static unw_rec_list *
-output_pfs_sprel (offset)
-     unsigned int offset;
+output_pfs_sprel (unsigned int offset)
 {
   unw_rec_list *ptr = alloc_record (pfs_sprel);
   ptr->r.record.p.off.sp = offset / 4;
@@ -1982,15 +1885,14 @@ output_pfs_sprel (offset)
 }
 
 static unw_rec_list *
-output_preds_when ()
+output_preds_when (void)
 {
   unw_rec_list *ptr = alloc_record (preds_when);
   return ptr;
 }
 
 static unw_rec_list *
-output_preds_gr (gr)
-     unsigned int gr;
+output_preds_gr (unsigned int gr)
 {
   unw_rec_list *ptr = alloc_record (preds_gr);
   ptr->r.record.p.r.gr = gr;
@@ -1998,8 +1900,7 @@ output_preds_gr (gr)
 }
 
 static unw_rec_list *
-output_preds_psprel (offset)
-     unsigned int offset;
+output_preds_psprel (unsigned int offset)
 {
   unw_rec_list *ptr = alloc_record (preds_psprel);
   ptr->r.record.p.off.psp = ENCODED_PSP_OFFSET (offset);
@@ -2007,8 +1908,7 @@ output_preds_psprel (offset)
 }
 
 static unw_rec_list *
-output_preds_sprel (offset)
-     unsigned int offset;
+output_preds_sprel (unsigned int offset)
 {
   unw_rec_list *ptr = alloc_record (preds_sprel);
   ptr->r.record.p.off.sp = offset / 4;
@@ -2016,8 +1916,7 @@ output_preds_sprel (offset)
 }
 
 static unw_rec_list *
-output_fr_mem (mask)
-     unsigned int mask;
+output_fr_mem (unsigned int mask)
 {
   unw_rec_list *ptr = alloc_record (fr_mem);
   unw_rec_list *cur = ptr;
@@ -2041,9 +1940,7 @@ output_fr_mem (mask)
 }
 
 static unw_rec_list *
-output_frgr_mem (gr_mask, fr_mask)
-     unsigned int gr_mask;
-     unsigned int fr_mask;
+output_frgr_mem (unsigned int gr_mask, unsigned int fr_mask)
 {
   unw_rec_list *ptr = alloc_record (frgr_mem);
   unw_rec_list *cur = ptr;
@@ -2082,9 +1979,7 @@ output_frgr_mem (gr_mask, fr_mask)
 }
 
 static unw_rec_list *
-output_gr_gr (mask, reg)
-     unsigned int mask;
-     unsigned int reg;
+output_gr_gr (unsigned int mask, unsigned int reg)
 {
   unw_rec_list *ptr = alloc_record (gr_gr);
   unw_rec_list *cur = ptr;
@@ -2111,8 +2006,7 @@ output_gr_gr (mask, reg)
 }
 
 static unw_rec_list *
-output_gr_mem (mask)
-     unsigned int mask;
+output_gr_mem (unsigned int mask)
 {
   unw_rec_list *ptr = alloc_record (gr_mem);
   unw_rec_list *cur = ptr;
@@ -2160,9 +2054,7 @@ output_br_mem (unsigned int mask)
 }
 
 static unw_rec_list *
-output_br_gr (mask, reg)
-     unsigned int mask;
-     unsigned int reg;
+output_br_gr (unsigned int mask, unsigned int reg)
 {
   unw_rec_list *ptr = alloc_record (br_gr);
   unw_rec_list *cur = ptr;
@@ -2189,8 +2081,7 @@ output_br_gr (mask, reg)
 }
 
 static unw_rec_list *
-output_spill_base (offset)
-     unsigned int offset;
+output_spill_base (unsigned int offset)
 {
   unw_rec_list *ptr = alloc_record (spill_base);
   ptr->r.record.p.off.psp = ENCODED_PSP_OFFSET (offset);
@@ -2198,15 +2089,14 @@ output_spill_base (offset)
 }
 
 static unw_rec_list *
-output_unat_when ()
+output_unat_when (void)
 {
   unw_rec_list *ptr = alloc_record (unat_when);
   return ptr;
 }
 
 static unw_rec_list *
-output_unat_gr (gr)
-     unsigned int gr;
+output_unat_gr (unsigned int gr)
 {
   unw_rec_list *ptr = alloc_record (unat_gr);
   ptr->r.record.p.r.gr = gr;
@@ -2214,8 +2104,7 @@ output_unat_gr (gr)
 }
 
 static unw_rec_list *
-output_unat_psprel (offset)
-     unsigned int offset;
+output_unat_psprel (unsigned int offset)
 {
   unw_rec_list *ptr = alloc_record (unat_psprel);
   ptr->r.record.p.off.psp = ENCODED_PSP_OFFSET (offset);
@@ -2223,8 +2112,7 @@ output_unat_psprel (offset)
 }
 
 static unw_rec_list *
-output_unat_sprel (offset)
-     unsigned int offset;
+output_unat_sprel (unsigned int offset)
 {
   unw_rec_list *ptr = alloc_record (unat_sprel);
   ptr->r.record.p.off.sp = offset / 4;
@@ -2232,15 +2120,14 @@ output_unat_sprel (offset)
 }
 
 static unw_rec_list *
-output_lc_when ()
+output_lc_when (void)
 {
   unw_rec_list *ptr = alloc_record (lc_when);
   return ptr;
 }
 
 static unw_rec_list *
-output_lc_gr (gr)
-     unsigned int gr;
+output_lc_gr (unsigned int gr)
 {
   unw_rec_list *ptr = alloc_record (lc_gr);
   ptr->r.record.p.r.gr = gr;
@@ -2248,8 +2135,7 @@ output_lc_gr (gr)
 }
 
 static unw_rec_list *
-output_lc_psprel (offset)
-     unsigned int offset;
+output_lc_psprel (unsigned int offset)
 {
   unw_rec_list *ptr = alloc_record (lc_psprel);
   ptr->r.record.p.off.psp = ENCODED_PSP_OFFSET (offset);
@@ -2257,8 +2143,7 @@ output_lc_psprel (offset)
 }
 
 static unw_rec_list *
-output_lc_sprel (offset)
-     unsigned int offset;
+output_lc_sprel (unsigned int offset)
 {
   unw_rec_list *ptr = alloc_record (lc_sprel);
   ptr->r.record.p.off.sp = offset / 4;
@@ -2266,15 +2151,14 @@ output_lc_sprel (offset)
 }
 
 static unw_rec_list *
-output_fpsr_when ()
+output_fpsr_when (void)
 {
   unw_rec_list *ptr = alloc_record (fpsr_when);
   return ptr;
 }
 
 static unw_rec_list *
-output_fpsr_gr (gr)
-     unsigned int gr;
+output_fpsr_gr (unsigned int gr)
 {
   unw_rec_list *ptr = alloc_record (fpsr_gr);
   ptr->r.record.p.r.gr = gr;
@@ -2282,8 +2166,7 @@ output_fpsr_gr (gr)
 }
 
 static unw_rec_list *
-output_fpsr_psprel (offset)
-     unsigned int offset;
+output_fpsr_psprel (unsigned int offset)
 {
   unw_rec_list *ptr = alloc_record (fpsr_psprel);
   ptr->r.record.p.off.psp = ENCODED_PSP_OFFSET (offset);
@@ -2291,8 +2174,7 @@ output_fpsr_psprel (offset)
 }
 
 static unw_rec_list *
-output_fpsr_sprel (offset)
-     unsigned int offset;
+output_fpsr_sprel (unsigned int offset)
 {
   unw_rec_list *ptr = alloc_record (fpsr_sprel);
   ptr->r.record.p.off.sp = offset / 4;
@@ -2300,22 +2182,21 @@ output_fpsr_sprel (offset)
 }
 
 static unw_rec_list *
-output_priunat_when_gr ()
+output_priunat_when_gr (void)
 {
   unw_rec_list *ptr = alloc_record (priunat_when_gr);
   return ptr;
 }
 
 static unw_rec_list *
-output_priunat_when_mem ()
+output_priunat_when_mem (void)
 {
   unw_rec_list *ptr = alloc_record (priunat_when_mem);
   return ptr;
 }
 
 static unw_rec_list *
-output_priunat_gr (gr)
-     unsigned int gr;
+output_priunat_gr (unsigned int gr)
 {
   unw_rec_list *ptr = alloc_record (priunat_gr);
   ptr->r.record.p.r.gr = gr;
@@ -2323,8 +2204,7 @@ output_priunat_gr (gr)
 }
 
 static unw_rec_list *
-output_priunat_psprel (offset)
-     unsigned int offset;
+output_priunat_psprel (unsigned int offset)
 {
   unw_rec_list *ptr = alloc_record (priunat_psprel);
   ptr->r.record.p.off.psp = ENCODED_PSP_OFFSET (offset);
@@ -2332,8 +2212,7 @@ output_priunat_psprel (offset)
 }
 
 static unw_rec_list *
-output_priunat_sprel (offset)
-     unsigned int offset;
+output_priunat_sprel (unsigned int offset)
 {
   unw_rec_list *ptr = alloc_record (priunat_sprel);
   ptr->r.record.p.off.sp = offset / 4;
@@ -2341,15 +2220,14 @@ output_priunat_sprel (offset)
 }
 
 static unw_rec_list *
-output_bsp_when ()
+output_bsp_when (void)
 {
   unw_rec_list *ptr = alloc_record (bsp_when);
   return ptr;
 }
 
 static unw_rec_list *
-output_bsp_gr (gr)
-     unsigned int gr;
+output_bsp_gr (unsigned int gr)
 {
   unw_rec_list *ptr = alloc_record (bsp_gr);
   ptr->r.record.p.r.gr = gr;
@@ -2357,8 +2235,7 @@ output_bsp_gr (gr)
 }
 
 static unw_rec_list *
-output_bsp_psprel (offset)
-     unsigned int offset;
+output_bsp_psprel (unsigned int offset)
 {
   unw_rec_list *ptr = alloc_record (bsp_psprel);
   ptr->r.record.p.off.psp = ENCODED_PSP_OFFSET (offset);
@@ -2366,8 +2243,7 @@ output_bsp_psprel (offset)
 }
 
 static unw_rec_list *
-output_bsp_sprel (offset)
-     unsigned int offset;
+output_bsp_sprel (unsigned int offset)
 {
   unw_rec_list *ptr = alloc_record (bsp_sprel);
   ptr->r.record.p.off.sp = offset / 4;
@@ -2375,15 +2251,14 @@ output_bsp_sprel (offset)
 }
 
 static unw_rec_list *
-output_bspstore_when ()
+output_bspstore_when (void)
 {
   unw_rec_list *ptr = alloc_record (bspstore_when);
   return ptr;
 }
 
 static unw_rec_list *
-output_bspstore_gr (gr)
-     unsigned int gr;
+output_bspstore_gr (unsigned int gr)
 {
   unw_rec_list *ptr = alloc_record (bspstore_gr);
   ptr->r.record.p.r.gr = gr;
@@ -2391,8 +2266,7 @@ output_bspstore_gr (gr)
 }
 
 static unw_rec_list *
-output_bspstore_psprel (offset)
-     unsigned int offset;
+output_bspstore_psprel (unsigned int offset)
 {
   unw_rec_list *ptr = alloc_record (bspstore_psprel);
   ptr->r.record.p.off.psp = ENCODED_PSP_OFFSET (offset);
@@ -2400,8 +2274,7 @@ output_bspstore_psprel (offset)
 }
 
 static unw_rec_list *
-output_bspstore_sprel (offset)
-     unsigned int offset;
+output_bspstore_sprel (unsigned int offset)
 {
   unw_rec_list *ptr = alloc_record (bspstore_sprel);
   ptr->r.record.p.off.sp = offset / 4;
@@ -2409,15 +2282,14 @@ output_bspstore_sprel (offset)
 }
 
 static unw_rec_list *
-output_rnat_when ()
+output_rnat_when (void)
 {
   unw_rec_list *ptr = alloc_record (rnat_when);
   return ptr;
 }
 
 static unw_rec_list *
-output_rnat_gr (gr)
-     unsigned int gr;
+output_rnat_gr (unsigned int gr)
 {
   unw_rec_list *ptr = alloc_record (rnat_gr);
   ptr->r.record.p.r.gr = gr;
@@ -2425,8 +2297,7 @@ output_rnat_gr (gr)
 }
 
 static unw_rec_list *
-output_rnat_psprel (offset)
-     unsigned int offset;
+output_rnat_psprel (unsigned int offset)
 {
   unw_rec_list *ptr = alloc_record (rnat_psprel);
   ptr->r.record.p.off.psp = ENCODED_PSP_OFFSET (offset);
@@ -2434,8 +2305,7 @@ output_rnat_psprel (offset)
 }
 
 static unw_rec_list *
-output_rnat_sprel (offset)
-     unsigned int offset;
+output_rnat_sprel (unsigned int offset)
 {
   unw_rec_list *ptr = alloc_record (rnat_sprel);
   ptr->r.record.p.off.sp = offset / 4;
@@ -2443,9 +2313,7 @@ output_rnat_sprel (offset)
 }
 
 static unw_rec_list *
-output_unwabi (abi, context)
-     unsigned long abi;
-     unsigned long context;
+output_unwabi (unsigned long abi, unsigned long context)
 {
   unw_rec_list *ptr = alloc_record (unwabi);
   ptr->r.record.p.abi = abi;
@@ -2478,11 +2346,10 @@ output_copy_state (unsigned long label)
 }
 
 static unw_rec_list *
-output_spill_psprel (ab, reg, offset, predicate)
-     unsigned int ab;
-     unsigned int reg;
-     unsigned int offset;
-     unsigned int predicate;
+output_spill_psprel (unsigned int ab,
+		     unsigned int reg,
+		     unsigned int offset,
+		     unsigned int predicate)
 {
   unw_rec_list *ptr = alloc_record (predicate ? spill_psprel_p : spill_psprel);
   ptr->r.record.x.ab = ab;
@@ -2493,11 +2360,10 @@ output_spill_psprel (ab, reg, offset, predicate)
 }
 
 static unw_rec_list *
-output_spill_sprel (ab, reg, offset, predicate)
-     unsigned int ab;
-     unsigned int reg;
-     unsigned int offset;
-     unsigned int predicate;
+output_spill_sprel (unsigned int ab,
+		    unsigned int reg,
+		    unsigned int offset,
+		    unsigned int predicate)
 {
   unw_rec_list *ptr = alloc_record (predicate ? spill_sprel_p : spill_sprel);
   ptr->r.record.x.ab = ab;
@@ -2508,12 +2374,11 @@ output_spill_sprel (ab, reg, offset, predicate)
 }
 
 static unw_rec_list *
-output_spill_reg (ab, reg, targ_reg, xy, predicate)
-     unsigned int ab;
-     unsigned int reg;
-     unsigned int targ_reg;
-     unsigned int xy;
-     unsigned int predicate;
+output_spill_reg (unsigned int ab,
+		  unsigned int reg,
+		  unsigned int targ_reg,
+		  unsigned int xy,
+		  unsigned int predicate)
 {
   unw_rec_list *ptr = alloc_record (predicate ? spill_reg_p : spill_reg);
   ptr->r.record.x.ab = ab;
@@ -2528,9 +2393,7 @@ output_spill_reg (ab, reg, targ_reg, xy, predicate)
    specified function.  */
 
 static void
-process_one_record (ptr, f)
-     unw_rec_list *ptr;
-     vbyte_func f;
+process_one_record (unw_rec_list *ptr, vbyte_func f)
 {
   unsigned int fr_mask, gr_mask;
 
@@ -2723,9 +2586,7 @@ process_one_record (ptr, f)
 /* Given a unw_rec_list list, process all the records with
    the specified function.  */
 static void
-process_unw_records (list, f)
-     unw_rec_list *list;
-     vbyte_func f;
+process_unw_records (unw_rec_list *list, vbyte_func f)
 {
   unw_rec_list *ptr;
   for (ptr = list; ptr; ptr = ptr->next)
@@ -2734,8 +2595,7 @@ process_unw_records (list, f)
 
 /* Determine the size of a record list in bytes.  */
 static int
-calc_record_size (list)
-     unw_rec_list *list;
+calc_record_size (unw_rec_list *list)
 {
   vbyte_count = 0;
   process_unw_records (list, count_output);
@@ -2775,11 +2635,10 @@ popcount (unsigned x)
 	2: instruction saves next general reg
 	3: instruction saves next branch reg */
 static void
-set_imask (region, regmask, t, type)
-     unw_rec_list *region;
-     unsigned long regmask;
-     unsigned long t;
-     unsigned int type;
+set_imask (unw_rec_list *region,
+	   unsigned long regmask,
+	   unsigned long t,
+	   unsigned int type)
 {
   unsigned char *imask;
   unsigned long imask_size;
@@ -2791,8 +2650,7 @@ set_imask (region, regmask, t, type)
   if (!imask)
     {
       imask_size = (region->r.record.r.rlen * 2 + 7) / 8 + 1;
-      imask = xmalloc (imask_size);
-      memset (imask, 0, imask_size);
+      imask = XCNEWVEC (unsigned char, imask_size);
 
       region->r.record.r.imask_size = imask_size;
       region->r.record.r.mask.i = imask;
@@ -2825,15 +2683,14 @@ set_imask (region, regmask, t, type)
    containing FIRST_ADDR.  If BEFORE_RELAX, then we use worst-case estimates
    for frag sizes.  */
 
-unsigned long
-slot_index (slot_addr, slot_frag, first_addr, first_frag, before_relax)
-     unsigned long slot_addr;
-     fragS *slot_frag;
-     unsigned long first_addr;
-     fragS *first_frag;
-     int before_relax;
+static unsigned long
+slot_index (unsigned long slot_addr,
+	    fragS *slot_frag,
+	    unsigned long first_addr,
+	    fragS *first_frag,
+	    int before_relax)
 {
-  unsigned long index = 0;
+  unsigned long s_index = 0;
 
   /* First time we are called, the initial address and frag are invalid.  */
   if (first_addr == 0)
@@ -2851,7 +2708,7 @@ slot_index (slot_addr, slot_frag, first_addr, first_frag, before_relax)
 	  /* We can get the final addresses only during and after
 	     relaxation.  */
 	  if (first_frag->fr_next && first_frag->fr_next->fr_address)
-	    index += 3 * ((first_frag->fr_next->fr_address
+	    s_index += 3 * ((first_frag->fr_next->fr_address
 			   - first_frag->fr_address
 			     - first_frag->fr_fix) >> 4);
 	}
@@ -2872,7 +2729,7 @@ slot_index (slot_addr, slot_frag, first_addr, first_frag, before_relax)
 	  case rs_align_test:
 	    /* Take alignment into account.  Assume the worst case
 	       before relaxation.  */
-	    index += 3 * ((1 << first_frag->fr_offset) >> 4);
+	    s_index += 3 * ((1 << first_frag->fr_offset) >> 4);
 	    break;
 
 	  case rs_org:
@@ -2882,14 +2739,14 @@ slot_index (slot_addr, slot_frag, first_addr, first_frag, before_relax)
 		break;
 	      }
 	  case rs_fill:
-	    index += 3 * (first_frag->fr_offset >> 4);
+	    s_index += 3 * (first_frag->fr_offset >> 4);
 	    break;
 	  }
 
       /* Add in the full size of the frag converted to instruction slots.  */
-      index += 3 * (first_frag->fr_fix >> 4);
+      s_index += 3 * (first_frag->fr_fix >> 4);
       /* Subtract away the initial part before first_addr.  */
-      index -= (3 * ((first_addr >> 4) - (start_addr >> 4))
+      s_index -= (3 * ((first_addr >> 4) - (start_addr >> 4))
 		+ ((first_addr & 0x3) - (start_addr & 0x3)));
 
       /* Move to the beginning of the next frag.  */
@@ -2905,16 +2762,15 @@ slot_index (slot_addr, slot_frag, first_addr, first_frag, before_relax)
     }
 
   /* Add in the used part of the last frag.  */
-  index += (3 * ((slot_addr >> 4) - (first_addr >> 4))
+  s_index += (3 * ((slot_addr >> 4) - (first_addr >> 4))
 	    + ((slot_addr & 0x3) - (first_addr & 0x3)));
-  return index;
+  return s_index;
 }
 
 /* Optimize unwind record directives.  */
 
 static unw_rec_list *
-optimize_unw_records (list)
-     unw_rec_list *list;
+optimize_unw_records (unw_rec_list *list)
 {
   if (!list)
     return NULL;
@@ -2935,9 +2791,7 @@ optimize_unw_records (list)
    within each record to generate an image.  */
 
 static void
-fixup_unw_records (list, before_relax)
-     unw_rec_list *list;
-     int before_relax;
+fixup_unw_records (unw_rec_list *list, int before_relax)
 {
   unw_rec_list *ptr, *region = 0;
   unsigned long first_addr = 0, rlen = 0, t;
@@ -3106,13 +2960,13 @@ ia64_estimate_size_before_relax (fragS *frag,
 
   /* fr_var carries the max_chars that we created the fragment with.
      We must, of course, have allocated enough memory earlier.  */
-  assert (frag->fr_var >= size);
+  gas_assert (frag->fr_var >= size);
 
   return frag->fr_fix + size;
 }
 
 /* This function converts a rs_machine_dependent variant frag into a
-  normal fill frag with the unwind image from the the record list.  */
+  normal fill frag with the unwind image from the record list.  */
 void
 ia64_convert_frag (fragS *frag)
 {
@@ -3137,7 +2991,7 @@ ia64_convert_frag (fragS *frag)
 
   /* fr_var carries the max_chars that we created the fragment with.
      We must, of course, have allocated enough memory earlier.  */
-  assert (frag->fr_var >= size);
+  gas_assert (frag->fr_var >= size);
 
   /* Initialize the header area. fr_offset is initialized with
      unwind.personality_routine.  */
@@ -3178,12 +3032,9 @@ ia64_convert_frag (fragS *frag)
 }
 
 static int
-parse_predicate_and_operand (e, qp, po)
-     expressionS * e;
-     unsigned * qp;
-     const char * po;
+parse_predicate_and_operand (expressionS *e, unsigned *qp, const char *po)
 {
-  int sep = parse_operand (e, ',');
+  int sep = parse_operand_and_eval (e, ',');
 
   *qp = e->X_add_number - REG_P;
   if (e->X_op != O_register || *qp > 63)
@@ -3194,19 +3045,18 @@ parse_predicate_and_operand (e, qp, po)
   else if (*qp == 0)
     as_warn (_("Pointless use of p0 as first operand to .%s"), po);
   if (sep == ',')
-    sep = parse_operand (e, ',');
+    sep = parse_operand_and_eval (e, ',');
   else
     e->X_op = O_absent;
   return sep;
 }
 
 static void
-convert_expr_to_ab_reg (e, ab, regp, po, n)
-     const expressionS *e;
-     unsigned int *ab;
-     unsigned int *regp;
-     const char * po;
-     int n;
+convert_expr_to_ab_reg (const expressionS *e,
+			unsigned int *ab,
+			unsigned int *regp,
+			const char *po,
+			int n)
 {
   unsigned int reg = e->X_add_number;
 
@@ -3256,12 +3106,11 @@ convert_expr_to_ab_reg (e, ab, regp, po, n)
 }
 
 static void
-convert_expr_to_xy_reg (e, xy, regp, po, n)
-     const expressionS *e;
-     unsigned int *xy;
-     unsigned int *regp;
-     const char * po;
-     int n;
+convert_expr_to_xy_reg (const expressionS *e,
+			unsigned int *xy,
+			unsigned int *regp,
+			const char *po,
+			int n)
 {
   unsigned int reg = e->X_add_number;
 
@@ -3298,8 +3147,7 @@ dot_align (int arg)
 }
 
 static void
-dot_radix (dummy)
-     int dummy ATTRIBUTE_UNUSED;
+dot_radix (int dummy ATTRIBUTE_UNUSED)
 {
   char *radix;
   int ch;
@@ -3308,12 +3156,11 @@ dot_radix (dummy)
 
   if (is_it_end_of_statement ())
     return;
-  radix = input_line_pointer;
-  ch = get_symbol_end ();
+  ch = get_symbol_name (&radix);
   ia64_canonicalize_symbol_name (radix);
   if (strcasecmp (radix, "C"))
     as_bad (_("Radix `%s' unsupported or invalid"), radix);
-  *input_line_pointer = ch;
+  (void) restore_line_pointer (ch);
   demand_empty_rest_of_line ();
 }
 
@@ -3330,8 +3177,7 @@ dot_loc (int x)
 
 /* .sbss, .bss etc. are macros that expand into ".section SECNAME".  */
 static void
-dot_special_section (which)
-     int which;
+dot_special_section (int which)
 {
   set_section ((char *) special_section_name[which]);
 }
@@ -3400,9 +3246,7 @@ in_body (const char *directive)
 }
 
 static void
-add_unwind_entry (ptr, sep)
-     unw_rec_list *ptr;
-     int sep;
+add_unwind_entry (unw_rec_list *ptr, int sep)
 {
   if (ptr)
     {
@@ -3423,11 +3267,12 @@ add_unwind_entry (ptr, sep)
 
   if (sep == ',')
     {
+      char *name;
       /* Parse a tag permitted for the current directive.  */
       int ch;
 
       SKIP_WHITESPACE ();
-      ch = get_symbol_end ();
+      ch = get_symbol_name (&name);
       /* FIXME: For now, just issue a warning that this isn't implemented.  */
       {
 	static int warned;
@@ -3438,15 +3283,14 @@ add_unwind_entry (ptr, sep)
 	    as_warn (_("Tags on unwind pseudo-ops aren't supported, yet"));
 	  }
       }
-      *input_line_pointer = ch;
+      (void) restore_line_pointer (ch);
     }
   if (sep != NOT_A_CHAR)
     demand_empty_rest_of_line ();
 }
 
 static void
-dot_fframe (dummy)
-     int dummy ATTRIBUTE_UNUSED;
+dot_fframe (int dummy ATTRIBUTE_UNUSED)
 {
   expressionS e;
   int sep;
@@ -3454,7 +3298,7 @@ dot_fframe (dummy)
   if (!in_prologue ("fframe"))
     return;
 
-  sep = parse_operand (&e, ',');
+  sep = parse_operand_and_eval (&e, ',');
 
   if (e.X_op != O_constant)
     {
@@ -3465,8 +3309,7 @@ dot_fframe (dummy)
 }
 
 static void
-dot_vframe (dummy)
-     int dummy ATTRIBUTE_UNUSED;
+dot_vframe (int dummy ATTRIBUTE_UNUSED)
 {
   expressionS e;
   unsigned reg;
@@ -3475,7 +3318,7 @@ dot_vframe (dummy)
   if (!in_prologue ("vframe"))
     return;
 
-  sep = parse_operand (&e, ',');
+  sep = parse_operand_and_eval (&e, ',');
   reg = e.X_add_number - REG_GR;
   if (e.X_op != O_register || reg > 127)
     {
@@ -3486,13 +3329,12 @@ dot_vframe (dummy)
   if (! (unwind.prologue_mask & 2))
     add_unwind_entry (output_psp_gr (reg), NOT_A_CHAR);
   else if (reg != unwind.prologue_gr
-		  + (unsigned) popcount (unwind.prologue_mask & (-2 << 1)))
+		  + (unsigned) popcount (unwind.prologue_mask & -(2 << 1)))
     as_warn (_("Operand of .vframe contradicts .prologue"));
 }
 
 static void
-dot_vframesp (psp)
-     int psp;
+dot_vframesp (int psp)
 {
   expressionS e;
   int sep;
@@ -3503,7 +3345,7 @@ dot_vframesp (psp)
   if (!in_prologue ("vframesp"))
     return;
 
-  sep = parse_operand (&e, ',');
+  sep = parse_operand_and_eval (&e, ',');
   if (e.X_op != O_constant)
     {
       as_bad (_("Operand to .vframesp must be a constant (sp-relative offset)"));
@@ -3514,8 +3356,7 @@ dot_vframesp (psp)
 }
 
 static void
-dot_save (dummy)
-     int dummy ATTRIBUTE_UNUSED;
+dot_save (int dummy ATTRIBUTE_UNUSED)
 {
   expressionS e1, e2;
   unsigned reg1, reg2;
@@ -3524,9 +3365,9 @@ dot_save (dummy)
   if (!in_prologue ("save"))
     return;
 
-  sep = parse_operand (&e1, ',');
+  sep = parse_operand_and_eval (&e1, ',');
   if (sep == ',')
-    sep = parse_operand (&e2, ',');
+    sep = parse_operand_and_eval (&e2, ',');
   else
     e2.X_op = O_absent;
 
@@ -3570,7 +3411,7 @@ dot_save (dummy)
       if (! (unwind.prologue_mask & 4))
 	add_unwind_entry (output_pfs_gr (reg2), NOT_A_CHAR);
       else if (reg2 != unwind.prologue_gr
-		       + (unsigned) popcount (unwind.prologue_mask & (-4 << 1)))
+		       + (unsigned) popcount (unwind.prologue_mask & -(4 << 1)))
 	as_warn (_("Second operand of .save contradicts .prologue"));
       break;
     case REG_AR + AR_LC:
@@ -3589,7 +3430,7 @@ dot_save (dummy)
       if (! (unwind.prologue_mask & 1))
 	add_unwind_entry (output_preds_gr (reg2), NOT_A_CHAR);
       else if (reg2 != unwind.prologue_gr
-		       + (unsigned) popcount (unwind.prologue_mask & (-1 << 1)))
+		       + (unsigned) popcount (unwind.prologue_mask & -(1 << 1)))
 	as_warn (_("Second operand of .save contradicts .prologue"));
       break;
     case REG_PRIUNAT:
@@ -3604,8 +3445,7 @@ dot_save (dummy)
 }
 
 static void
-dot_restore (dummy)
-     int dummy ATTRIBUTE_UNUSED;
+dot_restore (int dummy ATTRIBUTE_UNUSED)
 {
   expressionS e1;
   unsigned long ecount;	/* # of _additional_ regions to pop */
@@ -3614,7 +3454,7 @@ dot_restore (dummy)
   if (!in_body ("restore"))
     return;
 
-  sep = parse_operand (&e1, ',');
+  sep = parse_operand_and_eval (&e1, ',');
   if (e1.X_op != O_register || e1.X_add_number != REG_GR + 12)
     as_bad (_("First operand to .restore must be stack pointer (sp)"));
 
@@ -3622,7 +3462,7 @@ dot_restore (dummy)
     {
       expressionS e2;
 
-      sep = parse_operand (&e2, ',');
+      sep = parse_operand_and_eval (&e2, ',');
       if (e2.X_op != O_constant || e2.X_add_number < 0)
 	{
 	  as_bad (_("Second operand to .restore must be a constant >= 0"));
@@ -3649,8 +3489,7 @@ dot_restore (dummy)
 }
 
 static void
-dot_restorereg (pred)
-     int pred;
+dot_restorereg (int pred)
 {
   unsigned int qp, ab, reg;
   expressionS e;
@@ -3664,7 +3503,7 @@ dot_restorereg (pred)
     sep = parse_predicate_and_operand (&e, &qp, po);
   else
     {
-      sep = parse_operand (&e, ',');
+      sep = parse_operand_and_eval (&e, ',');
       qp = 0;
     }
   convert_expr_to_ab_reg (&e, &ab, &reg, po, 1 + pred);
@@ -3672,7 +3511,7 @@ dot_restorereg (pred)
   add_unwind_entry (output_spill_reg (ab, reg, 0, 0, qp), sep);
 }
 
-static char *special_linkonce_name[] =
+static const char *special_linkonce_name[] =
   {
     ".gnu.linkonce.ia64unw.", ".gnu.linkonce.ia64unwi."
   };
@@ -3717,7 +3556,6 @@ start_unwind_section (const segT text_seg, int sec_index)
   char *sec_name;
   const char *prefix = special_section_name [sec_index];
   const char *suffix;
-  size_t prefix_len, suffix_len, sec_name_len;
 
   sec_text_name = segment_name (text_seg);
   text_name = sec_text_name;
@@ -3741,20 +3579,13 @@ start_unwind_section (const segT text_seg, int sec_index)
       suffix += sizeof (".gnu.linkonce.t.") - 1;
     }
 
-  prefix_len = strlen (prefix);
-  suffix_len = strlen (suffix);
-  sec_name_len = prefix_len + suffix_len;
-  sec_name = alloca (sec_name_len + 1);
-  memcpy (sec_name, prefix, prefix_len);
-  memcpy (sec_name + prefix_len, suffix, suffix_len);
-  sec_name [sec_name_len] = '\0';
+  sec_name = concat (prefix, suffix, NULL);
 
   /* Handle COMDAT group.  */
   if ((text_seg->flags & SEC_LINK_ONCE) != 0
       && (elf_section_flags (text_seg) & SHF_GROUP) != 0)
     {
       char *section;
-      size_t len, group_name_len;
       const char *group_name = elf_group_name (text_seg);
 
       if (group_name == NULL)
@@ -3762,22 +3593,14 @@ start_unwind_section (const segT text_seg, int sec_index)
 	  as_bad (_("Group section `%s' has no group signature"),
 		  sec_text_name);
 	  ignore_rest_of_line ();
+	  free (sec_name);
 	  return;
 	}
-      /* We have to construct a fake section directive. */
-      group_name_len = strlen (group_name);
-      len = (sec_name_len
-	     + 16			/* ,"aG",@progbits,  */
-	     + group_name_len		/* ,group_name  */
-	     + 7);			/* ,comdat  */
-
-      section = alloca (len + 1);
-      memcpy (section, sec_name, sec_name_len);
-      memcpy (section + sec_name_len, ",\"aG\",@progbits,", 16);
-      memcpy (section + sec_name_len + 16, group_name, group_name_len);
-      memcpy (section + len - 7, ",comdat", 7);
-      section [len] = '\0';
+
+      /* We have to construct a fake section directive.  */
+      section = concat (sec_name, ",\"aG\",@progbits,", group_name, ",comdat", NULL);
       set_section (section);
+      free (section);
     }
   else
     {
@@ -3787,6 +3610,7 @@ start_unwind_section (const segT text_seg, int sec_index)
     }
 
   elf_linked_to_section (now_seg) = text_seg;
+  free (sec_name);
 }
 
 static void
@@ -3837,7 +3661,7 @@ generate_unwind_image (const segT text_seg)
 
       /* Set expression which points to start of unwind descriptor area.  */
       unwind.info = expr_build_dot ();
-      
+
       frag_var (rs_machine_dependent, size, size, 0, 0,
 		(offsetT) (long) unwind.personality_routine,
 		(char *) list);
@@ -3875,8 +3699,7 @@ generate_unwind_image (const segT text_seg)
 }
 
 static void
-dot_handlerdata (dummy)
-     int dummy ATTRIBUTE_UNUSED;
+dot_handlerdata (int dummy ATTRIBUTE_UNUSED)
 {
   if (!in_procedure ("handlerdata"))
     return;
@@ -3894,8 +3717,7 @@ dot_handlerdata (dummy)
 }
 
 static void
-dot_unwentry (dummy)
-     int dummy ATTRIBUTE_UNUSED;
+dot_unwentry (int dummy ATTRIBUTE_UNUSED)
 {
   if (!in_procedure ("unwentry"))
     return;
@@ -3904,8 +3726,7 @@ dot_unwentry (dummy)
 }
 
 static void
-dot_altrp (dummy)
-     int dummy ATTRIBUTE_UNUSED;
+dot_altrp (int dummy ATTRIBUTE_UNUSED)
 {
   expressionS e;
   unsigned reg;
@@ -3913,7 +3734,7 @@ dot_altrp (dummy)
   if (!in_prologue ("altrp"))
     return;
 
-  parse_operand (&e, 0);
+  parse_operand_and_eval (&e, 0);
   reg = e.X_add_number - REG_BR;
   if (e.X_op != O_register || reg > 7)
     {
@@ -3924,8 +3745,7 @@ dot_altrp (dummy)
 }
 
 static void
-dot_savemem (psprel)
-     int psprel;
+dot_savemem (int psprel)
 {
   expressionS e1, e2;
   int sep;
@@ -3935,9 +3755,9 @@ dot_savemem (psprel)
   if (!in_prologue (po))
     return;
 
-  sep = parse_operand (&e1, ',');
+  sep = parse_operand_and_eval (&e1, ',');
   if (sep == ',')
-    sep = parse_operand (&e2, ',');
+    sep = parse_operand_and_eval (&e2, ',');
   else
     e2.X_op = O_absent;
 
@@ -4026,8 +3846,7 @@ dot_savemem (psprel)
 }
 
 static void
-dot_saveg (dummy)
-     int dummy ATTRIBUTE_UNUSED;
+dot_saveg (int dummy ATTRIBUTE_UNUSED)
 {
   expressionS e;
   unsigned grmask;
@@ -4036,7 +3855,7 @@ dot_saveg (dummy)
   if (!in_prologue ("save.g"))
     return;
 
-  sep = parse_operand (&e, ',');
+  sep = parse_operand_and_eval (&e, ',');
 
   grmask = e.X_add_number;
   if (e.X_op != O_constant
@@ -4052,7 +3871,7 @@ dot_saveg (dummy)
       unsigned reg;
       int n = popcount (grmask);
 
-      parse_operand (&e, 0);
+      parse_operand_and_eval (&e, 0);
       reg = e.X_add_number - REG_GR;
       if (e.X_op != O_register || reg > 127)
 	{
@@ -4071,15 +3890,14 @@ dot_saveg (dummy)
 }
 
 static void
-dot_savef (dummy)
-     int dummy ATTRIBUTE_UNUSED;
+dot_savef (int dummy ATTRIBUTE_UNUSED)
 {
   expressionS e;
 
   if (!in_prologue ("save.f"))
     return;
 
-  parse_operand (&e, 0);
+  parse_operand_and_eval (&e, 0);
 
   if (e.X_op != O_constant
       || e.X_add_number <= 0
@@ -4092,8 +3910,7 @@ dot_savef (dummy)
 }
 
 static void
-dot_saveb (dummy)
-     int dummy ATTRIBUTE_UNUSED;
+dot_saveb (int dummy ATTRIBUTE_UNUSED)
 {
   expressionS e;
   unsigned brmask;
@@ -4102,7 +3919,7 @@ dot_saveb (dummy)
   if (!in_prologue ("save.b"))
     return;
 
-  sep = parse_operand (&e, ',');
+  sep = parse_operand_and_eval (&e, ',');
 
   brmask = e.X_add_number;
   if (e.X_op != O_constant
@@ -4118,7 +3935,7 @@ dot_saveb (dummy)
       unsigned reg;
       int n = popcount (brmask);
 
-      parse_operand (&e, 0);
+      parse_operand_and_eval (&e, 0);
       reg = e.X_add_number - REG_GR;
       if (e.X_op != O_register || reg > 127)
 	{
@@ -4137,16 +3954,15 @@ dot_saveb (dummy)
 }
 
 static void
-dot_savegf (dummy)
-     int dummy ATTRIBUTE_UNUSED;
+dot_savegf (int dummy ATTRIBUTE_UNUSED)
 {
   expressionS e1, e2;
 
   if (!in_prologue ("save.gf"))
     return;
 
-  if (parse_operand (&e1, ',') == ',')
-    parse_operand (&e2, 0);
+  if (parse_operand_and_eval (&e1, ',') == ',')
+    parse_operand_and_eval (&e2, 0);
   else
     e2.X_op = O_absent;
 
@@ -4176,15 +3992,14 @@ dot_savegf (dummy)
 }
 
 static void
-dot_spill (dummy)
-     int dummy ATTRIBUTE_UNUSED;
+dot_spill (int dummy ATTRIBUTE_UNUSED)
 {
   expressionS e;
 
   if (!in_prologue ("spill"))
     return;
 
-  parse_operand (&e, 0);
+  parse_operand_and_eval (&e, 0);
 
   if (e.X_op != O_constant)
     {
@@ -4195,8 +4010,7 @@ dot_spill (dummy)
 }
 
 static void
-dot_spillreg (pred)
-     int pred;
+dot_spillreg (int pred)
 {
   int sep;
   unsigned int qp, ab, xy, reg, treg;
@@ -4210,13 +4024,13 @@ dot_spillreg (pred)
     sep = parse_predicate_and_operand (&e, &qp, po);
   else
     {
-      sep = parse_operand (&e, ',');
+      sep = parse_operand_and_eval (&e, ',');
       qp = 0;
     }
   convert_expr_to_ab_reg (&e, &ab, &reg, po, 1 + pred);
 
   if (sep == ',')
-    sep = parse_operand (&e, ',');
+    sep = parse_operand_and_eval (&e, ',');
   else
     e.X_op = O_absent;
   convert_expr_to_xy_reg (&e, &xy, &treg, po, 2 + pred);
@@ -4225,8 +4039,7 @@ dot_spillreg (pred)
 }
 
 static void
-dot_spillmem (psprel)
-     int psprel;
+dot_spillmem (int psprel)
 {
   expressionS e;
   int pred = (psprel < 0), sep;
@@ -4248,13 +4061,13 @@ dot_spillmem (psprel)
     sep = parse_predicate_and_operand (&e, &qp, po);
   else
     {
-      sep = parse_operand (&e, ',');
+      sep = parse_operand_and_eval (&e, ',');
       qp = 0;
     }
   convert_expr_to_ab_reg (&e, &ab, &reg, po, 1 + pred);
 
   if (sep == ',')
-    sep = parse_operand (&e, ',');
+    sep = parse_operand_and_eval (&e, ',');
   else
     e.X_op = O_absent;
   if (e.X_op != O_constant)
@@ -4270,8 +4083,7 @@ dot_spillmem (psprel)
 }
 
 static unsigned int
-get_saved_prologue_count (lbl)
-     unsigned long lbl;
+get_saved_prologue_count (unsigned long lbl)
 {
   label_prologue_count *lpc = unwind.saved_prologue_counts;
 
@@ -4286,9 +4098,7 @@ get_saved_prologue_count (lbl)
 }
 
 static void
-save_prologue_count (lbl, count)
-     unsigned long lbl;
-     unsigned int count;
+save_prologue_count (unsigned long lbl, unsigned int count)
 {
   label_prologue_count *lpc = unwind.saved_prologue_counts;
 
@@ -4299,7 +4109,7 @@ save_prologue_count (lbl, count)
     lpc->prologue_count = count;
   else
     {
-      label_prologue_count *new_lpc = xmalloc (sizeof (* new_lpc));
+      label_prologue_count *new_lpc = XNEW (label_prologue_count);
 
       new_lpc->next = unwind.saved_prologue_counts;
       new_lpc->label_number = lbl;
@@ -4309,7 +4119,7 @@ save_prologue_count (lbl, count)
 }
 
 static void
-free_saved_prologue_counts ()
+free_saved_prologue_counts (void)
 {
   label_prologue_count *lpc = unwind.saved_prologue_counts;
   label_prologue_count *next;
@@ -4325,15 +4135,14 @@ free_saved_prologue_counts ()
 }
 
 static void
-dot_label_state (dummy)
-     int dummy ATTRIBUTE_UNUSED;
+dot_label_state (int dummy ATTRIBUTE_UNUSED)
 {
   expressionS e;
 
   if (!in_body ("label_state"))
     return;
 
-  parse_operand (&e, 0);
+  parse_operand_and_eval (&e, 0);
   if (e.X_op == O_constant)
     save_prologue_count (e.X_add_number, unwind.prologue_count);
   else
@@ -4345,15 +4154,14 @@ dot_label_state (dummy)
 }
 
 static void
-dot_copy_state (dummy)
-     int dummy ATTRIBUTE_UNUSED;
+dot_copy_state (int dummy ATTRIBUTE_UNUSED)
 {
   expressionS e;
 
   if (!in_body ("copy_state"))
     return;
 
-  parse_operand (&e, 0);
+  parse_operand_and_eval (&e, 0);
   if (e.X_op == O_constant)
     unwind.prologue_count = get_saved_prologue_count (e.X_add_number);
   else
@@ -4365,8 +4173,7 @@ dot_copy_state (dummy)
 }
 
 static void
-dot_unwabi (dummy)
-     int dummy ATTRIBUTE_UNUSED;
+dot_unwabi (int dummy ATTRIBUTE_UNUSED)
 {
   expressionS e1, e2;
   unsigned char sep;
@@ -4374,9 +4181,9 @@ dot_unwabi (dummy)
   if (!in_prologue ("unwabi"))
     return;
 
-  sep = parse_operand (&e1, ',');
+  sep = parse_operand_and_eval (&e1, ',');
   if (sep == ',')
-    parse_operand (&e2, 0);
+    parse_operand_and_eval (&e2, 0);
   else
     e2.X_op = O_absent;
 
@@ -4396,26 +4203,24 @@ dot_unwabi (dummy)
 }
 
 static void
-dot_personality (dummy)
-     int dummy ATTRIBUTE_UNUSED;
+dot_personality (int dummy ATTRIBUTE_UNUSED)
 {
   char *name, *p, c;
+
   if (!in_procedure ("personality"))
     return;
   SKIP_WHITESPACE ();
-  name = input_line_pointer;
-  c = get_symbol_end ();
+  c = get_symbol_name (&name);
   p = input_line_pointer;
   unwind.personality_routine = symbol_find_or_make (name);
   unwind.force_unwind_entry = 1;
   *p = c;
-  SKIP_WHITESPACE ();
+  SKIP_WHITESPACE_AFTER_NAME ();
   demand_empty_rest_of_line ();
 }
 
 static void
-dot_proc (dummy)
-     int dummy ATTRIBUTE_UNUSED;
+dot_proc (int dummy ATTRIBUTE_UNUSED)
 {
   char *name, *p, c;
   symbolS *sym;
@@ -4440,8 +4245,7 @@ dot_proc (dummy)
   while (1)
     {
       SKIP_WHITESPACE ();
-      name = input_line_pointer;
-      c = get_symbol_end ();
+      c = get_symbol_name (&name);
       p = input_line_pointer;
       if (!*name)
 	as_bad (_("Empty argument of .proc"));
@@ -4457,14 +4261,14 @@ dot_proc (dummy)
 	    }
 	  else
 	    {
-	      pending = xmalloc (sizeof (*pending));
+	      pending = XNEW (proc_pending);
 	      pending->sym = sym;
 	      last_pending = last_pending->next = pending;
 	    }
 	  symbol_get_bfdsym (sym)->flags |= BSF_FUNCTION;
 	}
       *p = c;
-      SKIP_WHITESPACE ();
+      SKIP_WHITESPACE_AFTER_NAME ();
       if (*input_line_pointer != ',')
 	break;
       ++input_line_pointer;
@@ -4476,7 +4280,7 @@ dot_proc (dummy)
     }
   last_pending->next = NULL;
   demand_empty_rest_of_line ();
-  ia64_do_align (16);
+  do_align (4, NULL, 0, 0);
 
   unwind.prologue = 0;
   unwind.prologue_count = 0;
@@ -4487,8 +4291,7 @@ dot_proc (dummy)
 }
 
 static void
-dot_body (dummy)
-     int dummy ATTRIBUTE_UNUSED;
+dot_body (int dummy ATTRIBUTE_UNUSED)
 {
   if (!in_procedure ("body"))
     return;
@@ -4504,8 +4307,7 @@ dot_body (dummy)
 }
 
 static void
-dot_prologue (dummy)
-     int dummy ATTRIBUTE_UNUSED;
+dot_prologue (int dummy ATTRIBUTE_UNUSED)
 {
   unsigned mask = 0, grsave = 0;
 
@@ -4523,7 +4325,7 @@ dot_prologue (dummy)
   if (!is_it_end_of_statement ())
     {
       expressionS e;
-      int n, sep = parse_operand (&e, ',');
+      int n, sep = parse_operand_and_eval (&e, ',');
 
       if (e.X_op != O_constant
 	  || e.X_add_number < 0
@@ -4533,12 +4335,14 @@ dot_prologue (dummy)
 	as_warn (_("Pointless use of zero first operand to .prologue"));
       else
 	mask = e.X_add_number;
-	n = popcount (mask);
+
+      n = popcount (mask);
 
       if (sep == ',')
-	parse_operand (&e, 0);
+	parse_operand_and_eval (&e, 0);
       else
 	e.X_op = O_absent;
+
       if (e.X_op == O_constant
 	  && e.X_add_number >= 0
 	  && e.X_add_number < 128)
@@ -4558,7 +4362,6 @@ dot_prologue (dummy)
 	  as_bad (_("Second operand to .prologue must be the first of %d general registers"), n);
 	  grsave = 0;
 	}
-
     }
 
   if (mask)
@@ -4574,8 +4377,7 @@ dot_prologue (dummy)
 }
 
 static void
-dot_endp (dummy)
-     int dummy ATTRIBUTE_UNUSED;
+dot_endp (int dummy ATTRIBUTE_UNUSED)
 {
   expressionS e;
   int bytes_per_address;
@@ -4638,14 +4440,15 @@ dot_endp (dummy)
 					  symbol_get_frag (unwind.proc_pending.sym));
       else
 	e.X_add_symbol = unwind.proc_pending.sym;
-      ia64_cons_fix_new (frag_now, where, bytes_per_address, &e);
+      ia64_cons_fix_new (frag_now, where, bytes_per_address, &e,
+			 BFD_RELOC_NONE);
 
       e.X_op = O_pseudo_fixup;
       e.X_op_symbol = pseudo_func[FUNC_SEG_RELATIVE].u.sym;
       e.X_add_number = 0;
       e.X_add_symbol = proc_end;
       ia64_cons_fix_new (frag_now, where + bytes_per_address,
-			 bytes_per_address, &e);
+			 bytes_per_address, &e, BFD_RELOC_NONE);
 
       if (unwind.info)
 	{
@@ -4654,7 +4457,7 @@ dot_endp (dummy)
 	  e.X_add_number = 0;
 	  e.X_add_symbol = unwind.info;
 	  ia64_cons_fix_new (frag_now, where + (bytes_per_address * 2),
-			     bytes_per_address, &e);
+			     bytes_per_address, &e, BFD_RELOC_NONE);
 	}
     }
   subseg_set (saved_seg, saved_subseg);
@@ -4680,8 +4483,7 @@ dot_endp (dummy)
 		    S_SET_SIZE (sym, frag_now_fix () - S_GET_VALUE (sym));
 		  else
 		    {
-		      symbol_get_obj (sym)->size =
-			(expressionS *) xmalloc (sizeof (expressionS));
+		      symbol_get_obj (sym)->size = XNEW (expressionS);
 		      symbol_get_obj (sym)->size->X_op = O_subtract;
 		      symbol_get_obj (sym)->size->X_add_symbol
 			= symbol_new (FAKE_LABEL_NAME, now_seg,
@@ -4700,8 +4502,7 @@ dot_endp (dummy)
       char *name, *p, c;
 
       SKIP_WHITESPACE ();
-      name = input_line_pointer;
-      c = get_symbol_end ();
+      c = get_symbol_name (&name);
       p = input_line_pointer;
       if (!*name)
 	(md.unwind_check == unwind_check_warning
@@ -4723,7 +4524,7 @@ dot_endp (dummy)
 	    as_warn (_("`%s' was not specified with previous .proc"), name);
 	}
       *p = c;
-      SKIP_WHITESPACE ();
+      SKIP_WHITESPACE_AFTER_NAME ();
       if (*input_line_pointer != ',')
 	break;
       ++input_line_pointer;
@@ -4747,15 +4548,13 @@ dot_endp (dummy)
 }
 
 static void
-dot_template (template)
-     int template;
+dot_template (int template_val)
 {
-  CURR_SLOT.user_template = template;
+  CURR_SLOT.user_template = template_val;
 }
 
 static void
-dot_regstk (dummy)
-     int dummy ATTRIBUTE_UNUSED;
+dot_regstk (int dummy ATTRIBUTE_UNUSED)
 {
   int ins, locs, outs, rots;
 
@@ -4783,8 +4582,7 @@ dot_regstk (dummy)
 }
 
 static void
-dot_rot (type)
-     int type;
+dot_rot (int type)
 {
   offsetT num_regs;
   valueT num_alloced = 0;
@@ -4812,12 +4610,11 @@ dot_rot (type)
   drpp = &md.dynreg[type];
   while (1)
     {
-      start = input_line_pointer;
-      ch = get_symbol_end ();
+      ch = get_symbol_name (&start);
       len = strlen (ia64_canonicalize_symbol_name (start));
       *input_line_pointer = ch;
 
-      SKIP_WHITESPACE ();
+      SKIP_WHITESPACE_AFTER_NAME ();
       if (*input_line_pointer != '[')
 	{
 	  as_bad (_("Expected '['"));
@@ -4906,8 +4703,7 @@ dot_rot (type)
 }
 
 static void
-dot_byteorder (byteorder)
-     int byteorder;
+dot_byteorder (int byteorder)
 {
   segment_info_type *seginfo = seg_info (now_seg);
 
@@ -4937,16 +4733,14 @@ dot_byteorder (byteorder)
 }
 
 static void
-dot_psr (dummy)
-     int dummy ATTRIBUTE_UNUSED;
+dot_psr (int dummy ATTRIBUTE_UNUSED)
 {
   char *option;
   int ch;
 
   while (1)
     {
-      option = input_line_pointer;
-      ch = get_symbol_end ();
+      ch = get_symbol_name (&option);
       if (strcmp (option, "lsb") == 0)
 	md.flags &= ~EF_IA_64_BE;
       else if (strcmp (option, "msb") == 0)
@@ -4959,7 +4753,7 @@ dot_psr (dummy)
 	as_bad (_("Unknown psr option `%s'"), option);
       *input_line_pointer = ch;
 
-      SKIP_WHITESPACE ();
+      SKIP_WHITESPACE_AFTER_NAME ();
       if (*input_line_pointer != ',')
 	break;
 
@@ -4970,52 +4764,33 @@ dot_psr (dummy)
 }
 
 static void
-dot_ln (dummy)
-     int dummy ATTRIBUTE_UNUSED;
+dot_ln (int dummy ATTRIBUTE_UNUSED)
 {
   new_logical_line (0, get_absolute_expression ());
   demand_empty_rest_of_line ();
 }
 
 static void
-cross_section (ref, cons, ua)
-     int ref;
-     void (*cons) PARAMS((int));
-     int ua;
+cross_section (int ref, void (*builder) (int), int ua)
 {
   char *start, *end;
   int saved_auto_align;
   unsigned int section_count;
+  char *name;
+  char c;
 
   SKIP_WHITESPACE ();
   start = input_line_pointer;
-  if (*start == '"')
+  c = get_symbol_name (&name);
+  if (input_line_pointer == start)
     {
-      int len;
-      char *name;
-
-      name = demand_copy_C_string (&len);
-      obstack_free(&notes, name);
-      if (!name)
-	{
-	  ignore_rest_of_line ();
-	  return;
-	}
-    }
-  else
-    {
-      char c = get_symbol_end ();
-
-      if (input_line_pointer == start)
-	{
-	  as_bad (_("Missing section name"));
-	  ignore_rest_of_line ();
-	  return;
-	}
-      *input_line_pointer = c;
+      as_bad (_("Missing section name"));
+      ignore_rest_of_line ();
+      return;
     }
+  * input_line_pointer = c;
+  SKIP_WHITESPACE_AFTER_NAME ();
   end = input_line_pointer;
-  SKIP_WHITESPACE ();
   if (*input_line_pointer != ',')
     {
       as_bad (_("Comma expected after section name"));
@@ -5026,15 +4801,15 @@ cross_section (ref, cons, ua)
   end = input_line_pointer + 1;		/* skip comma */
   input_line_pointer = start;
   md.keep_pending_output = 1;
-  section_count = bfd_count_sections(stdoutput);
+  section_count = bfd_count_sections (stdoutput);
   obj_elf_section (0);
-  if (section_count != bfd_count_sections(stdoutput))
+  if (section_count != bfd_count_sections (stdoutput))
     as_warn (_("Creating sections with .xdataN/.xrealN/.xstringZ is deprecated."));
   input_line_pointer = end;
   saved_auto_align = md.auto_align;
   if (ua)
     md.auto_align = 0;
-  (*cons) (ref);
+  (*builder) (ref);
   if (ua)
     md.auto_align = saved_auto_align;
   obj_elf_previous (0);
@@ -5042,8 +4817,7 @@ cross_section (ref, cons, ua)
 }
 
 static void
-dot_xdata (size)
-     int size;
+dot_xdata (int size)
 {
   cross_section (size, cons, 0);
 }
@@ -5051,34 +4825,32 @@ dot_xdata (size)
 /* Why doesn't float_cons() call md_cons_align() the way cons() does?  */
 
 static void
-stmt_float_cons (kind)
-     int kind;
+stmt_float_cons (int kind)
 {
   size_t alignment;
 
   switch (kind)
     {
     case 'd':
-      alignment = 8;
+      alignment = 3;
       break;
 
     case 'x':
     case 'X':
-      alignment = 16;
+      alignment = 4;
       break;
 
     case 'f':
     default:
-      alignment = 4;
+      alignment = 2;
       break;
     }
-  ia64_do_align (alignment);
+  do_align (alignment, NULL, 0, 0);
   float_cons (kind);
 }
 
 static void
-stmt_cons_ua (size)
-     int size;
+stmt_cons_ua (int size)
 {
   int saved_auto_align = md.auto_align;
 
@@ -5088,8 +4860,7 @@ stmt_cons_ua (size)
 }
 
 static void
-dot_xfloat_cons (kind)
-     int kind;
+dot_xfloat_cons (int kind)
 {
   cross_section (kind, stmt_float_cons, 0);
 }
@@ -5101,15 +4872,13 @@ dot_xstringer (int zero)
 }
 
 static void
-dot_xdata_ua (size)
-     int size;
+dot_xdata_ua (int size)
 {
   cross_section (size, cons, 1);
 }
 
 static void
-dot_xfloat_cons_ua (kind)
-     int kind;
+dot_xfloat_cons_ua (int kind)
 {
   cross_section (kind, float_cons, 1);
 }
@@ -5117,8 +4886,7 @@ dot_xfloat_cons_ua (kind)
 /* .reg.val <regname>,value */
 
 static void
-dot_reg_val (dummy)
-     int dummy ATTRIBUTE_UNUSED;
+dot_reg_val (int dummy ATTRIBUTE_UNUSED)
 {
   expressionS reg;
 
@@ -5154,8 +4922,7 @@ dot_reg_val (dummy)
   .serialize.instruction
  */
 static void
-dot_serialize (type)
-     int type;
+dot_serialize (int type)
 {
   insn_group_break (0, 0, 0);
   if (type)
@@ -5175,8 +4942,7 @@ dot_serialize (type)
  */
 
 static void
-dot_dv_mode (type)
-     int type;
+dot_dv_mode (int type)
 {
   if (md.manual_bundling)
     as_warn (_("Directive invalid within a bundle"));
@@ -5212,11 +4978,10 @@ dot_dv_mode (type)
 }
 
 static void
-print_prmask (mask)
-     valueT mask;
+print_prmask (valueT mask)
 {
   int regno;
-  char *comma = "";
+  const char *comma = "";
   for (regno = 0; regno < 64; regno++)
     {
       if (mask & ((valueT) 1 << regno))
@@ -5235,8 +5000,7 @@ print_prmask (mask)
  */
 
 static void
-dot_pred_rel (type)
-     int type;
+dot_pred_rel (int type)
 {
   valueT mask = 0;
   int count = 0;
@@ -5259,8 +5023,11 @@ dot_pred_rel (type)
 	}
       else if (*input_line_pointer == '@')
 	{
-	  char *form = ++input_line_pointer;
-	  char c = get_symbol_end();
+	  char *form;
+	  char c;
+
+	  ++input_line_pointer;
+	  c = get_symbol_name (&form);
 
 	  if (strcmp (form, "mutex") == 0)
 	    type = 'm';
@@ -5268,7 +5035,7 @@ dot_pred_rel (type)
 	    type = 'c';
 	  else if (strcmp (form, "imply") == 0)
 	    type = 'i';
-	  *input_line_pointer = c;
+	  (void) restore_line_pointer (c);
 	}
       else
 	{
@@ -5293,7 +5060,7 @@ dot_pred_rel (type)
       int sep, regno;
       expressionS pr, *pr1, *pr2;
 
-      sep = parse_operand (&pr, ',');
+      sep = parse_operand_and_eval (&pr, ',');
       if (pr.X_op == O_register
 	  && pr.X_add_number >= REG_P
 	  && pr.X_add_number <= REG_P + 63)
@@ -5397,8 +5164,7 @@ dot_pred_rel (type)
    Otherwise, only global labels are considered entry points.  */
 
 static void
-dot_entry (dummy)
-     int dummy ATTRIBUTE_UNUSED;
+dot_entry (int dummy ATTRIBUTE_UNUSED)
 {
   const char *err;
   char *name;
@@ -5407,17 +5173,16 @@ dot_entry (dummy)
 
   do
     {
-      name = input_line_pointer;
-      c = get_symbol_end ();
+      c = get_symbol_name (&name);
       symbolP = symbol_find_or_make (name);
 
-      err = hash_insert (md.entry_hash, S_GET_NAME (symbolP), (PTR) symbolP);
+      err = hash_insert (md.entry_hash, S_GET_NAME (symbolP), (void *) symbolP);
       if (err)
 	as_fatal (_("Inserting \"%s\" into entry hint table failed: %s"),
 		  name, err);
 
       *input_line_pointer = c;
-      SKIP_WHITESPACE ();
+      SKIP_WHITESPACE_AFTER_NAME ();
       c = *input_line_pointer;
       if (c == ',')
 	{
@@ -5436,8 +5201,7 @@ dot_entry (dummy)
    "base" is used to distinguish between offsets from a different base.  */
 
 static void
-dot_mem_offset (dummy)
-  int dummy ATTRIBUTE_UNUSED;
+dot_mem_offset (int dummy ATTRIBUTE_UNUSED)
 {
   md.mem_offset.hint = 1;
   md.mem_offset.offset = get_absolute_expression ();
@@ -5569,6 +5333,10 @@ const pseudo_typeS md_pseudo_table[] =
     {"4byte", stmt_cons_ua, 4},
     {"8byte", stmt_cons_ua, 8},
 
+#ifdef TE_VMS
+    {"vms_common", obj_elf_vms_common, 0},
+#endif
+
     { NULL, 0, 0 }
   };
 
@@ -5608,16 +5376,14 @@ pseudo_opcode[] =
    the symbol table.  */
 
 static symbolS *
-declare_register (name, regnum)
-     const char *name;
-     unsigned int regnum;
+declare_register (const char *name, unsigned int regnum)
 {
   const char *err;
   symbolS *sym;
 
   sym = symbol_create (name, reg_section, regnum, &zero_address_frag);
 
-  err = hash_insert (md.reg_hash, S_GET_NAME (sym), (PTR) sym);
+  err = hash_insert (md.reg_hash, S_GET_NAME (sym), (void *) sym);
   if (err)
     as_fatal ("Inserting \"%s\" into register table failed: %s",
 	      name, err);
@@ -5626,10 +5392,9 @@ declare_register (name, regnum)
 }
 
 static void
-declare_register_set (prefix, num_regs, base_regnum)
-     const char *prefix;
-     unsigned int num_regs;
-     unsigned int base_regnum;
+declare_register_set (const char *prefix,
+		      unsigned int num_regs,
+		      unsigned int base_regnum)
 {
   char name[8];
   unsigned int i;
@@ -5642,8 +5407,7 @@ declare_register_set (prefix, num_regs, base_regnum)
 }
 
 static unsigned int
-operand_width (opnd)
-     enum ia64_opnd opnd;
+operand_width (enum ia64_opnd opnd)
 {
   const struct ia64_operand *odesc = &elf64_ia64_operands[opnd];
   unsigned int bits = 0;
@@ -5657,12 +5421,9 @@ operand_width (opnd)
 }
 
 static enum operand_match_result
-operand_match (idesc, index, e)
-     const struct ia64_opcode *idesc;
-     int index;
-     expressionS *e;
+operand_match (const struct ia64_opcode *idesc, int res_index, expressionS *e)
 {
-  enum ia64_opnd opnd = idesc->operands[index];
+  enum ia64_opnd opnd = idesc->operands[res_index];
   int bits, relocatable = 0;
   struct insn_fix *fix;
   bfd_signed_vma val;
@@ -5772,6 +5533,12 @@ operand_match (idesc, index, e)
 	return OPERAND_MATCH;
       break;
 
+    case IA64_OPND_DAHR3:
+      if (e->X_op == O_register && e->X_add_number >= REG_DAHR
+	  && e->X_add_number < REG_DAHR + 8)
+	return OPERAND_MATCH;
+      break;
+
     case IA64_OPND_F1:
     case IA64_OPND_F2:
     case IA64_OPND_F3:
@@ -5816,6 +5583,7 @@ operand_match (idesc, index, e)
     case IA64_OPND_PKR_R3:
     case IA64_OPND_PMC_R3:
     case IA64_OPND_PMD_R3:
+    case IA64_OPND_DAHR_R3:
     case IA64_OPND_RR_R3:
       if (e->X_op == O_index && e->X_op_symbol
 	  && (S_GET_VALUE (e->X_op_symbol) - IND_CPUID
@@ -5832,7 +5600,7 @@ operand_match (idesc, index, e)
     case IA64_OPND_CNT2a:
     case IA64_OPND_LEN4:
     case IA64_OPND_LEN6:
-      bits = operand_width (idesc->operands[index]);
+      bits = operand_width (idesc->operands[res_index]);
       if (e->X_op == O_constant)
 	{
 	  if ((bfd_vma) (e->X_add_number - 1) < ((bfd_vma) 1 << bits))
@@ -5906,7 +5674,7 @@ operand_match (idesc, index, e)
 		e->X_op = O_symbol;
 	    }
 
-	  fix->opnd = idesc->operands[index];
+	  fix->opnd = idesc->operands[res_index];
 	  fix->expr = *e;
 	  fix->is_pcrel = 0;
 	  ++CURR_SLOT.num_fixups;
@@ -5936,12 +5704,14 @@ operand_match (idesc, index, e)
     case IA64_OPND_IMMU2:
     case IA64_OPND_IMMU7a:
     case IA64_OPND_IMMU7b:
+    case IA64_OPND_IMMU16:
+    case IA64_OPND_IMMU19:
     case IA64_OPND_IMMU21:
     case IA64_OPND_IMMU24:
     case IA64_OPND_MBTYPE4:
     case IA64_OPND_MHTYPE8:
     case IA64_OPND_POS6:
-      bits = operand_width (idesc->operands[index]);
+      bits = operand_width (idesc->operands[res_index]);
       if (e->X_op == O_constant)
 	{
 	  if ((bfd_vma) e->X_add_number < ((bfd_vma) 1 << bits))
@@ -5952,7 +5722,7 @@ operand_match (idesc, index, e)
       break;
 
     case IA64_OPND_IMMU9:
-      bits = operand_width (idesc->operands[index]);
+      bits = operand_width (idesc->operands[res_index]);
       if (e->X_op == O_constant)
 	{
 	  if ((bfd_vma) e->X_add_number < ((bfd_vma) 1 << bits))
@@ -6028,14 +5798,14 @@ operand_match (idesc, index, e)
     case IA64_OPND_IMM8M1U8:
     case IA64_OPND_IMM9a:
     case IA64_OPND_IMM9b:
-      bits = operand_width (idesc->operands[index]);
+      bits = operand_width (idesc->operands[res_index]);
       if (relocatable && (e->X_op == O_symbol
 			  || e->X_op == O_subtract
 			  || e->X_op == O_pseudo_fixup))
 	{
 	  fix = CURR_SLOT.fixup + CURR_SLOT.num_fixups;
 
-	  if (idesc->operands[index] == IA64_OPND_IMM14)
+	  if (idesc->operands[res_index] == IA64_OPND_IMM14)
 	    fix->code = BFD_RELOC_IA64_IMM14;
 	  else
 	    fix->code = BFD_RELOC_IA64_IMM22;
@@ -6047,7 +5817,7 @@ operand_match (idesc, index, e)
 		e->X_op = O_symbol;
 	    }
 
-	  fix->opnd = idesc->operands[index];
+	  fix->opnd = idesc->operands[res_index];
 	  fix->expr = *e;
 	  fix->is_pcrel = 0;
 	  ++CURR_SLOT.num_fixups;
@@ -6153,7 +5923,7 @@ operand_match (idesc, index, e)
 	    abort ();
 
 	  fix->code = ia64_gen_real_reloc_type (e->X_op_symbol, fix->code);
-	  fix->opnd = idesc->operands[index];
+	  fix->opnd = idesc->operands[res_index];
 	  fix->expr = *e;
 	  fix->is_pcrel = 1;
 	  ++CURR_SLOT.num_fixups;
@@ -6172,7 +5942,7 @@ operand_match (idesc, index, e)
 	     create a dummy reloc.  This will not live past md_apply_fix.  */
 	  fix->code = BFD_RELOC_UNUSED;
 	  fix->code = ia64_gen_real_reloc_type (e->X_op_symbol, fix->code);
-	  fix->opnd = idesc->operands[index];
+	  fix->opnd = idesc->operands[res_index];
 	  fix->expr = *e;
 	  fix->is_pcrel = 1;
 	  ++CURR_SLOT.num_fixups;
@@ -6186,12 +5956,45 @@ operand_match (idesc, index, e)
     case IA64_OPND_LDXMOV:
       fix = CURR_SLOT.fixup + CURR_SLOT.num_fixups;
       fix->code = BFD_RELOC_IA64_LDXMOV;
-      fix->opnd = idesc->operands[index];
+      fix->opnd = idesc->operands[res_index];
       fix->expr = *e;
       fix->is_pcrel = 0;
       ++CURR_SLOT.num_fixups;
       return OPERAND_MATCH;
 
+    case IA64_OPND_STRD5b:
+      if (e->X_op == O_constant)
+	{
+	  /* 5-bit signed scaled by 64 */
+	  if ((e->X_add_number <=  	( 0xf  << 6 ))
+	       && (e->X_add_number >=  -( 0x10 << 6 )))
+	    {
+
+	      /* Must be a multiple of 64 */
+	      if ((e->X_add_number & 0x3f) != 0)
+	        as_warn (_("stride must be a multiple of 64; lower 6 bits ignored"));
+
+	      e->X_add_number &= ~ 0x3f;
+	      return OPERAND_MATCH;
+	    }
+	  else
+	    return OPERAND_OUT_OF_RANGE;
+	}
+      break;
+    case IA64_OPND_CNT6a:
+      if (e->X_op == O_constant)
+	{
+	  /* 6-bit unsigned biased by 1 -- count 0 is meaningless */
+	  if ((e->X_add_number     <=   64)
+	       && (e->X_add_number > 0) )
+	    {
+	      return OPERAND_MATCH;
+	    }
+	  else
+	    return OPERAND_OUT_OF_RANGE;
+	}
+      break;
+
     default:
       break;
     }
@@ -6199,22 +6002,52 @@ operand_match (idesc, index, e)
 }
 
 static int
-parse_operand (e, more)
-     expressionS *e;
-     int more;
+parse_operand (expressionS *e, int more)
 {
   int sep = '\0';
 
   memset (e, 0, sizeof (*e));
   e->X_op = O_absent;
   SKIP_WHITESPACE ();
-  expression_and_evaluate (e);
+  expression (e);
   sep = *input_line_pointer;
   if (more && (sep == ',' || sep == more))
     ++input_line_pointer;
   return sep;
 }
 
+static int
+parse_operand_and_eval (expressionS *e, int more)
+{
+  int sep = parse_operand (e, more);
+  resolve_expression (e);
+  return sep;
+}
+
+static int
+parse_operand_maybe_eval (expressionS *e, int more, enum ia64_opnd op)
+{
+  int sep = parse_operand (e, more);
+  switch (op)
+    {
+    case IA64_OPND_IMM14:
+    case IA64_OPND_IMM22:
+    case IA64_OPND_IMMU64:
+    case IA64_OPND_TGT25:
+    case IA64_OPND_TGT25b:
+    case IA64_OPND_TGT25c:
+    case IA64_OPND_TGT64:
+    case IA64_OPND_TAG13:
+    case IA64_OPND_TAG13b:
+    case IA64_OPND_LDXMOV:
+      break;
+    default:
+      resolve_expression (e);
+      break;
+    }
+  return sep;
+}
+
 /* Returns the next entry in the opcode table that matches the one in
    IDESC, and frees the entry in IDESC.  If no matching entry is
    found, NULL is returned instead.  */
@@ -6231,8 +6064,7 @@ get_next_opcode (struct ia64_opcode *idesc)
    matches the specified operands, or NULL if no match is possible.  */
 
 static struct ia64_opcode *
-parse_operands (idesc)
-     struct ia64_opcode *idesc;
+parse_operands (struct ia64_opcode *idesc)
 {
   int i = 0, highest_unmatched_operand, num_operands = 0, num_outputs = 0;
   int error_pos, out_of_range_pos, curr_out_of_range_pos, sep = 0;
@@ -6244,7 +6076,7 @@ parse_operands (idesc)
   char *first_arg = 0, *end, *saved_input_pointer;
   unsigned int sof;
 
-  assert (strlen (idesc->name) <= 128);
+  gas_assert (strlen (idesc->name) <= 128);
 
   strcpy (mnemonic, idesc->name);
   if (idesc->operands[2] == IA64_OPND_SOF
@@ -6268,9 +6100,10 @@ parse_operands (idesc)
 
   for (; ; ++i)
     {
-      if (i < NELEMS (CURR_SLOT.opnd)) 
+      if (i < NELEMS (CURR_SLOT.opnd))
 	{
-	  sep = parse_operand (CURR_SLOT.opnd + i, '=');
+	  sep = parse_operand_maybe_eval (CURR_SLOT.opnd + i, '=',
+					  idesc->operands[i]);
 	  if (CURR_SLOT.opnd[i].X_op == O_absent)
 	    break;
 	}
@@ -6324,7 +6157,8 @@ parse_operands (idesc)
       /* now we can parse the first arg:  */
       saved_input_pointer = input_line_pointer;
       input_line_pointer = first_arg;
-      sep = parse_operand (CURR_SLOT.opnd + 0, '=');
+      sep = parse_operand_maybe_eval (CURR_SLOT.opnd + 0, '=',
+				      idesc->operands[0]);
       if (sep != '=')
 	--num_outputs;	/* force error */
       input_line_pointer = saved_input_pointer;
@@ -6548,9 +6382,7 @@ parse_operands (idesc)
 }
 
 static void
-build_insn (slot, insnp)
-     struct slot *slot;
-     bfd_vma *insnp;
+build_insn (struct slot *slot, bfd_vma *insnp)
 {
   const struct ia64_operand *odesc, *o2desc;
   struct ia64_opcode *idesc = slot->idesc;
@@ -6570,7 +6402,7 @@ build_insn (slot, insnp)
       else if (slot->opnd[i].X_op == O_big)
 	{
 	  /* This must be the value 0x10000000000000000.  */
-	  assert (idesc->operands[i] == IA64_OPND_IMM8M1U8);
+	  gas_assert (idesc->operands[i] == IA64_OPND_IMM8M1U8);
 	  val = 0;
 	}
       else
@@ -6613,6 +6445,10 @@ build_insn (slot, insnp)
 	  val -= REG_CR;
 	  break;
 
+	case IA64_OPND_DAHR3:
+	  val -= REG_DAHR;
+	  break;
+
 	case IA64_OPND_F1:
 	case IA64_OPND_F2:
 	case IA64_OPND_F3:
@@ -6639,6 +6475,7 @@ build_insn (slot, insnp)
 	case IA64_OPND_PKR_R3:
 	case IA64_OPND_PMC_R3:
 	case IA64_OPND_PMD_R3:
+	case IA64_OPND_DAHR_R3:
 	case IA64_OPND_RR_R3:
 	  val -= REG_GR;
 	  break;
@@ -6673,12 +6510,12 @@ build_insn (slot, insnp)
 }
 
 static void
-emit_one_bundle ()
+emit_one_bundle (void)
 {
   int manual_bundling_off = 0, manual_bundling = 0;
   enum ia64_unit required_unit, insn_unit = 0;
   enum ia64_insn_type type[3], insn_type;
-  unsigned int template, orig_template;
+  unsigned int template_val, orig_template;
   bfd_vma insn[3] = { -1, -1, -1 };
   struct ia64_opcode *idesc;
   int end_of_insn_group = 0, user_template = -1;
@@ -6700,7 +6537,7 @@ emit_one_bundle ()
      otherwise:  */
 
   if (md.slot[first].user_template >= 0)
-    user_template = template = md.slot[first].user_template;
+    user_template = template_val = md.slot[first].user_template;
   else
     {
       /* Auto select appropriate template.  */
@@ -6713,12 +6550,12 @@ emit_one_bundle ()
 	  type[i] = md.slot[curr].idesc->type;
 	  curr = (curr + 1) % NUM_SLOTS;
 	}
-      template = best_template[type[0]][type[1]][type[2]];
+      template_val = best_template[type[0]][type[1]][type[2]];
     }
 
   /* initialize instructions with appropriate nops:  */
   for (i = 0; i < 3; ++i)
-    insn[i] = nop[ia64_templ_desc[template].exec_unit[i]];
+    insn[i] = nop[ia64_templ_desc[template_val].exec_unit[i]];
 
   f = frag_more (16);
 
@@ -6812,7 +6649,7 @@ emit_one_bundle ()
 	     MBB, BBB, MMB, and MFB.  We don't handle anything other
 	     than M and B slots because these are the only kind of
 	     instructions that can have the IA64_OPCODE_LAST bit set.  */
-	  required_template = template;
+	  required_template = template_val;
 	  switch (idesc->type)
 	    {
 	    case IA64_TYPE_M:
@@ -6836,7 +6673,7 @@ emit_one_bundle ()
 		  || (required_slot == 2 && !manual_bundling_off)
 		  || (user_template >= 0
 		      /* Changing from MMI to M;MI is OK.  */
-		      && (template ^ required_template) > 1)))
+		      && (template_val ^ required_template) > 1)))
 	    {
 	      as_bad_where (md.slot[curr].src_file, md.slot[curr].src_line,
 			    _("`%s' must be last in instruction group"),
@@ -6849,7 +6686,7 @@ emit_one_bundle ()
 	    break;
 
 	  i = required_slot;
-	  if (required_template != template)
+	  if (required_template != template_val)
 	    {
 	      /* If we switch the template, we need to reset the NOPs
 	         after slot i.  The slot-types of the instructions ahead
@@ -6862,7 +6699,7 @@ emit_one_bundle ()
 		 middle, so we don't need another one emitted later.  */
 	      md.slot[curr].end_of_insn_group = 0;
 	    }
-	  template = required_template;
+	  template_val = required_template;
 	}
       if (curr != first && md.slot[curr].label_fixups)
 	{
@@ -6882,18 +6719,18 @@ emit_one_bundle ()
 	     bundle.  See if we can switch to an other template with
 	     an appropriate boundary.  */
 
-	  orig_template = template;
+	  orig_template = template_val;
 	  if (i == 1 && (user_template == 4
 			 || (user_template < 0
-			     && (ia64_templ_desc[template].exec_unit[0]
+			     && (ia64_templ_desc[template_val].exec_unit[0]
 				 == IA64_UNIT_M))))
 	    {
-	      template = 5;
+	      template_val = 5;
 	      end_of_insn_group = 0;
 	    }
 	  else if (i == 2 && (user_template == 0
 			      || (user_template < 0
-				  && (ia64_templ_desc[template].exec_unit[1]
+				  && (ia64_templ_desc[template_val].exec_unit[1]
 				      == IA64_UNIT_I)))
 		   /* This test makes sure we don't switch the template if
 		      the next instruction is one that needs to be first in
@@ -6906,7 +6743,7 @@ emit_one_bundle ()
 		      first in the group! --davidm 99/12/16  */
 		   && (idesc->flags & IA64_OPCODE_FIRST) == 0)
 	    {
-	      template = 1;
+	      template_val = 1;
 	      end_of_insn_group = 0;
 	    }
 	  else if (i == 1
@@ -6918,15 +6755,15 @@ emit_one_bundle ()
 	    /* can't fit this insn */
 	    break;
 
-	  if (template != orig_template)
+	  if (template_val != orig_template)
 	    /* if we switch the template, we need to reset the NOPs
 	       after slot i.  The slot-types of the instructions ahead
 	       of i never change, so we don't need to worry about
 	       changing NOPs in front of this slot.  */
 	    for (j = i; j < 3; ++j)
-	      insn[j] = nop[ia64_templ_desc[template].exec_unit[j]];
+	      insn[j] = nop[ia64_templ_desc[template_val].exec_unit[j]];
 	}
-      required_unit = ia64_templ_desc[template].exec_unit[i];
+      required_unit = ia64_templ_desc[template_val].exec_unit[i];
 
       /* resolve dynamic opcodes such as "break", "hint", and "nop":  */
       if (idesc->type == IA64_TYPE_DYN)
@@ -6967,7 +6804,7 @@ emit_one_bundle ()
 	    {
 	      insn_unit = IA64_UNIT_M;
 	      if (required_unit == IA64_UNIT_I
-		  || (required_unit == IA64_UNIT_F && template == 6))
+		  || (required_unit == IA64_UNIT_F && template_val == 6))
 		insn_unit = IA64_UNIT_I;
 	    }
 	  else
@@ -7054,15 +6891,6 @@ emit_one_bundle ()
 	  md.slot[curr].unwind_record = NULL;
 	}
 
-      if (required_unit == IA64_UNIT_L)
-	{
-	  know (i == 1);
-	  /* skip one slot for long/X-unit instructions */
-	  ++i;
-	}
-      --md.num_slots_in_use;
-      last_slot = i;
-
       for (j = 0; j < md.slot[curr].num_fixups; ++j)
 	{
 	  ifix = md.slot[curr].fixup + j;
@@ -7075,6 +6903,17 @@ emit_one_bundle ()
 
       end_of_insn_group = md.slot[curr].end_of_insn_group;
 
+      /* This adjustment to "i" must occur after the fix, otherwise the fix
+	 is assigned to the wrong slot, and the VMS linker complains.  */
+      if (required_unit == IA64_UNIT_L)
+	{
+	  know (i == 1);
+	  /* skip one slot for long/X-unit instructions */
+	  ++i;
+	}
+      --md.num_slots_in_use;
+      last_slot = i;
+
       /* clear slot:  */
       ia64_free_opcode (md.slot[curr].idesc);
       memset (md.slot + curr, 0, sizeof (md.slot[curr]));
@@ -7095,7 +6934,7 @@ emit_one_bundle ()
     {
       as_bad_where (md.slot[curr].src_file, md.slot[curr].src_line,
 		    _("`%s' does not fit into %s template"),
-		    idesc->name, ia64_templ_desc[template].name);
+		    idesc->name, ia64_templ_desc[template_val].name);
       /* Drop first insn so we don't livelock.  */
       --md.num_slots_in_use;
       know (curr == first);
@@ -7114,7 +6953,7 @@ emit_one_bundle ()
 	    {
 	      const char *where;
 
-	      if (template == 2)
+	      if (template_val == 2)
 		where = "X slot";
 	      else if (last_slot == 0)
 		where = "slots 2 or 3";
@@ -7122,17 +6961,17 @@ emit_one_bundle ()
 		where = "slot 3";
 	      as_bad_where (md.slot[curr].src_file, md.slot[curr].src_line,
 			    _("`%s' can't go in %s of %s template"),
-			    idesc->name, where, ia64_templ_desc[template].name);
+			    idesc->name, where, ia64_templ_desc[template_val].name);
 	    }
 	}
       else
 	as_bad_where (md.slot[curr].src_file, md.slot[curr].src_line,
 		      _("Missing '}' at end of file"));
     }
-	
+
   know (md.num_slots_in_use < NUM_SLOTS);
 
-  t0 = end_of_insn_group | (template << 1) | (insn[0] << 5) | (insn[1] << 46);
+  t0 = end_of_insn_group | (template_val << 1) | (insn[0] << 5) | (insn[1] << 46);
   t1 = ((insn[1] >> 18) & 0x7fffff) | (insn[2] << 23);
 
   number_to_chars_littleendian (f + 0, t0, 8);
@@ -7140,9 +6979,7 @@ emit_one_bundle ()
 }
 
 int
-md_parse_option (c, arg)
-     int c;
-     char *arg;
+md_parse_option (int c, const char *arg)
 {
 
   switch (c)
@@ -7301,8 +7138,7 @@ md_parse_option (c, arg)
 }
 
 void
-md_show_usage (stream)
-     FILE *stream;
+md_show_usage (FILE *stream)
 {
   fputs (_("\
 IA-64 options:\n\
@@ -7319,7 +7155,9 @@ IA-64 options:\n\
 			  unwind directive check (default -munwind-check=warning)\n\
   -mhint.b=[ok|warning|error]\n\
 			  hint.b check (default -mhint.b=error)\n\
-  -x | -xexplicit	  turn on dependency violation checking\n\
+  -x | -xexplicit	  turn on dependency violation checking\n"), stream);
+  /* Note for translators: "automagically" can be translated as "automatically" here.  */
+  fputs (_("\
   -xauto		  automagically remove dependency violations (default)\n\
   -xnone		  turn off dependency violation checking\n\
   -xdebug		  debug dependency violation checker\n\
@@ -7331,7 +7169,7 @@ IA-64 options:\n\
 }
 
 void
-ia64_after_parse_args ()
+ia64_after_parse_args (void)
 {
   if (debug_type == DEBUG_STABS)
     as_fatal (_("--gstabs is not supported for ia64"));
@@ -7399,7 +7237,7 @@ extra_goodness (int templ, int slot)
    up all the tables, etc. that the MD part of the assembler will need
    that can be determined before arguments are parsed.  */
 void
-md_begin ()
+md_begin (void)
 {
   int i, j, k, t, goodness, best, ok;
   const char *err;
@@ -7487,6 +7325,12 @@ md_begin ()
     symbol_new (".<iplt>", undefined_section, FUNC_IPLT_RELOC,
 		&zero_address_frag);
 
+#ifdef TE_VMS
+  pseudo_func[FUNC_SLOTCOUNT_RELOC].u.sym =
+    symbol_new (".<slotcount>", undefined_section, FUNC_SLOTCOUNT_RELOC,
+		&zero_address_frag);
+#endif
+
  if (md.tune != itanium1)
    {
      /* Convert MFI NOPs bundles into MMI NOPs bundles.  */
@@ -7606,6 +7450,9 @@ md_begin ()
   for (i = 0; i < NELEMS (cr); ++i)
     declare_register (cr[i].name, REG_CR + cr[i].regnum);
 
+  /* dahr registers:  */
+  declare_register_set ("dahr", 8, REG_DAHR);
+
   declare_register ("ip", REG_IP);
   declare_register ("cfm", REG_CFM);
   declare_register ("psr", REG_PSR);
@@ -7625,7 +7472,7 @@ md_begin ()
   for (i = 0; i < NELEMS (const_bits); ++i)
     {
       err = hash_insert (md.const_hash, const_bits[i].name,
-			 (PTR) (const_bits + i));
+			 (void *) (const_bits + i));
       if (err)
 	as_fatal (_("Inserting \"%s\" into constant hash table failed: %s"),
 		  name, err);
@@ -7665,12 +7512,13 @@ md_begin ()
    options in md based on command line options.  */
 
 void
-ia64_init (argc, argv)
-     int argc ATTRIBUTE_UNUSED;
-     char **argv ATTRIBUTE_UNUSED;
+ia64_init (int argc ATTRIBUTE_UNUSED, char **argv ATTRIBUTE_UNUSED)
 {
   md.flags = MD_FLAGS_DEFAULT;
+#ifndef TE_VMS
+  /* Don't turn on dependency checking for VMS, doesn't work.  */
   md.detect_dv = 1;
+#endif
   /* FIXME: We should change it to unwind_check_error someday.  */
   md.unwind_check = unwind_check_warning;
   md.hint_b = hint_b_error;
@@ -7680,7 +7528,7 @@ ia64_init (argc, argv)
 /* Return a string for the target object file format.  */
 
 const char *
-ia64_target_format ()
+ia64_target_format (void)
 {
   if (OUTPUT_FLAVOR == bfd_target_elf_flavour)
     {
@@ -7706,8 +7554,13 @@ ia64_target_format ()
       else
 	{
 	  if (md.flags & EF_IA_64_ABI64)
-#ifdef TE_AIX50
+#if defined (TE_AIX50)
 	    return "elf64-ia64-aix-little";
+#elif defined (TE_VMS)
+	  {
+	    md.flags |= EF_IA_64_ARCHVER_1;
+	    return "elf64-ia64-vms";
+	  }
 #else
 	    return "elf64-ia64-little";
 #endif
@@ -7724,7 +7577,7 @@ ia64_target_format ()
 }
 
 void
-ia64_end_of_source ()
+ia64_end_of_source (void)
 {
   /* terminate insn group upon reaching end of file:  */
   insn_group_break (1, 0, 0);
@@ -7738,7 +7591,7 @@ ia64_end_of_source ()
 }
 
 void
-ia64_start_line ()
+ia64_start_line (void)
 {
   static int first;
 
@@ -7812,8 +7665,7 @@ ia64_start_line ()
 static int defining_tag = 0;
 
 int
-ia64_unrecognized_line (ch)
-     int ch;
+ia64_unrecognized_line (int ch)
 {
   switch (ch)
     {
@@ -7853,8 +7705,7 @@ ia64_unrecognized_line (ch)
 	   recognize labels.  */
 	if (is_name_beginner (*input_line_pointer))
 	  {
-	    s = input_line_pointer;
-	    c = get_symbol_end ();
+	    c = get_symbol_name (&s);
 	  }
 	else if (LOCAL_LABELS_FB
 		 && ISDIGIT (*input_line_pointer))
@@ -7906,8 +7757,7 @@ ia64_unrecognized_line (ch)
 }
 
 void
-ia64_frob_label (sym)
-     struct symbol *sym;
+ia64_frob_label (struct symbol *sym)
 {
   struct label_fix *fix;
 
@@ -7937,9 +7787,8 @@ ia64_frob_label (sym)
       if (md.path == md.maxpaths)
 	{
 	  md.maxpaths += 20;
-	  md.entry_labels = (const char **)
-	    xrealloc ((void *) md.entry_labels,
-		      md.maxpaths * sizeof (char *));
+	  md.entry_labels = XRESIZEVEC (const char *, md.entry_labels,
+					md.maxpaths);
 	}
       md.entry_labels[md.path++] = S_GET_NAME (sym);
     }
@@ -7950,12 +7799,11 @@ ia64_frob_label (sym)
    that are declared but unused.  This routine removes declared,
    unused symbols from an object.  */
 int
-ia64_frob_symbol (sym)
-     struct symbol *sym;
+ia64_frob_symbol (struct symbol *sym)
 {
-  if ((S_GET_SEGMENT (sym) == &bfd_und_section && ! symbol_used_p (sym) &&
+  if ((S_GET_SEGMENT (sym) == bfd_und_section_ptr && ! symbol_used_p (sym) &&
        ELF_ST_VISIBILITY (S_GET_OTHER (sym)) == STV_DEFAULT)
-      || (S_GET_SEGMENT (sym) == &bfd_abs_section
+      || (S_GET_SEGMENT (sym) == bfd_abs_section_ptr
 	  && ! S_IS_EXTERNAL (sym)))
     return 1;
   return 0;
@@ -7963,7 +7811,7 @@ ia64_frob_symbol (sym)
 #endif
 
 void
-ia64_flush_pending_output ()
+ia64_flush_pending_output (void)
 {
   if (!md.keep_pending_output
       && bfd_get_section_flags (stdoutput, now_seg) & SEC_CODE)
@@ -7980,10 +7828,7 @@ ia64_flush_pending_output ()
    of rotating registers or due to the indexing of indirect register
    sets.  */
 int
-ia64_optimize_expr (l, op, r)
-     expressionS *l;
-     operatorT op;
-     expressionS *r;
+ia64_optimize_expr (expressionS *l, operatorT op, expressionS *r)
 {
   if (op != O_index)
     return 0;
@@ -8033,10 +7878,7 @@ ia64_optimize_expr (l, op, r)
 }
 
 int
-ia64_parse_name (name, e, nextcharP)
-     char *name;
-     expressionS *e;
-     char *nextcharP;
+ia64_parse_name (char *name, expressionS *e, char *nextcharP)
 {
   struct const_desc *cdesc;
   struct dynreg *dr = 0;
@@ -8076,6 +7918,15 @@ ia64_parse_name (name, e, nextcharP)
 	    }
 	  /* Skip ')'.  */
 	  ++input_line_pointer;
+#ifdef TE_VMS
+          if (idx == FUNC_SLOTCOUNT_RELOC)
+            {
+              /* @slotcount can accept any expression.  Canonicalize.  */
+              e->X_add_symbol = make_expr_symbol (e);
+              e->X_op = O_symbol;
+              e->X_add_number = 0;
+            }
+#endif
 	  if (e->X_op != O_symbol)
 	    {
 	      if (e->X_op != O_pseudo_fixup)
@@ -8200,8 +8051,7 @@ ia64_parse_name (name, e, nextcharP)
 	}
     }
 
-  end = alloca (strlen (name) + 1);
-  strcpy (end, name);
+  end = xstrdup (name);
   name = ia64_canonicalize_symbol_name (end);
   if ((dr = hash_find (md.dynreg_hash, name)))
     {
@@ -8211,16 +8061,17 @@ ia64_parse_name (name, e, nextcharP)
 	 bits.  */
       e->X_op = O_register;
       e->X_add_number = dr->base | (dr->num_regs << 16);
+      free (end);
       return 1;
     }
+  free (end);
   return 0;
 }
 
 /* Remove the '#' suffix that indicates a symbol as opposed to a register.  */
 
 char *
-ia64_canonicalize_symbol_name (name)
-     char *name;
+ia64_canonicalize_symbol_name (char *name)
 {
   size_t len = strlen (name), full = len;
 
@@ -8245,8 +8096,7 @@ ia64_canonicalize_symbol_name (name)
    through, and which use no resources if they do fall through.  */
 
 static int
-is_conditional_branch (idesc)
-     struct ia64_opcode *idesc;
+is_conditional_branch (struct ia64_opcode *idesc)
 {
   /* br is a conditional branch.  Everything that starts with br. except
      br.ia, br.c{loop,top,exit}, and br.w{top,exit} is a conditional branch.
@@ -8266,8 +8116,7 @@ is_conditional_branch (idesc)
    returns zero.  */
 
 static int
-is_taken_branch (idesc)
-     struct ia64_opcode *idesc;
+is_taken_branch (struct ia64_opcode *idesc)
 {
   return ((is_conditional_branch (idesc) && CURR_SLOT.qp_regno == 0)
 	  || strncmp (idesc->name, "br.ia", 5) == 0);
@@ -8277,8 +8126,7 @@ is_taken_branch (idesc)
    doubt, returns zero.  */
 
 static int
-is_interruption_or_rfi (idesc)
-     struct ia64_opcode *idesc;
+is_interruption_or_rfi (struct ia64_opcode *idesc)
 {
   if (strcmp (idesc->name, "rfi") == 0)
     return 1;
@@ -8289,9 +8137,7 @@ is_interruption_or_rfi (idesc)
    -1 if there is no dependency.  */
 
 static int
-depends_on (depind, idesc)
-     int depind;
-     struct ia64_opcode *idesc;
+depends_on (int depind, struct ia64_opcode *idesc)
 {
   int i;
   const struct ia64_opcode_dependency *dep = idesc->dependencies;
@@ -8356,13 +8202,16 @@ depends_on (depind, idesc)
 #define DV_REG 0
 
 static int
-specify_resource (dep, idesc, type, specs, note, path)
-     const struct ia64_dependency *dep;
-     struct ia64_opcode *idesc;
-     int type;                         /* is this a DV chk or a DV reg? */
-     struct rsrc specs[MAX_SPECS];     /* returned specific resources */
-     int note;                         /* resource note for this insn's usage */
-     int path;                         /* which execution path to examine */
+specify_resource (const struct ia64_dependency *dep,
+		  struct ia64_opcode *idesc,
+		  /* is this a DV chk or a DV reg? */
+		  int type,
+		  /* returned specific resources */
+		  struct rsrc specs[MAX_SPECS],
+		  /* resource note for this insn's usage */
+		  int note,
+		  /* which execution path to examine */
+		  int path)
 {
   int count = 0;
   int i;
@@ -8696,9 +8545,9 @@ dep->name, idesc->name, (rsrc_write?"write":"read"), note)
 	      || (!rsrc_write && idesc->operands[1] == IA64_OPND_PMD_R3))
 
 	    {
-	      int index = ((idesc->operands[1] == IA64_OPND_R3 && !rsrc_write)
-			   ? 1 : !rsrc_write);
-	      int regno = CURR_SLOT.opnd[index].X_add_number - REG_GR;
+	      int reg_index = ((idesc->operands[1] == IA64_OPND_R3 && !rsrc_write)
+			       ? 1 : !rsrc_write);
+	      int regno = CURR_SLOT.opnd[reg_index].X_add_number - REG_GR;
 	      if (regno >= 0 && regno < NELEMS (gr_values)
 		  && KNOWN (regno))
 		{
@@ -8806,6 +8655,23 @@ dep->name, idesc->name, (rsrc_write?"write":"read"), note)
 	}
       break;
 
+    case IA64_RS_CR_IIB:
+      if (note != 0)
+	{
+	  UNHANDLED;
+	}
+      else
+	{
+	  int regno = CURR_SLOT.opnd[!rsrc_write].X_add_number - REG_CR;
+	  if (idesc->operands[!rsrc_write] == IA64_OPND_CR3
+	      && (regno == CR_IIB0 || regno == CR_IIB1))
+	    {
+	      specs[count] = tmpl;
+	      specs[count++].index = regno;
+	    }
+	}
+      break;
+
     case IA64_RS_CR_LRR:
       if (note != 1)
 	{
@@ -8839,6 +8705,22 @@ dep->name, idesc->name, (rsrc_write?"write":"read"), note)
 	}
       break;
 
+    case IA64_RS_DAHR:
+      if (note == 0)
+	{
+	  if (idesc->operands[!rsrc_write] == IA64_OPND_DAHR3)
+	    {
+	      specs[count] = tmpl;
+	      specs[count++].index =
+		CURR_SLOT.opnd[!rsrc_write].X_add_number - REG_DAHR;
+	    }
+	}
+      else
+	{
+	  UNHANDLED;
+	}
+      break;
+
     case IA64_RS_FR:
     case IA64_RS_FRb:
       if (note != 1)
@@ -8913,6 +8795,7 @@ dep->name, idesc->name, (rsrc_write?"write":"read"), note)
 		      || idesc->operands[i] == IA64_OPND_PKR_R3
 		      || idesc->operands[i] == IA64_OPND_PMC_R3
 		      || idesc->operands[i] == IA64_OPND_PMD_R3
+		      || idesc->operands[i] == IA64_OPND_DAHR_R3
 		      || idesc->operands[i] == IA64_OPND_RR_R3
 		      || ((i >= idesc->num_outputs)
 			  && (idesc->operands[i] == IA64_OPND_R1
@@ -9219,11 +9102,11 @@ dep->name, idesc->name, (rsrc_write?"write":"read"), note)
 		      if (idesc->operands[0] == IA64_OPND_CR3
 			  || idesc->operands[1] == IA64_OPND_CR3)
 			{
-			  int index =
+			  int reg_index =
 			    ((idesc->operands[0] == IA64_OPND_CR3)
 			     ? 0 : 1);
 			  int regno =
-			    CURR_SLOT.opnd[index].X_add_number - REG_CR;
+			    CURR_SLOT.opnd[reg_index].X_add_number - REG_CR;
 
 			  switch (regno)
 			    {
@@ -9237,6 +9120,8 @@ dep->name, idesc->name, (rsrc_write?"write":"read"), note)
 			    case CR_ISR:
 			    case CR_IFA:
 			    case CR_IHA:
+			    case CR_IIB0:
+			    case CR_IIB1:
 			    case CR_IIPA:
 			      specs[count++] = tmpl;
 			      break;
@@ -9255,15 +9140,15 @@ dep->name, idesc->name, (rsrc_write?"write":"read"), note)
 		      if (idesc->operands[0] == IA64_OPND_AR3
 			  || idesc->operands[1] == IA64_OPND_AR3)
 			{
-			  int index =
+			  int reg_index =
 			    ((idesc->operands[0] == IA64_OPND_AR3)
 			     ? 0 : 1);
 			  int regno =
-			    CURR_SLOT.opnd[index].X_add_number - REG_AR;
+			    CURR_SLOT.opnd[reg_index].X_add_number - REG_AR;
 
 			  if (regno == AR_ITC
 			      || regno == AR_RUC
-			      || (index == 0
+			      || (reg_index == 0
 				  && (regno == AR_RSC
 				      || (regno >= AR_K0
 					  && regno <= AR_K7))))
@@ -9679,8 +9564,7 @@ dep->name, idesc->name, (rsrc_write?"write":"read"), note)
    QP of the marking instruction and a subsequent branch on the same QP.  */
 
 static void
-clear_qp_branch_flag (mask)
-     valueT mask;
+clear_qp_branch_flag (valueT mask)
 {
   int i;
   for (i = 0; i < regdepslen; i++)
@@ -9725,7 +9609,7 @@ update_qp_mutex (valueT mask)
 		  print_prmask (qp_mutexes[i].prmask);
 		  fprintf (stderr, "\n");
 		}
-	      
+
 	      /* Deal with the old mutex with more than 3+ PRs only if
 		 the new mutex on the same execution path with it.
 
@@ -9738,7 +9622,7 @@ update_qp_mutex (valueT mask)
 		  if (add == 0
 		      && (qp_mutexes[i].prmask & mask) == mask)
 		    add = 1;
-		  
+
 		  qp_mutexes[i].prmask &= ~mask;
 		  if (qp_mutexes[i].prmask & (qp_mutexes[i].prmask - 1))
 		    {
@@ -9748,7 +9632,7 @@ update_qp_mutex (valueT mask)
 		      i++;
 		    }
 		}
-	      
+
 	      if (keep == 0)
 		/* Remove the mutex.  */
 		qp_mutexes[i] = qp_mutexes[--qp_mutexeslen];
@@ -9769,8 +9653,7 @@ update_qp_mutex (valueT mask)
    Any changes to a PR clears the mutex relations which include that PR.  */
 
 static void
-clear_qp_mutex (mask)
-     valueT mask;
+clear_qp_mutex (valueT mask)
 {
   int i;
 
@@ -9797,9 +9680,7 @@ clear_qp_mutex (mask)
    indicates the implied PR.  */
 
 static void
-clear_qp_implies (p1_mask, p2_mask)
-     valueT p1_mask;
-     valueT p2_mask;
+clear_qp_implies (valueT p1_mask, valueT p2_mask)
 {
   int i;
 
@@ -9822,8 +9703,7 @@ clear_qp_implies (p1_mask, p2_mask)
 /* Add the PRs specified to the list of implied relations.  */
 
 static void
-add_qp_imply (p1, p2)
-     int p1, p2;
+add_qp_imply (int p1, int p2)
 {
   valueT mask;
   valueT bit;
@@ -9849,9 +9729,7 @@ add_qp_imply (p1, p2)
   if (qp_implieslen == qp_impliestotlen)
     {
       qp_impliestotlen += 20;
-      qp_implies = (struct qp_imply *)
-	xrealloc ((void *) qp_implies,
-		  qp_impliestotlen * sizeof (struct qp_imply));
+      qp_implies = XRESIZEVEC (struct qp_imply, qp_implies, qp_impliestotlen);
     }
   if (md.debug_dv)
     fprintf (stderr, "  Registering PR%d implies PR%d\n", p1, p2);
@@ -9886,8 +9764,7 @@ add_qp_imply (p1, p2)
    the mask.  */
 
 static void
-add_qp_mutex (mask)
-     valueT mask;
+add_qp_mutex (valueT mask)
 {
   if (mask & 0x1)
     abort ();
@@ -9895,9 +9772,7 @@ add_qp_mutex (mask)
   if (qp_mutexeslen == qp_mutexestotlen)
     {
       qp_mutexestotlen += 20;
-      qp_mutexes = (struct qpmutex *)
-	xrealloc ((void *) qp_mutexes,
-		  qp_mutexestotlen * sizeof (struct qpmutex));
+      qp_mutexes = XRESIZEVEC (struct qpmutex, qp_mutexes, qp_mutexestotlen);
     }
   if (md.debug_dv)
     {
@@ -9910,9 +9785,7 @@ add_qp_mutex (mask)
 }
 
 static int
-has_suffix_p (name, suffix)
-     const char *name;
-     const char *suffix;
+has_suffix_p (const char *name, const char *suffix)
 {
   size_t namelen = strlen (name);
   size_t sufflen = strlen (suffix);
@@ -9923,7 +9796,7 @@ has_suffix_p (name, suffix)
 }
 
 static void
-clear_register_values ()
+clear_register_values (void)
 {
   int i;
   if (md.debug_dv)
@@ -9938,8 +9811,7 @@ clear_register_values ()
    have to examine a group of strings to identify them.  */
 
 static void
-note_register_values (idesc)
-     struct ia64_opcode *idesc;
+note_register_values (struct ia64_opcode *idesc)
 {
   valueT qp_changemask = 0;
   int i;
@@ -10138,10 +10010,7 @@ note_register_values (idesc)
 /* Return whether the given predicate registers are currently mutex.  */
 
 static int
-qp_mutex (p1, p2, path)
-     int p1;
-     int p2;
-     int path;
+qp_mutex (int p1, int p2, int path)
 {
   int i;
   valueT mask;
@@ -10164,12 +10033,11 @@ qp_mutex (p1, p2, path)
    conflict.  */
 
 static int
-resources_match (rs, idesc, note, qp_regno, path)
-     struct rsrc *rs;
-     struct ia64_opcode *idesc;
-     int note;
-     int qp_regno;
-     int path;
+resources_match (struct rsrc *rs,
+		 struct ia64_opcode *idesc,
+		 int note,
+		 int qp_regno,
+		 int path)
 {
   struct rsrc specs[MAX_SPECS];
   int count;
@@ -10245,10 +10113,7 @@ resources_match (rs, idesc, note, qp_regno, path)
    instruction.  */
 
 static void
-insn_group_break (insert_stop, qp_regno, save_current)
-     int insert_stop;
-     int qp_regno;
-     int save_current;
+insn_group_break (int insert_stop, int qp_regno, int save_current)
 {
   int i;
 
@@ -10312,19 +10177,16 @@ insn_group_break (insert_stop, qp_regno, save_current)
 /* Add the given resource usage spec to the list of active dependencies.  */
 
 static void
-mark_resource (idesc, dep, spec, depind, path)
-     struct ia64_opcode *idesc ATTRIBUTE_UNUSED;
-     const struct ia64_dependency *dep ATTRIBUTE_UNUSED;
-     struct rsrc *spec;
-     int depind;
-     int path;
+mark_resource (struct ia64_opcode *idesc ATTRIBUTE_UNUSED,
+	       const struct ia64_dependency *dep ATTRIBUTE_UNUSED,
+	       struct rsrc *spec,
+	       int depind,
+	       int path)
 {
   if (regdepslen == regdepstotlen)
     {
       regdepstotlen += 20;
-      regdeps = (struct rsrc *)
-	xrealloc ((void *) regdeps,
-		  regdepstotlen * sizeof (struct rsrc));
+      regdeps = XRESIZEVEC (struct rsrc, regdeps, regdepstotlen);
     }
 
   regdeps[regdepslen] = *spec;
@@ -10339,9 +10201,7 @@ mark_resource (idesc, dep, spec, depind, path)
 }
 
 static void
-print_dependency (action, depind)
-     const char *action;
-     int depind;
+print_dependency (const char *action, int depind)
 {
   if (md.debug_dv)
     {
@@ -10362,7 +10222,7 @@ print_dependency (action, depind)
 }
 
 static void
-instruction_serialization ()
+instruction_serialization (void)
 {
   int i;
   if (md.debug_dv)
@@ -10373,7 +10233,7 @@ instruction_serialization ()
 }
 
 static void
-data_serialization ()
+data_serialization (void)
 {
   int i = 0;
   if (md.debug_dv)
@@ -10396,8 +10256,7 @@ data_serialization ()
 /* Insert stops and serializations as needed to avoid DVs.  */
 
 static void
-remove_marked_resource (rs)
-     struct rsrc *rs;
+remove_marked_resource (struct rsrc *rs)
 {
   switch (rs->dependency->semantics)
     {
@@ -10472,8 +10331,7 @@ remove_marked_resource (rs)
 */
 
 static void
-check_dependencies (idesc)
-     struct ia64_opcode *idesc;
+check_dependencies (struct ia64_opcode *idesc)
 {
   const struct ia64_opcode_dependency *opdeps = idesc->dependencies;
   int path;
@@ -10597,8 +10455,7 @@ check_dependencies (idesc)
 /* Register new dependencies based on the given opcode.  */
 
 static void
-mark_resources (idesc)
-     struct ia64_opcode *idesc;
+mark_resources (struct ia64_opcode *idesc)
 {
   int i;
   const struct ia64_opcode_dependency *opdeps = idesc->dependencies;
@@ -10671,8 +10528,7 @@ mark_resources (idesc)
 /* Remove dependencies when they no longer apply.  */
 
 static void
-update_dependencies (idesc)
-     struct ia64_opcode *idesc;
+update_dependencies (struct ia64_opcode *idesc)
 {
   int i;
 
@@ -10752,8 +10608,7 @@ update_dependencies (idesc)
 /* Examine the current instruction for dependency violations.  */
 
 static int
-check_dv (idesc)
-     struct ia64_opcode *idesc;
+check_dv (struct ia64_opcode *idesc)
 {
   if (md.debug_dv)
     {
@@ -10801,10 +10656,10 @@ check_dv (idesc)
 /* Translate one line of assembly.  Pseudo ops and labels do not show
    here.  */
 void
-md_assemble (str)
-     char *str;
+md_assemble (char *str)
 {
-  char *saved_input_line_pointer, *mnemonic;
+  char *saved_input_line_pointer, *temp;
+  const char *mnemonic;
   const struct pseudo_opcode *pdesc;
   struct ia64_opcode *idesc;
   unsigned char qp_regno;
@@ -10816,12 +10671,12 @@ md_assemble (str)
 
   /* extract the opcode (mnemonic):  */
 
-  mnemonic = input_line_pointer;
-  ch = get_symbol_end ();
+  ch = get_symbol_name (&temp);
+  mnemonic = temp;
   pdesc = (struct pseudo_opcode *) hash_find (md.pseudo_hash, mnemonic);
   if (pdesc)
     {
-      *input_line_pointer = ch;
+      (void) restore_line_pointer (ch);
       (*pdesc->handler) (pdesc->arg);
       goto done;
     }
@@ -10829,7 +10684,7 @@ md_assemble (str)
   /* Find the instruction descriptor matching the arguments.  */
 
   idesc = ia64_find_opcode (mnemonic);
-  *input_line_pointer = ch;
+  (void) restore_line_pointer (ch);
   if (!idesc)
     {
       as_bad (_("Unknown opcode `%s'"), mnemonic);
@@ -10893,7 +10748,7 @@ md_assemble (str)
     {
       enum ia64_opnd opnd1, opnd2;
       int rop;
-      
+
       opnd1 = idesc->operands[0];
       opnd2 = idesc->operands[1];
       if (opnd1 == IA64_OPND_AR3)
@@ -10971,7 +10826,7 @@ md_assemble (str)
   /* Build the instruction.  */
   CURR_SLOT.qp_regno = qp_regno;
   CURR_SLOT.idesc = idesc;
-  as_where (&CURR_SLOT.src_file, &CURR_SLOT.src_line);
+  CURR_SLOT.src_file = as_where (&CURR_SLOT.src_line);
   dwarf2_where (&CURR_SLOT.debug_line);
   dwarf2_consume_line_info ();
 
@@ -11017,8 +10872,7 @@ md_assemble (str)
    Should be used for dynamic valued symbols only.  */
 
 symbolS *
-md_undefined_symbol (name)
-     char *name ATTRIBUTE_UNUSED;
+md_undefined_symbol (char *name ATTRIBUTE_UNUSED)
 {
   return 0;
 }
@@ -11028,8 +10882,7 @@ md_undefined_symbol (name)
    the expression.  */
 
 void
-md_operand (e)
-     expressionS *e;
+md_operand (expressionS *e)
 {
   switch (*input_line_pointer)
     {
@@ -11070,8 +10923,7 @@ md_operand (e)
    directives we don't want such adjustments since we need to have the
    original symbol's name in the reloc.  */
 int
-ia64_fix_adjustable (fix)
-     fixS *fix;
+ia64_fix_adjustable (fixS *fix)
 {
   /* Prevent all adjustments to global symbols */
   if (S_IS_EXTERNAL (fix->fx_addsy) || S_IS_WEAK (fix->fx_addsy))
@@ -11095,8 +10947,7 @@ ia64_fix_adjustable (fix)
 }
 
 int
-ia64_force_relocation (fix)
-     fixS *fix;
+ia64_force_relocation (fixS *fix)
 {
   switch (fix->fx_r_type)
     {
@@ -11129,9 +10980,7 @@ ia64_force_relocation (fix)
 /* Decide from what point a pc-relative relocation is relative to,
    relative to the pc-relative fixup.  Er, relatively speaking.  */
 long
-ia64_pcrel_from_section (fix, sec)
-     fixS *fix;
-     segT sec;
+ia64_pcrel_from_section (fixS *fix, segT sec)
 {
   unsigned long off = fix->fx_frag->fr_address + fix->fx_where;
 
@@ -11146,26 +10995,22 @@ ia64_pcrel_from_section (fix, sec)
 void
 ia64_dwarf2_emit_offset (symbolS *symbol, unsigned int size)
 {
-  expressionS expr;
+  expressionS exp;
 
-  expr.X_op = O_pseudo_fixup;
-  expr.X_op_symbol = pseudo_func[FUNC_SEC_RELATIVE].u.sym;
-  expr.X_add_number = 0;
-  expr.X_add_symbol = symbol;
-  emit_expr (&expr, size);
+  exp.X_op = O_pseudo_fixup;
+  exp.X_op_symbol = pseudo_func[FUNC_SEC_RELATIVE].u.sym;
+  exp.X_add_number = 0;
+  exp.X_add_symbol = symbol;
+  emit_expr (&exp, size);
 }
 
 /* This is called whenever some data item (not an instruction) needs a
    fixup.  We pick the right reloc code depending on the byteorder
    currently in effect.  */
 void
-ia64_cons_fix_new (f, where, nbytes, exp)
-     fragS *f;
-     int where;
-     int nbytes;
-     expressionS *exp;
+ia64_cons_fix_new (fragS *f, int where, int nbytes, expressionS *exp,
+		   bfd_reloc_code_real_type code)
 {
-  bfd_reloc_code_real_type code;
   fixS *fix;
 
   switch (nbytes)
@@ -11244,11 +11089,9 @@ ia64_cons_fix_new (f, where, nbytes, exp)
    symbols in the pseudo_func array, or NULL.  */
 
 static bfd_reloc_code_real_type
-ia64_gen_real_reloc_type (sym, r_type)
-     struct symbol *sym;
-     bfd_reloc_code_real_type r_type;
+ia64_gen_real_reloc_type (struct symbol *sym, bfd_reloc_code_real_type r_type)
 {
-  bfd_reloc_code_real_type new = 0;
+  bfd_reloc_code_real_type newr = 0;
   const char *type = NULL, *suffix = "";
 
   if (sym == NULL)
@@ -11261,11 +11104,11 @@ ia64_gen_real_reloc_type (sym, r_type)
     case FUNC_FPTR_RELATIVE:
       switch (r_type)
 	{
-	case BFD_RELOC_IA64_IMM64:	new = BFD_RELOC_IA64_FPTR64I; break;
-	case BFD_RELOC_IA64_DIR32MSB:	new = BFD_RELOC_IA64_FPTR32MSB; break;
-	case BFD_RELOC_IA64_DIR32LSB:	new = BFD_RELOC_IA64_FPTR32LSB; break;
-	case BFD_RELOC_IA64_DIR64MSB:	new = BFD_RELOC_IA64_FPTR64MSB; break;
-	case BFD_RELOC_IA64_DIR64LSB:	new = BFD_RELOC_IA64_FPTR64LSB; break;
+	case BFD_RELOC_IA64_IMM64:	newr = BFD_RELOC_IA64_FPTR64I; break;
+	case BFD_RELOC_IA64_DIR32MSB:	newr = BFD_RELOC_IA64_FPTR32MSB; break;
+	case BFD_RELOC_IA64_DIR32LSB:	newr = BFD_RELOC_IA64_FPTR32LSB; break;
+	case BFD_RELOC_IA64_DIR64MSB:	newr = BFD_RELOC_IA64_FPTR64MSB; break;
+	case BFD_RELOC_IA64_DIR64LSB:	newr = BFD_RELOC_IA64_FPTR64LSB; break;
 	default:			type = "FPTR"; break;
 	}
       break;
@@ -11273,12 +11116,12 @@ ia64_gen_real_reloc_type (sym, r_type)
     case FUNC_GP_RELATIVE:
       switch (r_type)
 	{
-	case BFD_RELOC_IA64_IMM22:	new = BFD_RELOC_IA64_GPREL22; break;
-	case BFD_RELOC_IA64_IMM64:	new = BFD_RELOC_IA64_GPREL64I; break;
-	case BFD_RELOC_IA64_DIR32MSB:	new = BFD_RELOC_IA64_GPREL32MSB; break;
-	case BFD_RELOC_IA64_DIR32LSB:	new = BFD_RELOC_IA64_GPREL32LSB; break;
-	case BFD_RELOC_IA64_DIR64MSB:	new = BFD_RELOC_IA64_GPREL64MSB; break;
-	case BFD_RELOC_IA64_DIR64LSB:	new = BFD_RELOC_IA64_GPREL64LSB; break;
+	case BFD_RELOC_IA64_IMM22:	newr = BFD_RELOC_IA64_GPREL22; break;
+	case BFD_RELOC_IA64_IMM64:	newr = BFD_RELOC_IA64_GPREL64I; break;
+	case BFD_RELOC_IA64_DIR32MSB:	newr = BFD_RELOC_IA64_GPREL32MSB; break;
+	case BFD_RELOC_IA64_DIR32LSB:	newr = BFD_RELOC_IA64_GPREL32LSB; break;
+	case BFD_RELOC_IA64_DIR64MSB:	newr = BFD_RELOC_IA64_GPREL64MSB; break;
+	case BFD_RELOC_IA64_DIR64LSB:	newr = BFD_RELOC_IA64_GPREL64LSB; break;
 	default:			type = "GPREL"; break;
 	}
       break;
@@ -11286,8 +11129,8 @@ ia64_gen_real_reloc_type (sym, r_type)
     case FUNC_LT_RELATIVE:
       switch (r_type)
 	{
-	case BFD_RELOC_IA64_IMM22:	new = BFD_RELOC_IA64_LTOFF22; break;
-	case BFD_RELOC_IA64_IMM64:	new = BFD_RELOC_IA64_LTOFF64I; break;
+	case BFD_RELOC_IA64_IMM22:	newr = BFD_RELOC_IA64_LTOFF22; break;
+	case BFD_RELOC_IA64_IMM64:	newr = BFD_RELOC_IA64_LTOFF64I; break;
 	default:			type = "LTOFF"; break;
 	}
       break;
@@ -11295,7 +11138,7 @@ ia64_gen_real_reloc_type (sym, r_type)
     case FUNC_LT_RELATIVE_X:
       switch (r_type)
 	{
-	case BFD_RELOC_IA64_IMM22:	new = BFD_RELOC_IA64_LTOFF22X; break;
+	case BFD_RELOC_IA64_IMM22:	newr = BFD_RELOC_IA64_LTOFF22X; break;
 	default:			type = "LTOFF"; suffix = "X"; break;
 	}
       break;
@@ -11303,12 +11146,12 @@ ia64_gen_real_reloc_type (sym, r_type)
     case FUNC_PC_RELATIVE:
       switch (r_type)
 	{
-	case BFD_RELOC_IA64_IMM22:	new = BFD_RELOC_IA64_PCREL22; break;
-	case BFD_RELOC_IA64_IMM64:	new = BFD_RELOC_IA64_PCREL64I; break;
-	case BFD_RELOC_IA64_DIR32MSB:	new = BFD_RELOC_IA64_PCREL32MSB; break;
-	case BFD_RELOC_IA64_DIR32LSB:	new = BFD_RELOC_IA64_PCREL32LSB; break;
-	case BFD_RELOC_IA64_DIR64MSB:	new = BFD_RELOC_IA64_PCREL64MSB; break;
-	case BFD_RELOC_IA64_DIR64LSB:	new = BFD_RELOC_IA64_PCREL64LSB; break;
+	case BFD_RELOC_IA64_IMM22:	newr = BFD_RELOC_IA64_PCREL22; break;
+	case BFD_RELOC_IA64_IMM64:	newr = BFD_RELOC_IA64_PCREL64I; break;
+	case BFD_RELOC_IA64_DIR32MSB:	newr = BFD_RELOC_IA64_PCREL32MSB; break;
+	case BFD_RELOC_IA64_DIR32LSB:	newr = BFD_RELOC_IA64_PCREL32LSB; break;
+	case BFD_RELOC_IA64_DIR64MSB:	newr = BFD_RELOC_IA64_PCREL64MSB; break;
+	case BFD_RELOC_IA64_DIR64LSB:	newr = BFD_RELOC_IA64_PCREL64LSB; break;
 	default:			type = "PCREL"; break;
 	}
       break;
@@ -11316,10 +11159,10 @@ ia64_gen_real_reloc_type (sym, r_type)
     case FUNC_PLT_RELATIVE:
       switch (r_type)
 	{
-	case BFD_RELOC_IA64_IMM22:	new = BFD_RELOC_IA64_PLTOFF22; break;
-	case BFD_RELOC_IA64_IMM64:	new = BFD_RELOC_IA64_PLTOFF64I; break;
-	case BFD_RELOC_IA64_DIR64MSB:	new = BFD_RELOC_IA64_PLTOFF64MSB;break;
-	case BFD_RELOC_IA64_DIR64LSB:	new = BFD_RELOC_IA64_PLTOFF64LSB;break;
+	case BFD_RELOC_IA64_IMM22:	newr = BFD_RELOC_IA64_PLTOFF22; break;
+	case BFD_RELOC_IA64_IMM64:	newr = BFD_RELOC_IA64_PLTOFF64I; break;
+	case BFD_RELOC_IA64_DIR64MSB:	newr = BFD_RELOC_IA64_PLTOFF64MSB;break;
+	case BFD_RELOC_IA64_DIR64LSB:	newr = BFD_RELOC_IA64_PLTOFF64LSB;break;
 	default:			type = "PLTOFF"; break;
 	}
       break;
@@ -11327,10 +11170,10 @@ ia64_gen_real_reloc_type (sym, r_type)
     case FUNC_SEC_RELATIVE:
       switch (r_type)
 	{
-	case BFD_RELOC_IA64_DIR32MSB:	new = BFD_RELOC_IA64_SECREL32MSB;break;
-	case BFD_RELOC_IA64_DIR32LSB:	new = BFD_RELOC_IA64_SECREL32LSB;break;
-	case BFD_RELOC_IA64_DIR64MSB:	new = BFD_RELOC_IA64_SECREL64MSB;break;
-	case BFD_RELOC_IA64_DIR64LSB:	new = BFD_RELOC_IA64_SECREL64LSB;break;
+	case BFD_RELOC_IA64_DIR32MSB:	newr = BFD_RELOC_IA64_SECREL32MSB;break;
+	case BFD_RELOC_IA64_DIR32LSB:	newr = BFD_RELOC_IA64_SECREL32LSB;break;
+	case BFD_RELOC_IA64_DIR64MSB:	newr = BFD_RELOC_IA64_SECREL64MSB;break;
+	case BFD_RELOC_IA64_DIR64LSB:	newr = BFD_RELOC_IA64_SECREL64LSB;break;
 	default:			type = "SECREL"; break;
 	}
       break;
@@ -11338,10 +11181,10 @@ ia64_gen_real_reloc_type (sym, r_type)
     case FUNC_SEG_RELATIVE:
       switch (r_type)
 	{
-	case BFD_RELOC_IA64_DIR32MSB:	new = BFD_RELOC_IA64_SEGREL32MSB;break;
-	case BFD_RELOC_IA64_DIR32LSB:	new = BFD_RELOC_IA64_SEGREL32LSB;break;
-	case BFD_RELOC_IA64_DIR64MSB:	new = BFD_RELOC_IA64_SEGREL64MSB;break;
-	case BFD_RELOC_IA64_DIR64LSB:	new = BFD_RELOC_IA64_SEGREL64LSB;break;
+	case BFD_RELOC_IA64_DIR32MSB:	newr = BFD_RELOC_IA64_SEGREL32MSB;break;
+	case BFD_RELOC_IA64_DIR32LSB:	newr = BFD_RELOC_IA64_SEGREL32LSB;break;
+	case BFD_RELOC_IA64_DIR64MSB:	newr = BFD_RELOC_IA64_SEGREL64MSB;break;
+	case BFD_RELOC_IA64_DIR64LSB:	newr = BFD_RELOC_IA64_SEGREL64LSB;break;
 	default:			type = "SEGREL"; break;
 	}
       break;
@@ -11349,10 +11192,10 @@ ia64_gen_real_reloc_type (sym, r_type)
     case FUNC_LTV_RELATIVE:
       switch (r_type)
 	{
-	case BFD_RELOC_IA64_DIR32MSB:	new = BFD_RELOC_IA64_LTV32MSB; break;
-	case BFD_RELOC_IA64_DIR32LSB:	new = BFD_RELOC_IA64_LTV32LSB; break;
-	case BFD_RELOC_IA64_DIR64MSB:	new = BFD_RELOC_IA64_LTV64MSB; break;
-	case BFD_RELOC_IA64_DIR64LSB:	new = BFD_RELOC_IA64_LTV64LSB; break;
+	case BFD_RELOC_IA64_DIR32MSB:	newr = BFD_RELOC_IA64_LTV32MSB; break;
+	case BFD_RELOC_IA64_DIR32LSB:	newr = BFD_RELOC_IA64_LTV32LSB; break;
+	case BFD_RELOC_IA64_DIR64MSB:	newr = BFD_RELOC_IA64_LTV64MSB; break;
+	case BFD_RELOC_IA64_DIR64LSB:	newr = BFD_RELOC_IA64_LTV64LSB; break;
 	default:			type = "LTV"; break;
 	}
       break;
@@ -11361,17 +11204,17 @@ ia64_gen_real_reloc_type (sym, r_type)
       switch (r_type)
 	{
 	case BFD_RELOC_IA64_IMM22:
-	  new = BFD_RELOC_IA64_LTOFF_FPTR22; break;
+	  newr = BFD_RELOC_IA64_LTOFF_FPTR22; break;
 	case BFD_RELOC_IA64_IMM64:
-	  new = BFD_RELOC_IA64_LTOFF_FPTR64I; break;
+	  newr = BFD_RELOC_IA64_LTOFF_FPTR64I; break;
 	case BFD_RELOC_IA64_DIR32MSB:
-	  new = BFD_RELOC_IA64_LTOFF_FPTR32MSB; break;
+	  newr = BFD_RELOC_IA64_LTOFF_FPTR32MSB; break;
 	case BFD_RELOC_IA64_DIR32LSB:
-	  new = BFD_RELOC_IA64_LTOFF_FPTR32LSB; break;
+	  newr = BFD_RELOC_IA64_LTOFF_FPTR32LSB; break;
 	case BFD_RELOC_IA64_DIR64MSB:
-	  new = BFD_RELOC_IA64_LTOFF_FPTR64MSB; break;
+	  newr = BFD_RELOC_IA64_LTOFF_FPTR64MSB; break;
 	case BFD_RELOC_IA64_DIR64LSB:
-	  new = BFD_RELOC_IA64_LTOFF_FPTR64LSB; break;
+	  newr = BFD_RELOC_IA64_LTOFF_FPTR64LSB; break;
 	default:
 	  type = "LTOFF_FPTR"; break;
 	}
@@ -11380,11 +11223,11 @@ ia64_gen_real_reloc_type (sym, r_type)
     case FUNC_TP_RELATIVE:
       switch (r_type)
 	{
-	case BFD_RELOC_IA64_IMM14:      new = BFD_RELOC_IA64_TPREL14; break;
-	case BFD_RELOC_IA64_IMM22:      new = BFD_RELOC_IA64_TPREL22; break;
-	case BFD_RELOC_IA64_IMM64:      new = BFD_RELOC_IA64_TPREL64I; break;
-	case BFD_RELOC_IA64_DIR64MSB:   new = BFD_RELOC_IA64_TPREL64MSB; break;
-	case BFD_RELOC_IA64_DIR64LSB:   new = BFD_RELOC_IA64_TPREL64LSB; break;
+	case BFD_RELOC_IA64_IMM14:      newr = BFD_RELOC_IA64_TPREL14; break;
+	case BFD_RELOC_IA64_IMM22:      newr = BFD_RELOC_IA64_TPREL22; break;
+	case BFD_RELOC_IA64_IMM64:      newr = BFD_RELOC_IA64_TPREL64I; break;
+	case BFD_RELOC_IA64_DIR64MSB:   newr = BFD_RELOC_IA64_TPREL64MSB; break;
+	case BFD_RELOC_IA64_DIR64LSB:   newr = BFD_RELOC_IA64_TPREL64LSB; break;
 	default:                        type = "TPREL"; break;
 	}
       break;
@@ -11393,7 +11236,7 @@ ia64_gen_real_reloc_type (sym, r_type)
       switch (r_type)
 	{
 	case BFD_RELOC_IA64_IMM22:
-	  new = BFD_RELOC_IA64_LTOFF_TPREL22; break;
+	  newr = BFD_RELOC_IA64_LTOFF_TPREL22; break;
 	default:
 	  type = "LTOFF_TPREL"; break;
 	}
@@ -11403,9 +11246,9 @@ ia64_gen_real_reloc_type (sym, r_type)
       switch (r_type)
 	{
 	case BFD_RELOC_IA64_DIR64MSB:
-	  new = BFD_RELOC_IA64_DTPMOD64MSB; break;
+	  newr = BFD_RELOC_IA64_DTPMOD64MSB; break;
 	case BFD_RELOC_IA64_DIR64LSB:
-	  new = BFD_RELOC_IA64_DTPMOD64LSB; break;
+	  newr = BFD_RELOC_IA64_DTPMOD64LSB; break;
 	default:
 	  type = "DTPMOD"; break;
 	}
@@ -11415,7 +11258,7 @@ ia64_gen_real_reloc_type (sym, r_type)
       switch (r_type)
 	{
 	case BFD_RELOC_IA64_IMM22:
-	  new = BFD_RELOC_IA64_LTOFF_DTPMOD22; break;
+	  newr = BFD_RELOC_IA64_LTOFF_DTPMOD22; break;
 	default:
 	  type = "LTOFF_DTPMOD"; break;
 	}
@@ -11425,19 +11268,19 @@ ia64_gen_real_reloc_type (sym, r_type)
       switch (r_type)
 	{
 	case BFD_RELOC_IA64_DIR32MSB:
-	  new = BFD_RELOC_IA64_DTPREL32MSB; break;
+	  newr = BFD_RELOC_IA64_DTPREL32MSB; break;
 	case BFD_RELOC_IA64_DIR32LSB:
-	  new = BFD_RELOC_IA64_DTPREL32LSB; break;
+	  newr = BFD_RELOC_IA64_DTPREL32LSB; break;
 	case BFD_RELOC_IA64_DIR64MSB:
-	  new = BFD_RELOC_IA64_DTPREL64MSB; break;
+	  newr = BFD_RELOC_IA64_DTPREL64MSB; break;
 	case BFD_RELOC_IA64_DIR64LSB:
-	  new = BFD_RELOC_IA64_DTPREL64LSB; break;
+	  newr = BFD_RELOC_IA64_DTPREL64LSB; break;
 	case BFD_RELOC_IA64_IMM14:
-	  new = BFD_RELOC_IA64_DTPREL14; break;
+	  newr = BFD_RELOC_IA64_DTPREL14; break;
 	case BFD_RELOC_IA64_IMM22:
-	  new = BFD_RELOC_IA64_DTPREL22; break;
+	  newr = BFD_RELOC_IA64_DTPREL22; break;
 	case BFD_RELOC_IA64_IMM64:
-	  new = BFD_RELOC_IA64_DTPREL64I; break;
+	  newr = BFD_RELOC_IA64_DTPREL64I; break;
 	default:
 	  type = "DTPREL"; break;
 	}
@@ -11447,7 +11290,7 @@ ia64_gen_real_reloc_type (sym, r_type)
       switch (r_type)
 	{
 	case BFD_RELOC_IA64_IMM22:
-	  new = BFD_RELOC_IA64_LTOFF_DTPREL22; break;
+	  newr = BFD_RELOC_IA64_LTOFF_DTPREL22; break;
 	default:
 	  type = "LTOFF_DTPREL"; break;
 	}
@@ -11462,12 +11305,17 @@ ia64_gen_real_reloc_type (sym, r_type)
 	}
       break;
 
+#ifdef TE_VMS
+    case FUNC_SLOTCOUNT_RELOC:
+      return DUMMY_RELOC_IA64_SLOTCOUNT;
+#endif
+
     default:
       abort ();
     }
 
-  if (new)
-    return new;
+  if (newr)
+    return newr;
   else
     {
       int width;
@@ -11497,8 +11345,7 @@ ia64_gen_real_reloc_type (sym, r_type)
 /* Here is where generate the appropriate reloc for pseudo relocation
    functions.  */
 void
-ia64_validate_fix (fix)
-     fixS *fix;
+ia64_validate_fix (fixS *fix)
 {
   switch (fix->fx_r_type)
     {
@@ -11517,10 +11364,7 @@ ia64_validate_fix (fix)
 }
 
 static void
-fix_insn (fix, odesc, value)
-     fixS *fix;
-     const struct ia64_operand *odesc;
-     valueT value;
+fix_insn (fixS *fix, const struct ia64_operand *odesc, valueT value)
 {
   bfd_vma insn[3], t0, t1, control_bits;
   const char *err;
@@ -11551,7 +11395,7 @@ fix_insn (fix, odesc, value)
   else if (odesc - elf64_ia64_operands == IA64_OPND_IMMU62)
     {
       if (value & ~0x3fffffffffffffffULL)
-	err = "integer operand out of range";
+	err = _("integer operand out of range");
       insn[1] = (value >> 21) & 0x1ffffffffffLL;
       insn[2] |= (((value & 0xfffff) << 6) | (((value >> 20) & 0x1) << 36));
     }
@@ -11566,7 +11410,7 @@ fix_insn (fix, odesc, value)
     err = (*odesc->insert) (odesc, value, insn + slot);
 
   if (err)
-    as_bad_where (fix->fx_file, fix->fx_line, err);
+    as_bad_where (fix->fx_file, fix->fx_line, "%s", err);
 
   t0 = control_bits | (insn[0] << 5) | (insn[1] << 46);
   t1 = ((insn[1] >> 18) & 0x7fffff) | (insn[2] << 23);
@@ -11582,10 +11426,7 @@ fix_insn (fix, odesc, value)
    (if possible).  */
 
 void
-md_apply_fix (fix, valP, seg)
-     fixS *fix;
-     valueT *valP;
-     segT seg ATTRIBUTE_UNUSED;
+md_apply_fix (fixS *fix, valueT *valP, segT seg ATTRIBUTE_UNUSED)
 {
   char *fixpos;
   valueT value = *valP;
@@ -11615,7 +11456,7 @@ md_apply_fix (fix, valP, seg)
     }
   if (fix->fx_addsy)
     {
-      switch (fix->fx_r_type)
+      switch ((unsigned) fix->fx_r_type)
 	{
 	case BFD_RELOC_UNUSED:
 	  /* This must be a TAG13 or TAG13b operand.  There are no external
@@ -11638,12 +11479,48 @@ md_apply_fix (fix, valP, seg)
 	  S_SET_THREAD_LOCAL (fix->fx_addsy);
 	  break;
 
+#ifdef TE_VMS
+        case DUMMY_RELOC_IA64_SLOTCOUNT:
+	  as_bad_where (fix->fx_file, fix->fx_line,
+			_("cannot resolve @slotcount parameter"));
+	  fix->fx_done = 1;
+	  return;
+#endif
+
 	default:
 	  break;
 	}
     }
   else if (fix->tc_fix_data.opnd == IA64_OPND_NIL)
     {
+#ifdef TE_VMS
+      if (fix->fx_r_type == DUMMY_RELOC_IA64_SLOTCOUNT)
+        {
+          /* For @slotcount, convert an addresses difference to a slots
+             difference.  */
+          valueT v;
+
+          v = (value >> 4) * 3;
+          switch (value & 0x0f)
+            {
+            case 0:
+            case 1:
+            case 2:
+              v += value & 0x0f;
+              break;
+            case 0x0f:
+              v += 2;
+              break;
+            case 0x0e:
+              v += 1;
+              break;
+            default:
+              as_bad (_("invalid @slotcount value"));
+            }
+          value = v;
+        }
+#endif
+
       if (fix->tc_fix_data.bigendian)
 	number_to_chars_bigendian (fixpos, value, fix->fx_size);
       else
@@ -11661,14 +11538,12 @@ md_apply_fix (fix, valP, seg)
    fixup used internally in the assembler.  */
 
 arelent *
-tc_gen_reloc (sec, fixp)
-     asection *sec ATTRIBUTE_UNUSED;
-     fixS *fixp;
+tc_gen_reloc (asection *sec ATTRIBUTE_UNUSED, fixS *fixp)
 {
   arelent *reloc;
 
-  reloc = xmalloc (sizeof (*reloc));
-  reloc->sym_ptr_ptr = (asymbol **) xmalloc (sizeof (asymbol *));
+  reloc = XNEW (arelent);
+  reloc->sym_ptr_ptr = XNEW (asymbol *);
   *reloc->sym_ptr_ptr = symbol_get_bfdsym (fixp->fx_addsy);
   reloc->address = fixp->fx_frag->fr_address + fixp->fx_where;
   reloc->addend = fixp->fx_offset;
@@ -11692,7 +11567,7 @@ tc_gen_reloc (sec, fixp)
 
 #define MAX_LITTLENUMS 5
 
-char *
+const char *
 md_atof (int type, char *lit, int *size)
 {
   LITTLENUM_TYPE words[MAX_LITTLENUMS];
@@ -11748,11 +11623,10 @@ md_atof (int type, char *lit, int *size)
 /* Handle ia64 specific semantics of the align directive.  */
 
 void
-ia64_md_do_align (n, fill, len, max)
-     int n ATTRIBUTE_UNUSED;
-     const char *fill ATTRIBUTE_UNUSED;
-     int len ATTRIBUTE_UNUSED;
-     int max ATTRIBUTE_UNUSED;
+ia64_md_do_align (int n ATTRIBUTE_UNUSED,
+		  const char *fill ATTRIBUTE_UNUSED,
+		  int len ATTRIBUTE_UNUSED,
+		  int max ATTRIBUTE_UNUSED)
 {
   if (subseg_text_p (now_seg))
     ia64_flush_insns ();
@@ -11762,23 +11636,22 @@ ia64_md_do_align (n, fill, len, max)
    of an rs_align_code fragment.  */
 
 void
-ia64_handle_align (fragp)
-     fragS *fragp;
+ia64_handle_align (fragS *fragp)
 {
   int bytes;
   char *p;
-  const unsigned char *nop;
+  const unsigned char *nop_type;
 
   if (fragp->fr_type != rs_align_code)
     return;
 
   /* Check if this frag has to end with a stop bit.  */
-  nop = fragp->tc_frag_data ? le_nop_stop : le_nop;
+  nop_type = fragp->tc_frag_data ? le_nop_stop : le_nop;
 
   bytes = fragp->fr_next->fr_address - fragp->fr_address - fragp->fr_fix;
   p = fragp->fr_literal + fragp->fr_fix;
 
-  /* If no paddings are needed, we check if we need a stop bit.  */ 
+  /* If no paddings are needed, we check if we need a stop bit.  */
   if (!bytes && fragp->tc_frag_data)
     {
       if (fragp->fr_fix < 16)
@@ -11810,7 +11683,7 @@ ia64_handle_align (fragp)
     }
 
   /* Instruction bundles are always little-endian.  */
-  memcpy (p, nop, 16);
+  memcpy (p, nop_type, 16);
   fragp->fr_var = 16;
 }
 
@@ -11839,7 +11712,7 @@ ia64_float_to_chars_littleendian (char *lit, LITTLENUM_TYPE *words,
 }
 
 void
-ia64_elf_section_change_hook  (void)
+ia64_elf_section_change_hook (void)
 {
   if (elf_section_type (now_seg) == SHT_IA_64_UNWIND
       && elf_linked_to_section (now_seg) == NULL)
@@ -11863,7 +11736,7 @@ ia64_check_label (symbolS *label)
    the relocatable file.  */
 struct alias
 {
-  char *file;		/* The file where the directive is seen.  */
+  const char *file;		/* The file where the directive is seen.  */
   unsigned int line;	/* The line number the directive is at.  */
   const char *name;	/* The original name of the symbol.  */
 };
@@ -11883,8 +11756,7 @@ dot_alias (int section)
   struct hash_control *ahash, *nhash;
   const char *kind;
 
-  name = input_line_pointer;
-  delim = get_symbol_end ();
+  delim = get_symbol_name (&name);
   end_name = input_line_pointer;
   *end_name = delim;
 
@@ -11895,7 +11767,7 @@ dot_alias (int section)
       return;
     }
 
-  SKIP_WHITESPACE ();
+  SKIP_WHITESPACE_AFTER_NAME ();
 
   if (*input_line_pointer != ',')
     {
@@ -11956,11 +11828,11 @@ dot_alias (int section)
       goto out;
     }
 
-  h = (struct alias *) xmalloc (sizeof (struct alias));
-  as_where (&h->file, &h->line);
+  h = XNEW (struct alias);
+  h->file = as_where (&h->line);
   h->name = name;
-  
-  error_string = hash_jam (ahash, alias, (PTR) h);
+
+  error_string = hash_jam (ahash, alias, (void *) h);
   if (error_string)
     {
       as_fatal (_("inserting \"%s\" into %s alias hash table failed: %s"),
@@ -11968,7 +11840,7 @@ dot_alias (int section)
       goto out;
     }
 
-  error_string = hash_jam (nhash, name, (PTR) alias);
+  error_string = hash_jam (nhash, name, (void *) alias);
   if (error_string)
     {
       as_fatal (_("inserting \"%s\" into %s name hash table failed: %s"),
@@ -11983,15 +11855,23 @@ out:
 
 /* It renames the original symbol name to its alias.  */
 static void
-do_alias (const char *alias, PTR value)
+do_alias (const char *alias, void *value)
 {
   struct alias *h = (struct alias *) value;
   symbolS *sym = symbol_find (h->name);
 
   if (sym == NULL)
-    as_warn_where (h->file, h->line,
-		   _("symbol `%s' aliased to `%s' is not used"),
-		   h->name, alias);
+    {
+#ifdef TE_VMS
+      /* Uses .alias extensively to alias CRTL functions to same with
+	 decc$ prefix. Sometimes function gets optimized away and a
+	 warning results, which should be suppressed.  */
+      if (strncmp (alias, "decc$", 5) != 0)
+#endif
+	as_warn_where (h->file, h->line,
+		       _("symbol `%s' aliased to `%s' is not used"),
+		       h->name, alias);
+    }
     else
       S_SET_NAME (sym, (char *) alias);
 }
@@ -12005,7 +11885,7 @@ ia64_adjust_symtab (void)
 
 /* It renames the original section name to its alias.  */
 static void
-do_secalias (const char *alias, PTR value)
+do_secalias (const char *alias, void *value)
 {
   struct alias *h = (struct alias *) value;
   segT sec = bfd_get_section_by_name (stdoutput, h->name);
@@ -12024,3 +11904,117 @@ ia64_frob_file (void)
 {
   hash_traverse (secalias_hash, do_secalias);
 }
+
+#ifdef TE_VMS
+#define NT_VMS_MHD 1
+#define NT_VMS_LNM 2
+
+/* Integrity VMS 8.x identifies it's ELF modules with a standard ELF
+   .note section.  */
+
+/* Manufacture a VMS-like time string.  */
+static void
+get_vms_time (char *Now)
+{
+  char *pnt;
+  time_t timeb;
+
+  time (&timeb);
+  pnt = ctime (&timeb);
+  pnt[3] = 0;
+  pnt[7] = 0;
+  pnt[10] = 0;
+  pnt[16] = 0;
+  pnt[24] = 0;
+  sprintf (Now, "%2s-%3s-%s %s", pnt + 8, pnt + 4, pnt + 20, pnt + 11);
+}
+
+void
+ia64_vms_note (void)
+{
+  char *p;
+  asection *seg = now_seg;
+  subsegT subseg = now_subseg;
+  asection *secp = NULL;
+  char *bname;
+  char buf [256];
+  symbolS *sym;
+
+  /* Create the .note section.  */
+
+  secp = subseg_new (".note", 0);
+  bfd_set_section_flags (stdoutput,
+			 secp,
+			 SEC_HAS_CONTENTS | SEC_READONLY);
+
+  /* Module header note (MHD).  */
+  bname = xstrdup (lbasename (out_file_name));
+  if ((p = strrchr (bname, '.')))
+    *p = '\0';
+
+  /* VMS note header is 24 bytes long.  */
+  p = frag_more (8 + 8 + 8);
+  number_to_chars_littleendian (p + 0, 8, 8);
+  number_to_chars_littleendian (p + 8, 40 + strlen (bname), 8);
+  number_to_chars_littleendian (p + 16, NT_VMS_MHD, 8);
+
+  p = frag_more (8);
+  strcpy (p, "IPF/VMS");
+
+  p = frag_more (17 + 17 + strlen (bname) + 1 + 5);
+  get_vms_time (p);
+  strcpy (p + 17, "24-FEB-2005 15:00");
+  p += 17 + 17;
+  strcpy (p, bname);
+  p += strlen (bname) + 1;
+  free (bname);
+  strcpy (p, "V1.0");
+
+  frag_align (3, 0, 0);
+
+  /* Language processor name note.  */
+  sprintf (buf, "GNU assembler version %s (%s) using BFD version %s",
+	   VERSION, TARGET_ALIAS, BFD_VERSION_STRING);
+
+  p = frag_more (8 + 8 + 8);
+  number_to_chars_littleendian (p + 0, 8, 8);
+  number_to_chars_littleendian (p + 8, strlen (buf) + 1, 8);
+  number_to_chars_littleendian (p + 16, NT_VMS_LNM, 8);
+
+  p = frag_more (8);
+  strcpy (p, "IPF/VMS");
+
+  p = frag_more (strlen (buf) + 1);
+  strcpy (p, buf);
+
+  frag_align (3, 0, 0);
+
+  secp = subseg_new (".vms_display_name_info", 0);
+  bfd_set_section_flags (stdoutput,
+			 secp,
+			 SEC_HAS_CONTENTS | SEC_READONLY);
+
+  /* This symbol should be passed on the command line and be variable
+     according to language.  */
+  sym = symbol_new ("__gnat_vms_display_name@gnat_demangler_rtl",
+		    absolute_section, 0, &zero_address_frag);
+  symbol_table_insert (sym);
+  symbol_get_bfdsym (sym)->flags |= BSF_DEBUGGING | BSF_DYNAMIC;
+
+  p = frag_more (4);
+  /* Format 3 of VMS demangler Spec.  */
+  number_to_chars_littleendian (p, 3, 4);
+
+  p = frag_more (4);
+  /* Place holder for symbol table index of above symbol.  */
+  number_to_chars_littleendian (p, -1, 4);
+
+  frag_align (3, 0, 0);
+
+  /* We probably can't restore the current segment, for there likely
+     isn't one yet...  */
+  if (seg && subseg)
+    subseg_set (seg, subseg);
+}
+
+#endif /* TE_VMS */