projects / deliverable / binutils-gdb.git / blobdiff
? search:
summary | shortlog | log | commit | commitdiff | tree
raw | inline | side by side
tic54x: rename typedef of struct symbol_
[deliverable/binutils-gdb.git] / gas / config / tc-ia64.c
diff --git a/gas/config/tc-ia64.c b/gas/config/tc-ia64.c
index 5da30987bea461ee35af1a0947c0629e79b6ddc5..c0eb593f02b11422eaba4561d281169fd147d6f4 100644 (file)
--- a/gas/config/tc-ia64.c
+++ b/gas/config/tc-ia64.c
@@ -1,13 +1,12 @@
 /* tc-ia64.c -- Assembler for the HP/Intel IA-64 architecture.
 /* tc-ia64.c -- Assembler for the HP/Intel IA-64 architecture.
-   Copyright 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005
-   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.
 
    GAS is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    Contributed by David Mosberger-Tang <davidm@hpl.hp.com>
 
    This file is part of GAS, the GNU Assembler.
 
    GAS is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
-   the Free Software Foundation; either version 2, or (at your option)
+   the Free Software Foundation; either version 3, or (at your option)
    any later version.
 
    GAS is distributed in the hope that it will be useful,
    any later version.
 
    GAS is distributed in the hope that it will be useful,
@@ -50,6 +49,8 @@
 #include "opcode/ia64.h"
 
 #include "elf/ia64.h"
 #include "opcode/ia64.h"
 
 #include "elf/ia64.h"
+#include "bfdver.h"
+#include <time.h>
 
 #ifdef HAVE_LIMITS_H
 #include <limits.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,
     FUNC_LT_DTP_RELATIVE,
     FUNC_LT_TP_RELATIVE,
     FUNC_IPLT_RELOC,
+#ifdef TE_VMS
+    FUNC_SLOTCOUNT_RELOC,
+#endif
   };
 
 enum reg_symbol
   };
 
 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_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,
     REG_BR     = (REG_P  + 64),
     REG_IP     = (REG_BR + 8),
     REG_CFM,
@@ -124,11 +129,11 @@ enum reg_symbol
     IND_DTR,
     IND_ITR,
     IND_IBR,
     IND_DTR,
     IND_ITR,
     IND_IBR,
-    IND_MEM,
     IND_MSR,
     IND_PKR,
     IND_PMC,
     IND_PMD,
     IND_MSR,
     IND_PKR,
     IND_PMC,
     IND_PMD,
+    IND_DAHR,
     IND_RR,
     /* The following pseudo-registers are used for unwind directives only:  */
     REG_PSP,
     IND_RR,
     /* The following pseudo-registers are used for unwind directives only:  */
     REG_PSP,
@@ -162,20 +167,23 @@ struct label_fix
   bfd_boolean dw2_mark_labels;
 };
 
   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;
 
 /* 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 (char *, LITTLENUM_TYPE *, int);
+static void ia64_float_to_chars_littleendian (char *, LITTLENUM_TYPE *, 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) (char *, LITTLENUM_TYPE *, int);
 
 static struct hash_control *alias_hash;
 static struct hash_control *alias_name_hash;
 
 static struct hash_control *alias_hash;
 static struct hash_control *alias_name_hash;
@@ -226,11 +234,9 @@ static struct
     struct hash_control *const_hash;   /* constant hash table */
     struct hash_control *entry_hash;    /* code entry hint hash table */
 
     struct hash_control *const_hash;   /* constant hash table */
     struct hash_control *entry_hash;    /* code entry hint hash table */
 
-    symbolS *regsym[REG_NUM];
-
     /* If X_op is != O_absent, the registername for the instruction's
        qualifying predicate.  If NULL, p0 is assumed for instructions
     /* If X_op is != O_absent, the registername for the instruction's
        qualifying predicate.  If NULL, p0 is assumed for instructions
-       that are predicatable.  */
+       that are predictable.  */
     expressionS qp;
 
     /* Optimize for which CPU.  */
     expressionS qp;
 
     /* Optimize for which CPU.  */
@@ -296,7 +302,7 @@ static struct
        struct label_fix *tag_fixups;
        struct unw_rec_list *unwind_record;     /* Unwind directive.  */
        expressionS opnd[6];
        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;
       }
        unsigned int src_line;
        struct dwarf2_line_info debug_line;
       }
@@ -329,6 +335,8 @@ static struct
 
     int pointer_size;       /* size in bytes of a pointer */
     int pointer_size_shift; /* shift size of a pointer for alignment */
 
     int pointer_size;       /* size in bytes of a pointer */
     int pointer_size_shift; /* shift size of a pointer for alignment */
+
+    symbolS *indregsym[IND_RR - IND_CPUID + 1];
   }
 md;
 
   }
 md;
 
@@ -355,33 +363,53 @@ static unsigned char le_nop_stop[16] =
 #define AR_BSP         17
 #define AR_BSPSTORE    18
 #define AR_RNAT                19
 #define AR_BSP         17
 #define AR_BSPSTORE    18
 #define AR_RNAT                19
+#define AR_FCR         21
+#define AR_EFLAG       24
+#define AR_CSD         25
+#define AR_SSD         26
+#define AR_CFLG                27
+#define AR_FSR         28
+#define AR_FIR         29
+#define AR_FDR         30
+#define AR_CCV         32
 #define AR_UNAT                36
 #define AR_FPSR                40
 #define AR_ITC         44
 #define AR_UNAT                36
 #define AR_FPSR                40
 #define AR_ITC         44
+#define AR_RUC         45
 #define AR_PFS         64
 #define AR_LC          65
 #define AR_PFS         64
 #define AR_LC          65
+#define AR_EC          66
 
 static const struct
   {
     const char *name;
 
 static const struct
   {
     const char *name;
-    int regnum;
+    unsigned int regnum;
   }
 ar[] =
   {
   }
 ar[] =
   {
-    {"ar.k0", 0}, {"ar.k1", 1}, {"ar.k2", 2}, {"ar.k3", 3},
-    {"ar.k4", 4}, {"ar.k5", 5}, {"ar.k6", 6}, {"ar.k7", 7},
-    {"ar.rsc",         16}, {"ar.bsp",         17},
-    {"ar.bspstore",    18}, {"ar.rnat",        19},
-    {"ar.fcr",         21}, {"ar.eflag",       24},
-    {"ar.csd",         25}, {"ar.ssd",         26},
-    {"ar.cflg",                27}, {"ar.fsr",         28},
-    {"ar.fir",         29}, {"ar.fdr",         30},
-    {"ar.ccv",         32}, {"ar.unat",        36},
-    {"ar.fpsr",                40}, {"ar.itc",         44},
-    {"ar.pfs",         64}, {"ar.lc",          65},
-    {"ar.ec",          66},
+    {"ar.k0",          AR_K0},         {"ar.k1",       AR_K0 + 1},
+    {"ar.k2",          AR_K0 + 2},     {"ar.k3",       AR_K0 + 3},
+    {"ar.k4",          AR_K0 + 4},     {"ar.k5",       AR_K0 + 5},
+    {"ar.k6",          AR_K0 + 6},     {"ar.k7",       AR_K7},
+    {"ar.rsc",         AR_RSC},        {"ar.bsp",      AR_BSP},
+    {"ar.bspstore",    AR_BSPSTORE},   {"ar.rnat",     AR_RNAT},
+    {"ar.fcr",         AR_FCR},        {"ar.eflag",    AR_EFLAG},
+    {"ar.csd",         AR_CSD},        {"ar.ssd",      AR_SSD},
+    {"ar.cflg",                AR_CFLG},       {"ar.fsr",      AR_FSR},
+    {"ar.fir",         AR_FIR},        {"ar.fdr",      AR_FDR},
+    {"ar.ccv",         AR_CCV},        {"ar.unat",     AR_UNAT},
+    {"ar.fpsr",                AR_FPSR},       {"ar.itc",      AR_ITC},
+    {"ar.ruc",         AR_RUC},        {"ar.pfs",      AR_PFS},
+    {"ar.lc",          AR_LC},         {"ar.ec",       AR_EC},
   };
 
   };
 
+/* control registers:  */
+
+#define CR_DCR           0
+#define CR_ITM           1
+#define CR_IVA           2
+#define CR_PTA           8
+#define CR_GPTA          9
 #define CR_IPSR         16
 #define CR_ISR          17
 #define CR_IIP          19
 #define CR_IPSR         16
 #define CR_ISR          17
 #define CR_IIP          19
@@ -391,49 +419,56 @@ ar[] =
 #define CR_IFS          23
 #define CR_IIM          24
 #define CR_IHA          25
 #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
 #define CR_EOI          67
 #define CR_IRR0         68
 #define CR_IRR3         71
 #define CR_IVR          65
 #define CR_TPR          66
 #define CR_EOI          67
 #define CR_IRR0         68
 #define CR_IRR3         71
+#define CR_ITV          72
+#define CR_PMV          73
+#define CR_CMCV         74
 #define CR_LRR0         80
 #define CR_LRR1         81
 
 #define CR_LRR0         80
 #define CR_LRR1         81
 
-/* control registers:  */
 static const struct
   {
     const char *name;
 static const struct
   {
     const char *name;
-    int regnum;
+    unsigned int regnum;
   }
 cr[] =
   {
   }
 cr[] =
   {
-    {"cr.dcr",  0},
-    {"cr.itm",  1},
-    {"cr.iva",  2},
-    {"cr.pta",  8},
-    {"cr.gpta",         9},
-    {"cr.ipsr",        16},
-    {"cr.isr", 17},
-    {"cr.iip", 19},
-    {"cr.ifa", 20},
-    {"cr.itir",        21},
-    {"cr.iipa",        22},
-    {"cr.ifs", 23},
-    {"cr.iim", 24},
-    {"cr.iha", 25},
-    {"cr.lid", 64},
-    {"cr.ivr", 65},
-    {"cr.tpr", 66},
-    {"cr.eoi", 67},
-    {"cr.irr0",        68},
-    {"cr.irr1",        69},
-    {"cr.irr2",        70},
-    {"cr.irr3",        71},
-    {"cr.itv", 72},
-    {"cr.pmv", 73},
-    {"cr.cmcv",        74},
-    {"cr.lrr0",        80},
-    {"cr.lrr1",        81}
+    {"cr.dcr", CR_DCR},
+    {"cr.itm", CR_ITM},
+    {"cr.iva", CR_IVA},
+    {"cr.pta", CR_PTA},
+    {"cr.gpta",        CR_GPTA},
+    {"cr.ipsr",        CR_IPSR},
+    {"cr.isr", CR_ISR},
+    {"cr.iip", CR_IIP},
+    {"cr.ifa", CR_IFA},
+    {"cr.itir",        CR_ITIR},
+    {"cr.iipa",        CR_IIPA},
+    {"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},
+    {"cr.eoi", CR_EOI},
+    {"cr.irr0",        CR_IRR0},
+    {"cr.irr1",        CR_IRR0 + 1},
+    {"cr.irr2",        CR_IRR0 + 2},
+    {"cr.irr3",        CR_IRR3},
+    {"cr.itv", CR_ITV},
+    {"cr.pmv", CR_PMV},
+    {"cr.cmcv",        CR_CMCV},
+    {"cr.lrr0",        CR_LRR0},
+    {"cr.lrr1",        CR_LRR1}
   };
 
 #define PSR_MFL         4
   };
 
 #define PSR_MFL         4
@@ -491,7 +526,7 @@ const_bits[] =
 static const struct
   {
     const char *name;
 static const struct
   {
     const char *name;
-    int regnum;
+    unsigned int regnum;
   }
 indirect_reg[] =
   {
   }
 indirect_reg[] =
   {
@@ -505,6 +540,7 @@ indirect_reg[] =
     { "pkr",   IND_PKR },
     { "pmc",   IND_PMC },
     { "pmd",   IND_PMD },
     { "pkr",   IND_PKR },
     { "pmc",   IND_PMC },
     { "pmd",   IND_PMD },
+    { "dahr",  IND_DAHR },
     { "rr",    IND_RR },
   };
 
     { "rr",    IND_RR },
   };
 
@@ -549,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 } },
     { 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 } },
 
     /* mbtype4 constants:  */
     { "alt",   PSEUDO_FUNC_CONST, { 0xa } },
@@ -572,12 +611,18 @@ pseudo_func[] =
 
     /* hint constants: */
     { "pause", PSEUDO_FUNC_CONST, { 0x0 } },
 
     /* 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 */
 
     /* 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 } },
     { "freebsd", PSEUDO_FUNC_CONST,    { ELFOSABI_FREEBSD } },
     { "openvms", PSEUDO_FUNC_CONST,    { ELFOSABI_OPENVMS } },
     { "nsk",   PSEUDO_FUNC_CONST,      { ELFOSABI_NSK } },
@@ -627,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 */
   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? */
   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? */
@@ -722,7 +767,7 @@ static struct
   unw_rec_list *list;
   unw_rec_list *tail;
 
   unw_rec_list *list;
   unw_rec_list *tail;
 
-  /* Any unwind entires that should be attached to the current slot
+  /* Any unwind entries that should be attached to the current slot
      that an insn is being constructed for.  */
   unw_rec_list *current_entry;
 
      that an insn is being constructed for.  */
   unw_rec_list *current_entry;
 
@@ -754,211 +799,26 @@ static struct
 
 #define ENCODED_PSP_OFFSET(OFFSET) (((OFFSET) + 16) / 4)
 
 
 #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:  */
 
 /* 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, int regnum));
-static void declare_register_set PARAMS ((const char *, int, 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).  */
 
 /* Determine if application register REGNUM resides only in the integer
    unit (as opposed to the memory unit).  */
@@ -969,7 +829,7 @@ ar_is_only_in_integer_unit (int reg)
   return reg >= 64 && reg <= 111;
 }
 
   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)
    unit (as opposed to the integer unit).  */
 static int
 ar_is_only_in_memory_unit (int reg)
@@ -983,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
    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;
 
 {
   char *saved_input_line_pointer;
 
@@ -996,26 +855,30 @@ set_section (name)
 
 /* Map 's' to SHF_IA_64_SHORT.  */
 
 
 /* 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;
 {
   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
   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;
 {
   if (attr & SHF_IA_64_SHORT)
     flags |= SEC_SMALL_DATA;
@@ -1023,9 +886,7 @@ ia64_elf_section_flags (flags, attr, type)
 }
 
 int
 }
 
 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))
 
 {
 #define STREQ(s) ((len == sizeof (s) - 1) && (strncmp (str, s, sizeof (s) - 1) == 0))
 
@@ -1049,8 +910,10 @@ ia64_elf_section_type (str, len)
 }
 
 static unsigned int
 }
 
 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;
 {
   /* Size of frame.  */
   unsigned int sof;
@@ -1058,12 +921,12 @@ set_regstack (ins, locs, outs, rots)
   sof = ins + locs + outs;
   if (sof > 96)
     {
   sof = ins + locs + outs;
   if (sof > 96)
     {
-      as_bad ("Size of frame exceeds maximum of 96 registers");
+      as_bad (_("Size of frame exceeds maximum of 96 registers"));
       return 0;
     }
   if (rots > sof)
     {
       return 0;
     }
   if (rots > sof)
     {
-      as_warn ("Size of rotating registers exceeds frame size");
+      as_warn (_("Size of rotating registers exceeds frame size"));
       return 0;
     }
   md.in.base = REG_GR + 32;
       return 0;
     }
   md.in.base = REG_GR + 32;
@@ -1078,7 +941,7 @@ set_regstack (ins, locs, outs, rots)
 }
 
 void
 }
 
 void
-ia64_flush_insns ()
+ia64_flush_insns (void)
 {
   struct label_fix *lfix;
   segT saved_seg;
 {
   struct label_fix *lfix;
   segT saved_seg;
@@ -1110,6 +973,7 @@ ia64_flush_insns ()
       dwarf2_where (&CURR_SLOT.debug_line);
       CURR_SLOT.debug_line.flags |= DWARF2_FLAG_BASIC_BLOCK;
       dwarf2_gen_line_info (frag_now_fix (), &CURR_SLOT.debug_line);
       dwarf2_where (&CURR_SLOT.debug_line);
       CURR_SLOT.debug_line.flags |= DWARF2_FLAG_BASIC_BLOCK;
       dwarf2_gen_line_info (frag_now_fix (), &CURR_SLOT.debug_line);
+      dwarf2_consume_line_info ();
     }
   CURR_SLOT.label_fixups = 0;
 
     }
   CURR_SLOT.label_fixups = 0;
 
@@ -1158,40 +1022,161 @@ ia64_flush_insns ()
   subseg_set (saved_seg, saved_subseg);
 
   if (md.qp.X_op == O_register)
   subseg_set (saved_seg, saved_subseg);
 
   if (md.qp.X_op == O_register)
-    as_bad ("qualifying predicate not followed by instruction");
+    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 == ',')
     {
     {
-      char *saved_input_line_pointer = input_line_pointer;
-      input_line_pointer = "";
-      s_align_bytes (nbytes);
-      input_line_pointer = saved_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 *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;
 
 /* 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)
 {
   int x;
   if (vbyte_mem_ptr == NULL)
@@ -1205,20 +1190,16 @@ output_vbyte_mem (count, ptr, comment)
 
 /* Count the number of bytes required for records.  */
 static int vbyte_count = 0;
 
 /* 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
 {
   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;
 {
   int r = 0;
   char byte;
@@ -1231,17 +1212,14 @@ output_R1_format (f, rtype, rlen)
   if (rtype == body)
     r = 1;
   else if (rtype != prologue)
   if (rtype == body)
     r = 1;
   else if (rtype != prologue)
-    as_bad ("record type is not valid");
+    as_bad (_("record type is not valid"));
 
   byte = UNW_R1 | (r << 5) | (rlen & 0x1f);
   (*f) (1, &byte, NULL);
 }
 
 static void
 
   byte = UNW_R1 | (r << 5) | (rlen & 0x1f);
   (*f) (1, &byte, NULL);
 }
 
 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;
 {
   char bytes[20];
   int count = 2;
@@ -1255,10 +1233,7 @@ output_R2_format (f, mask, grsave, rlen)
 }
 
 static void
 }
 
 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];
 {
   int r = 0, count;
   char bytes[20];
@@ -1271,16 +1246,14 @@ output_R3_format (f, rtype, rlen)
   if (rtype == body)
     r = 1;
   else if (rtype != prologue)
   if (rtype == body)
     r = 1;
   else if (rtype != prologue)
-    as_bad ("record type is not valid");
+    as_bad (_("record type is not valid"));
   bytes[0] = (UNW_R3 | r);
   count = output_leb128 (bytes + 1, rlen, 0);
   (*f) (count + 1, bytes, NULL);
 }
 
 static void
   bytes[0] = (UNW_R3 | r);
   count = output_leb128 (bytes + 1, rlen, 0);
   (*f) (count + 1, bytes, NULL);
 }
 
 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);
 {
   char byte;
   byte = UNW_P1 | (brmask & 0x1f);
@@ -1288,10 +1261,7 @@ output_P1_format (f, brmask)
 }
 
 static void
 }
 
 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);
 {
   char bytes[2];
   brmask = (brmask & 0x1f);
@@ -1301,10 +1271,7 @@ output_P2_format (f, brmask, gr)
 }
 
 static void
 }
 
 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;
 {
   char bytes[2];
   int r = 0;
@@ -1348,7 +1315,7 @@ output_P3_format (f, rtype, reg)
       r = 11;
       break;
     default:
       r = 11;
       break;
     default:
-      as_bad ("Invalid record type for P3 format.");
+      as_bad (_("Invalid record type for P3 format."));
     }
   bytes[0] = (UNW_P3 | (r >> 1));
   bytes[1] = (((r & 1) << 7) | reg);
     }
   bytes[0] = (UNW_P3 | (r >> 1));
   bytes[1] = (((r & 1) << 7) | reg);
@@ -1356,20 +1323,14 @@ output_P3_format (f, rtype, reg)
 }
 
 static void
 }
 
 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
 {
   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);
 {
   char bytes[4];
   grmask = (grmask & 0x0f);
@@ -1382,10 +1343,7 @@ output_P5_format (f, grmask, frmask)
 }
 
 static void
 }
 
 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;
 {
   char byte;
   int r = 0;
@@ -1393,17 +1351,16 @@ output_P6_format (f, rtype, rmask)
   if (rtype == gr_mem)
     r = 1;
   else if (rtype != fr_mem)
   if (rtype == gr_mem)
     r = 1;
   else if (rtype != fr_mem)
-    as_bad ("Invalid record type for format P6");
+    as_bad (_("Invalid record type for format P6"));
   byte = (UNW_P6 | (r << 4) | (rmask & 0x0f));
   (*f) (1, &byte, NULL);
 }
 
 static void
   byte = (UNW_P6 | (r << 4) | (rmask & 0x0f));
   (*f) (1, &byte, NULL);
 }
 
 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;
 {
   char bytes[20];
   int count = 1;
@@ -1468,10 +1425,7 @@ output_P7_format (f, rtype, w1, w2)
 }
 
 static void
 }
 
 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;
 {
   char bytes[20];
   int r = 0;
@@ -1545,10 +1499,7 @@ output_P8_format (f, rtype, t)
 }
 
 static void
 }
 
 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;
 {
   char bytes[3];
   bytes[0] = UNW_P9;
@@ -1558,10 +1509,7 @@ output_P9_format (f, grmask, gr)
 }
 
 static void
 }
 
 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;
 {
   char bytes[3];
   bytes[0] = UNW_P10;
@@ -1571,10 +1519,7 @@ output_P10_format (f, abi, context)
 }
 
 static void
 }
 
 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;
 {
   char byte;
   int r = 0;
@@ -1586,17 +1531,14 @@ output_B1_format (f, rtype, label)
   if (rtype == copy_state)
     r = 1;
   else if (rtype != label_state)
   if (rtype == copy_state)
     r = 1;
   else if (rtype != label_state)
-    as_bad ("Invalid record type for format B1");
+    as_bad (_("Invalid record type for format B1"));
 
   byte = (UNW_B1 | (r << 5) | (label & 0x1f));
   (*f) (1, &byte, NULL);
 }
 
 static void
 
   byte = (UNW_B1 | (r << 5) | (label & 0x1f));
   (*f) (1, &byte, NULL);
 }
 
 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;
 {
   char bytes[20];
   int count = 1;
@@ -1611,10 +1553,7 @@ output_B2_format (f, ecount, t)
 }
 
 static void
 }
 
 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;
 {
   char bytes[20];
   int count = 1;
@@ -1630,10 +1569,7 @@ output_B3_format (f, ecount, t)
 }
 
 static void
 }
 
 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;
 {
   char bytes[20];
   int r = 0;
@@ -1647,7 +1583,7 @@ output_B4_format (f, rtype, label)
   if (rtype == copy_state)
     r = 1;
   else if (rtype != label_state)
   if (rtype == copy_state)
     r = 1;
   else if (rtype != label_state)
-    as_bad ("Invalid record type for format B1");
+    as_bad (_("Invalid record type for format B1"));
 
   bytes[0] = (UNW_B4 | (r << 3));
   count += output_leb128 (bytes + 1, label, 0);
 
   bytes[0] = (UNW_B4 | (r << 3));
   count += output_leb128 (bytes + 1, label, 0);
@@ -1655,9 +1591,7 @@ output_B4_format (f, rtype, label)
 }
 
 static char
 }
 
 static char
-format_ab_reg (ab, reg)
-     int ab;
-     int reg;
+format_ab_reg (int ab, int reg)
 {
   int ret;
   ab = (ab & 3);
 {
   int ret;
   ab = (ab & 3);
@@ -1667,12 +1601,12 @@ format_ab_reg (ab, reg)
 }
 
 static void
 }
 
 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;
 {
   char bytes[20];
   int r = 0;
@@ -1682,7 +1616,7 @@ output_X1_format (f, rtype, ab, reg, t, w1)
   if (rtype == spill_sprel)
     r = 1;
   else if (rtype != spill_psprel)
   if (rtype == spill_sprel)
     r = 1;
   else if (rtype != spill_psprel)
-    as_bad ("Invalid record type for format X1");
+    as_bad (_("Invalid record type for format X1"));
   bytes[1] = ((r << 7) | format_ab_reg (ab, reg));
   count += output_leb128 (bytes + 2, t, 0);
   count += output_leb128 (bytes + count, w1, 0);
   bytes[1] = ((r << 7) | format_ab_reg (ab, reg));
   count += output_leb128 (bytes + 2, t, 0);
   count += output_leb128 (bytes + count, w1, 0);
@@ -1690,11 +1624,13 @@ output_X1_format (f, rtype, ab, reg, t, w1)
 }
 
 static void
 }
 
 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;
 {
   char bytes[20];
   int count = 3;
@@ -1706,13 +1642,13 @@ output_X2_format (f, ab, reg, x, y, treg, t)
 }
 
 static void
 }
 
 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;
 {
   char bytes[20];
   int r = 0;
@@ -1722,7 +1658,7 @@ output_X3_format (f, rtype, qp, ab, reg, t, w1)
   if (rtype == spill_sprel_p)
     r = 1;
   else if (rtype != spill_psprel_p)
   if (rtype == spill_sprel_p)
     r = 1;
   else if (rtype != spill_psprel_p)
-    as_bad ("Invalid record type for format X3");
+    as_bad (_("Invalid record type for format X3"));
   bytes[1] = ((r << 7) | (qp & 0x3f));
   bytes[2] = format_ab_reg (ab, reg);
   count += output_leb128 (bytes + 3, t, 0);
   bytes[1] = ((r << 7) | (qp & 0x3f));
   bytes[2] = format_ab_reg (ab, reg);
   count += output_leb128 (bytes + 3, t, 0);
@@ -1731,12 +1667,14 @@ output_X3_format (f, rtype, qp, ab, reg, t, w1)
 }
 
 static void
 }
 
 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;
 {
   char bytes[20];
   int count = 4;
@@ -1758,7 +1696,7 @@ check_pending_save (void)
     {
       unw_rec_list *cur, *prev;
 
     {
       unw_rec_list *cur, *prev;
 
-      as_warn ("Previous .save incomplete");
+      as_warn (_("Previous .save incomplete"));
       for (cur = unwind.list, prev = NULL; cur; )
        if (&cur->r.record.p == unwind.pending_saves)
          {
       for (cur = unwind.list, prev = NULL; cur; )
        if (&cur->r.record.p == unwind.pending_saves)
          {
@@ -1803,7 +1741,7 @@ static unw_rec_list *
 alloc_record (unw_record_type t)
 {
   unw_rec_list *ptr;
 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;
   memset (ptr, 0, sizeof (*ptr));
   ptr->slot_number = SLOT_NUM_NOT_SET;
   ptr->r.type = t;
@@ -1814,14 +1752,14 @@ alloc_record (unw_record_type t)
    body region.  */
 
 static unw_rec_list *
    body region.  */
 
 static unw_rec_list *
-output_endp ()
+output_endp (void)
 {
   unw_rec_list *ptr = alloc_record (endp);
   return ptr;
 }
 
 static unw_rec_list *
 {
   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));
 {
   unw_rec_list *ptr = alloc_record (prologue);
   memset (&ptr->r.record.r.mask, 0, sizeof (ptr->r.record.r.mask));
@@ -1829,9 +1767,7 @@ output_prologue ()
 }
 
 static unw_rec_list *
 }
 
 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));
 {
   unw_rec_list *ptr = alloc_record (prologue_gr);
   memset (&ptr->r.record.r.mask, 0, sizeof (ptr->r.record.r.mask));
@@ -1841,15 +1777,14 @@ output_prologue_gr (saved_mask, reg)
 }
 
 static unw_rec_list *
 }
 
 static unw_rec_list *
-output_body ()
+output_body (void)
 {
   unw_rec_list *ptr = alloc_record (body);
   return ptr;
 }
 
 static unw_rec_list *
 {
   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;
 {
   unw_rec_list *ptr = alloc_record (mem_stack_f);
   ptr->r.record.p.size = size;
@@ -1857,15 +1792,14 @@ output_mem_stack_f (size)
 }
 
 static unw_rec_list *
 }
 
 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 *
 {
   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;
 {
   unw_rec_list *ptr = alloc_record (psp_gr);
   ptr->r.record.p.r.gr = gr;
@@ -1873,8 +1807,7 @@ output_psp_gr (gr)
 }
 
 static unw_rec_list *
 }
 
 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;
 {
   unw_rec_list *ptr = alloc_record (psp_sprel);
   ptr->r.record.p.off.sp = offset / 4;
@@ -1882,15 +1815,14 @@ output_psp_sprel (offset)
 }
 
 static unw_rec_list *
 }
 
 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 *
 {
   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;
 {
   unw_rec_list *ptr = alloc_record (rp_gr);
   ptr->r.record.p.r.gr = gr;
@@ -1898,8 +1830,7 @@ output_rp_gr (gr)
 }
 
 static unw_rec_list *
 }
 
 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;
 {
   unw_rec_list *ptr = alloc_record (rp_br);
   ptr->r.record.p.r.br = br;
@@ -1907,8 +1838,7 @@ output_rp_br (br)
 }
 
 static unw_rec_list *
 }
 
 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);
 {
   unw_rec_list *ptr = alloc_record (rp_psprel);
   ptr->r.record.p.off.psp = ENCODED_PSP_OFFSET (offset);
@@ -1916,8 +1846,7 @@ output_rp_psprel (offset)
 }
 
 static unw_rec_list *
 }
 
 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;
 {
   unw_rec_list *ptr = alloc_record (rp_sprel);
   ptr->r.record.p.off.sp = offset / 4;
@@ -1925,15 +1854,14 @@ output_rp_sprel (offset)
 }
 
 static unw_rec_list *
 }
 
 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 *
 {
   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;
 {
   unw_rec_list *ptr = alloc_record (pfs_gr);
   ptr->r.record.p.r.gr = gr;
@@ -1941,8 +1869,7 @@ output_pfs_gr (gr)
 }
 
 static unw_rec_list *
 }
 
 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);
 {
   unw_rec_list *ptr = alloc_record (pfs_psprel);
   ptr->r.record.p.off.psp = ENCODED_PSP_OFFSET (offset);
@@ -1950,8 +1877,7 @@ output_pfs_psprel (offset)
 }
 
 static unw_rec_list *
 }
 
 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;
 {
   unw_rec_list *ptr = alloc_record (pfs_sprel);
   ptr->r.record.p.off.sp = offset / 4;
@@ -1959,15 +1885,14 @@ output_pfs_sprel (offset)
 }
 
 static unw_rec_list *
 }
 
 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 *
 {
   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;
 {
   unw_rec_list *ptr = alloc_record (preds_gr);
   ptr->r.record.p.r.gr = gr;
@@ -1975,8 +1900,7 @@ output_preds_gr (gr)
 }
 
 static unw_rec_list *
 }
 
 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);
 {
   unw_rec_list *ptr = alloc_record (preds_psprel);
   ptr->r.record.p.off.psp = ENCODED_PSP_OFFSET (offset);
@@ -1984,8 +1908,7 @@ output_preds_psprel (offset)
 }
 
 static unw_rec_list *
 }
 
 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;
 {
   unw_rec_list *ptr = alloc_record (preds_sprel);
   ptr->r.record.p.off.sp = offset / 4;
@@ -1993,8 +1916,7 @@ output_preds_sprel (offset)
 }
 
 static unw_rec_list *
 }
 
 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;
 {
   unw_rec_list *ptr = alloc_record (fr_mem);
   unw_rec_list *cur = ptr;
@@ -2018,9 +1940,7 @@ output_fr_mem (mask)
 }
 
 static unw_rec_list *
 }
 
 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;
 {
   unw_rec_list *ptr = alloc_record (frgr_mem);
   unw_rec_list *cur = ptr;
@@ -2059,9 +1979,7 @@ output_frgr_mem (gr_mask, fr_mask)
 }
 
 static unw_rec_list *
 }
 
 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;
 {
   unw_rec_list *ptr = alloc_record (gr_gr);
   unw_rec_list *cur = ptr;
@@ -2088,8 +2006,7 @@ output_gr_gr (mask, reg)
 }
 
 static unw_rec_list *
 }
 
 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;
 {
   unw_rec_list *ptr = alloc_record (gr_mem);
   unw_rec_list *cur = ptr;
@@ -2137,9 +2054,7 @@ output_br_mem (unsigned int mask)
 }
 
 static unw_rec_list *
 }
 
 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;
 {
   unw_rec_list *ptr = alloc_record (br_gr);
   unw_rec_list *cur = ptr;
@@ -2166,8 +2081,7 @@ output_br_gr (mask, reg)
 }
 
 static unw_rec_list *
 }
 
 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);
 {
   unw_rec_list *ptr = alloc_record (spill_base);
   ptr->r.record.p.off.psp = ENCODED_PSP_OFFSET (offset);
@@ -2175,15 +2089,14 @@ output_spill_base (offset)
 }
 
 static unw_rec_list *
 }
 
 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 *
 {
   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;
 {
   unw_rec_list *ptr = alloc_record (unat_gr);
   ptr->r.record.p.r.gr = gr;
@@ -2191,8 +2104,7 @@ output_unat_gr (gr)
 }
 
 static unw_rec_list *
 }
 
 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);
 {
   unw_rec_list *ptr = alloc_record (unat_psprel);
   ptr->r.record.p.off.psp = ENCODED_PSP_OFFSET (offset);
@@ -2200,8 +2112,7 @@ output_unat_psprel (offset)
 }
 
 static unw_rec_list *
 }
 
 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;
 {
   unw_rec_list *ptr = alloc_record (unat_sprel);
   ptr->r.record.p.off.sp = offset / 4;
@@ -2209,15 +2120,14 @@ output_unat_sprel (offset)
 }
 
 static unw_rec_list *
 }
 
 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 *
 {
   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;
 {
   unw_rec_list *ptr = alloc_record (lc_gr);
   ptr->r.record.p.r.gr = gr;
@@ -2225,8 +2135,7 @@ output_lc_gr (gr)
 }
 
 static unw_rec_list *
 }
 
 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);
 {
   unw_rec_list *ptr = alloc_record (lc_psprel);
   ptr->r.record.p.off.psp = ENCODED_PSP_OFFSET (offset);
@@ -2234,8 +2143,7 @@ output_lc_psprel (offset)
 }
 
 static unw_rec_list *
 }
 
 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;
 {
   unw_rec_list *ptr = alloc_record (lc_sprel);
   ptr->r.record.p.off.sp = offset / 4;
@@ -2243,15 +2151,14 @@ output_lc_sprel (offset)
 }
 
 static unw_rec_list *
 }
 
 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 *
 {
   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;
 {
   unw_rec_list *ptr = alloc_record (fpsr_gr);
   ptr->r.record.p.r.gr = gr;
@@ -2259,8 +2166,7 @@ output_fpsr_gr (gr)
 }
 
 static unw_rec_list *
 }
 
 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);
 {
   unw_rec_list *ptr = alloc_record (fpsr_psprel);
   ptr->r.record.p.off.psp = ENCODED_PSP_OFFSET (offset);
@@ -2268,8 +2174,7 @@ output_fpsr_psprel (offset)
 }
 
 static unw_rec_list *
 }
 
 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;
 {
   unw_rec_list *ptr = alloc_record (fpsr_sprel);
   ptr->r.record.p.off.sp = offset / 4;
@@ -2277,22 +2182,21 @@ output_fpsr_sprel (offset)
 }
 
 static unw_rec_list *
 }
 
 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 *
 {
   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 *
 {
   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;
 {
   unw_rec_list *ptr = alloc_record (priunat_gr);
   ptr->r.record.p.r.gr = gr;
@@ -2300,8 +2204,7 @@ output_priunat_gr (gr)
 }
 
 static unw_rec_list *
 }
 
 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);
 {
   unw_rec_list *ptr = alloc_record (priunat_psprel);
   ptr->r.record.p.off.psp = ENCODED_PSP_OFFSET (offset);
@@ -2309,8 +2212,7 @@ output_priunat_psprel (offset)
 }
 
 static unw_rec_list *
 }
 
 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;
 {
   unw_rec_list *ptr = alloc_record (priunat_sprel);
   ptr->r.record.p.off.sp = offset / 4;
@@ -2318,15 +2220,14 @@ output_priunat_sprel (offset)
 }
 
 static unw_rec_list *
 }
 
 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 *
 {
   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;
 {
   unw_rec_list *ptr = alloc_record (bsp_gr);
   ptr->r.record.p.r.gr = gr;
@@ -2334,8 +2235,7 @@ output_bsp_gr (gr)
 }
 
 static unw_rec_list *
 }
 
 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);
 {
   unw_rec_list *ptr = alloc_record (bsp_psprel);
   ptr->r.record.p.off.psp = ENCODED_PSP_OFFSET (offset);
@@ -2343,8 +2243,7 @@ output_bsp_psprel (offset)
 }
 
 static unw_rec_list *
 }
 
 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;
 {
   unw_rec_list *ptr = alloc_record (bsp_sprel);
   ptr->r.record.p.off.sp = offset / 4;
@@ -2352,15 +2251,14 @@ output_bsp_sprel (offset)
 }
 
 static unw_rec_list *
 }
 
 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 *
 {
   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;
 {
   unw_rec_list *ptr = alloc_record (bspstore_gr);
   ptr->r.record.p.r.gr = gr;
@@ -2368,8 +2266,7 @@ output_bspstore_gr (gr)
 }
 
 static unw_rec_list *
 }
 
 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);
 {
   unw_rec_list *ptr = alloc_record (bspstore_psprel);
   ptr->r.record.p.off.psp = ENCODED_PSP_OFFSET (offset);
@@ -2377,8 +2274,7 @@ output_bspstore_psprel (offset)
 }
 
 static unw_rec_list *
 }
 
 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;
 {
   unw_rec_list *ptr = alloc_record (bspstore_sprel);
   ptr->r.record.p.off.sp = offset / 4;
@@ -2386,15 +2282,14 @@ output_bspstore_sprel (offset)
 }
 
 static unw_rec_list *
 }
 
 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 *
 {
   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;
 {
   unw_rec_list *ptr = alloc_record (rnat_gr);
   ptr->r.record.p.r.gr = gr;
@@ -2402,8 +2297,7 @@ output_rnat_gr (gr)
 }
 
 static unw_rec_list *
 }
 
 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);
 {
   unw_rec_list *ptr = alloc_record (rnat_psprel);
   ptr->r.record.p.off.psp = ENCODED_PSP_OFFSET (offset);
@@ -2411,8 +2305,7 @@ output_rnat_psprel (offset)
 }
 
 static unw_rec_list *
 }
 
 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;
 {
   unw_rec_list *ptr = alloc_record (rnat_sprel);
   ptr->r.record.p.off.sp = offset / 4;
@@ -2420,9 +2313,7 @@ output_rnat_sprel (offset)
 }
 
 static unw_rec_list *
 }
 
 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;
 {
   unw_rec_list *ptr = alloc_record (unwabi);
   ptr->r.record.p.abi = abi;
@@ -2455,11 +2346,10 @@ output_copy_state (unsigned long label)
 }
 
 static unw_rec_list *
 }
 
 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;
 {
   unw_rec_list *ptr = alloc_record (predicate ? spill_psprel_p : spill_psprel);
   ptr->r.record.x.ab = ab;
@@ -2470,11 +2360,10 @@ output_spill_psprel (ab, reg, offset, predicate)
 }
 
 static unw_rec_list *
 }
 
 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;
 {
   unw_rec_list *ptr = alloc_record (predicate ? spill_sprel_p : spill_sprel);
   ptr->r.record.x.ab = ab;
@@ -2485,12 +2374,11 @@ output_spill_sprel (ab, reg, offset, predicate)
 }
 
 static unw_rec_list *
 }
 
 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;
 {
   unw_rec_list *ptr = alloc_record (predicate ? spill_reg_p : spill_reg);
   ptr->r.record.x.ab = ab;
@@ -2505,9 +2393,7 @@ output_spill_reg (ab, reg, targ_reg, xy, predicate)
    specified function.  */
 
 static void
    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;
 
 {
   unsigned int fr_mask, gr_mask;
 
@@ -2635,7 +2521,7 @@ process_one_record (ptr, f)
        }
       break;
     case spill_mask:
        }
       break;
     case spill_mask:
-      as_bad ("spill_mask record unimplemented.");
+      as_bad (_("spill_mask record unimplemented."));
       break;
     case priunat_when_gr:
     case priunat_when_mem:
       break;
     case priunat_when_gr:
     case priunat_when_mem:
@@ -2692,7 +2578,7 @@ process_one_record (ptr, f)
                        ptr->r.record.x.t);
       break;
     default:
                        ptr->r.record.x.t);
       break;
     default:
-      as_bad ("record_type_not_valid");
+      as_bad (_("record_type_not_valid"));
       break;
     }
 }
       break;
     }
 }
@@ -2700,9 +2586,7 @@ process_one_record (ptr, f)
 /* Given a unw_rec_list list, process all the records with
    the specified function.  */
 static void
 /* 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)
 {
   unw_rec_list *ptr;
   for (ptr = list; ptr; ptr = ptr->next)
@@ -2711,8 +2595,7 @@ process_unw_records (list, f)
 
 /* Determine the size of a record list in bytes.  */
 static int
 
 /* 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);
 {
   vbyte_count = 0;
   process_unw_records (list, count_output);
@@ -2752,11 +2635,10 @@ popcount (unsigned x)
        2: instruction saves next general reg
        3: instruction saves next branch reg */
 static void
        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;
 {
   unsigned char *imask;
   unsigned long imask_size;
@@ -2768,8 +2650,7 @@ set_imask (region, regmask, t, type)
   if (!imask)
     {
       imask_size = (region->r.record.r.rlen * 2 + 7) / 8 + 1;
   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;
 
       region->r.record.r.imask_size = imask_size;
       region->r.record.r.mask.i = imask;
@@ -2781,7 +2662,7 @@ set_imask (region, regmask, t, type)
     {
       if (i >= imask_size)
        {
     {
       if (i >= imask_size)
        {
-         as_bad ("Ignoring attempt to spill beyond end of region");
+         as_bad (_("Ignoring attempt to spill beyond end of region"));
          return;
        }
 
          return;
        }
 
@@ -2802,15 +2683,14 @@ set_imask (region, regmask, t, type)
    containing FIRST_ADDR.  If BEFORE_RELAX, then we use worst-case estimates
    for frag sizes.  */
 
    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)
 
   /* First time we are called, the initial address and frag are invalid.  */
   if (first_addr == 0)
@@ -2828,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)
          /* 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);
        }
                           - first_frag->fr_address
                             - first_frag->fr_fix) >> 4);
        }
@@ -2841,7 +2721,7 @@ slot_index (slot_addr, slot_frag, first_addr, first_frag, before_relax)
            break;
 
          case rs_space:
            break;
 
          case rs_space:
-           as_fatal ("only constant space allocation is supported");
+           as_fatal (_("Only constant space allocation is supported"));
            break;
 
          case rs_align:
            break;
 
          case rs_align:
@@ -2849,24 +2729,24 @@ 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.  */
          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:
            if (first_frag->fr_symbol)
              {
            break;
 
          case rs_org:
            if (first_frag->fr_symbol)
              {
-               as_fatal ("only constant offsets are supported");
+               as_fatal (_("Only constant offsets are supported"));
                break;
              }
          case rs_fill:
                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.  */
            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.  */
       /* 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.  */
                + ((first_addr & 0x3) - (start_addr & 0x3)));
 
       /* Move to the beginning of the next frag.  */
@@ -2874,37 +2754,23 @@ slot_index (slot_addr, slot_frag, first_addr, first_frag, before_relax)
       first_addr = (unsigned long) &first_frag->fr_literal;
 
       /* This can happen if there is section switching in the middle of a
       first_addr = (unsigned long) &first_frag->fr_literal;
 
       /* This can happen if there is section switching in the middle of a
-        function, causing the frag chain for the function to be broken.  */
+        function, causing the frag chain for the function to be broken.
+        It is too difficult to recover safely from this problem, so we just
+        exit with an error.  */
       if (first_frag == NULL)
       if (first_frag == NULL)
-       {
-         /* We get six warnings for one problem, because of the loop in
-            fixup_unw_records, and because fixup_unw_records is called 3
-            times: once before creating the variant frag, once to estimate
-            its size, and once to relax it.  This is unreasonable, so we use
-            a static var to make sure we only emit the warning once.  */
-         static int warned = 0;
-
-         if (!warned)
-           {
-             as_warn ("Corrupted unwind info due to unsupported section switching");
-             warned = 1;
-           }
-
-         return index;
-       }
+       as_fatal (_("Section switching in code is not supported."));
     }
 
   /* Add in the used part of the last frag.  */
     }
 
   /* 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)));
            + ((slot_addr & 0x3) - (first_addr & 0x3)));
-  return index;
+  return s_index;
 }
 
 /* Optimize unwind record directives.  */
 
 static unw_rec_list *
 }
 
 /* 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;
 {
   if (!list)
     return NULL;
@@ -2925,9 +2791,7 @@ optimize_unw_records (list)
    within each record to generate an image.  */
 
 static void
    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;
 {
   unw_rec_list *ptr, *region = 0;
   unsigned long first_addr = 0, rlen = 0, t;
@@ -2936,7 +2800,7 @@ fixup_unw_records (list, before_relax)
   for (ptr = list; ptr; ptr = ptr->next)
     {
       if (ptr->slot_number == SLOT_NUM_NOT_SET)
   for (ptr = list; ptr; ptr = ptr->next)
     {
       if (ptr->slot_number == SLOT_NUM_NOT_SET)
-       as_bad (" Insn slot not set in unwind record.");
+       as_bad (_(" Insn slot not set in unwind record."));
       t = slot_index (ptr->slot_number, ptr->slot_frag,
                      first_addr, first_frag, before_relax);
       switch (ptr->r.type)
       t = slot_index (ptr->slot_number, ptr->slot_frag,
                      first_addr, first_frag, before_relax);
       switch (ptr->r.type)
@@ -3010,7 +2874,7 @@ fixup_unw_records (list, before_relax)
        case frgr_mem:
          if (!region)
            {
        case frgr_mem:
          if (!region)
            {
-             as_bad ("frgr_mem record before region record!");
+             as_bad (_("frgr_mem record before region record!"));
              return;
            }
          region->r.record.r.mask.fr_mem |= ptr->r.record.p.frmask;
              return;
            }
          region->r.record.r.mask.fr_mem |= ptr->r.record.p.frmask;
@@ -3021,7 +2885,7 @@ fixup_unw_records (list, before_relax)
        case fr_mem:
          if (!region)
            {
        case fr_mem:
          if (!region)
            {
-             as_bad ("fr_mem record before region record!");
+             as_bad (_("fr_mem record before region record!"));
              return;
            }
          region->r.record.r.mask.fr_mem |= ptr->r.record.p.frmask;
              return;
            }
          region->r.record.r.mask.fr_mem |= ptr->r.record.p.frmask;
@@ -3030,7 +2894,7 @@ fixup_unw_records (list, before_relax)
        case gr_mem:
          if (!region)
            {
        case gr_mem:
          if (!region)
            {
-             as_bad ("gr_mem record before region record!");
+             as_bad (_("gr_mem record before region record!"));
              return;
            }
          region->r.record.r.mask.gr_mem |= ptr->r.record.p.grmask;
              return;
            }
          region->r.record.r.mask.gr_mem |= ptr->r.record.p.grmask;
@@ -3039,7 +2903,7 @@ fixup_unw_records (list, before_relax)
        case br_mem:
          if (!region)
            {
        case br_mem:
          if (!region)
            {
-             as_bad ("br_mem record before region record!");
+             as_bad (_("br_mem record before region record!"));
              return;
            }
          region->r.record.r.mask.br_mem |= ptr->r.record.p.brmask;
              return;
            }
          region->r.record.r.mask.br_mem |= ptr->r.record.p.brmask;
@@ -3049,7 +2913,7 @@ fixup_unw_records (list, before_relax)
        case gr_gr:
          if (!region)
            {
        case gr_gr:
          if (!region)
            {
-             as_bad ("gr_gr record before region record!");
+             as_bad (_("gr_gr record before region record!"));
              return;
            }
          set_imask (region, ptr->r.record.p.grmask, t, 2);
              return;
            }
          set_imask (region, ptr->r.record.p.grmask, t, 2);
@@ -3057,7 +2921,7 @@ fixup_unw_records (list, before_relax)
        case br_gr:
          if (!region)
            {
        case br_gr:
          if (!region)
            {
-             as_bad ("br_gr record before region record!");
+             as_bad (_("br_gr record before region record!"));
              return;
            }
          set_imask (region, ptr->r.record.p.brmask, t, 3);
              return;
            }
          set_imask (region, ptr->r.record.p.brmask, t, 3);
@@ -3096,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.  */
 
   /* 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
 
   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)
 {
 void
 ia64_convert_frag (fragS *frag)
 {
@@ -3127,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.  */
 
   /* 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.  */
 
   /* Initialize the header area. fr_offset is initialized with
      unwind.personality_routine.  */
@@ -3156,6 +3020,10 @@ ia64_convert_frag (fragS *frag)
   if (pad != 0)
     md_number_to_chars (frag->fr_literal + len + 8 - md.pointer_size + pad, 0,
                        md.pointer_size - pad);
   if (pad != 0)
     md_number_to_chars (frag->fr_literal + len + 8 - md.pointer_size + pad, 0,
                        md.pointer_size - pad);
+  /* Fill the unwind personality with zeros.  */
+  if (frag->fr_offset)
+    md_number_to_chars (frag->fr_literal + size - md.pointer_size, 0,
+                       md.pointer_size);
 
   frag->fr_fix += size;
   frag->fr_type = rs_fill;
 
   frag->fr_fix += size;
   frag->fr_type = rs_fill;
@@ -3164,35 +3032,31 @@ ia64_convert_frag (fragS *frag)
 }
 
 static int
 }
 
 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)
     {
 
   *qp = e->X_add_number - REG_P;
   if (e->X_op != O_register || *qp > 63)
     {
-      as_bad ("First operand to .%s must be a predicate", po);
+      as_bad (_("First operand to .%s must be a predicate"), po);
       *qp = 0;
     }
   else if (*qp == 0)
       *qp = 0;
     }
   else if (*qp == 0)
-    as_warn ("Pointless use of p0 as first operand to .%s", po);
+    as_warn (_("Pointless use of p0 as first operand to .%s"), po);
   if (sep == ',')
   if (sep == ',')
-    sep = parse_operand (e, ',');
+    sep = parse_operand_and_eval (e, ',');
   else
     e->X_op = O_absent;
   return sep;
 }
 
 static void
   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;
 
 {
   unsigned int reg = e->X_add_number;
 
@@ -3235,19 +3099,18 @@ convert_expr_to_ab_reg (e, ab, regp, po, n)
        case REG_AR + AR_LC:    *regp = 10; break;
 
        default:
        case REG_AR + AR_LC:    *regp = 10; break;
 
        default:
-         as_bad ("Operand %d to .%s must be a preserved register", n, po);
+         as_bad (_("Operand %d to .%s must be a preserved register"), n, po);
          break;
        }
     }
 }
 
 static void
          break;
        }
     }
 }
 
 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;
 
 {
   unsigned int reg = e->X_add_number;
 
@@ -3272,7 +3135,7 @@ convert_expr_to_xy_reg (e, xy, regp, po, n)
       *regp = reg - REG_BR;
     }
   else
       *regp = reg - REG_BR;
     }
   else
-    as_bad ("Operand %d to .%s must be a writable register", n, po);
+    as_bad (_("Operand %d to .%s must be a writable register"), n, po);
 }
 
 static void
 }
 
 static void
@@ -3284,8 +3147,7 @@ dot_align (int arg)
 }
 
 static void
 }
 
 static void
-dot_radix (dummy)
-     int dummy ATTRIBUTE_UNUSED;
+dot_radix (int dummy ATTRIBUTE_UNUSED)
 {
   char *radix;
   int ch;
 {
   char *radix;
   int ch;
@@ -3294,12 +3156,11 @@ dot_radix (dummy)
 
   if (is_it_end_of_statement ())
     return;
 
   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"))
   ia64_canonicalize_symbol_name (radix);
   if (strcasecmp (radix, "C"))
-    as_bad ("Radix `%s' unsupported or invalid", radix);
-  *input_line_pointer = ch;
+    as_bad (_("Radix `%s' unsupported or invalid"), radix);
+  (void) restore_line_pointer (ch);
   demand_empty_rest_of_line ();
 }
 
   demand_empty_rest_of_line ();
 }
 
@@ -3316,8 +3177,7 @@ dot_loc (int x)
 
 /* .sbss, .bss etc. are macros that expand into ".section SECNAME".  */
 static void
 
 /* .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]);
 }
 {
   set_section ((char *) special_section_name[which]);
 }
@@ -3329,12 +3189,12 @@ unwind_diagnostic (const char * region, const char *directive)
 {
   if (md.unwind_check == unwind_check_warning)
     {
 {
   if (md.unwind_check == unwind_check_warning)
     {
-      as_warn (".%s outside of %s", directive, region);
+      as_warn (_(".%s outside of %s"), directive, region);
       return -1;
     }
   else
     {
       return -1;
     }
   else
     {
-      as_bad (".%s outside of %s", directive, region);
+      as_bad (_(".%s outside of %s"), directive, region);
       ignore_rest_of_line ();
       return 0;
     }
       ignore_rest_of_line ();
       return 0;
     }
@@ -3386,9 +3246,7 @@ in_body (const char *directive)
 }
 
 static void
 }
 
 static void
-add_unwind_entry (ptr, sep)
-     unw_rec_list *ptr;
-     int sep;
+add_unwind_entry (unw_rec_list *ptr, int sep)
 {
   if (ptr)
     {
 {
   if (ptr)
     {
@@ -3409,11 +3267,12 @@ add_unwind_entry (ptr, sep)
 
   if (sep == ',')
     {
 
   if (sep == ',')
     {
+      char *name;
       /* Parse a tag permitted for the current directive.  */
       int ch;
 
       SKIP_WHITESPACE ();
       /* 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;
       /* FIXME: For now, just issue a warning that this isn't implemented.  */
       {
        static int warned;
@@ -3421,18 +3280,17 @@ add_unwind_entry (ptr, sep)
        if (!warned)
          {
            warned = 1;
        if (!warned)
          {
            warned = 1;
-           as_warn ("Tags on unwind pseudo-ops aren't supported, yet");
+           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
     }
   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;
 {
   expressionS e;
   int sep;
@@ -3440,19 +3298,18 @@ dot_fframe (dummy)
   if (!in_prologue ("fframe"))
     return;
 
   if (!in_prologue ("fframe"))
     return;
 
-  sep = parse_operand (&e, ',');
+  sep = parse_operand_and_eval (&e, ',');
 
   if (e.X_op != O_constant)
     {
 
   if (e.X_op != O_constant)
     {
-      as_bad ("First operand to .fframe must be a constant");
+      as_bad (_("First operand to .fframe must be a constant"));
       e.X_add_number = 0;
     }
   add_unwind_entry (output_mem_stack_f (e.X_add_number), sep);
 }
 
 static void
       e.X_add_number = 0;
     }
   add_unwind_entry (output_mem_stack_f (e.X_add_number), sep);
 }
 
 static void
-dot_vframe (dummy)
-     int dummy ATTRIBUTE_UNUSED;
+dot_vframe (int dummy ATTRIBUTE_UNUSED)
 {
   expressionS e;
   unsigned reg;
 {
   expressionS e;
   unsigned reg;
@@ -3461,38 +3318,37 @@ dot_vframe (dummy)
   if (!in_prologue ("vframe"))
     return;
 
   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)
     {
   reg = e.X_add_number - REG_GR;
   if (e.X_op != O_register || reg > 127)
     {
-      as_bad ("First operand to .vframe must be a general register");
+      as_bad (_("First operand to .vframe must be a general register"));
       reg = 0;
     }
   add_unwind_entry (output_mem_stack_v (), sep);
   if (! (unwind.prologue_mask & 2))
     add_unwind_entry (output_psp_gr (reg), NOT_A_CHAR);
   else if (reg != unwind.prologue_gr
       reg = 0;
     }
   add_unwind_entry (output_mem_stack_v (), sep);
   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)))
-    as_warn ("Operand of .vframe contradicts .prologue");
+                 + (unsigned) popcount (unwind.prologue_mask & -(2 << 1)))
+    as_warn (_("Operand of .vframe contradicts .prologue"));
 }
 
 static void
 }
 
 static void
-dot_vframesp (psp)
-     int psp;
+dot_vframesp (int psp)
 {
   expressionS e;
   int sep;
 
   if (psp)
 {
   expressionS e;
   int sep;
 
   if (psp)
-    as_warn (".vframepsp is meaningless, assuming .vframesp was meant");
+    as_warn (_(".vframepsp is meaningless, assuming .vframesp was meant"));
 
   if (!in_prologue ("vframesp"))
     return;
 
 
   if (!in_prologue ("vframesp"))
     return;
 
-  sep = parse_operand (&e, ',');
+  sep = parse_operand_and_eval (&e, ',');
   if (e.X_op != O_constant)
     {
   if (e.X_op != O_constant)
     {
-      as_bad ("Operand to .vframesp must be a constant (sp-relative offset)");
+      as_bad (_("Operand to .vframesp must be a constant (sp-relative offset)"));
       e.X_add_number = 0;
     }
   add_unwind_entry (output_mem_stack_v (), sep);
       e.X_add_number = 0;
     }
   add_unwind_entry (output_mem_stack_v (), sep);
@@ -3500,8 +3356,7 @@ dot_vframesp (psp)
 }
 
 static void
 }
 
 static void
-dot_save (dummy)
-     int dummy ATTRIBUTE_UNUSED;
+dot_save (int dummy ATTRIBUTE_UNUSED)
 {
   expressionS e1, e2;
   unsigned reg1, reg2;
 {
   expressionS e1, e2;
   unsigned reg1, reg2;
@@ -3510,9 +3365,9 @@ dot_save (dummy)
   if (!in_prologue ("save"))
     return;
 
   if (!in_prologue ("save"))
     return;
 
-  sep = parse_operand (&e1, ',');
+  sep = parse_operand_and_eval (&e1, ',');
   if (sep == ',')
   if (sep == ',')
-    sep = parse_operand (&e2, ',');
+    sep = parse_operand_and_eval (&e2, ',');
   else
     e2.X_op = O_absent;
 
   else
     e2.X_op = O_absent;
 
@@ -3520,13 +3375,13 @@ dot_save (dummy)
   /* Make sure its a valid ar.xxx reg, OR its br0, aka 'rp'.  */
   if (e1.X_op != O_register)
     {
   /* Make sure its a valid ar.xxx reg, OR its br0, aka 'rp'.  */
   if (e1.X_op != O_register)
     {
-      as_bad ("First operand to .save not a register");
+      as_bad (_("First operand to .save not a register"));
       reg1 = REG_PR; /* Anything valid is good here.  */
     }
   reg2 = e2.X_add_number - REG_GR;
   if (e2.X_op != O_register || reg2 > 127)
     {
       reg1 = REG_PR; /* Anything valid is good here.  */
     }
   reg2 = e2.X_add_number - REG_GR;
   if (e2.X_op != O_register || reg2 > 127)
     {
-      as_bad ("Second operand to .save not a valid register");
+      as_bad (_("Second operand to .save not a valid register"));
       reg2 = 0;
     }
   switch (reg1)
       reg2 = 0;
     }
   switch (reg1)
@@ -3556,8 +3411,8 @@ dot_save (dummy)
       if (! (unwind.prologue_mask & 4))
        add_unwind_entry (output_pfs_gr (reg2), NOT_A_CHAR);
       else if (reg2 != unwind.prologue_gr
       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)))
-       as_warn ("Second operand of .save contradicts .prologue");
+                      + (unsigned) popcount (unwind.prologue_mask & -(4 << 1)))
+       as_warn (_("Second operand of .save contradicts .prologue"));
       break;
     case REG_AR + AR_LC:
       add_unwind_entry (output_lc_when (), sep);
       break;
     case REG_AR + AR_LC:
       add_unwind_entry (output_lc_when (), sep);
@@ -3568,30 +3423,29 @@ dot_save (dummy)
       if (! (unwind.prologue_mask & 8))
        add_unwind_entry (output_rp_gr (reg2), NOT_A_CHAR);
       else if (reg2 != unwind.prologue_gr)
       if (! (unwind.prologue_mask & 8))
        add_unwind_entry (output_rp_gr (reg2), NOT_A_CHAR);
       else if (reg2 != unwind.prologue_gr)
-       as_warn ("Second operand of .save contradicts .prologue");
+       as_warn (_("Second operand of .save contradicts .prologue"));
       break;
     case REG_PR:
       add_unwind_entry (output_preds_when (), sep);
       if (! (unwind.prologue_mask & 1))
        add_unwind_entry (output_preds_gr (reg2), NOT_A_CHAR);
       else if (reg2 != unwind.prologue_gr
       break;
     case REG_PR:
       add_unwind_entry (output_preds_when (), sep);
       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)))
-       as_warn ("Second operand of .save contradicts .prologue");
+                      + (unsigned) popcount (unwind.prologue_mask & -(1 << 1)))
+       as_warn (_("Second operand of .save contradicts .prologue"));
       break;
     case REG_PRIUNAT:
       add_unwind_entry (output_priunat_when_gr (), sep);
       add_unwind_entry (output_priunat_gr (reg2), NOT_A_CHAR);
       break;
     default:
       break;
     case REG_PRIUNAT:
       add_unwind_entry (output_priunat_when_gr (), sep);
       add_unwind_entry (output_priunat_gr (reg2), NOT_A_CHAR);
       break;
     default:
-      as_bad ("First operand to .save not a valid register");
+      as_bad (_("First operand to .save not a valid register"));
       add_unwind_entry (NULL, sep);
       break;
     }
 }
 
 static void
       add_unwind_entry (NULL, sep);
       break;
     }
 }
 
 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 */
 {
   expressionS e1;
   unsigned long ecount;        /* # of _additional_ regions to pop */
@@ -3600,18 +3454,18 @@ dot_restore (dummy)
   if (!in_body ("restore"))
     return;
 
   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)
   if (e1.X_op != O_register || e1.X_add_number != REG_GR + 12)
-    as_bad ("First operand to .restore must be stack pointer (sp)");
+    as_bad (_("First operand to .restore must be stack pointer (sp)"));
 
   if (sep == ',')
     {
       expressionS e2;
 
 
   if (sep == ',')
     {
       expressionS e2;
 
-      sep = parse_operand (&e2, ',');
+      sep = parse_operand_and_eval (&e2, ',');
       if (e2.X_op != O_constant || e2.X_add_number < 0)
        {
       if (e2.X_op != O_constant || e2.X_add_number < 0)
        {
-         as_bad ("Second operand to .restore must be a constant >= 0");
+         as_bad (_("Second operand to .restore must be a constant >= 0"));
          e2.X_add_number = 0;
        }
       ecount = e2.X_add_number;
          e2.X_add_number = 0;
        }
       ecount = e2.X_add_number;
@@ -3621,7 +3475,7 @@ dot_restore (dummy)
 
   if (ecount >= unwind.prologue_count)
     {
 
   if (ecount >= unwind.prologue_count)
     {
-      as_bad ("Epilogue count of %lu exceeds number of nested prologues (%u)",
+      as_bad (_("Epilogue count of %lu exceeds number of nested prologues (%u)"),
              ecount + 1, unwind.prologue_count);
       ecount = 0;
     }
              ecount + 1, unwind.prologue_count);
       ecount = 0;
     }
@@ -3635,8 +3489,7 @@ dot_restore (dummy)
 }
 
 static void
 }
 
 static void
-dot_restorereg (pred)
-     int pred;
+dot_restorereg (int pred)
 {
   unsigned int qp, ab, reg;
   expressionS e;
 {
   unsigned int qp, ab, reg;
   expressionS e;
@@ -3650,7 +3503,7 @@ dot_restorereg (pred)
     sep = parse_predicate_and_operand (&e, &qp, po);
   else
     {
     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);
       qp = 0;
     }
   convert_expr_to_ab_reg (&e, &ab, &reg, po, 1 + pred);
@@ -3658,7 +3511,7 @@ dot_restorereg (pred)
   add_unwind_entry (output_spill_reg (ab, reg, 0, 0, qp), sep);
 }
 
   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."
   };
   {
     ".gnu.linkonce.ia64unw.", ".gnu.linkonce.ia64unwi."
   };
@@ -3703,13 +3556,12 @@ start_unwind_section (const segT text_seg, int sec_index)
   char *sec_name;
   const char *prefix = special_section_name [sec_index];
   const char *suffix;
   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;
   if (strncmp (text_name, "_info", 5) == 0)
     {
 
   sec_text_name = segment_name (text_seg);
   text_name = sec_text_name;
   if (strncmp (text_name, "_info", 5) == 0)
     {
-      as_bad ("Illegal section name `%s' (causes unwind section name clash)",
+      as_bad (_("Illegal section name `%s' (causes unwind section name clash)"),
              text_name);
       ignore_rest_of_line ();
       return;
              text_name);
       ignore_rest_of_line ();
       return;
@@ -3727,43 +3579,28 @@ start_unwind_section (const segT text_seg, int sec_index)
       suffix += sizeof (".gnu.linkonce.t.") - 1;
     }
 
       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;
 
   /* 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)
        {
       const char *group_name = elf_group_name (text_seg);
 
       if (group_name == NULL)
        {
-         as_bad ("Group section `%s' has no group signature",
+         as_bad (_("Group section `%s' has no group signature"),
                  sec_text_name);
          ignore_rest_of_line ();
                  sec_text_name);
          ignore_rest_of_line ();
+         free (sec_name);
          return;
        }
          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);
       set_section (section);
+      free (section);
     }
   else
     {
     }
   else
     {
@@ -3773,6 +3610,7 @@ start_unwind_section (const segT text_seg, int sec_index)
     }
 
   elf_linked_to_section (now_seg) = text_seg;
     }
 
   elf_linked_to_section (now_seg) = text_seg;
+  free (sec_name);
 }
 
 static void
 }
 
 static void
@@ -3823,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 ();
 
       /* 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);
       frag_var (rs_machine_dependent, size, size, 0, 0,
                (offsetT) (long) unwind.personality_routine,
                (char *) list);
@@ -3861,8 +3699,7 @@ generate_unwind_image (const segT text_seg)
 }
 
 static void
 }
 
 static void
-dot_handlerdata (dummy)
-     int dummy ATTRIBUTE_UNUSED;
+dot_handlerdata (int dummy ATTRIBUTE_UNUSED)
 {
   if (!in_procedure ("handlerdata"))
     return;
 {
   if (!in_procedure ("handlerdata"))
     return;
@@ -3880,8 +3717,7 @@ dot_handlerdata (dummy)
 }
 
 static void
 }
 
 static void
-dot_unwentry (dummy)
-     int dummy ATTRIBUTE_UNUSED;
+dot_unwentry (int dummy ATTRIBUTE_UNUSED)
 {
   if (!in_procedure ("unwentry"))
     return;
 {
   if (!in_procedure ("unwentry"))
     return;
@@ -3890,8 +3726,7 @@ dot_unwentry (dummy)
 }
 
 static void
 }
 
 static void
-dot_altrp (dummy)
-     int dummy ATTRIBUTE_UNUSED;
+dot_altrp (int dummy ATTRIBUTE_UNUSED)
 {
   expressionS e;
   unsigned reg;
 {
   expressionS e;
   unsigned reg;
@@ -3899,19 +3734,18 @@ dot_altrp (dummy)
   if (!in_prologue ("altrp"))
     return;
 
   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)
     {
   reg = e.X_add_number - REG_BR;
   if (e.X_op != O_register || reg > 7)
     {
-      as_bad ("First operand to .altrp not a valid branch register");
+      as_bad (_("First operand to .altrp not a valid branch register"));
       reg = 0;
     }
   add_unwind_entry (output_rp_br (reg), 0);
 }
 
 static void
       reg = 0;
     }
   add_unwind_entry (output_rp_br (reg), 0);
 }
 
 static void
-dot_savemem (psprel)
-     int psprel;
+dot_savemem (int psprel)
 {
   expressionS e1, e2;
   int sep;
 {
   expressionS e1, e2;
   int sep;
@@ -3921,9 +3755,9 @@ dot_savemem (psprel)
   if (!in_prologue (po))
     return;
 
   if (!in_prologue (po))
     return;
 
-  sep = parse_operand (&e1, ',');
+  sep = parse_operand_and_eval (&e1, ',');
   if (sep == ',')
   if (sep == ',')
-    sep = parse_operand (&e2, ',');
+    sep = parse_operand_and_eval (&e2, ',');
   else
     e2.X_op = O_absent;
 
   else
     e2.X_op = O_absent;
 
@@ -3933,12 +3767,12 @@ dot_savemem (psprel)
   /* Make sure its a valid ar.xxx reg, OR its br0, aka 'rp'.  */
   if (e1.X_op != O_register)
     {
   /* Make sure its a valid ar.xxx reg, OR its br0, aka 'rp'.  */
   if (e1.X_op != O_register)
     {
-      as_bad ("First operand to .%s not a register", po);
+      as_bad (_("First operand to .%s not a register"), po);
       reg1 = REG_PR; /* Anything valid is good here.  */
     }
   if (e2.X_op != O_constant)
     {
       reg1 = REG_PR; /* Anything valid is good here.  */
     }
   if (e2.X_op != O_constant)
     {
-      as_bad ("Second operand to .%s not a constant", po);
+      as_bad (_("Second operand to .%s not a constant"), po);
       val = 0;
     }
 
       val = 0;
     }
 
@@ -4005,15 +3839,14 @@ dot_savemem (psprel)
                         : output_priunat_sprel) (val), NOT_A_CHAR);
       break;
     default:
                         : output_priunat_sprel) (val), NOT_A_CHAR);
       break;
     default:
-      as_bad ("First operand to .%s not a valid register", po);
+      as_bad (_("First operand to .%s not a valid register"), po);
       add_unwind_entry (NULL, sep);
       break;
     }
 }
 
 static void
       add_unwind_entry (NULL, sep);
       break;
     }
 }
 
 static void
-dot_saveg (dummy)
-     int dummy ATTRIBUTE_UNUSED;
+dot_saveg (int dummy ATTRIBUTE_UNUSED)
 {
   expressionS e;
   unsigned grmask;
 {
   expressionS e;
   unsigned grmask;
@@ -4022,14 +3855,14 @@ dot_saveg (dummy)
   if (!in_prologue ("save.g"))
     return;
 
   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
       || e.X_add_number <= 0
       || e.X_add_number > 0xf)
     {
 
   grmask = e.X_add_number;
   if (e.X_op != O_constant
       || e.X_add_number <= 0
       || e.X_add_number > 0xf)
     {
-      as_bad ("First operand to .save.g must be a positive 4-bit constant");
+      as_bad (_("First operand to .save.g must be a positive 4-bit constant"));
       grmask = 0;
     }
 
       grmask = 0;
     }
 
@@ -4038,16 +3871,16 @@ dot_saveg (dummy)
       unsigned reg;
       int n = popcount (grmask);
 
       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)
        {
       reg = e.X_add_number - REG_GR;
       if (e.X_op != O_register || reg > 127)
        {
-         as_bad ("Second operand to .save.g must be a general register");
+         as_bad (_("Second operand to .save.g must be a general register"));
          reg = 0;
        }
       else if (reg > 128U - n)
        {
          reg = 0;
        }
       else if (reg > 128U - n)
        {
-         as_bad ("Second operand to .save.g must be the first of %d general registers", n);
+         as_bad (_("Second operand to .save.g must be the first of %d general registers"), n);
          reg = 0;
        }
       add_unwind_entry (output_gr_gr (grmask, reg), 0);
          reg = 0;
        }
       add_unwind_entry (output_gr_gr (grmask, reg), 0);
@@ -4057,29 +3890,27 @@ dot_saveg (dummy)
 }
 
 static void
 }
 
 static void
-dot_savef (dummy)
-     int dummy ATTRIBUTE_UNUSED;
+dot_savef (int dummy ATTRIBUTE_UNUSED)
 {
   expressionS e;
 
   if (!in_prologue ("save.f"))
     return;
 
 {
   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
       || e.X_add_number > 0xfffff)
     {
 
   if (e.X_op != O_constant
       || e.X_add_number <= 0
       || e.X_add_number > 0xfffff)
     {
-      as_bad ("Operand to .save.f must be a positive 20-bit constant");
+      as_bad (_("Operand to .save.f must be a positive 20-bit constant"));
       e.X_add_number = 0;
     }
   add_unwind_entry (output_fr_mem (e.X_add_number), 0);
 }
 
 static void
       e.X_add_number = 0;
     }
   add_unwind_entry (output_fr_mem (e.X_add_number), 0);
 }
 
 static void
-dot_saveb (dummy)
-     int dummy ATTRIBUTE_UNUSED;
+dot_saveb (int dummy ATTRIBUTE_UNUSED)
 {
   expressionS e;
   unsigned brmask;
 {
   expressionS e;
   unsigned brmask;
@@ -4088,14 +3919,14 @@ dot_saveb (dummy)
   if (!in_prologue ("save.b"))
     return;
 
   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
       || e.X_add_number <= 0
       || e.X_add_number > 0x1f)
     {
 
   brmask = e.X_add_number;
   if (e.X_op != O_constant
       || e.X_add_number <= 0
       || e.X_add_number > 0x1f)
     {
-      as_bad ("First operand to .save.b must be a positive 5-bit constant");
+      as_bad (_("First operand to .save.b must be a positive 5-bit constant"));
       brmask = 0;
     }
 
       brmask = 0;
     }
 
@@ -4104,16 +3935,16 @@ dot_saveb (dummy)
       unsigned reg;
       int n = popcount (brmask);
 
       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)
        {
       reg = e.X_add_number - REG_GR;
       if (e.X_op != O_register || reg > 127)
        {
-         as_bad ("Second operand to .save.b must be a general register");
+         as_bad (_("Second operand to .save.b must be a general register"));
          reg = 0;
        }
       else if (reg > 128U - n)
        {
          reg = 0;
        }
       else if (reg > 128U - n)
        {
-         as_bad ("Second operand to .save.b must be the first of %d general registers", n);
+         as_bad (_("Second operand to .save.b must be the first of %d general registers"), n);
          reg = 0;
        }
       add_unwind_entry (output_br_gr (brmask, reg), 0);
          reg = 0;
        }
       add_unwind_entry (output_br_gr (brmask, reg), 0);
@@ -4123,16 +3954,15 @@ dot_saveb (dummy)
 }
 
 static void
 }
 
 static void
-dot_savegf (dummy)
-     int dummy ATTRIBUTE_UNUSED;
+dot_savegf (int dummy ATTRIBUTE_UNUSED)
 {
   expressionS e1, e2;
 
   if (!in_prologue ("save.gf"))
     return;
 
 {
   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;
 
   else
     e2.X_op = O_absent;
 
@@ -4140,7 +3970,7 @@ dot_savegf (dummy)
       || e1.X_add_number < 0
       || e1.X_add_number > 0xf)
     {
       || e1.X_add_number < 0
       || e1.X_add_number > 0xf)
     {
-      as_bad ("First operand to .save.gf must be a non-negative 4-bit constant");
+      as_bad (_("First operand to .save.gf must be a non-negative 4-bit constant"));
       e1.X_op = O_absent;
       e1.X_add_number = 0;
     }
       e1.X_op = O_absent;
       e1.X_add_number = 0;
     }
@@ -4148,7 +3978,7 @@ dot_savegf (dummy)
       || e2.X_add_number < 0
       || e2.X_add_number > 0xfffff)
     {
       || e2.X_add_number < 0
       || e2.X_add_number > 0xfffff)
     {
-      as_bad ("Second operand to .save.gf must be a non-negative 20-bit constant");
+      as_bad (_("Second operand to .save.gf must be a non-negative 20-bit constant"));
       e2.X_op = O_absent;
       e2.X_add_number = 0;
     }
       e2.X_op = O_absent;
       e2.X_add_number = 0;
     }
@@ -4156,33 +3986,31 @@ dot_savegf (dummy)
       && e2.X_op == O_constant
       && e1.X_add_number == 0
       && e2.X_add_number == 0)
       && e2.X_op == O_constant
       && e1.X_add_number == 0
       && e2.X_add_number == 0)
-    as_bad ("Operands to .save.gf may not be both zero");
+    as_bad (_("Operands to .save.gf may not be both zero"));
 
   add_unwind_entry (output_frgr_mem (e1.X_add_number, e2.X_add_number), 0);
 }
 
 static void
 
   add_unwind_entry (output_frgr_mem (e1.X_add_number, e2.X_add_number), 0);
 }
 
 static void
-dot_spill (dummy)
-     int dummy ATTRIBUTE_UNUSED;
+dot_spill (int dummy ATTRIBUTE_UNUSED)
 {
   expressionS e;
 
   if (!in_prologue ("spill"))
     return;
 
 {
   expressionS e;
 
   if (!in_prologue ("spill"))
     return;
 
-  parse_operand (&e, 0);
+  parse_operand_and_eval (&e, 0);
 
   if (e.X_op != O_constant)
     {
 
   if (e.X_op != O_constant)
     {
-      as_bad ("Operand to .spill must be a constant");
+      as_bad (_("Operand to .spill must be a constant"));
       e.X_add_number = 0;
     }
   add_unwind_entry (output_spill_base (e.X_add_number), 0);
 }
 
 static void
       e.X_add_number = 0;
     }
   add_unwind_entry (output_spill_base (e.X_add_number), 0);
 }
 
 static void
-dot_spillreg (pred)
-     int pred;
+dot_spillreg (int pred)
 {
   int sep;
   unsigned int qp, ab, xy, reg, treg;
 {
   int sep;
   unsigned int qp, ab, xy, reg, treg;
@@ -4196,13 +4024,13 @@ dot_spillreg (pred)
     sep = parse_predicate_and_operand (&e, &qp, po);
   else
     {
     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 == ',')
       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);
   else
     e.X_op = O_absent;
   convert_expr_to_xy_reg (&e, &xy, &treg, po, 2 + pred);
@@ -4211,8 +4039,7 @@ dot_spillreg (pred)
 }
 
 static void
 }
 
 static void
-dot_spillmem (psprel)
-     int psprel;
+dot_spillmem (int psprel)
 {
   expressionS e;
   int pred = (psprel < 0), sep;
 {
   expressionS e;
   int pred = (psprel < 0), sep;
@@ -4234,18 +4061,18 @@ dot_spillmem (psprel)
     sep = parse_predicate_and_operand (&e, &qp, po);
   else
     {
     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 == ',')
       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)
     {
   else
     e.X_op = O_absent;
   if (e.X_op != O_constant)
     {
-      as_bad ("Operand %d to .%s must be a constant", 2 + pred, po);
+      as_bad (_("Operand %d to .%s must be a constant"), 2 + pred, po);
       e.X_add_number = 0;
     }
 
       e.X_add_number = 0;
     }
 
@@ -4256,8 +4083,7 @@ dot_spillmem (psprel)
 }
 
 static unsigned int
 }
 
 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;
 
 {
   label_prologue_count *lpc = unwind.saved_prologue_counts;
 
@@ -4267,14 +4093,12 @@ get_saved_prologue_count (lbl)
   if (lpc != NULL)
     return lpc->prologue_count;
 
   if (lpc != NULL)
     return lpc->prologue_count;
 
-  as_bad ("Missing .label_state %ld", lbl);
+  as_bad (_("Missing .label_state %ld"), lbl);
   return 1;
 }
 
 static void
   return 1;
 }
 
 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;
 
 {
   label_prologue_count *lpc = unwind.saved_prologue_counts;
 
@@ -4285,7 +4109,7 @@ save_prologue_count (lbl, count)
     lpc->prologue_count = count;
   else
     {
     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;
 
       new_lpc->next = unwind.saved_prologue_counts;
       new_lpc->label_number = lbl;
@@ -4295,7 +4119,7 @@ save_prologue_count (lbl, count)
 }
 
 static void
 }
 
 static void
-free_saved_prologue_counts ()
+free_saved_prologue_counts (void)
 {
   label_prologue_count *lpc = unwind.saved_prologue_counts;
   label_prologue_count *next;
 {
   label_prologue_count *lpc = unwind.saved_prologue_counts;
   label_prologue_count *next;
@@ -4311,48 +4135,45 @@ free_saved_prologue_counts ()
 }
 
 static void
 }
 
 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;
 
 {
   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
     {
   if (e.X_op == O_constant)
     save_prologue_count (e.X_add_number, unwind.prologue_count);
   else
     {
-      as_bad ("Operand to .label_state must be a constant");
+      as_bad (_("Operand to .label_state must be a constant"));
       e.X_add_number = 0;
     }
   add_unwind_entry (output_label_state (e.X_add_number), 0);
 }
 
 static void
       e.X_add_number = 0;
     }
   add_unwind_entry (output_label_state (e.X_add_number), 0);
 }
 
 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;
 
 {
   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
     {
   if (e.X_op == O_constant)
     unwind.prologue_count = get_saved_prologue_count (e.X_add_number);
   else
     {
-      as_bad ("Operand to .copy_state must be a constant");
+      as_bad (_("Operand to .copy_state must be a constant"));
       e.X_add_number = 0;
     }
   add_unwind_entry (output_copy_state (e.X_add_number), 0);
 }
 
 static void
       e.X_add_number = 0;
     }
   add_unwind_entry (output_copy_state (e.X_add_number), 0);
 }
 
 static void
-dot_unwabi (dummy)
-     int dummy ATTRIBUTE_UNUSED;
+dot_unwabi (int dummy ATTRIBUTE_UNUSED)
 {
   expressionS e1, e2;
   unsigned char sep;
 {
   expressionS e1, e2;
   unsigned char sep;
@@ -4360,21 +4181,21 @@ dot_unwabi (dummy)
   if (!in_prologue ("unwabi"))
     return;
 
   if (!in_prologue ("unwabi"))
     return;
 
-  sep = parse_operand (&e1, ',');
+  sep = parse_operand_and_eval (&e1, ',');
   if (sep == ',')
   if (sep == ',')
-    parse_operand (&e2, 0);
+    parse_operand_and_eval (&e2, 0);
   else
     e2.X_op = O_absent;
 
   if (e1.X_op != O_constant)
     {
   else
     e2.X_op = O_absent;
 
   if (e1.X_op != O_constant)
     {
-      as_bad ("First operand to .unwabi must be a constant");
+      as_bad (_("First operand to .unwabi must be a constant"));
       e1.X_add_number = 0;
     }
 
   if (e2.X_op != O_constant)
     {
       e1.X_add_number = 0;
     }
 
   if (e2.X_op != O_constant)
     {
-      as_bad ("Second operand to .unwabi must be a constant");
+      as_bad (_("Second operand to .unwabi must be a constant"));
       e2.X_add_number = 0;
     }
 
       e2.X_add_number = 0;
     }
 
@@ -4382,26 +4203,24 @@ dot_unwabi (dummy)
 }
 
 static void
 }
 
 static void
-dot_personality (dummy)
-     int dummy ATTRIBUTE_UNUSED;
+dot_personality (int dummy ATTRIBUTE_UNUSED)
 {
   char *name, *p, c;
 {
   char *name, *p, c;
+
   if (!in_procedure ("personality"))
     return;
   SKIP_WHITESPACE ();
   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;
   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
   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;
 {
   char *name, *p, c;
   symbolS *sym;
@@ -4411,7 +4230,7 @@ dot_proc (dummy)
     {
       (md.unwind_check == unwind_check_warning
        ? as_warn
     {
       (md.unwind_check == unwind_check_warning
        ? as_warn
-       : as_bad) ("Missing .endp after previous .proc");
+       : as_bad) (_("Missing .endp after previous .proc"));
       while (unwind.proc_pending.next)
        {
          pending = unwind.proc_pending.next;
       while (unwind.proc_pending.next)
        {
          pending = unwind.proc_pending.next;
@@ -4426,16 +4245,15 @@ dot_proc (dummy)
   while (1)
     {
       SKIP_WHITESPACE ();
   while (1)
     {
       SKIP_WHITESPACE ();
-      name = input_line_pointer;
-      c = get_symbol_end ();
+      c = get_symbol_name (&name);
       p = input_line_pointer;
       if (!*name)
       p = input_line_pointer;
       if (!*name)
-       as_bad ("Empty argument of .proc");
+       as_bad (_("Empty argument of .proc"));
       else
        {
          sym = symbol_find_or_make (name);
          if (S_IS_DEFINED (sym))
       else
        {
          sym = symbol_find_or_make (name);
          if (S_IS_DEFINED (sym))
-           as_bad ("`%s' was already defined", name);
+           as_bad (_("`%s' was already defined"), name);
          else if (!last_pending)
            {
              unwind.proc_pending.sym = sym;
          else if (!last_pending)
            {
              unwind.proc_pending.sym = sym;
@@ -4443,14 +4261,14 @@ dot_proc (dummy)
            }
          else
            {
            }
          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;
              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;
       if (*input_line_pointer != ',')
        break;
       ++input_line_pointer;
@@ -4462,7 +4280,7 @@ dot_proc (dummy)
     }
   last_pending->next = NULL;
   demand_empty_rest_of_line ();
     }
   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;
 
   unwind.prologue = 0;
   unwind.prologue_count = 0;
@@ -4473,13 +4291,12 @@ dot_proc (dummy)
 }
 
 static void
 }
 
 static void
-dot_body (dummy)
-     int dummy ATTRIBUTE_UNUSED;
+dot_body (int dummy ATTRIBUTE_UNUSED)
 {
   if (!in_procedure ("body"))
     return;
   if (!unwind.prologue && !unwind.body && unwind.insn)
 {
   if (!in_procedure ("body"))
     return;
   if (!unwind.prologue && !unwind.body && unwind.insn)
-    as_warn ("Initial .body should precede any instructions");
+    as_warn (_("Initial .body should precede any instructions"));
   check_pending_save ();
 
   unwind.prologue = 0;
   check_pending_save ();
 
   unwind.prologue = 0;
@@ -4490,8 +4307,7 @@ dot_body (dummy)
 }
 
 static void
 }
 
 static void
-dot_prologue (dummy)
-     int dummy ATTRIBUTE_UNUSED;
+dot_prologue (int dummy ATTRIBUTE_UNUSED)
 {
   unsigned mask = 0, grsave = 0;
 
 {
   unsigned mask = 0, grsave = 0;
 
@@ -4499,52 +4315,53 @@ dot_prologue (dummy)
     return;
   if (unwind.prologue)
     {
     return;
   if (unwind.prologue)
     {
-      as_bad (".prologue within prologue");
+      as_bad (_(".prologue within prologue"));
       ignore_rest_of_line ();
       return;
     }
   if (!unwind.body && unwind.insn)
       ignore_rest_of_line ();
       return;
     }
   if (!unwind.body && unwind.insn)
-    as_warn ("Initial .prologue should precede any instructions");
+    as_warn (_("Initial .prologue should precede any instructions"));
 
   if (!is_it_end_of_statement ())
     {
       expressionS e;
 
   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
          || e.X_add_number > 0xf)
 
       if (e.X_op != O_constant
          || e.X_add_number < 0
          || e.X_add_number > 0xf)
-       as_bad ("First operand to .prologue must be a positive 4-bit constant");
+       as_bad (_("First operand to .prologue must be a positive 4-bit constant"));
       else if (e.X_add_number == 0)
       else if (e.X_add_number == 0)
-       as_warn ("Pointless use of zero first operand to .prologue");
+       as_warn (_("Pointless use of zero first operand to .prologue"));
       else
        mask = e.X_add_number;
       else
        mask = e.X_add_number;
-       n = popcount (mask);
+
+      n = popcount (mask);
 
       if (sep == ',')
 
       if (sep == ',')
-       parse_operand (&e, 0);
+       parse_operand_and_eval (&e, 0);
       else
        e.X_op = O_absent;
       else
        e.X_op = O_absent;
+
       if (e.X_op == O_constant
          && e.X_add_number >= 0
          && e.X_add_number < 128)
        {
          if (md.unwind_check == unwind_check_error)
       if (e.X_op == O_constant
          && e.X_add_number >= 0
          && e.X_add_number < 128)
        {
          if (md.unwind_check == unwind_check_error)
-           as_warn ("Using a constant as second operand to .prologue is deprecated");
+           as_warn (_("Using a constant as second operand to .prologue is deprecated"));
          grsave = e.X_add_number;
        }
       else if (e.X_op != O_register
               || (grsave = e.X_add_number - REG_GR) > 127)
        {
          grsave = e.X_add_number;
        }
       else if (e.X_op != O_register
               || (grsave = e.X_add_number - REG_GR) > 127)
        {
-         as_bad ("Second operand to .prologue must be a general register");
+         as_bad (_("Second operand to .prologue must be a general register"));
          grsave = 0;
        }
       else if (grsave > 128U - n)
        {
          grsave = 0;
        }
       else if (grsave > 128U - n)
        {
-         as_bad ("Second operand to .prologue must be the first of %d general registers", n);
+         as_bad (_("Second operand to .prologue must be the first of %d general registers"), n);
          grsave = 0;
        }
          grsave = 0;
        }
-
     }
 
   if (mask)
     }
 
   if (mask)
@@ -4560,8 +4377,7 @@ dot_prologue (dummy)
 }
 
 static void
 }
 
 static void
-dot_endp (dummy)
-     int dummy ATTRIBUTE_UNUSED;
+dot_endp (int dummy ATTRIBUTE_UNUSED)
 {
   expressionS e;
   int bytes_per_address;
 {
   expressionS e;
   int bytes_per_address;
@@ -4624,14 +4440,15 @@ dot_endp (dummy)
                                          symbol_get_frag (unwind.proc_pending.sym));
       else
        e.X_add_symbol = unwind.proc_pending.sym;
                                          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,
 
       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)
        {
 
       if (unwind.info)
        {
@@ -4640,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),
          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);
        }
     }
   subseg_set (saved_seg, saved_subseg);
@@ -4654,7 +4471,7 @@ dot_endp (dummy)
          symbolS *sym = pending->sym;
 
          if (!S_IS_DEFINED (sym))
          symbolS *sym = pending->sym;
 
          if (!S_IS_DEFINED (sym))
-           as_bad ("`%s' was not defined within procedure", S_GET_NAME (sym));
+           as_bad (_("`%s' was not defined within procedure"), S_GET_NAME (sym));
          else if (S_GET_SIZE (sym) == 0
                   && symbol_get_obj (sym)->size == NULL)
            {
          else if (S_GET_SIZE (sym) == 0
                   && symbol_get_obj (sym)->size == NULL)
            {
@@ -4666,8 +4483,7 @@ dot_endp (dummy)
                    S_SET_SIZE (sym, frag_now_fix () - S_GET_VALUE (sym));
                  else
                    {
                    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,
                      symbol_get_obj (sym)->size->X_op = O_subtract;
                      symbol_get_obj (sym)->size->X_add_symbol
                        = symbol_new (FAKE_LABEL_NAME, now_seg,
@@ -4686,13 +4502,12 @@ dot_endp (dummy)
       char *name, *p, c;
 
       SKIP_WHITESPACE ();
       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
         ? as_warn
       p = input_line_pointer;
       if (!*name)
        (md.unwind_check == unwind_check_warning
         ? as_warn
-        : as_bad) ("Empty argument of .endp");
+        : as_bad) (_("Empty argument of .endp"));
       else
        {
          symbolS *sym = symbol_find (name);
       else
        {
          symbolS *sym = symbol_find (name);
@@ -4706,10 +4521,10 @@ dot_endp (dummy)
                }
            }
          if (!sym || !pending)
                }
            }
          if (!sym || !pending)
-           as_warn ("`%s' was not specified with previous .proc", name);
+           as_warn (_("`%s' was not specified with previous .proc"), name);
        }
       *p = c;
        }
       *p = c;
-      SKIP_WHITESPACE ();
+      SKIP_WHITESPACE_AFTER_NAME ();
       if (*input_line_pointer != ',')
        break;
       ++input_line_pointer;
       if (*input_line_pointer != ',')
        break;
       ++input_line_pointer;
@@ -4721,7 +4536,7 @@ dot_endp (dummy)
   if (unwind.proc_pending.sym
       && S_GET_NAME (unwind.proc_pending.sym)
       && strcmp (S_GET_NAME (unwind.proc_pending.sym), FAKE_LABEL_NAME))
   if (unwind.proc_pending.sym
       && S_GET_NAME (unwind.proc_pending.sym)
       && strcmp (S_GET_NAME (unwind.proc_pending.sym), FAKE_LABEL_NAME))
-    as_warn ("`%s' should be an operand to this .endp",
+    as_warn (_("`%s' should be an operand to this .endp"),
             S_GET_NAME (unwind.proc_pending.sym));
   while (unwind.proc_pending.next)
     {
             S_GET_NAME (unwind.proc_pending.sym));
   while (unwind.proc_pending.next)
     {
@@ -4733,15 +4548,13 @@ dot_endp (dummy)
 }
 
 static void
 }
 
 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
 }
 
 static void
-dot_regstk (dummy)
-     int dummy ATTRIBUTE_UNUSED;
+dot_regstk (int dummy ATTRIBUTE_UNUSED)
 {
   int ins, locs, outs, rots;
 
 {
   int ins, locs, outs, rots;
 
@@ -4764,15 +4577,15 @@ dot_regstk (dummy)
   return;
 
  err:
   return;
 
  err:
-  as_bad ("Comma expected");
+  as_bad (_("Comma expected"));
   ignore_rest_of_line ();
 }
 
 static void
   ignore_rest_of_line ();
 }
 
 static void
-dot_rot (type)
-     int type;
+dot_rot (int type)
 {
 {
-  unsigned num_regs, num_alloced = 0;
+  offsetT num_regs;
+  valueT num_alloced = 0;
   struct dynreg **drpp, *dr;
   int ch, base_reg = 0;
   char *name, *start;
   struct dynreg **drpp, *dr;
   int ch, base_reg = 0;
   char *name, *start;
@@ -4789,7 +4602,7 @@ dot_rot (type)
   /* First, remove existing names from hash table.  */
   for (dr = md.dynreg[type]; dr && dr->num_regs; dr = dr->next)
     {
   /* First, remove existing names from hash table.  */
   for (dr = md.dynreg[type]; dr && dr->num_regs; dr = dr->next)
     {
-      hash_delete (md.dynreg_hash, dr->name);
+      hash_delete (md.dynreg_hash, dr->name, FALSE);
       /* FIXME: Free dr->name.  */
       dr->num_regs = 0;
     }
       /* FIXME: Free dr->name.  */
       dr->num_regs = 0;
     }
@@ -4797,15 +4610,14 @@ dot_rot (type)
   drpp = &md.dynreg[type];
   while (1)
     {
   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;
 
       len = strlen (ia64_canonicalize_symbol_name (start));
       *input_line_pointer = ch;
 
-      SKIP_WHITESPACE ();
+      SKIP_WHITESPACE_AFTER_NAME ();
       if (*input_line_pointer != '[')
        {
       if (*input_line_pointer != '[')
        {
-         as_bad ("Expected '['");
+         as_bad (_("Expected '['"));
          goto err;
        }
       ++input_line_pointer;    /* skip '[' */
          goto err;
        }
       ++input_line_pointer;    /* skip '[' */
@@ -4814,7 +4626,12 @@ dot_rot (type)
 
       if (*input_line_pointer++ != ']')
        {
 
       if (*input_line_pointer++ != ']')
        {
-         as_bad ("Expected ']'");
+         as_bad (_("Expected ']'"));
+         goto err;
+       }
+      if (num_regs <= 0)
+       {
+         as_bad (_("Number of elements must be positive"));
          goto err;
        }
       SKIP_WHITESPACE ();
          goto err;
        }
       SKIP_WHITESPACE ();
@@ -4825,7 +4642,7 @@ dot_rot (type)
        case DYNREG_GR:
          if (num_alloced > md.rot.num_regs)
            {
        case DYNREG_GR:
          if (num_alloced > md.rot.num_regs)
            {
-             as_bad ("Used more than the declared %d rotating registers",
+             as_bad (_("Used more than the declared %d rotating registers"),
                      md.rot.num_regs);
              goto err;
            }
                      md.rot.num_regs);
              goto err;
            }
@@ -4833,14 +4650,14 @@ dot_rot (type)
        case DYNREG_FR:
          if (num_alloced > 96)
            {
        case DYNREG_FR:
          if (num_alloced > 96)
            {
-             as_bad ("Used more than the available 96 rotating registers");
+             as_bad (_("Used more than the available 96 rotating registers"));
              goto err;
            }
          break;
        case DYNREG_PR:
          if (num_alloced > 48)
            {
              goto err;
            }
          break;
        case DYNREG_PR:
          if (num_alloced > 48)
            {
-             as_bad ("Used more than the available 48 rotating registers");
+             as_bad (_("Used more than the available 48 rotating registers"));
              goto err;
            }
          break;
              goto err;
            }
          break;
@@ -4868,7 +4685,7 @@ dot_rot (type)
 
       if (hash_insert (md.dynreg_hash, name, dr))
        {
 
       if (hash_insert (md.dynreg_hash, name, dr))
        {
-         as_bad ("Attempt to redefine register set `%s'", name);
+         as_bad (_("Attempt to redefine register set `%s'"), name);
          obstack_free (&notes, name);
          goto err;
        }
          obstack_free (&notes, name);
          goto err;
        }
@@ -4886,8 +4703,7 @@ dot_rot (type)
 }
 
 static void
 }
 
 static void
-dot_byteorder (byteorder)
-     int byteorder;
+dot_byteorder (int byteorder)
 {
   segment_info_type *seginfo = seg_info (now_seg);
 
 {
   segment_info_type *seginfo = seg_info (now_seg);
 
@@ -4917,16 +4733,14 @@ dot_byteorder (byteorder)
 }
 
 static void
 }
 
 static void
-dot_psr (dummy)
-     int dummy ATTRIBUTE_UNUSED;
+dot_psr (int dummy ATTRIBUTE_UNUSED)
 {
   char *option;
   int ch;
 
   while (1)
     {
 {
   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)
       if (strcmp (option, "lsb") == 0)
        md.flags &= ~EF_IA_64_BE;
       else if (strcmp (option, "msb") == 0)
@@ -4936,10 +4750,10 @@ dot_psr (dummy)
       else if (strcmp (option, "abi64") == 0)
        md.flags |= EF_IA_64_ABI64;
       else
       else if (strcmp (option, "abi64") == 0)
        md.flags |= EF_IA_64_ABI64;
       else
-       as_bad ("Unknown psr option `%s'", option);
+       as_bad (_("Unknown psr option `%s'"), option);
       *input_line_pointer = ch;
 
       *input_line_pointer = ch;
 
-      SKIP_WHITESPACE ();
+      SKIP_WHITESPACE_AFTER_NAME ();
       if (*input_line_pointer != ',')
        break;
 
       if (*input_line_pointer != ',')
        break;
 
@@ -4950,55 +4764,36 @@ dot_psr (dummy)
 }
 
 static void
 }
 
 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
 {
   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 *start, *end;
   int saved_auto_align;
   unsigned int section_count;
+  char *name;
+  char c;
 
   SKIP_WHITESPACE ();
   start = input_line_pointer;
 
   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;
   end = input_line_pointer;
-  SKIP_WHITESPACE ();
   if (*input_line_pointer != ',')
     {
   if (*input_line_pointer != ',')
     {
-      as_bad ("Comma expected after section name");
+      as_bad (_("Comma expected after section name"));
       ignore_rest_of_line ();
       return;
     }
       ignore_rest_of_line ();
       return;
     }
@@ -5006,15 +4801,15 @@ cross_section (ref, cons, ua)
   end = input_line_pointer + 1;                /* skip comma */
   input_line_pointer = start;
   md.keep_pending_output = 1;
   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);
   obj_elf_section (0);
-  if (section_count != bfd_count_sections(stdoutput))
-    as_warn ("Creating sections with .xdataN/.xrealN/.xstringZ is deprecated.");
+  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;
   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);
   if (ua)
     md.auto_align = saved_auto_align;
   obj_elf_previous (0);
@@ -5022,8 +4817,7 @@ cross_section (ref, cons, ua)
 }
 
 static void
 }
 
 static void
-dot_xdata (size)
-     int size;
+dot_xdata (int size)
 {
   cross_section (size, cons, 0);
 }
 {
   cross_section (size, cons, 0);
 }
@@ -5031,34 +4825,32 @@ dot_xdata (size)
 /* Why doesn't float_cons() call md_cons_align() the way cons() does?  */
 
 static void
 /* 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':
 {
   size_t alignment;
 
   switch (kind)
     {
     case 'd':
-      alignment = 8;
+      alignment = 3;
       break;
 
     case 'x':
     case 'X':
       break;
 
     case 'x':
     case 'X':
-      alignment = 16;
+      alignment = 4;
       break;
 
     case 'f':
     default:
       break;
 
     case 'f':
     default:
-      alignment = 4;
+      alignment = 2;
       break;
     }
       break;
     }
-  ia64_do_align (alignment);
+  do_align (alignment, NULL, 0, 0);
   float_cons (kind);
 }
 
 static void
   float_cons (kind);
 }
 
 static void
-stmt_cons_ua (size)
-     int size;
+stmt_cons_ua (int size)
 {
   int saved_auto_align = md.auto_align;
 
 {
   int saved_auto_align = md.auto_align;
 
@@ -5068,29 +4860,25 @@ stmt_cons_ua (size)
 }
 
 static void
 }
 
 static void
-dot_xfloat_cons (kind)
-     int kind;
+dot_xfloat_cons (int kind)
 {
   cross_section (kind, stmt_float_cons, 0);
 }
 
 static void
 {
   cross_section (kind, stmt_float_cons, 0);
 }
 
 static void
-dot_xstringer (zero)
-     int zero;
+dot_xstringer (int zero)
 {
   cross_section (zero, stringer, 0);
 }
 
 static void
 {
   cross_section (zero, stringer, 0);
 }
 
 static void
-dot_xdata_ua (size)
-     int size;
+dot_xdata_ua (int size)
 {
   cross_section (size, cons, 1);
 }
 
 static void
 {
   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);
 }
 {
   cross_section (kind, float_cons, 1);
 }
@@ -5098,8 +4886,7 @@ dot_xfloat_cons_ua (kind)
 /* .reg.val <regname>,value */
 
 static void
 /* .reg.val <regname>,value */
 
 static void
-dot_reg_val (dummy)
-     int dummy ATTRIBUTE_UNUSED;
+dot_reg_val (int dummy ATTRIBUTE_UNUSED)
 {
   expressionS reg;
 
 {
   expressionS reg;
 
@@ -5135,8 +4922,7 @@ dot_reg_val (dummy)
   .serialize.instruction
  */
 static void
   .serialize.instruction
  */
 static void
-dot_serialize (type)
-     int type;
+dot_serialize (int type)
 {
   insn_group_break (0, 0, 0);
   if (type)
 {
   insn_group_break (0, 0, 0);
   if (type)
@@ -5156,8 +4942,7 @@ dot_serialize (type)
  */
 
 static void
  */
 
 static void
-dot_dv_mode (type)
-     int type;
+dot_dv_mode (int type)
 {
   if (md.manual_bundling)
     as_warn (_("Directive invalid within a bundle"));
 {
   if (md.manual_bundling)
     as_warn (_("Directive invalid within a bundle"));
@@ -5193,11 +4978,10 @@ dot_dv_mode (type)
 }
 
 static void
 }
 
 static void
-print_prmask (mask)
-     valueT mask;
+print_prmask (valueT mask)
 {
   int regno;
 {
   int regno;
-  char *comma = "";
+  const char *comma = "";
   for (regno = 0; regno < 64; regno++)
     {
       if (mask & ((valueT) 1 << regno))
   for (regno = 0; regno < 64; regno++)
     {
       if (mask & ((valueT) 1 << regno))
@@ -5216,8 +5000,7 @@ print_prmask (mask)
  */
 
 static void
  */
 
 static void
-dot_pred_rel (type)
-     int type;
+dot_pred_rel (int type)
 {
   valueT mask = 0;
   int count = 0;
 {
   valueT mask = 0;
   int count = 0;
@@ -5240,8 +5023,11 @@ dot_pred_rel (type)
        }
       else if (*input_line_pointer == '@')
        {
        }
       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';
 
          if (strcmp (form, "mutex") == 0)
            type = 'm';
@@ -5249,7 +5035,7 @@ dot_pred_rel (type)
            type = 'c';
          else if (strcmp (form, "imply") == 0)
            type = 'i';
            type = 'c';
          else if (strcmp (form, "imply") == 0)
            type = 'i';
-         *input_line_pointer = c;
+         (void) restore_line_pointer (c);
        }
       else
        {
        }
       else
        {
@@ -5268,14 +5054,13 @@ dot_pred_rel (type)
       SKIP_WHITESPACE ();
     }
 
       SKIP_WHITESPACE ();
     }
 
-  SKIP_WHITESPACE ();
   while (1)
     {
       valueT bits = 1;
   while (1)
     {
       valueT bits = 1;
-      int regno;
+      int sep, regno;
       expressionS pr, *pr1, *pr2;
 
       expressionS pr, *pr1, *pr2;
 
-      expression_and_evaluate (&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)
       if (pr.X_op == O_register
          && pr.X_add_number >= REG_P
          && pr.X_add_number <= REG_P + 63)
@@ -5322,10 +5107,8 @@ dot_pred_rel (type)
       if (mask & bits)
        as_warn (_("Duplicate predicate register ignored"));
       mask |= bits;
       if (mask & bits)
        as_warn (_("Duplicate predicate register ignored"));
       mask |= bits;
-      if (*input_line_pointer != ',')
+      if (sep != ',')
        break;
        break;
-      ++input_line_pointer;
-      SKIP_WHITESPACE ();
     }
 
   switch (type)
     }
 
   switch (type)
@@ -5381,8 +5164,7 @@ dot_pred_rel (type)
    Otherwise, only global labels are considered entry points.  */
 
 static void
    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;
 {
   const char *err;
   char *name;
@@ -5391,17 +5173,16 @@ dot_entry (dummy)
 
   do
     {
 
   do
     {
-      name = input_line_pointer;
-      c = get_symbol_end ();
+      c = get_symbol_name (&name);
       symbolP = symbol_find_or_make (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;
       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 == ',')
        {
       c = *input_line_pointer;
       if (c == ',')
        {
@@ -5420,8 +5201,7 @@ dot_entry (dummy)
    "base" is used to distinguish between offsets from a different base.  */
 
 static void
    "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 ();
 {
   md.mem_offset.hint = 1;
   md.mem_offset.offset = get_absolute_expression ();
@@ -5516,8 +5296,8 @@ const pseudo_typeS md_pseudo_table[] =
     { "xreal8", dot_xfloat_cons, 'd' },
     { "xreal10", dot_xfloat_cons, 'x' },
     { "xreal16", dot_xfloat_cons, 'X' },
     { "xreal8", dot_xfloat_cons, 'd' },
     { "xreal10", dot_xfloat_cons, 'x' },
     { "xreal16", dot_xfloat_cons, 'X' },
-    { "xstring", dot_xstringer, 0 },
-    { "xstringz", dot_xstringer, 1 },
+    { "xstring", dot_xstringer, 8 + 0 },
+    { "xstringz", dot_xstringer, 8 + 1 },
 
     /* unaligned versions:  */
     { "xdata2.ua", dot_xdata_ua, 2 },
 
     /* unaligned versions:  */
     { "xdata2.ua", dot_xdata_ua, 2 },
@@ -5553,6 +5333,10 @@ const pseudo_typeS md_pseudo_table[] =
     {"4byte", stmt_cons_ua, 4},
     {"8byte", stmt_cons_ua, 8},
 
     {"4byte", stmt_cons_ua, 4},
     {"8byte", stmt_cons_ua, 8},
 
+#ifdef TE_VMS
+    {"vms_common", obj_elf_vms_common, 0},
+#endif
+
     { NULL, 0, 0 }
   };
 
     { NULL, 0, 0 }
   };
 
@@ -5574,8 +5358,8 @@ pseudo_opcode[] =
     { "real8", stmt_float_cons, 'd' },
     { "real10", stmt_float_cons, 'x' },
     { "real16", stmt_float_cons, 'X' },
     { "real8", stmt_float_cons, 'd' },
     { "real10", stmt_float_cons, 'x' },
     { "real16", stmt_float_cons, 'X' },
-    { "string", stringer, 0 },
-    { "stringz", stringer, 1 },
+    { "string", stringer, 8 + 0 },
+    { "stringz", stringer, 8 + 1 },
 
     /* unaligned versions:  */
     { "data2.ua", stmt_cons_ua, 2 },
 
     /* unaligned versions:  */
     { "data2.ua", stmt_cons_ua, 2 },
@@ -5592,16 +5376,14 @@ pseudo_opcode[] =
    the symbol table.  */
 
 static symbolS *
    the symbol table.  */
 
 static symbolS *
-declare_register (name, regnum)
-     const char *name;
-     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);
 
 {
   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);
   if (err)
     as_fatal ("Inserting \"%s\" into register table failed: %s",
              name, err);
@@ -5610,24 +5392,22 @@ declare_register (name, regnum)
 }
 
 static void
 }
 
 static void
-declare_register_set (prefix, num_regs, base_regnum)
-     const char *prefix;
-     int num_regs;
-     int base_regnum;
+declare_register_set (const char *prefix,
+                     unsigned int num_regs,
+                     unsigned int base_regnum)
 {
   char name[8];
 {
   char name[8];
-  int i;
+  unsigned int i;
 
   for (i = 0; i < num_regs; ++i)
     {
 
   for (i = 0; i < num_regs; ++i)
     {
-      sprintf (name, "%s%u", prefix, i);
+      snprintf (name, sizeof (name), "%s%u", prefix, i);
       declare_register (name, base_regnum + i);
     }
 }
 
 static unsigned int
       declare_register (name, base_regnum + i);
     }
 }
 
 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;
 {
   const struct ia64_operand *odesc = &elf64_ia64_operands[opnd];
   unsigned int bits = 0;
@@ -5641,12 +5421,9 @@ operand_width (opnd)
 }
 
 static enum operand_match_result
 }
 
 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;
   int bits, relocatable = 0;
   struct insn_fix *fix;
   bfd_signed_vma val;
@@ -5756,6 +5533,12 @@ operand_match (idesc, index, e)
        return OPERAND_MATCH;
       break;
 
        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:
     case IA64_OPND_F1:
     case IA64_OPND_F2:
     case IA64_OPND_F3:
@@ -5800,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_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
     case IA64_OPND_RR_R3:
       if (e->X_op == O_index && e->X_op_symbol
          && (S_GET_VALUE (e->X_op_symbol) - IND_CPUID
@@ -5816,7 +5600,7 @@ operand_match (idesc, index, e)
     case IA64_OPND_CNT2a:
     case IA64_OPND_LEN4:
     case IA64_OPND_LEN6:
     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))
       if (e->X_op == O_constant)
        {
          if ((bfd_vma) (e->X_add_number - 1) < ((bfd_vma) 1 << bits))
@@ -5890,7 +5674,7 @@ operand_match (idesc, index, e)
                e->X_op = O_symbol;
            }
 
                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;
          fix->expr = *e;
          fix->is_pcrel = 0;
          ++CURR_SLOT.num_fixups;
@@ -5900,6 +5684,17 @@ operand_match (idesc, index, e)
        return OPERAND_MATCH;
       break;
 
        return OPERAND_MATCH;
       break;
 
+    case IA64_OPND_IMMU5b:
+      if (e->X_op == O_constant)
+       {
+         val = e->X_add_number;
+         if (val >= 32 && val <= 63)
+           return OPERAND_MATCH;
+         else
+           return OPERAND_OUT_OF_RANGE;
+       }
+      break;
+
     case IA64_OPND_CCNT5:
     case IA64_OPND_CNT5:
     case IA64_OPND_CNT6:
     case IA64_OPND_CCNT5:
     case IA64_OPND_CNT5:
     case IA64_OPND_CNT6:
@@ -5909,12 +5704,14 @@ operand_match (idesc, index, e)
     case IA64_OPND_IMMU2:
     case IA64_OPND_IMMU7a:
     case IA64_OPND_IMMU7b:
     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:
     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))
       if (e->X_op == O_constant)
        {
          if ((bfd_vma) e->X_add_number < ((bfd_vma) 1 << bits))
@@ -5925,7 +5722,7 @@ operand_match (idesc, index, e)
       break;
 
     case IA64_OPND_IMMU9:
       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))
       if (e->X_op == O_constant)
        {
          if ((bfd_vma) e->X_add_number < ((bfd_vma) 1 << bits))
@@ -6001,14 +5798,14 @@ operand_match (idesc, index, e)
     case IA64_OPND_IMM8M1U8:
     case IA64_OPND_IMM9a:
     case IA64_OPND_IMM9b:
     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 (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;
            fix->code = BFD_RELOC_IA64_IMM14;
          else
            fix->code = BFD_RELOC_IA64_IMM22;
@@ -6020,7 +5817,7 @@ operand_match (idesc, index, e)
                e->X_op = O_symbol;
            }
 
                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;
          fix->expr = *e;
          fix->is_pcrel = 0;
          ++CURR_SLOT.num_fixups;
@@ -6126,7 +5923,7 @@ operand_match (idesc, index, e)
            abort ();
 
          fix->code = ia64_gen_real_reloc_type (e->X_op_symbol, fix->code);
            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;
          fix->expr = *e;
          fix->is_pcrel = 1;
          ++CURR_SLOT.num_fixups;
@@ -6145,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);
             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;
          fix->expr = *e;
          fix->is_pcrel = 1;
          ++CURR_SLOT.num_fixups;
@@ -6159,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;
     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;
 
       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;
     }
     default:
       break;
     }
@@ -6172,22 +6002,52 @@ operand_match (idesc, index, e)
 }
 
 static int
 }
 
 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 ();
 {
   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;
 }
 
   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.  */
 /* 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.  */
@@ -6204,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 *
    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;
 {
   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;
@@ -6217,7 +6076,7 @@ parse_operands (idesc)
   char *first_arg = 0, *end, *saved_input_pointer;
   unsigned int sof;
 
   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
 
   strcpy (mnemonic, idesc->name);
   if (idesc->operands[2] == IA64_OPND_SOF
@@ -6231,7 +6090,7 @@ parse_operands (idesc)
       end = strchr (input_line_pointer, '=');
       if (!end)
        {
       end = strchr (input_line_pointer, '=');
       if (!end)
        {
-         as_bad ("Expected separator `='");
+         as_bad (_("Expected separator `='"));
          return 0;
        }
       input_line_pointer = end + 1;
          return 0;
        }
       input_line_pointer = end + 1;
@@ -6241,9 +6100,10 @@ parse_operands (idesc)
 
   for (; ; ++i)
     {
 
   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;
        }
          if (CURR_SLOT.opnd[i].X_op == O_absent)
            break;
        }
@@ -6264,14 +6124,14 @@ parse_operands (idesc)
       if (sep == '=')
        {
          if (num_outputs > 0)
       if (sep == '=')
        {
          if (num_outputs > 0)
-           as_bad ("Duplicate equal sign (=) in instruction");
+           as_bad (_("Duplicate equal sign (=) in instruction"));
          else
            num_outputs = i + 1;
        }
     }
   if (sep != '\0')
     {
          else
            num_outputs = i + 1;
        }
     }
   if (sep != '\0')
     {
-      as_bad ("Illegal operand separator `%c'", sep);
+      as_bad (_("Illegal operand separator `%c'"), sep);
       return 0;
     }
 
       return 0;
     }
 
@@ -6297,7 +6157,8 @@ parse_operands (idesc)
       /* now we can parse the first arg:  */
       saved_input_pointer = input_line_pointer;
       input_line_pointer = first_arg;
       /* 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;
       if (sep != '=')
        --num_outputs;  /* force error */
       input_line_pointer = saved_input_pointer;
@@ -6385,15 +6246,15 @@ parse_operands (idesc)
   if (!idesc)
     {
       if (expected_operand)
   if (!idesc)
     {
       if (expected_operand)
-       as_bad ("Operand %u of `%s' should be %s",
+       as_bad (_("Operand %u of `%s' should be %s"),
                error_pos + 1, mnemonic,
                elf64_ia64_operands[expected_operand].desc);
       else if (highest_unmatched_operand < 0 && !(highest_unmatched_operand & 1))
                error_pos + 1, mnemonic,
                elf64_ia64_operands[expected_operand].desc);
       else if (highest_unmatched_operand < 0 && !(highest_unmatched_operand & 1))
-       as_bad ("Wrong number of output operands");
+       as_bad (_("Wrong number of output operands"));
       else if (highest_unmatched_operand < 0 && !(highest_unmatched_operand & 2))
       else if (highest_unmatched_operand < 0 && !(highest_unmatched_operand & 2))
-       as_bad ("Wrong number of input operands");
+       as_bad (_("Wrong number of input operands"));
       else
       else
-       as_bad ("Operand mismatch");
+       as_bad (_("Operand mismatch"));
       return 0;
     }
 
       return 0;
     }
 
@@ -6475,10 +6336,10 @@ parse_operands (idesc)
        case 0:
          break;
        default:
        case 0:
          break;
        default:
-         as_warn ("Invalid use of `%c%d' as output operand", reg_class, regno);
+         as_warn (_("Invalid use of `%c%d' as output operand"), reg_class, regno);
          break;
        case 'm':
          break;
        case 'm':
-         as_warn ("Invalid use of `r%d' as base update address operand", regno);
+         as_warn (_("Invalid use of `r%d' as base update address operand"), regno);
          break;
        }
     }
          break;
        }
     }
@@ -6502,28 +6363,26 @@ parse_operands (idesc)
       else
        reg_class = 0;
       if (reg_class)
       else
        reg_class = 0;
       if (reg_class)
-       as_warn ("Invalid duplicate use of `%c%d'", reg_class, reg1);
+       as_warn (_("Invalid duplicate use of `%c%d'"), reg_class, reg1);
     }
   else if (((reg1 >= REG_FR && reg1 <= REG_FR + 31
             && reg2 >= REG_FR && reg2 <= REG_FR + 31)
            || (reg1 >= REG_FR + 32 && reg1 <= REG_FR + 127
             && reg2 >= REG_FR + 32 && reg2 <= REG_FR + 127))
           && ! ((reg1 ^ reg2) & 1))
     }
   else if (((reg1 >= REG_FR && reg1 <= REG_FR + 31
             && reg2 >= REG_FR && reg2 <= REG_FR + 31)
            || (reg1 >= REG_FR + 32 && reg1 <= REG_FR + 127
             && reg2 >= REG_FR + 32 && reg2 <= REG_FR + 127))
           && ! ((reg1 ^ reg2) & 1))
-    as_warn ("Invalid simultaneous use of `f%d' and `f%d'",
+    as_warn (_("Invalid simultaneous use of `f%d' and `f%d'"),
             reg1 - REG_FR, reg2 - REG_FR);
   else if ((reg1 >= REG_FR && reg1 <= REG_FR + 31
            && reg2 >= REG_FR + 32 && reg2 <= REG_FR + 127)
           || (reg1 >= REG_FR + 32 && reg1 <= REG_FR + 127
            && reg2 >= REG_FR && reg2 <= REG_FR + 31))
             reg1 - REG_FR, reg2 - REG_FR);
   else if ((reg1 >= REG_FR && reg1 <= REG_FR + 31
            && reg2 >= REG_FR + 32 && reg2 <= REG_FR + 127)
           || (reg1 >= REG_FR + 32 && reg1 <= REG_FR + 127
            && reg2 >= REG_FR && reg2 <= REG_FR + 31))
-    as_warn ("Dangerous simultaneous use of `f%d' and `f%d'",
+    as_warn (_("Dangerous simultaneous use of `f%d' and `f%d'"),
             reg1 - REG_FR, reg2 - REG_FR);
   return idesc;
 }
 
 static void
             reg1 - REG_FR, reg2 - REG_FR);
   return 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;
 {
   const struct ia64_operand *odesc, *o2desc;
   struct ia64_opcode *idesc = slot->idesc;
@@ -6543,7 +6402,7 @@ build_insn (slot, insnp)
       else if (slot->opnd[i].X_op == O_big)
        {
          /* This must be the value 0x10000000000000000.  */
       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
          val = 0;
        }
       else
@@ -6586,6 +6445,10 @@ build_insn (slot, insnp)
          val -= REG_CR;
          break;
 
          val -= REG_CR;
          break;
 
+       case IA64_OPND_DAHR3:
+         val -= REG_DAHR;
+         break;
+
        case IA64_OPND_F1:
        case IA64_OPND_F2:
        case IA64_OPND_F3:
        case IA64_OPND_F1:
        case IA64_OPND_F2:
        case IA64_OPND_F3:
@@ -6612,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_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;
        case IA64_OPND_RR_R3:
          val -= REG_GR;
          break;
@@ -6624,7 +6488,7 @@ build_insn (slot, insnp)
       err = (*odesc->insert) (odesc, val, &insn);
       if (err)
        as_bad_where (slot->src_file, slot->src_line,
       err = (*odesc->insert) (odesc, val, &insn);
       if (err)
        as_bad_where (slot->src_file, slot->src_line,
-                     "Bad operand value: %s", err);
+                     _("Bad operand value: %s"), err);
       if (idesc->flags & IA64_OPCODE_PSEUDO)
        {
          if ((idesc->flags & IA64_OPCODE_F2_EQ_F3)
       if (idesc->flags & IA64_OPCODE_PSEUDO)
        {
          if ((idesc->flags & IA64_OPCODE_F2_EQ_F3)
@@ -6646,12 +6510,12 @@ build_insn (slot, insnp)
 }
 
 static void
 }
 
 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;
 {
   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;
   bfd_vma insn[3] = { -1, -1, -1 };
   struct ia64_opcode *idesc;
   int end_of_insn_group = 0, user_template = -1;
@@ -6666,14 +6530,14 @@ emit_one_bundle ()
   int addr_mod;
 
   first = (md.curr_slot + NUM_SLOTS - md.num_slots_in_use) % NUM_SLOTS;
   int addr_mod;
 
   first = (md.curr_slot + NUM_SLOTS - md.num_slots_in_use) % NUM_SLOTS;
-  know (first >= 0 & first < NUM_SLOTS);
+  know (first >= 0 && first < NUM_SLOTS);
   n = MIN (3, md.num_slots_in_use);
 
   /* Determine template: user user_template if specified, best match
      otherwise:  */
 
   if (md.slot[first].user_template >= 0)
   n = MIN (3, md.num_slots_in_use);
 
   /* Determine template: user user_template if specified, best match
      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.  */
   else
     {
       /* Auto select appropriate template.  */
@@ -6686,12 +6550,12 @@ emit_one_bundle ()
          type[i] = md.slot[curr].idesc->type;
          curr = (curr + 1) % NUM_SLOTS;
        }
          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)
     }
 
   /* 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);
 
 
   f = frag_more (16);
 
@@ -6767,7 +6631,7 @@ emit_one_bundle ()
          if (manual_bundling && !manual_bundling_off)
            {
              as_bad_where (md.slot[curr].src_file, md.slot[curr].src_line,
          if (manual_bundling && !manual_bundling_off)
            {
              as_bad_where (md.slot[curr].src_file, md.slot[curr].src_line,
-                           "`%s' must be last in bundle", idesc->name);
+                           _("`%s' must be last in bundle"), idesc->name);
              if (i < 2)
                manual_bundling = -1; /* Suppress meaningless post-loop errors.  */
            }
              if (i < 2)
                manual_bundling = -1; /* Suppress meaningless post-loop errors.  */
            }
@@ -6785,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.  */
             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:
          switch (idesc->type)
            {
            case IA64_TYPE_M:
@@ -6799,8 +6663,8 @@ emit_one_bundle ()
 
            default:
              as_bad_where (md.slot[curr].src_file, md.slot[curr].src_line,
 
            default:
              as_bad_where (md.slot[curr].src_file, md.slot[curr].src_line,
-                           "Internal error: don't know how to force %s to end"
-                           "of instruction group", idesc->name);
+                           _("Internal error: don't know how to force %s to end of instruction group"),
+                           idesc->name);
              required_slot = i;
              break;
            }
              required_slot = i;
              break;
            }
@@ -6809,10 +6673,10 @@ emit_one_bundle ()
                  || (required_slot == 2 && !manual_bundling_off)
                  || (user_template >= 0
                      /* Changing from MMI to M;MI is OK.  */
                  || (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,
            {
              as_bad_where (md.slot[curr].src_file, md.slot[curr].src_line,
-                           "`%s' must be last in instruction group",
+                           _("`%s' must be last in instruction group"),
                            idesc->name);
              if (i < 2 && required_slot == 2 && !manual_bundling_off)
                manual_bundling = -1; /* Suppress meaningless post-loop errors.  */
                            idesc->name);
              if (i < 2 && required_slot == 2 && !manual_bundling_off)
                manual_bundling = -1; /* Suppress meaningless post-loop errors.  */
@@ -6822,7 +6686,7 @@ emit_one_bundle ()
            break;
 
          i = required_slot;
            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
            {
              /* If we switch the template, we need to reset the NOPs
                 after slot i.  The slot-types of the instructions ahead
@@ -6830,15 +6694,19 @@ emit_one_bundle ()
                 changing NOPs in front of this slot.  */
              for (j = i; j < 3; ++j)
                insn[j] = nop[ia64_templ_desc[required_template].exec_unit[j]];
                 changing NOPs in front of this slot.  */
              for (j = i; j < 3; ++j)
                insn[j] = nop[ia64_templ_desc[required_template].exec_unit[j]];
+
+             /* We just picked a template that includes the stop bit in the
+                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)
        {
          if (manual_bundling)
            {
              as_bad_where (md.slot[curr].src_file, md.slot[curr].src_line,
        }
       if (curr != first && md.slot[curr].label_fixups)
        {
          if (manual_bundling)
            {
              as_bad_where (md.slot[curr].src_file, md.slot[curr].src_line,
-                         "Label must be first in a bundle");
+                           _("Label must be first in a bundle"));
              manual_bundling = -1; /* Suppress meaningless post-loop errors.  */
            }
          /* This insn must go into the first slot of a bundle.  */
              manual_bundling = -1; /* Suppress meaningless post-loop errors.  */
            }
          /* This insn must go into the first slot of a bundle.  */
@@ -6851,18 +6719,18 @@ emit_one_bundle ()
             bundle.  See if we can switch to an other template with
             an appropriate boundary.  */
 
             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
          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))))
            {
                                 == IA64_UNIT_M))))
            {
-             template = 5;
+             template_val = 5;
              end_of_insn_group = 0;
            }
          else if (i == 2 && (user_template == 0
                              || (user_template < 0
              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
                                      == 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
@@ -6875,7 +6743,7 @@ emit_one_bundle ()
                      first in the group! --davidm 99/12/16  */
                   && (idesc->flags & IA64_OPCODE_FIRST) == 0)
            {
                      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
              end_of_insn_group = 0;
            }
          else if (i == 1
@@ -6887,15 +6755,15 @@ emit_one_bundle ()
            /* can't fit this insn */
            break;
 
            /* 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)
            /* 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)
 
       /* resolve dynamic opcodes such as "break", "hint", and "nop":  */
       if (idesc->type == IA64_TYPE_DYN)
@@ -6915,7 +6783,7 @@ emit_one_bundle ()
                    case hint_b_ok:
                      break;
                    case hint_b_warning:
                    case hint_b_ok:
                      break;
                    case hint_b_warning:
-                     as_warn ("hint in B unit may be treated as nop");
+                     as_warn (_("hint in B unit may be treated as nop"));
                      break;
                    case hint_b_error:
                      /* When manual bundling is off and there is no
                      break;
                    case hint_b_error:
                      /* When manual bundling is off and there is no
@@ -6926,7 +6794,7 @@ emit_one_bundle ()
                      if (!manual_bundling && user_template < 0)
                        insn_unit = IA64_UNIT_I;
                      else
                      if (!manual_bundling && user_template < 0)
                        insn_unit = IA64_UNIT_I;
                      else
-                       as_bad ("hint in B unit can't be used");
+                       as_bad (_("hint in B unit can't be used"));
                      break;
                    }
                }
                      break;
                    }
                }
@@ -6936,13 +6804,14 @@ emit_one_bundle ()
            {
              insn_unit = IA64_UNIT_M;
              if (required_unit == IA64_UNIT_I
            {
              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
                insn_unit = IA64_UNIT_I;
            }
          else
-           as_fatal ("emit_one_bundle: unexpected dynamic op");
+           as_fatal (_("emit_one_bundle: unexpected dynamic op"));
 
 
-         sprintf (mnemonic, "%s.%c", idesc->name, "?imbfxx"[insn_unit]);
+         snprintf (mnemonic, sizeof (mnemonic), "%s.%c",
+                   idesc->name, "?imbfxx"[insn_unit]);
          opnd1 = idesc->operands[0];
          opnd2 = idesc->operands[1];
          ia64_free_opcode (idesc);
          opnd1 = idesc->operands[0];
          opnd2 = idesc->operands[1];
          ia64_free_opcode (idesc);
@@ -7022,28 +6891,29 @@ emit_one_bundle ()
          md.slot[curr].unwind_record = NULL;
        }
 
          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;
          fix = fix_new_exp (frag_now, frag_now_fix () - 16 + i, 8,
                             &ifix->expr, ifix->is_pcrel, ifix->code);
          fix->tc_fix_data.opnd = ifix->opnd;
       for (j = 0; j < md.slot[curr].num_fixups; ++j)
        {
          ifix = md.slot[curr].fixup + j;
          fix = fix_new_exp (frag_now, frag_now_fix () - 16 + i, 8,
                             &ifix->expr, ifix->is_pcrel, ifix->code);
          fix->tc_fix_data.opnd = ifix->opnd;
-         fix->fx_plt = (fix->fx_r_type == BFD_RELOC_IA64_PLTOFF22);
          fix->fx_file = md.slot[curr].src_file;
          fix->fx_line = md.slot[curr].src_line;
        }
 
       end_of_insn_group = md.slot[curr].end_of_insn_group;
 
          fix->fx_file = md.slot[curr].src_file;
          fix->fx_line = md.slot[curr].src_line;
        }
 
       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]));
       /* clear slot:  */
       ia64_free_opcode (md.slot[curr].idesc);
       memset (md.slot + curr, 0, sizeof (md.slot[curr]));
@@ -7057,47 +6927,51 @@ emit_one_bundle ()
       curr = (curr + 1) % NUM_SLOTS;
       idesc = md.slot[curr].idesc;
     }
       curr = (curr + 1) % NUM_SLOTS;
       idesc = md.slot[curr].idesc;
     }
-  if (manual_bundling > 0)
+
+  /* A user template was specified, but the first following instruction did
+     not fit.  This can happen with or without manual bundling.  */
+  if (md.num_slots_in_use > 0 && last_slot < 0)
+    {
+      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_val].name);
+      /* Drop first insn so we don't livelock.  */
+      --md.num_slots_in_use;
+      know (curr == first);
+      ia64_free_opcode (md.slot[curr].idesc);
+      memset (md.slot + curr, 0, sizeof (md.slot[curr]));
+      md.slot[curr].user_template = -1;
+    }
+  else if (manual_bundling > 0)
     {
       if (md.num_slots_in_use > 0)
        {
          if (last_slot >= 2)
            as_bad_where (md.slot[curr].src_file, md.slot[curr].src_line,
     {
       if (md.num_slots_in_use > 0)
        {
          if (last_slot >= 2)
            as_bad_where (md.slot[curr].src_file, md.slot[curr].src_line,
-                         "`%s' does not fit into bundle", idesc->name);
-         else if (last_slot < 0)
-           {
-             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);
-             /* Drop first insn so we don't livelock.  */
-             --md.num_slots_in_use;
-             know (curr == first);
-             ia64_free_opcode (md.slot[curr].idesc);
-             memset (md.slot + curr, 0, sizeof (md.slot[curr]));
-             md.slot[curr].user_template = -1;
-           }
+                         _("`%s' does not fit into bundle"), idesc->name);
          else
            {
              const char *where;
 
          else
            {
              const char *where;
 
-             if (template == 2)
+             if (template_val == 2)
                where = "X slot";
              else if (last_slot == 0)
                where = "slots 2 or 3";
              else
                where = "slot 3";
              as_bad_where (md.slot[curr].src_file, md.slot[curr].src_line,
                where = "X slot";
              else if (last_slot == 0)
                where = "slots 2 or 3";
              else
                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);
+                           _("`%s' can't go in %s of %s template"),
+                           idesc->name, where, ia64_templ_desc[template_val].name);
            }
        }
       else
        as_bad_where (md.slot[curr].src_file, md.slot[curr].src_line,
            }
        }
       else
        as_bad_where (md.slot[curr].src_file, md.slot[curr].src_line,
-                     "Missing '}' at end of file");
+                     _("Missing '}' at end of file"));
     }
     }
+
   know (md.num_slots_in_use < NUM_SLOTS);
 
   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);
   t1 = ((insn[1] >> 18) & 0x7fffff) | (insn[2] << 23);
 
   number_to_chars_littleendian (f + 0, t0, 8);
@@ -7105,9 +6979,7 @@ emit_one_bundle ()
 }
 
 int
 }
 
 int
-md_parse_option (c, arg)
-     int c;
-     char *arg;
+md_parse_option (int c, const char *arg)
 {
 
   switch (c)
 {
 
   switch (c)
@@ -7266,8 +7138,7 @@ md_parse_option (c, arg)
 }
 
 void
 }
 
 void
-md_show_usage (stream)
-     FILE *stream;
+md_show_usage (FILE *stream)
 {
   fputs (_("\
 IA-64 options:\n\
 {
   fputs (_("\
 IA-64 options:\n\
@@ -7284,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\
                          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\
   -xauto                 automagically remove dependency violations (default)\n\
   -xnone                 turn off dependency violation checking\n\
   -xdebug                debug dependency violation checker\n\
@@ -7296,7 +7169,7 @@ IA-64 options:\n\
 }
 
 void
 }
 
 void
-ia64_after_parse_args ()
+ia64_after_parse_args (void)
 {
   if (debug_type == DEBUG_STABS)
     as_fatal (_("--gstabs is not supported for ia64"));
 {
   if (debug_type == DEBUG_STABS)
     as_fatal (_("--gstabs is not supported for ia64"));
@@ -7364,9 +7237,9 @@ 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
    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, regnum, ok;
+  int i, j, k, t, goodness, best, ok;
   const char *err;
   char name[8];
 
   const char *err;
   char name[8];
 
@@ -7452,6 +7325,12 @@ md_begin ()
     symbol_new (".<iplt>", undefined_section, FUNC_IPLT_RELOC,
                &zero_address_frag);
 
     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.  */
  if (md.tune != itanium1)
    {
      /* Convert MFI NOPs bundles into MMI NOPs bundles.  */
@@ -7531,7 +7410,7 @@ md_begin ()
       err = hash_insert (md.pseudo_hash, pseudo_opcode[i].name,
                         (void *) (pseudo_opcode + i));
       if (err)
       err = hash_insert (md.pseudo_hash, pseudo_opcode[i].name,
                         (void *) (pseudo_opcode + i));
       if (err)
-       as_fatal ("ia64.md_begin: can't hash `%s': %s",
+       as_fatal (_("ia64.md_begin: can't hash `%s': %s"),
                  pseudo_opcode[i].name, err);
     }
 
                  pseudo_opcode[i].name, err);
     }
 
@@ -7541,87 +7420,61 @@ md_begin ()
   md.entry_hash = hash_new ();
 
   /* general registers:  */
   md.entry_hash = hash_new ();
 
   /* general registers:  */
-  for (i = REG_GR; i < REG_GR + 128; ++i)
-    {
-      sprintf (name, "r%d", i - REG_GR);
-      md.regsym[i] = declare_register (name, i);
-    }
+  declare_register_set ("r", 128, REG_GR);
+  declare_register ("gp", REG_GR +  1);
+  declare_register ("sp", REG_GR + 12);
+  declare_register ("tp", REG_GR + 13);
+  declare_register_set ("ret", 4, REG_GR + 8);
 
   /* floating point registers:  */
 
   /* floating point registers:  */
-  for (i = REG_FR; i < REG_FR + 128; ++i)
-    {
-      sprintf (name, "f%d", i - REG_FR);
-      md.regsym[i] = declare_register (name, i);
-    }
-
-  /* application registers:  */
-  for (i = REG_AR; i < REG_AR + 128; ++i)
-    {
-      sprintf (name, "ar%d", i - REG_AR);
-      md.regsym[i] = declare_register (name, i);
-    }
-
-  /* control registers:  */
-  for (i = REG_CR; i < REG_CR + 128; ++i)
-    {
-      sprintf (name, "cr%d", i - REG_CR);
-      md.regsym[i] = declare_register (name, i);
-    }
-
-  /* predicate registers:  */
-  for (i = REG_P; i < REG_P + 64; ++i)
-    {
-      sprintf (name, "p%d", i - REG_P);
-      md.regsym[i] = declare_register (name, i);
-    }
+  declare_register_set ("f", 128, REG_FR);
+  declare_register_set ("farg", 8, REG_FR + 8);
+  declare_register_set ("fret", 8, REG_FR + 8);
 
   /* branch registers:  */
 
   /* branch registers:  */
-  for (i = REG_BR; i < REG_BR + 8; ++i)
-    {
-      sprintf (name, "b%d", i - REG_BR);
-      md.regsym[i] = declare_register (name, i);
-    }
-
-  md.regsym[REG_IP] = declare_register ("ip", REG_IP);
-  md.regsym[REG_CFM] = declare_register ("cfm", REG_CFM);
-  md.regsym[REG_PR] = declare_register ("pr", REG_PR);
-  md.regsym[REG_PR_ROT] = declare_register ("pr.rot", REG_PR_ROT);
-  md.regsym[REG_PSR] = declare_register ("psr", REG_PSR);
-  md.regsym[REG_PSR_L] = declare_register ("psr.l", REG_PSR_L);
-  md.regsym[REG_PSR_UM] = declare_register ("psr.um", REG_PSR_UM);
+  declare_register_set ("b", 8, REG_BR);
+  declare_register ("rp", REG_BR + 0);
 
 
-  for (i = 0; i < NELEMS (indirect_reg); ++i)
-    {
-      regnum = indirect_reg[i].regnum;
-      md.regsym[regnum] = declare_register (indirect_reg[i].name, regnum);
-    }
+  /* predicate registers:  */
+  declare_register_set ("p", 64, REG_P);
+  declare_register ("pr", REG_PR);
+  declare_register ("pr.rot", REG_PR_ROT);
 
 
-  /* define synonyms for application registers:  */
+  /* application registers:  */
+  declare_register_set ("ar", 128, REG_AR);
   for (i = 0; i < NELEMS (ar); ++i)
     declare_register (ar[i].name, REG_AR + ar[i].regnum);
 
   for (i = 0; i < NELEMS (ar); ++i)
     declare_register (ar[i].name, REG_AR + ar[i].regnum);
 
-  /* define synonyms for control registers:  */
+  /* control registers:  */
+  declare_register_set ("cr", 128, REG_CR);
   for (i = 0; i < NELEMS (cr); ++i)
     declare_register (cr[i].name, REG_CR + cr[i].regnum);
 
   for (i = 0; i < NELEMS (cr); ++i)
     declare_register (cr[i].name, REG_CR + cr[i].regnum);
 
-  declare_register ("gp", REG_GR +  1);
-  declare_register ("sp", REG_GR + 12);
-  declare_register ("tp", REG_GR + 13);
-  declare_register ("rp", REG_BR +  0);
+  /* dahr registers:  */
+  declare_register_set ("dahr", 8, REG_DAHR);
+
+  declare_register ("ip", REG_IP);
+  declare_register ("cfm", REG_CFM);
+  declare_register ("psr", REG_PSR);
+  declare_register ("psr.l", REG_PSR_L);
+  declare_register ("psr.um", REG_PSR_UM);
+
+  for (i = 0; i < NELEMS (indirect_reg); ++i)
+    {
+      unsigned int regnum = indirect_reg[i].regnum;
+
+      md.indregsym[regnum - IND_CPUID] = declare_register (indirect_reg[i].name, regnum);
+    }
 
   /* pseudo-registers used to specify unwind info:  */
   declare_register ("psp", REG_PSP);
 
 
   /* pseudo-registers used to specify unwind info:  */
   declare_register ("psp", REG_PSP);
 
-  declare_register_set ("ret", 4, REG_GR + 8);
-  declare_register_set ("farg", 8, REG_FR + 8);
-  declare_register_set ("fret", 8, REG_FR + 8);
-
   for (i = 0; i < NELEMS (const_bits); ++i)
     {
       err = hash_insert (md.const_hash, const_bits[i].name,
   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)
       if (err)
-       as_fatal ("Inserting \"%s\" into constant hash table failed: %s",
+       as_fatal (_("Inserting \"%s\" into constant hash table failed: %s"),
                  name, err);
     }
 
                  name, err);
     }
 
@@ -7659,12 +7512,13 @@ md_begin ()
    options in md based on command line options.  */
 
 void
    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;
 {
   md.flags = MD_FLAGS_DEFAULT;
+#ifndef TE_VMS
+  /* Don't turn on dependency checking for VMS, doesn't work.  */
   md.detect_dv = 1;
   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;
   /* FIXME: We should change it to unwind_check_error someday.  */
   md.unwind_check = unwind_check_warning;
   md.hint_b = hint_b_error;
@@ -7674,7 +7528,7 @@ ia64_init (argc, argv)
 /* Return a string for the target object file format.  */
 
 const char *
 /* 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)
     {
 {
   if (OUTPUT_FLAVOR == bfd_target_elf_flavour)
     {
@@ -7700,8 +7554,13 @@ ia64_target_format ()
       else
        {
          if (md.flags & EF_IA_64_ABI64)
       else
        {
          if (md.flags & EF_IA_64_ABI64)
-#ifdef TE_AIX50
+#if defined (TE_AIX50)
            return "elf64-ia64-aix-little";
            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
 #else
            return "elf64-ia64-little";
 #endif
@@ -7718,7 +7577,7 @@ ia64_target_format ()
 }
 
 void
 }
 
 void
-ia64_end_of_source ()
+ia64_end_of_source (void)
 {
   /* terminate insn group upon reaching end of file:  */
   insn_group_break (1, 0, 0);
 {
   /* terminate insn group upon reaching end of file:  */
   insn_group_break (1, 0, 0);
@@ -7732,7 +7591,7 @@ ia64_end_of_source ()
 }
 
 void
 }
 
 void
-ia64_start_line ()
+ia64_start_line (void)
 {
   static int first;
 
 {
   static int first;
 
@@ -7744,7 +7603,7 @@ ia64_start_line ()
   }
 
   if (md.qp.X_op == O_register)
   }
 
   if (md.qp.X_op == O_register)
-    as_bad ("qualifying predicate not followed by instruction");
+    as_bad (_("qualifying predicate not followed by instruction"));
   md.qp.X_op = O_absent;
 
   if (ignore_input ())
   md.qp.X_op = O_absent;
 
   if (ignore_input ())
@@ -7768,7 +7627,7 @@ ia64_start_line ()
   else if (input_line_pointer[-1] == '{')
     {
       if (md.manual_bundling)
   else if (input_line_pointer[-1] == '{')
     {
       if (md.manual_bundling)
-       as_warn ("Found '{' when manual bundling is already turned on");
+       as_warn (_("Found '{' when manual bundling is already turned on"));
       else
        CURR_SLOT.manual_bundling_on = 1;
       md.manual_bundling = 1;
       else
        CURR_SLOT.manual_bundling_on = 1;
       md.manual_bundling = 1;
@@ -7787,7 +7646,7 @@ ia64_start_line ()
   else if (input_line_pointer[-1] == '}')
     {
       if (!md.manual_bundling)
   else if (input_line_pointer[-1] == '}')
     {
       if (!md.manual_bundling)
-       as_warn ("Found '}' when manual bundling is off");
+       as_warn (_("Found '}' when manual bundling is off"));
       else
        PREV_SLOT.manual_bundling_off = 1;
       md.manual_bundling = 0;
       else
        PREV_SLOT.manual_bundling_off = 1;
       md.manual_bundling = 0;
@@ -7806,8 +7665,7 @@ ia64_start_line ()
 static int defining_tag = 0;
 
 int
 static int defining_tag = 0;
 
 int
-ia64_unrecognized_line (ch)
-     int ch;
+ia64_unrecognized_line (int ch)
 {
   switch (ch)
     {
 {
   switch (ch)
     {
@@ -7815,17 +7673,17 @@ ia64_unrecognized_line (ch)
       expression_and_evaluate (&md.qp);
       if (*input_line_pointer++ != ')')
        {
       expression_and_evaluate (&md.qp);
       if (*input_line_pointer++ != ')')
        {
-         as_bad ("Expected ')'");
+         as_bad (_("Expected ')'"));
          return 0;
        }
       if (md.qp.X_op != O_register)
        {
          return 0;
        }
       if (md.qp.X_op != O_register)
        {
-         as_bad ("Qualifying predicate expected");
+         as_bad (_("Qualifying predicate expected"));
          return 0;
        }
       if (md.qp.X_add_number < REG_P || md.qp.X_add_number >= REG_P + 64)
        {
          return 0;
        }
       if (md.qp.X_add_number < REG_P || md.qp.X_add_number >= REG_P + 64)
        {
-         as_bad ("Predicate register expected");
+         as_bad (_("Predicate register expected"));
          return 0;
        }
       return 1;
          return 0;
        }
       return 1;
@@ -7839,7 +7697,7 @@ ia64_unrecognized_line (ch)
 
        if (md.qp.X_op == O_register)
          {
 
        if (md.qp.X_op == O_register)
          {
-           as_bad ("Tag must come before qualifying predicate.");
+           as_bad (_("Tag must come before qualifying predicate."));
            return 0;
          }
 
            return 0;
          }
 
@@ -7847,8 +7705,7 @@ ia64_unrecognized_line (ch)
           recognize labels.  */
        if (is_name_beginner (*input_line_pointer))
          {
           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))
          }
        else if (LOCAL_LABELS_FB
                 && ISDIGIT (*input_line_pointer))
@@ -7869,7 +7726,7 @@ ia64_unrecognized_line (ch)
          {
            /* Put ':' back for error messages' sake.  */
            *input_line_pointer++ = ':';
          {
            /* Put ':' back for error messages' sake.  */
            *input_line_pointer++ = ':';
-           as_bad ("Expected ':'");
+           as_bad (_("Expected ':'"));
            return 0;
          }
 
            return 0;
          }
 
@@ -7880,12 +7737,12 @@ ia64_unrecognized_line (ch)
        *input_line_pointer++ = ':';
        if (*input_line_pointer++ != ']')
          {
        *input_line_pointer++ = ':';
        if (*input_line_pointer++ != ']')
          {
-           as_bad ("Expected ']'");
+           as_bad (_("Expected ']'"));
            return 0;
          }
        if (! tag)
          {
            return 0;
          }
        if (! tag)
          {
-           as_bad ("Tag name expected");
+           as_bad (_("Tag name expected"));
            return 0;
          }
        return 1;
            return 0;
          }
        return 1;
@@ -7900,8 +7757,7 @@ ia64_unrecognized_line (ch)
 }
 
 void
 }
 
 void
-ia64_frob_label (sym)
-     struct symbol *sym;
+ia64_frob_label (struct symbol *sym)
 {
   struct label_fix *fix;
 
 {
   struct label_fix *fix;
 
@@ -7931,9 +7787,8 @@ ia64_frob_label (sym)
       if (md.path == md.maxpaths)
        {
          md.maxpaths += 20;
       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);
     }
        }
       md.entry_labels[md.path++] = S_GET_NAME (sym);
     }
@@ -7944,12 +7799,11 @@ ia64_frob_label (sym)
    that are declared but unused.  This routine removes declared,
    unused symbols from an object.  */
 int
    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)
        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;
          && ! S_IS_EXTERNAL (sym)))
     return 1;
   return 0;
@@ -7957,7 +7811,7 @@ ia64_frob_symbol (sym)
 #endif
 
 void
 #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)
 {
   if (!md.keep_pending_output
       && bfd_get_section_flags (stdoutput, now_seg) & SEC_CODE)
@@ -7974,51 +7828,57 @@ ia64_flush_pending_output ()
    of rotating registers or due to the indexing of indirect register
    sets.  */
 int
    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)
 {
 {
-  unsigned num_regs;
-
-  if (op == O_index)
+  if (op != O_index)
+    return 0;
+  resolve_expression (l);
+  if (l->X_op == O_register)
     {
     {
-      if (l->X_op == O_register && r->X_op == O_constant)
+      unsigned num_regs = l->X_add_number >> 16;
+
+      resolve_expression (r);
+      if (num_regs)
        {
        {
-         num_regs = (l->X_add_number >> 16);
-         if ((unsigned) r->X_add_number >= num_regs)
+         /* Left side is a .rotX-allocated register.  */
+         if (r->X_op != O_constant)
            {
            {
-             if (!num_regs)
-               as_bad ("No current frame");
-             else
-               as_bad ("Index out of range 0..%u", num_regs - 1);
+             as_bad (_("Rotating register index must be a non-negative constant"));
+             r->X_add_number = 0;
+           }
+         else if ((valueT) r->X_add_number >= num_regs)
+           {
+             as_bad (_("Index out of range 0..%u"), num_regs - 1);
              r->X_add_number = 0;
            }
          l->X_add_number = (l->X_add_number & 0xffff) + r->X_add_number;
          return 1;
        }
              r->X_add_number = 0;
            }
          l->X_add_number = (l->X_add_number & 0xffff) + r->X_add_number;
          return 1;
        }
-      else if (l->X_op == O_register && r->X_op == O_register)
+      else if (l->X_add_number >= IND_CPUID && l->X_add_number <= IND_RR)
        {
        {
-         if (l->X_add_number < IND_CPUID || l->X_add_number > IND_RR
-             || l->X_add_number == IND_MEM)
+         if (r->X_op != O_register
+             || r->X_add_number < REG_GR
+             || r->X_add_number > REG_GR + 127)
            {
            {
-             as_bad ("Indirect register set name expected");
-             l->X_add_number = IND_CPUID;
+             as_bad (_("Indirect register index must be a general register"));
+             r->X_add_number = REG_GR;
            }
          l->X_op = O_index;
            }
          l->X_op = O_index;
-         l->X_op_symbol = md.regsym[l->X_add_number];
+         l->X_op_symbol = md.indregsym[l->X_add_number - IND_CPUID];
          l->X_add_number = r->X_add_number;
          return 1;
        }
     }
          l->X_add_number = r->X_add_number;
          return 1;
        }
     }
-  return 0;
+  as_bad (_("Index can only be applied to rotating or indirect registers"));
+  /* Fall back to some register use of which has as little as possible
+     side effects, to minimize subsequent error messages.  */
+  l->X_op = O_register;
+  l->X_add_number = REG_GR + 3;
+  return 1;
 }
 
 int
 }
 
 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;
 {
   struct const_desc *cdesc;
   struct dynreg *dr = 0;
@@ -8045,7 +7905,7 @@ ia64_parse_name (name, e, nextcharP)
          end = input_line_pointer;
          if (*nextcharP != '(')
            {
          end = input_line_pointer;
          if (*nextcharP != '(')
            {
-             as_bad ("Expected '('");
+             as_bad (_("Expected '('"));
              break;
            }
          /* Skip '('.  */
              break;
            }
          /* Skip '('.  */
@@ -8053,21 +7913,30 @@ ia64_parse_name (name, e, nextcharP)
          expression (e);
          if (*input_line_pointer != ')')
            {
          expression (e);
          if (*input_line_pointer != ')')
            {
-             as_bad ("Missing ')'");
+             as_bad (_("Missing ')'"));
              goto done;
            }
          /* Skip ')'.  */
          ++input_line_pointer;
              goto done;
            }
          /* 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)
                {
          if (e->X_op != O_symbol)
            {
              if (e->X_op != O_pseudo_fixup)
                {
-                 as_bad ("Not a symbolic expression");
+                 as_bad (_("Not a symbolic expression"));
                  goto done;
                }
              if (idx != FUNC_LT_RELATIVE)
                {
                  goto done;
                }
              if (idx != FUNC_LT_RELATIVE)
                {
-                 as_bad ("Illegal combination of relocation functions");
+                 as_bad (_("Illegal combination of relocation functions"));
                  goto done;
                }
              switch (S_GET_VALUE (e->X_op_symbol))
                  goto done;
                }
              switch (S_GET_VALUE (e->X_op_symbol))
@@ -8081,7 +7950,7 @@ ia64_parse_name (name, e, nextcharP)
                case FUNC_TP_RELATIVE:
                  idx = FUNC_LT_TP_RELATIVE; break;
                default:
                case FUNC_TP_RELATIVE:
                  idx = FUNC_LT_TP_RELATIVE; break;
                default:
-                 as_bad ("Illegal combination of relocation functions");
+                 as_bad (_("Illegal combination of relocation functions"));
                  goto done;
                }
            }
                  goto done;
                }
            }
@@ -8170,9 +8039,9 @@ ia64_parse_name (name, e, nextcharP)
          if (regnum >= dr->num_regs)
            {
              if (!dr->num_regs)
          if (regnum >= dr->num_regs)
            {
              if (!dr->num_regs)
-               as_bad ("No current frame");
+               as_bad (_("No current frame"));
              else
              else
-               as_bad ("Register number out of range 0..%u",
+               as_bad (_("Register number out of range 0..%u"),
                        dr->num_regs - 1);
              regnum = 0;
            }
                        dr->num_regs - 1);
              regnum = 0;
            }
@@ -8182,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)))
     {
   name = ia64_canonicalize_symbol_name (end);
   if ((dr = hash_find (md.dynreg_hash, name)))
     {
@@ -8193,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);
         bits.  */
       e->X_op = O_register;
       e->X_add_number = dr->base | (dr->num_regs << 16);
+      free (end);
       return 1;
     }
       return 1;
     }
+  free (end);
   return 0;
 }
 
 /* Remove the '#' suffix that indicates a symbol as opposed to a register.  */
 
 char *
   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;
 
 {
   size_t len = strlen (name), full = len;
 
@@ -8211,10 +8080,10 @@ ia64_canonicalize_symbol_name (name)
   if (len <= 0)
     {
       if (full > 0)
   if (len <= 0)
     {
       if (full > 0)
-       as_bad ("Standalone `#' is illegal");
+       as_bad (_("Standalone `#' is illegal"));
     }
   else if (len < full - 1)
     }
   else if (len < full - 1)
-    as_warn ("Redundant `#' suffix operators");
+    as_warn (_("Redundant `#' suffix operators"));
   name[len] = '\0';
   return name;
 }
   name[len] = '\0';
   return name;
 }
@@ -8227,8 +8096,7 @@ ia64_canonicalize_symbol_name (name)
    through, and which use no resources if they do fall through.  */
 
 static int
    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.
 {
   /* 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.
@@ -8248,8 +8116,7 @@ is_conditional_branch (idesc)
    returns zero.  */
 
 static int
    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);
 {
   return ((is_conditional_branch (idesc) && CURR_SLOT.qp_regno == 0)
          || strncmp (idesc->name, "br.ia", 5) == 0);
@@ -8259,8 +8126,7 @@ is_taken_branch (idesc)
    doubt, returns zero.  */
 
 static int
    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;
 {
   if (strcmp (idesc->name, "rfi") == 0)
     return 1;
@@ -8271,9 +8137,7 @@ is_interruption_or_rfi (idesc)
    -1 if there is no dependency.  */
 
 static int
    -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;
 {
   int i;
   const struct ia64_opcode_dependency *dep = idesc->dependencies;
@@ -8317,7 +8181,7 @@ depends_on (depind, idesc)
    cannot statically be determined, all source registers are marked used.
    12) This insn only reads the specified predicate register when that
    register is the PR[qp].
    cannot statically be determined, all source registers are marked used.
    12) This insn only reads the specified predicate register when that
    register is the PR[qp].
-   13) This reference to ld-c only applies to teh GR whose value is loaded
+   13) This reference to ld-c only applies to the GR whose value is loaded
    with data returned from memory, not the post-incremented address register.
    14) The RSE resource includes the implementation-specific RSE internal
    state resources.  At least one (and possibly more) of these resources are
    with data returned from memory, not the post-incremented address register.
    14) The RSE resource includes the implementation-specific RSE internal
    state resources.  At least one (and possibly more) of these resources are
@@ -8326,6 +8190,8 @@ depends_on (depind, idesc)
    IC:rse-writers.
    15+16) Represents reserved instructions, which the assembler does not
    generate.
    IC:rse-writers.
    15+16) Represents reserved instructions, which the assembler does not
    generate.
+   17) CR[TPR] has a RAW dependency only between mov-to-CR-TPR and
+   mov-to-PSR-l or ssm instructions that set PSR.i, PSR.pp or PSR.up.
 
    Memory resources (i.e. locations in memory) are *not* marked or tracked by
    this code; there are no dependency violations based on memory access.
 
    Memory resources (i.e. locations in memory) are *not* marked or tracked by
    this code; there are no dependency violations based on memory access.
@@ -8336,13 +8202,16 @@ depends_on (depind, idesc)
 #define DV_REG 0
 
 static int
 #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;
 {
   int count = 0;
   int i;
@@ -8676,9 +8545,9 @@ dep->name, idesc->name, (rsrc_write?"write":"read"), note)
              || (!rsrc_write && idesc->operands[1] == IA64_OPND_PMD_R3))
 
            {
              || (!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))
                {
              if (regno >= 0 && regno < NELEMS (gr_values)
                  && KNOWN (regno))
                {
@@ -8786,6 +8655,23 @@ dep->name, idesc->name, (rsrc_write?"write":"read"), note)
        }
       break;
 
        }
       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)
        {
     case IA64_RS_CR_LRR:
       if (note != 1)
        {
@@ -8819,6 +8705,22 @@ dep->name, idesc->name, (rsrc_write?"write":"read"), note)
        }
       break;
 
        }
       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)
     case IA64_RS_FR:
     case IA64_RS_FRb:
       if (note != 1)
@@ -8893,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_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
                      || idesc->operands[i] == IA64_OPND_RR_R3
                      || ((i >= idesc->num_outputs)
                          && (idesc->operands[i] == IA64_OPND_R1
@@ -9199,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)
                        {
                      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 =
                            ((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)
                            {
 
                          switch (regno)
                            {
@@ -9217,6 +9120,8 @@ dep->name, idesc->name, (rsrc_write?"write":"read"), note)
                            case CR_ISR:
                            case CR_IFA:
                            case CR_IHA:
                            case CR_ISR:
                            case CR_IFA:
                            case CR_IHA:
+                           case CR_IIB0:
+                           case CR_IIB1:
                            case CR_IIPA:
                              specs[count++] = tmpl;
                              break;
                            case CR_IIPA:
                              specs[count++] = tmpl;
                              break;
@@ -9235,16 +9140,16 @@ dep->name, idesc->name, (rsrc_write?"write":"read"), note)
                      if (idesc->operands[0] == IA64_OPND_AR3
                          || idesc->operands[1] == IA64_OPND_AR3)
                        {
                      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 =
                            ((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
 
                          if (regno == AR_ITC
-                             || (index == 0
-                                 && (regno == AR_ITC
-                                     || regno == AR_RSC
+                             || regno == AR_RUC
+                             || (reg_index == 0
+                                 && (regno == AR_RSC
                                      || (regno >= AR_K0
                                          && regno <= AR_K7))))
                            {
                                      || (regno >= AR_K0
                                          && regno <= AR_K7))))
                            {
@@ -9414,8 +9319,9 @@ dep->name, idesc->name, (rsrc_write?"write":"read"), note)
       break;
 
     case IA64_RS_CRX:
       break;
 
     case IA64_RS_CRX:
-      /* Handle all CR[REG] resources */
-      if (note == 0 || note == 1)
+      /* Handle all CR[REG] resources.
+        ??? FIXME: The rule 17 isn't really handled correctly.   */
+      if (note == 0 || note == 1 || note == 17)
        {
          if (idesc->operands[!rsrc_write] == IA64_OPND_CR3)
            {
        {
          if (idesc->operands[!rsrc_write] == IA64_OPND_CR3)
            {
@@ -9658,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
    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++)
 {
   int i;
   for (i = 0; i < regdepslen; i++)
@@ -9704,7 +9609,7 @@ update_qp_mutex (valueT mask)
                  print_prmask (qp_mutexes[i].prmask);
                  fprintf (stderr, "\n");
                }
                  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.
 
              /* Deal with the old mutex with more than 3+ PRs only if
                 the new mutex on the same execution path with it.
 
@@ -9717,7 +9622,7 @@ update_qp_mutex (valueT mask)
                  if (add == 0
                      && (qp_mutexes[i].prmask & mask) == mask)
                    add = 1;
                  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))
                    {
                  qp_mutexes[i].prmask &= ~mask;
                  if (qp_mutexes[i].prmask & (qp_mutexes[i].prmask - 1))
                    {
@@ -9727,7 +9632,7 @@ update_qp_mutex (valueT mask)
                      i++;
                    }
                }
                      i++;
                    }
                }
-             
+
              if (keep == 0)
                /* Remove the mutex.  */
                qp_mutexes[i] = qp_mutexes[--qp_mutexeslen];
              if (keep == 0)
                /* Remove the mutex.  */
                qp_mutexes[i] = qp_mutexes[--qp_mutexeslen];
@@ -9748,8 +9653,7 @@ update_qp_mutex (valueT mask)
    Any changes to a PR clears the mutex relations which include that PR.  */
 
 static void
    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;
 
 {
   int i;
 
@@ -9776,9 +9680,7 @@ clear_qp_mutex (mask)
    indicates the implied PR.  */
 
 static void
    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;
 
 {
   int i;
 
@@ -9801,8 +9703,7 @@ clear_qp_implies (p1_mask, p2_mask)
 /* Add the PRs specified to the list of implied relations.  */
 
 static void
 /* 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;
 {
   valueT mask;
   valueT bit;
@@ -9828,9 +9729,7 @@ add_qp_imply (p1, p2)
   if (qp_implieslen == qp_impliestotlen)
     {
       qp_impliestotlen += 20;
   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);
     }
   if (md.debug_dv)
     fprintf (stderr, "  Registering PR%d implies PR%d\n", p1, p2);
@@ -9865,8 +9764,7 @@ add_qp_imply (p1, p2)
    the mask.  */
 
 static void
    the mask.  */
 
 static void
-add_qp_mutex (mask)
-     valueT mask;
+add_qp_mutex (valueT mask)
 {
   if (mask & 0x1)
     abort ();
 {
   if (mask & 0x1)
     abort ();
@@ -9874,9 +9772,7 @@ add_qp_mutex (mask)
   if (qp_mutexeslen == qp_mutexestotlen)
     {
       qp_mutexestotlen += 20;
   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)
     {
     }
   if (md.debug_dv)
     {
@@ -9889,9 +9785,7 @@ add_qp_mutex (mask)
 }
 
 static int
 }
 
 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);
 {
   size_t namelen = strlen (name);
   size_t sufflen = strlen (suffix);
@@ -9902,7 +9796,7 @@ has_suffix_p (name, suffix)
 }
 
 static void
 }
 
 static void
-clear_register_values ()
+clear_register_values (void)
 {
   int i;
   if (md.debug_dv)
 {
   int i;
   if (md.debug_dv)
@@ -9917,8 +9811,7 @@ clear_register_values ()
    have to examine a group of strings to identify them.  */
 
 static void
    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;
 {
   valueT qp_changemask = 0;
   int i;
@@ -10117,10 +10010,7 @@ note_register_values (idesc)
 /* Return whether the given predicate registers are currently mutex.  */
 
 static int
 /* 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;
 {
   int i;
   valueT mask;
@@ -10143,12 +10033,11 @@ qp_mutex (p1, p2, path)
    conflict.  */
 
 static int
    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;
 {
   struct rsrc specs[MAX_SPECS];
   int count;
@@ -10224,10 +10113,7 @@ resources_match (rs, idesc, note, qp_regno, path)
    instruction.  */
 
 static void
    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;
 
 {
   int i;
 
@@ -10291,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
 /* 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;
 {
   if (regdepslen == regdepstotlen)
     {
       regdepstotlen += 20;
-      regdeps = (struct rsrc *)
-       xrealloc ((void *) regdeps,
-                 regdepstotlen * sizeof (struct rsrc));
+      regdeps = XRESIZEVEC (struct rsrc, regdeps, regdepstotlen);
     }
 
   regdeps[regdepslen] = *spec;
     }
 
   regdeps[regdepslen] = *spec;
@@ -10318,9 +10201,7 @@ mark_resource (idesc, dep, spec, depind, path)
 }
 
 static void
 }
 
 static void
-print_dependency (action, depind)
-     const char *action;
-     int depind;
+print_dependency (const char *action, int depind)
 {
   if (md.debug_dv)
     {
 {
   if (md.debug_dv)
     {
@@ -10341,7 +10222,7 @@ print_dependency (action, depind)
 }
 
 static void
 }
 
 static void
-instruction_serialization ()
+instruction_serialization (void)
 {
   int i;
   if (md.debug_dv)
 {
   int i;
   if (md.debug_dv)
@@ -10352,7 +10233,7 @@ instruction_serialization ()
 }
 
 static void
 }
 
 static void
-data_serialization ()
+data_serialization (void)
 {
   int i = 0;
   if (md.debug_dv)
 {
   int i = 0;
   if (md.debug_dv)
@@ -10375,8 +10256,7 @@ data_serialization ()
 /* Insert stops and serializations as needed to avoid DVs.  */
 
 static void
 /* 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)
     {
 {
   switch (rs->dependency->semantics)
     {
@@ -10451,8 +10331,7 @@ remove_marked_resource (rs)
 */
 
 static void
 */
 
 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;
 {
   const struct ia64_opcode_dependency *opdeps = idesc->dependencies;
   int path;
@@ -10525,12 +10404,15 @@ check_dependencies (idesc)
              int certain = (matchtype == 1 && CURR_SLOT.qp_regno == 0);
 
              if (path != 0)
              int certain = (matchtype == 1 && CURR_SLOT.qp_regno == 0);
 
              if (path != 0)
-               sprintf (pathmsg, " when entry is at label '%s'",
+               snprintf (pathmsg, sizeof (pathmsg),
+                         " when entry is at label '%s'",
                         md.entry_labels[path - 1]);
              if (matchtype == 1 && rs->index >= 0)
                         md.entry_labels[path - 1]);
              if (matchtype == 1 && rs->index >= 0)
-               sprintf (indexmsg, ", specific resource number is %d",
+               snprintf (indexmsg, sizeof (indexmsg),
+                         ", specific resource number is %d",
                         rs->index);
                         rs->index);
-             sprintf (msg, "Use of '%s' %s %s dependency '%s' (%s)%s%s",
+             snprintf (msg, sizeof (msg),
+                       "Use of '%s' %s %s dependency '%s' (%s)%s%s",
                       idesc->name,
                       (certain ? "violates" : "may violate"),
                       dv_mode[dep->mode], dep->name,
                       idesc->name,
                       (certain ? "violates" : "may violate"),
                       dv_mode[dep->mode], dep->name,
@@ -10541,11 +10423,9 @@ check_dependencies (idesc)
                {
                  as_warn ("%s", msg);
                  if (path < md.path)
                {
                  as_warn ("%s", msg);
                  if (path < md.path)
-                   as_warn (_("Only the first path encountering the conflict "
-                              "is reported"));
+                   as_warn (_("Only the first path encountering the conflict is reported"));
                  as_warn_where (rs->file, rs->line,
                  as_warn_where (rs->file, rs->line,
-                                _("This is the location of the "
-                                  "conflicting usage"));
+                                _("This is the location of the conflicting usage"));
                  /* Don't bother checking other paths, to avoid duplicating
                     the same warning */
                  break;
                  /* Don't bother checking other paths, to avoid duplicating
                     the same warning */
                  break;
@@ -10575,8 +10455,7 @@ check_dependencies (idesc)
 /* Register new dependencies based on the given opcode.  */
 
 static void
 /* 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;
 {
   int i;
   const struct ia64_opcode_dependency *opdeps = idesc->dependencies;
@@ -10649,8 +10528,7 @@ mark_resources (idesc)
 /* Remove dependencies when they no longer apply.  */
 
 static void
 /* Remove dependencies when they no longer apply.  */
 
 static void
-update_dependencies (idesc)
-     struct ia64_opcode *idesc;
+update_dependencies (struct ia64_opcode *idesc)
 {
   int i;
 
 {
   int i;
 
@@ -10730,8 +10608,7 @@ update_dependencies (idesc)
 /* Examine the current instruction for dependency violations.  */
 
 static int
 /* 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)
     {
 {
   if (md.debug_dv)
     {
@@ -10779,10 +10656,10 @@ check_dv (idesc)
 /* Translate one line of assembly.  Pseudo ops and labels do not show
    here.  */
 void
 /* 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;
   const struct pseudo_opcode *pdesc;
   struct ia64_opcode *idesc;
   unsigned char qp_regno;
@@ -10794,12 +10671,12 @@ md_assemble (str)
 
   /* extract the opcode (mnemonic):  */
 
 
   /* 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)
     {
   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;
     }
       (*pdesc->handler) (pdesc->arg);
       goto done;
     }
@@ -10807,10 +10684,10 @@ md_assemble (str)
   /* Find the instruction descriptor matching the arguments.  */
 
   idesc = ia64_find_opcode (mnemonic);
   /* Find the instruction descriptor matching the arguments.  */
 
   idesc = ia64_find_opcode (mnemonic);
-  *input_line_pointer = ch;
+  (void) restore_line_pointer (ch);
   if (!idesc)
     {
   if (!idesc)
     {
-      as_bad ("Unknown opcode `%s'", mnemonic);
+      as_bad (_("Unknown opcode `%s'"), mnemonic);
       goto done;
     }
 
       goto done;
     }
 
@@ -10871,7 +10748,7 @@ md_assemble (str)
     {
       enum ia64_opnd opnd1, opnd2;
       int rop;
     {
       enum ia64_opnd opnd1, opnd2;
       int rop;
-      
+
       opnd1 = idesc->operands[0];
       opnd2 = idesc->operands[1];
       if (opnd1 == IA64_OPND_AR3)
       opnd1 = idesc->operands[0];
       opnd2 = idesc->operands[1];
       if (opnd1 == IA64_OPND_AR3)
@@ -10888,7 +10765,7 @@ md_assemble (str)
          else if (ar_is_only_in_memory_unit (CURR_SLOT.opnd[rop].X_add_number))
            unit = 'm';
          if (unit != 'a' && unit != idesc->name [4])
          else if (ar_is_only_in_memory_unit (CURR_SLOT.opnd[rop].X_add_number))
            unit = 'm';
          if (unit != 'a' && unit != idesc->name [4])
-           as_bad ("AR %d can only be accessed by %c-unit",
+           as_bad (_("AR %d can only be accessed by %c-unit"),
                    (int) (CURR_SLOT.opnd[rop].X_add_number - REG_AR),
                    TOUPPER (unit));
        }
                    (int) (CURR_SLOT.opnd[rop].X_add_number - REG_AR),
                    TOUPPER (unit));
        }
@@ -10900,10 +10777,10 @@ md_assemble (str)
        case hint_b_ok:
          break;
        case hint_b_warning:
        case hint_b_ok:
          break;
        case hint_b_warning:
-         as_warn ("hint.b may be treated as nop");
+         as_warn (_("hint.b may be treated as nop"));
          break;
        case hint_b_error:
          break;
        case hint_b_error:
-         as_bad ("hint.b shouldn't be used");
+         as_bad (_("hint.b shouldn't be used"));
          break;
        }
     }
          break;
        }
     }
@@ -10942,15 +10819,16 @@ md_assemble (str)
 
   if ((flags & IA64_OPCODE_NO_PRED) != 0 && qp_regno != 0)
     {
 
   if ((flags & IA64_OPCODE_NO_PRED) != 0 && qp_regno != 0)
     {
-      as_bad ("`%s' cannot be predicated", idesc->name);
+      as_bad (_("`%s' cannot be predicated"), idesc->name);
       goto done;
     }
 
   /* Build the instruction.  */
   CURR_SLOT.qp_regno = qp_regno;
   CURR_SLOT.idesc = idesc;
       goto done;
     }
 
   /* 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_where (&CURR_SLOT.debug_line);
+  dwarf2_consume_line_info ();
 
   /* Add unwind entries, if there are any.  */
   if (unwind.current_entry)
 
   /* Add unwind entries, if there are any.  */
   if (unwind.current_entry)
@@ -10994,8 +10872,7 @@ md_assemble (str)
    Should be used for dynamic valued symbols only.  */
 
 symbolS *
    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;
 }
 {
   return 0;
 }
@@ -11005,8 +10882,7 @@ md_undefined_symbol (name)
    the expression.  */
 
 void
    the expression.  */
 
 void
-md_operand (e)
-     expressionS *e;
+md_operand (expressionS *e)
 {
   switch (*input_line_pointer)
     {
 {
   switch (*input_line_pointer)
     {
@@ -11015,13 +10891,18 @@ md_operand (e)
       expression_and_evaluate (e);
       if (*input_line_pointer != ']')
        {
       expression_and_evaluate (e);
       if (*input_line_pointer != ']')
        {
-         as_bad ("Closing bracket missing");
+         as_bad (_("Closing bracket missing"));
          goto err;
        }
       else
        {
          goto err;
        }
       else
        {
-         if (e->X_op != O_register)
-           as_bad ("Register expected as index");
+         if (e->X_op != O_register
+             || e->X_add_number < REG_GR
+             || e->X_add_number > REG_GR + 127)
+           {
+             as_bad (_("Index must be a general register"));
+             e->X_add_number = REG_GR;
+           }
 
          ++input_line_pointer;
          e->X_op = O_index;
 
          ++input_line_pointer;
          e->X_op = O_index;
@@ -11042,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
    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))
 {
   /* Prevent all adjustments to global symbols */
   if (S_IS_EXTERNAL (fix->fx_addsy) || S_IS_WEAK (fix->fx_addsy))
@@ -11067,8 +10947,7 @@ ia64_fix_adjustable (fix)
 }
 
 int
 }
 
 int
-ia64_force_relocation (fix)
-     fixS *fix;
+ia64_force_relocation (fixS *fix)
 {
   switch (fix->fx_r_type)
     {
 {
   switch (fix->fx_r_type)
     {
@@ -11101,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
 /* 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;
 
 {
   unsigned long off = fix->fx_frag->fr_address + fix->fx_where;
 
@@ -11118,26 +10995,22 @@ ia64_pcrel_from_section (fix, sec)
 void
 ia64_dwarf2_emit_offset (symbolS *symbol, unsigned int size)
 {
 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
 }
 
 /* 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)
   fixS *fix;
 
   switch (nbytes)
@@ -11192,7 +11065,7 @@ ia64_cons_fix_new (f, where, nbytes, exp)
       /* FALLTHRU */
 
     default:
       /* FALLTHRU */
 
     default:
-      as_bad ("Unsupported fixup size %d", nbytes);
+      as_bad (_("Unsupported fixup size %d"), nbytes);
       ignore_rest_of_line ();
       return;
     }
       ignore_rest_of_line ();
       return;
     }
@@ -11216,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
    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)
   const char *type = NULL, *suffix = "";
 
   if (sym == NULL)
@@ -11233,11 +11104,11 @@ ia64_gen_real_reloc_type (sym, r_type)
     case FUNC_FPTR_RELATIVE:
       switch (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;
        default:                        type = "FPTR"; break;
        }
       break;
@@ -11245,12 +11116,12 @@ ia64_gen_real_reloc_type (sym, r_type)
     case FUNC_GP_RELATIVE:
       switch (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;
        default:                        type = "GPREL"; break;
        }
       break;
@@ -11258,8 +11129,8 @@ ia64_gen_real_reloc_type (sym, r_type)
     case FUNC_LT_RELATIVE:
       switch (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;
        default:                        type = "LTOFF"; break;
        }
       break;
@@ -11267,7 +11138,7 @@ ia64_gen_real_reloc_type (sym, r_type)
     case FUNC_LT_RELATIVE_X:
       switch (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;
        default:                        type = "LTOFF"; suffix = "X"; break;
        }
       break;
@@ -11275,12 +11146,12 @@ ia64_gen_real_reloc_type (sym, r_type)
     case FUNC_PC_RELATIVE:
       switch (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;
        default:                        type = "PCREL"; break;
        }
       break;
@@ -11288,10 +11159,10 @@ ia64_gen_real_reloc_type (sym, r_type)
     case FUNC_PLT_RELATIVE:
       switch (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;
        default:                        type = "PLTOFF"; break;
        }
       break;
@@ -11299,10 +11170,10 @@ ia64_gen_real_reloc_type (sym, r_type)
     case FUNC_SEC_RELATIVE:
       switch (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;
        default:                        type = "SECREL"; break;
        }
       break;
@@ -11310,10 +11181,10 @@ ia64_gen_real_reloc_type (sym, r_type)
     case FUNC_SEG_RELATIVE:
       switch (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;
        default:                        type = "SEGREL"; break;
        }
       break;
@@ -11321,10 +11192,10 @@ ia64_gen_real_reloc_type (sym, r_type)
     case FUNC_LTV_RELATIVE:
       switch (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;
        default:                        type = "LTV"; break;
        }
       break;
@@ -11333,17 +11204,17 @@ ia64_gen_real_reloc_type (sym, r_type)
       switch (r_type)
        {
        case BFD_RELOC_IA64_IMM22:
       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:
        case BFD_RELOC_IA64_IMM64:
-         new = BFD_RELOC_IA64_LTOFF_FPTR64I; break;
+         newr = BFD_RELOC_IA64_LTOFF_FPTR64I; break;
        case BFD_RELOC_IA64_DIR32MSB:
        case BFD_RELOC_IA64_DIR32MSB:
-         new = BFD_RELOC_IA64_LTOFF_FPTR32MSB; break;
+         newr = BFD_RELOC_IA64_LTOFF_FPTR32MSB; break;
        case BFD_RELOC_IA64_DIR32LSB:
        case BFD_RELOC_IA64_DIR32LSB:
-         new = BFD_RELOC_IA64_LTOFF_FPTR32LSB; break;
+         newr = BFD_RELOC_IA64_LTOFF_FPTR32LSB; break;
        case BFD_RELOC_IA64_DIR64MSB:
        case BFD_RELOC_IA64_DIR64MSB:
-         new = BFD_RELOC_IA64_LTOFF_FPTR64MSB; break;
+         newr = BFD_RELOC_IA64_LTOFF_FPTR64MSB; break;
        case BFD_RELOC_IA64_DIR64LSB:
        case BFD_RELOC_IA64_DIR64LSB:
-         new = BFD_RELOC_IA64_LTOFF_FPTR64LSB; break;
+         newr = BFD_RELOC_IA64_LTOFF_FPTR64LSB; break;
        default:
          type = "LTOFF_FPTR"; break;
        }
        default:
          type = "LTOFF_FPTR"; break;
        }
@@ -11352,11 +11223,11 @@ ia64_gen_real_reloc_type (sym, r_type)
     case FUNC_TP_RELATIVE:
       switch (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;
        default:                        type = "TPREL"; break;
        }
       break;
@@ -11365,7 +11236,7 @@ ia64_gen_real_reloc_type (sym, r_type)
       switch (r_type)
        {
        case BFD_RELOC_IA64_IMM22:
       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;
        }
        default:
          type = "LTOFF_TPREL"; break;
        }
@@ -11375,9 +11246,9 @@ ia64_gen_real_reloc_type (sym, r_type)
       switch (r_type)
        {
        case BFD_RELOC_IA64_DIR64MSB:
       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:
        case BFD_RELOC_IA64_DIR64LSB:
-         new = BFD_RELOC_IA64_DTPMOD64LSB; break;
+         newr = BFD_RELOC_IA64_DTPMOD64LSB; break;
        default:
          type = "DTPMOD"; break;
        }
        default:
          type = "DTPMOD"; break;
        }
@@ -11387,7 +11258,7 @@ ia64_gen_real_reloc_type (sym, r_type)
       switch (r_type)
        {
        case BFD_RELOC_IA64_IMM22:
       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;
        }
        default:
          type = "LTOFF_DTPMOD"; break;
        }
@@ -11397,19 +11268,19 @@ ia64_gen_real_reloc_type (sym, r_type)
       switch (r_type)
        {
        case BFD_RELOC_IA64_DIR32MSB:
       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:
        case BFD_RELOC_IA64_DIR32LSB:
-         new = BFD_RELOC_IA64_DTPREL32LSB; break;
+         newr = BFD_RELOC_IA64_DTPREL32LSB; break;
        case BFD_RELOC_IA64_DIR64MSB:
        case BFD_RELOC_IA64_DIR64MSB:
-         new = BFD_RELOC_IA64_DTPREL64MSB; break;
+         newr = BFD_RELOC_IA64_DTPREL64MSB; break;
        case BFD_RELOC_IA64_DIR64LSB:
        case BFD_RELOC_IA64_DIR64LSB:
-         new = BFD_RELOC_IA64_DTPREL64LSB; break;
+         newr = BFD_RELOC_IA64_DTPREL64LSB; break;
        case BFD_RELOC_IA64_IMM14:
        case BFD_RELOC_IA64_IMM14:
-         new = BFD_RELOC_IA64_DTPREL14; break;
+         newr = BFD_RELOC_IA64_DTPREL14; break;
        case BFD_RELOC_IA64_IMM22:
        case BFD_RELOC_IA64_IMM22:
-         new = BFD_RELOC_IA64_DTPREL22; break;
+         newr = BFD_RELOC_IA64_DTPREL22; break;
        case BFD_RELOC_IA64_IMM64:
        case BFD_RELOC_IA64_IMM64:
-         new = BFD_RELOC_IA64_DTPREL64I; break;
+         newr = BFD_RELOC_IA64_DTPREL64I; break;
        default:
          type = "DTPREL"; break;
        }
        default:
          type = "DTPREL"; break;
        }
@@ -11419,7 +11290,7 @@ ia64_gen_real_reloc_type (sym, r_type)
       switch (r_type)
        {
        case BFD_RELOC_IA64_IMM22:
       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;
        }
        default:
          type = "LTOFF_DTPREL"; break;
        }
@@ -11434,12 +11305,17 @@ ia64_gen_real_reloc_type (sym, r_type)
        }
       break;
 
        }
       break;
 
+#ifdef TE_VMS
+    case FUNC_SLOTCOUNT_RELOC:
+      return DUMMY_RELOC_IA64_SLOTCOUNT;
+#endif
+
     default:
       abort ();
     }
 
     default:
       abort ();
     }
 
-  if (new)
-    return new;
+  if (newr)
+    return newr;
   else
     {
       int width;
   else
     {
       int width;
@@ -11460,8 +11336,8 @@ ia64_gen_real_reloc_type (sym, r_type)
        }
 
       /* This should be an error, but since previously there wasn't any
        }
 
       /* This should be an error, but since previously there wasn't any
-        diagnostic here, dont't make it fail because of this for now.  */
-      as_warn ("Cannot express %s%d%s relocation", type, width, suffix);
+        diagnostic here, don't make it fail because of this for now.  */
+      as_warn (_("Cannot express %s%d%s relocation"), type, width, suffix);
       return r_type;
     }
 }
       return r_type;
     }
 }
@@ -11469,8 +11345,7 @@ ia64_gen_real_reloc_type (sym, r_type)
 /* Here is where generate the appropriate reloc for pseudo relocation
    functions.  */
 void
 /* 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)
     {
 {
   switch (fix->fx_r_type)
     {
@@ -11481,7 +11356,7 @@ ia64_validate_fix (fix)
     case BFD_RELOC_IA64_LTOFF_FPTR64I:
       if (fix->fx_offset != 0)
        as_bad_where (fix->fx_file, fix->fx_line,
     case BFD_RELOC_IA64_LTOFF_FPTR64I:
       if (fix->fx_offset != 0)
        as_bad_where (fix->fx_file, fix->fx_line,
-                     "No addend allowed in @fptr() relocation");
+                     _("No addend allowed in @fptr() relocation"));
       break;
     default:
       break;
       break;
     default:
       break;
@@ -11489,10 +11364,7 @@ ia64_validate_fix (fix)
 }
 
 static void
 }
 
 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;
 {
   bfd_vma insn[3], t0, t1, control_bits;
   const char *err;
@@ -11523,7 +11395,7 @@ fix_insn (fix, odesc, value)
   else if (odesc - elf64_ia64_operands == IA64_OPND_IMMU62)
     {
       if (value & ~0x3fffffffffffffffULL)
   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));
     }
       insn[1] = (value >> 21) & 0x1ffffffffffLL;
       insn[2] |= (((value & 0xfffff) << 6) | (((value >> 20) & 0x1) << 36));
     }
@@ -11538,7 +11410,7 @@ fix_insn (fix, odesc, value)
     err = (*odesc->insert) (odesc, value, insn + slot);
 
   if (err)
     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);
 
   t0 = control_bits | (insn[0] << 5) | (insn[1] << 46);
   t1 = ((insn[1] >> 18) & 0x7fffff) | (insn[2] << 23);
@@ -11554,10 +11426,7 @@ fix_insn (fix, odesc, value)
    (if possible).  */
 
 void
    (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;
 {
   char *fixpos;
   valueT value = *valP;
@@ -11587,13 +11456,13 @@ md_apply_fix (fix, valP, seg)
     }
   if (fix->fx_addsy)
     {
     }
   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
             relocs defined for them, so we must give an error.  */
          as_bad_where (fix->fx_file, fix->fx_line,
        {
        case BFD_RELOC_UNUSED:
          /* This must be a TAG13 or TAG13b operand.  There are no external
             relocs defined for them, so we must give an error.  */
          as_bad_where (fix->fx_file, fix->fx_line,
-                       "%s must have a constant value",
+                       _("%s must have a constant value"),
                        elf64_ia64_operands[fix->tc_fix_data.opnd].desc);
          fix->fx_done = 1;
          return;
                        elf64_ia64_operands[fix->tc_fix_data.opnd].desc);
          fix->fx_done = 1;
          return;
@@ -11610,12 +11479,48 @@ md_apply_fix (fix, valP, seg)
          S_SET_THREAD_LOCAL (fix->fx_addsy);
          break;
 
          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)
     {
        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
       if (fix->tc_fix_data.bigendian)
        number_to_chars_bigendian (fixpos, value, fix->fx_size);
       else
@@ -11633,14 +11538,12 @@ md_apply_fix (fix, valP, seg)
    fixup used internally in the assembler.  */
 
 arelent *
    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;
 
 {
   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;
   *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;
@@ -11649,8 +11552,10 @@ tc_gen_reloc (sec, fixp)
   if (!reloc->howto)
     {
       as_bad_where (fixp->fx_file, fixp->fx_line,
   if (!reloc->howto)
     {
       as_bad_where (fixp->fx_file, fixp->fx_line,
-                   "Cannot represent %s relocation in object file",
+                   _("Cannot represent %s relocation in object file"),
                    bfd_get_reloc_code_name (fixp->fx_r_type));
                    bfd_get_reloc_code_name (fixp->fx_r_type));
+      free (reloc);
+      return NULL;
     }
   return reloc;
 }
     }
   return reloc;
 }
@@ -11662,11 +11567,8 @@ tc_gen_reloc (sec, fixp)
 
 #define MAX_LITTLENUMS 5
 
 
 #define MAX_LITTLENUMS 5
 
-char *
-md_atof (type, lit, size)
-     int type;
-     char *lit;
-     int *size;
+const char *
+md_atof (int type, char *lit, int *size)
 {
   LITTLENUM_TYPE words[MAX_LITTLENUMS];
   char *t;
 {
   LITTLENUM_TYPE words[MAX_LITTLENUMS];
   char *t;
@@ -11698,7 +11600,7 @@ md_atof (type, lit, size)
 
     default:
       *size = 0;
 
     default:
       *size = 0;
-      return "Bad call to MD_ATOF()";
+      return _("Unrecognized or unsupported floating point constant");
     }
   t = atof_ieee (input_line_pointer, type, words);
   if (t)
     }
   t = atof_ieee (input_line_pointer, type, words);
   if (t)
@@ -11715,17 +11617,16 @@ md_atof (type, lit, size)
   else
     *size = prec * sizeof (LITTLENUM_TYPE);
 
   else
     *size = prec * sizeof (LITTLENUM_TYPE);
 
-  return 0;
+  return NULL;
 }
 
 /* Handle ia64 specific semantics of the align directive.  */
 
 void
 }
 
 /* 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 ();
 {
   if (subseg_text_p (now_seg))
     ia64_flush_insns ();
@@ -11735,23 +11636,22 @@ ia64_md_do_align (n, fill, len, max)
    of an rs_align_code fragment.  */
 
 void
    of an rs_align_code fragment.  */
 
 void
-ia64_handle_align (fragp)
-     fragS *fragp;
+ia64_handle_align (fragS *fragp)
 {
   int bytes;
   char *p;
 {
   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.  */
 
   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;
 
 
   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)
   if (!bytes && fragp->tc_frag_data)
     {
       if (fragp->fr_fix < 16)
@@ -11783,7 +11683,7 @@ ia64_handle_align (fragp)
     }
 
   /* Instruction bundles are always little-endian.  */
     }
 
   /* Instruction bundles are always little-endian.  */
-  memcpy (p, nop, 16);
+  memcpy (p, nop_type, 16);
   fragp->fr_var = 16;
 }
 
   fragp->fr_var = 16;
 }
 
@@ -11812,7 +11712,7 @@ ia64_float_to_chars_littleendian (char *lit, LITTLENUM_TYPE *words,
 }
 
 void
 }
 
 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)
 {
   if (elf_section_type (now_seg) == SHT_IA_64_UNWIND
       && elf_linked_to_section (now_seg) == NULL)
@@ -11836,9 +11736,9 @@ ia64_check_label (symbolS *label)
    the relocatable file.  */
 struct alias
 {
    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.  */
   unsigned int line;   /* The line number the directive is at.  */
-  const char *name;    /* The orignale name of the symbol.  */
+  const char *name;    /* The original name of the symbol.  */
 };
 
 /* Called for .alias and .secalias directives. If SECTION is 1, it is
 };
 
 /* Called for .alias and .secalias directives. If SECTION is 1, it is
@@ -11856,8 +11756,7 @@ dot_alias (int section)
   struct hash_control *ahash, *nhash;
   const char *kind;
 
   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;
 
   end_name = input_line_pointer;
   *end_name = delim;
 
@@ -11868,7 +11767,7 @@ dot_alias (int section)
       return;
     }
 
       return;
     }
 
-  SKIP_WHITESPACE ();
+  SKIP_WHITESPACE_AFTER_NAME ();
 
   if (*input_line_pointer != ',')
     {
 
   if (*input_line_pointer != ',')
     {
@@ -11929,11 +11828,11 @@ dot_alias (int section)
       goto out;
     }
 
       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;
   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"),
   if (error_string)
     {
       as_fatal (_("inserting \"%s\" into %s alias hash table failed: %s"),
@@ -11941,7 +11840,7 @@ dot_alias (int section)
       goto out;
     }
 
       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"),
   if (error_string)
     {
       as_fatal (_("inserting \"%s\" into %s name hash table failed: %s"),
@@ -11956,15 +11855,23 @@ out:
 
 /* It renames the original symbol name to its alias.  */
 static void
 
 /* 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)
 {
   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);
 }
     else
       S_SET_NAME (sym, (char *) alias);
 }
@@ -11978,7 +11885,7 @@ ia64_adjust_symtab (void)
 
 /* It renames the original section name to its alias.  */
 static 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);
 {
   struct alias *h = (struct alias *) value;
   segT sec = bfd_get_section_by_name (stdoutput, h->name);
@@ -11997,3 +11904,117 @@ ia64_frob_file (void)
 {
   hash_traverse (secalias_hash, do_secalias);
 }
 {
   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 */
GDB Binutils - Deliverables
This page took 0.202971 seconds and 4 git commands to generate.