2000-09-07 Kazu Hirata <kazu@hxi.com>
[deliverable/binutils-gdb.git] / gas / config / tc-arm.c
index b5d8f3dbd03174151daf2c316e99cf5e35f622a0..faded9626bcf4ac1291a054f6dc6a3eacc9fcd9a 100644 (file)
@@ -1,5 +1,6 @@
 /* tc-arm.c -- Assemble for the ARM
-   Copyright (C) 1994, 95, 96, 97, 98, 1999 Free Software Foundation, Inc.
+   Copyright (C) 1994, 95, 96, 97, 98, 1999, 2000
+   Free Software Foundation, Inc.
    Contributed by Richard Earnshaw (rwe@pegasus.esprit.ec.org)
        Modified by David Taylor (dtaylor@armltd.co.uk)
 
@@ -25,7 +26,7 @@
 #define  NO_RELOC 0
 #include "as.h"
 
-/* need TARGET_CPU */
+/* Need TARGET_CPU.  */
 #include "config.h"
 #include "subsegs.h"
 #include "obstack.h"
 #define ARM_3          0x00000004
 #define ARM_250                ARM_3
 #define ARM_6          0x00000008
-#define ARM_7          ARM_6           /* same core instruction set */
-#define ARM_8          ARM_6           /* same core instruction set */
-#define ARM_9          ARM_6           /* same core instruction set */
+#define ARM_7          ARM_6           /* Same core instruction set.  */
+#define ARM_8          ARM_6           /* Same core instruction set.  */
+#define ARM_9          ARM_6           /* Same core instruction set.  */
 #define ARM_CPU_MASK   0x0000000f
 
-/* The following bitmasks control CPU extensions (ARM7 onwards): */
-#define ARM_LONGMUL    0x00000010      /* allow long multiplies */
-#define ARM_HALFWORD    0x00000020     /* allow half word loads */
-#define ARM_THUMB       0x00000040     /* allow BX instruction  */
-#define ARM_EXT_V5     0x00000080      /* allow CLZ etc         */
+/* The following bitmasks control CPU extensions (ARM7 onwards):   */
+#define ARM_LONGMUL    0x00000010      /* Allow long multiplies.  */
+#define ARM_HALFWORD   0x00000020      /* Allow half word loads.  */
+#define ARM_THUMB      0x00000040      /* Allow BX instruction.   */
+#define ARM_EXT_V5     0x00000080      /* Allow CLZ, etc.         */
 
-/* Architectures are the sum of the base and extensions */
+/* Architectures are the sum of the base and extensions */
 #define ARM_ARCH_V4    (ARM_7 | ARM_LONGMUL | ARM_HALFWORD)
 #define ARM_ARCH_V4T   (ARM_ARCH_V4 | ARM_THUMB)
 #define ARM_ARCH_V5    (ARM_ARCH_V4 | ARM_EXT_V5)
 /* Some useful combinations:  */
 #define ARM_ANY                0x00ffffff
 #define ARM_2UP                (ARM_ANY - ARM_1)
-#define ARM_ALL                ARM_2UP         /* Not arm1 only */
+#define ARM_ALL                ARM_2UP         /* Not arm1 only */
 #define ARM_3UP                0x00fffffc
-#define ARM_6UP                0x00fffff8      /* Includes ARM7 */
+#define ARM_6UP                0x00fffff8      /* Includes ARM7 */
 
 #define FPU_CORE       0x80000000
 #define FPU_FPA10      0x40000000
 #define FPU_FPA11      0x40000000
 #define FPU_NONE       0
 
-/* Some useful combinations  */
-#define FPU_ALL                0xff000000      /* Note this is ~ARM_ANY */
-#define FPU_MEMMULTI   0x7f000000      /* Not fpu_core */
+/* Some useful combinations.  */
+#define FPU_ALL                0xff000000      /* Note this is ~ARM_ANY */
+#define FPU_MEMMULTI   0x7f000000      /* Not fpu_core */
 
-     
 #ifndef CPU_DEFAULT
 #if defined __thumb__
 #define CPU_DEFAULT (ARM_ARCH_V4 | ARM_THUMB)
 #endif
 
 #define streq(a, b)           (strcmp (a, b) == 0)
-#define skip_whitespace(str)  while (* (str) == ' ') ++ (str)
+#define skip_whitespace(str)  while (*(str) == ' ') ++(str)
 
-static unsigned long   cpu_variant = CPU_DEFAULT | FPU_DEFAULT;
+static unsigned long cpu_variant = CPU_DEFAULT | FPU_DEFAULT;
 static int target_oabi = 0;
 
 #if defined OBJ_COFF || defined OBJ_ELF
-/* Flags stored in private area of BFD structure */
-static boolean         uses_apcs_26 = false;
-static boolean         support_interwork = false;
-static boolean         uses_apcs_float = false;
-static boolean         pic_code = false;
+/* Flags stored in private area of BFD structure */
+static boolean uses_apcs_26      = false;
+static boolean support_interwork = false;
+static boolean uses_apcs_float   = false;
+static boolean pic_code          = false;
 #endif
 
 /* This array holds the chars that always start a comment.  If the
-   pre-processor is disabled, these aren't very useful */
+   pre-processor is disabled, these aren't very useful */
 CONST char comment_chars[] = "@";
 
 /* This array holds the chars that only start a comment at the beginning of
    a line.  If the line seems to have the form '# 123 filename'
-   .line and .file directives will appear in the pre-processed output */
+   .line and .file directives will appear in the pre-processed output */
 /* Note that input_file.c hand checks for '#' at the beginning of the
    first line of the input file.  This is because the compiler outputs
-   #NO_APP at the beginning of its output. */
-/* Also note that comments like this one will always work. */
+   #NO_APP at the beginning of its output.  */
+/* Also note that comments like this one will always work.  */
 CONST char line_comment_chars[] = "#";
 
-#ifdef TE_LINUX
 CONST char line_separator_chars[] = ";";
-#else
-CONST char line_separator_chars[] = "";
-#endif
 
-/* Chars that can be used to separate mant from exp in floating point nums */
+/* Chars that can be used to separate mant
+   from exp in floating point numbers.  */
 CONST char EXP_CHARS[] = "eE";
 
-/* Chars that mean this number is a floating point constant */
-/* As in 0f12.456 */
-/* or    0d1.2345e12 */
+/* Chars that mean this number is a floating point constant */
+/* As in 0f12.456  */
+/* or    0d1.2345e12  */
 
 CONST char FLT_CHARS[] = "rRsSfFdDxXeEpP";
 
@@ -135,12 +132,18 @@ CONST char FLT_CHARS[] = "rRsSfFdDxXeEpP";
 #define is_immediate_prefix(C) ((C) == '#' || (C) == '$')
 
 #ifdef OBJ_ELF
-symbolS * GOT_symbol;          /* Pre-defined "_GLOBAL_OFFSET_TABLE_" */
+/* Pre-defined "_GLOBAL_OFFSET_TABLE_"  */
+symbolS * GOT_symbol;
 #endif
 
-CONST int md_reloc_size = 8;           /* Size of relocation record */
+/* Size of relocation record.  */
+CONST int md_reloc_size = 8;
 
-static int thumb_mode = 0;      /* non-zero if assembling thumb instructions */
+/* 0: assemble for ARM,
+   1: assemble for Thumb,
+   2: assemble for Thumb even though target CPU does not support thumb
+      instructions.  */
+static int thumb_mode = 0;
 
 typedef struct arm_fix
 {
@@ -154,35 +157,61 @@ struct arm_it
   int           suffix;
   int           size;
   struct
-    {
-      bfd_reloc_code_real_type type;
-      expressionS              exp;
-      int                      pc_rel;
-    } reloc;
+  {
+    bfd_reloc_code_real_type type;
+    expressionS              exp;
+    int                      pc_rel;
+  } reloc;
 };
 
 struct arm_it inst;
 
-struct asm_shift
+enum asm_shift_index
 {
-  CONST char *  template;
-  unsigned long value;
+  SHIFT_LSL = 0,
+  SHIFT_LSR,
+  SHIFT_ASR,
+  SHIFT_ROR,
+  SHIFT_RRX
+};
+
+struct asm_shift_properties
+{
+  enum asm_shift_index index;
+  unsigned long        bit_field;
+  unsigned int         allows_0  : 1;
+  unsigned int         allows_32 : 1;
+};
+
+static const struct asm_shift_properties shift_properties [] =
+{
+  { SHIFT_LSL, 0,    1, 0},
+  { SHIFT_LSR, 0x20, 0, 1},
+  { SHIFT_ASR, 0x40, 0, 1},
+  { SHIFT_ROR, 0x60, 0, 0},
+  { SHIFT_RRX, 0x60, 0, 0}
 };
 
-static CONST struct asm_shift shift[] =
-{
-  {"asl", 0},
-  {"lsl", 0},
-  {"lsr", 0x00000020},
-  {"asr", 0x00000040},
-  {"ror", 0x00000060},
-  {"rrx", 0x00000060},
-  {"ASL", 0},
-  {"LSL", 0},
-  {"LSR", 0x00000020},
-  {"ASR", 0x00000040},
-  {"ROR", 0x00000060},
-  {"RRX", 0x00000060}
+struct asm_shift_name
+{
+  const char *                        name;
+  const struct asm_shift_properties * properties;
+};
+
+static const struct asm_shift_name shift_names [] =
+{
+  { "asl", shift_properties + SHIFT_LSL },
+  { "lsl", shift_properties + SHIFT_LSL },
+  { "lsr", shift_properties + SHIFT_LSR },
+  { "asr", shift_properties + SHIFT_ASR },
+  { "ror", shift_properties + SHIFT_ROR },
+  { "rrx", shift_properties + SHIFT_RRX },
+  { "ASL", shift_properties + SHIFT_LSL },
+  { "LSL", shift_properties + SHIFT_LSL },
+  { "LSR", shift_properties + SHIFT_LSR },
+  { "ASR", shift_properties + SHIFT_ASR },
+  { "ROR", shift_properties + SHIFT_ROR },
+  { "RRX", shift_properties + SHIFT_RRX }
 };
 
 #define NO_SHIFT_RESTRICT 1
@@ -190,12 +219,12 @@ static CONST struct asm_shift shift[] =
 
 #define NUM_FLOAT_VALS 8
 
-CONST char * fp_const[] = 
+CONST char * fp_const[] =
 {
   "0.0", "1.0", "2.0", "3.0", "4.0", "5.0", "0.5", "10.0", 0
 };
 
-/* Number of littlenums required to hold an extended precision number */
+/* Number of littlenums required to hold an extended precision number */
 #define MAX_LITTLENUMS 6
 
 LITTLENUM_TYPE fp_values[NUM_FLOAT_VALS][MAX_LITTLENUMS];
@@ -224,10 +253,10 @@ struct asm_cond
   unsigned long value;
 };
 
-/* This is to save a hash look-up in the common case */
+/* This is to save a hash look-up in the common case */
 #define COND_ALWAYS 0xe0000000
 
-static CONST struct asm_cond conds[] = 
+static CONST struct asm_cond conds[] =
 {
   {"eq", 0x00000000},
   {"ne", 0x10000000},
@@ -249,11 +278,11 @@ static CONST struct asm_cond conds[] =
 
 /* Warning: If the top bit of the set_bits is set, then the standard
    instruction bitmask is ignored, and the new bitmask is taken from
-   the set_bits: */
+   the set_bits:  */
 struct asm_flg
 {
-  CONST char *  template;      /* Basic flag string */
-  unsigned long set_bits;      /* Bits to set */
+  CONST char *  template;      /* Basic flag string */
+  unsigned long set_bits;      /* Bits to set */
 };
 
 static CONST struct asm_flg s_flag[] =
@@ -379,43 +408,178 @@ static CONST struct asm_flg cplong_flag[] =
 struct asm_psr
 {
   CONST char *  template;
-  unsigned long number;
+  boolean       cpsr;
+  unsigned long field;
 };
 
-#define PSR_FIELD_MASK  0x000f0000
+/* The bit that distnguishes CPSR and SPSR.  */
+#define SPSR_BIT   (1 << 22)
 
-#define PSR_FLAGS      0x00080000
-#define PSR_CONTROL    0x00010000 /* Undocumented instruction, its use is discouraged by ARM */
-#define PSR_ALL                0x00090000
+/* How many bits to shift the PSR_xxx bits up by.  */
+#define PSR_SHIFT  16
 
-#define CPSR_ALL       0
-#define SPSR_ALL       1
-#define CPSR_FLG       2
-#define SPSR_FLG       3
-#define CPSR_CTL       4
-#define SPSR_CTL       5
+#define PSR_c   (1 << 0)
+#define PSR_x   (1 << 1)
+#define PSR_s   (1 << 2)
+#define PSR_f   (1 << 3)
 
 static CONST struct asm_psr psrs[] =
 {
-  /* Valid <psr>'s */
-  {"cpsr",     CPSR_ALL},
-  {"cpsr_all", CPSR_ALL},
-  {"spsr",     SPSR_ALL},
-  {"spsr_all", SPSR_ALL},
-
-  /* Valid <psrf>'s */
-  {"cpsr_flg", CPSR_FLG},
-  {"spsr_flg", SPSR_FLG},
-  
-  /* Valid <psrc>'s */
-  {"cpsr_c",   CPSR_CTL},
-  {"cpsr_ctl", CPSR_CTL},
-  {"spsr_c",   SPSR_CTL},
-  {"spsr_ctl", SPSR_CTL}
+  {"CPSR",     true,  PSR_c | PSR_f},
+  {"CPSR_all", true,  PSR_c | PSR_f},
+  {"SPSR",     false, PSR_c | PSR_f},
+  {"SPSR_all", false, PSR_c | PSR_f},
+  {"CPSR_flg", true,  PSR_f},
+  {"CPSR_f",    true,  PSR_f},
+  {"SPSR_flg", false, PSR_f},
+  {"SPSR_f",    false, PSR_f},
+  {"CPSR_c",   true,  PSR_c},
+  {"CPSR_ctl", true,  PSR_c},
+  {"SPSR_c",   false, PSR_c},
+  {"SPSR_ctl", false, PSR_c},
+  {"CPSR_x",    true,  PSR_x},
+  {"CPSR_s",    true,  PSR_s},
+  {"SPSR_x",    false, PSR_x},
+  {"SPSR_s",    false, PSR_s},
+  /* Combinations of flags.  */
+  {"CPSR_fs",  true, PSR_f | PSR_s},
+  {"CPSR_fx",  true, PSR_f | PSR_x},
+  {"CPSR_fc",  true, PSR_f | PSR_c},
+  {"CPSR_sf",  true, PSR_s | PSR_f},
+  {"CPSR_sx",  true, PSR_s | PSR_x},
+  {"CPSR_sc",  true, PSR_s | PSR_c},
+  {"CPSR_xf",  true, PSR_x | PSR_f},
+  {"CPSR_xs",  true, PSR_x | PSR_s},
+  {"CPSR_xc",  true, PSR_x | PSR_c},
+  {"CPSR_cf",  true, PSR_c | PSR_f},
+  {"CPSR_cs",  true, PSR_c | PSR_s},
+  {"CPSR_cx",  true, PSR_c | PSR_x},
+  {"CPSR_fsx", true, PSR_f | PSR_s | PSR_x},
+  {"CPSR_fsc", true, PSR_f | PSR_s | PSR_c},
+  {"CPSR_fxs", true, PSR_f | PSR_x | PSR_s},
+  {"CPSR_fxc", true, PSR_f | PSR_x | PSR_c},
+  {"CPSR_fcs", true, PSR_f | PSR_c | PSR_s},
+  {"CPSR_fcx", true, PSR_f | PSR_c | PSR_x},
+  {"CPSR_sfx", true, PSR_s | PSR_f | PSR_x},
+  {"CPSR_sfc", true, PSR_s | PSR_f | PSR_c},
+  {"CPSR_sxf", true, PSR_s | PSR_x | PSR_f},
+  {"CPSR_sxc", true, PSR_s | PSR_x | PSR_c},
+  {"CPSR_scf", true, PSR_s | PSR_c | PSR_f},
+  {"CPSR_scx", true, PSR_s | PSR_c | PSR_x},
+  {"CPSR_xfs", true, PSR_x | PSR_f | PSR_s},
+  {"CPSR_xfc", true, PSR_x | PSR_f | PSR_c},
+  {"CPSR_xsf", true, PSR_x | PSR_s | PSR_f},
+  {"CPSR_xsc", true, PSR_x | PSR_s | PSR_c},
+  {"CPSR_xcf", true, PSR_x | PSR_c | PSR_f},
+  {"CPSR_xcs", true, PSR_x | PSR_c | PSR_s},
+  {"CPSR_cfs", true, PSR_c | PSR_f | PSR_s},
+  {"CPSR_cfx", true, PSR_c | PSR_f | PSR_x},
+  {"CPSR_csf", true, PSR_c | PSR_s | PSR_f},
+  {"CPSR_csx", true, PSR_c | PSR_s | PSR_x},
+  {"CPSR_cxf", true, PSR_c | PSR_x | PSR_f},
+  {"CPSR_cxs", true, PSR_c | PSR_x | PSR_s},
+  {"CPSR_fsxc",        true, PSR_f | PSR_s | PSR_x | PSR_c},
+  {"CPSR_fscx",        true, PSR_f | PSR_s | PSR_c | PSR_x},
+  {"CPSR_fxsc",        true, PSR_f | PSR_x | PSR_s | PSR_c},
+  {"CPSR_fxcs",        true, PSR_f | PSR_x | PSR_c | PSR_s},
+  {"CPSR_fcsx",        true, PSR_f | PSR_c | PSR_s | PSR_x},
+  {"CPSR_fcxs",        true, PSR_f | PSR_c | PSR_x | PSR_s},
+  {"CPSR_sfxc",        true, PSR_s | PSR_f | PSR_x | PSR_c},
+  {"CPSR_sfcx",        true, PSR_s | PSR_f | PSR_c | PSR_x},
+  {"CPSR_sxfc",        true, PSR_s | PSR_x | PSR_f | PSR_c},
+  {"CPSR_sxcf",        true, PSR_s | PSR_x | PSR_c | PSR_f},
+  {"CPSR_scfx",        true, PSR_s | PSR_c | PSR_f | PSR_x},
+  {"CPSR_scxf",        true, PSR_s | PSR_c | PSR_x | PSR_f},
+  {"CPSR_xfsc",        true, PSR_x | PSR_f | PSR_s | PSR_c},
+  {"CPSR_xfcs",        true, PSR_x | PSR_f | PSR_c | PSR_s},
+  {"CPSR_xsfc",        true, PSR_x | PSR_s | PSR_f | PSR_c},
+  {"CPSR_xscf",        true, PSR_x | PSR_s | PSR_c | PSR_f},
+  {"CPSR_xcfs",        true, PSR_x | PSR_c | PSR_f | PSR_s},
+  {"CPSR_xcsf",        true, PSR_x | PSR_c | PSR_s | PSR_f},
+  {"CPSR_cfsx",        true, PSR_c | PSR_f | PSR_s | PSR_x},
+  {"CPSR_cfxs",        true, PSR_c | PSR_f | PSR_x | PSR_s},
+  {"CPSR_csfx",        true, PSR_c | PSR_s | PSR_f | PSR_x},
+  {"CPSR_csxf",        true, PSR_c | PSR_s | PSR_x | PSR_f},
+  {"CPSR_cxfs",        true, PSR_c | PSR_x | PSR_f | PSR_s},
+  {"CPSR_cxsf",        true, PSR_c | PSR_x | PSR_s | PSR_f},
+  {"SPSR_fs",  false, PSR_f | PSR_s},
+  {"SPSR_fx",  false, PSR_f | PSR_x},
+  {"SPSR_fc",  false, PSR_f | PSR_c},
+  {"SPSR_sf",  false, PSR_s | PSR_f},
+  {"SPSR_sx",  false, PSR_s | PSR_x},
+  {"SPSR_sc",  false, PSR_s | PSR_c},
+  {"SPSR_xf",  false, PSR_x | PSR_f},
+  {"SPSR_xs",  false, PSR_x | PSR_s},
+  {"SPSR_xc",  false, PSR_x | PSR_c},
+  {"SPSR_cf",  false, PSR_c | PSR_f},
+  {"SPSR_cs",  false, PSR_c | PSR_s},
+  {"SPSR_cx",  false, PSR_c | PSR_x},
+  {"SPSR_fsx", false, PSR_f | PSR_s | PSR_x},
+  {"SPSR_fsc", false, PSR_f | PSR_s | PSR_c},
+  {"SPSR_fxs", false, PSR_f | PSR_x | PSR_s},
+  {"SPSR_fxc", false, PSR_f | PSR_x | PSR_c},
+  {"SPSR_fcs", false, PSR_f | PSR_c | PSR_s},
+  {"SPSR_fcx", false, PSR_f | PSR_c | PSR_x},
+  {"SPSR_sfx", false, PSR_s | PSR_f | PSR_x},
+  {"SPSR_sfc", false, PSR_s | PSR_f | PSR_c},
+  {"SPSR_sxf", false, PSR_s | PSR_x | PSR_f},
+  {"SPSR_sxc", false, PSR_s | PSR_x | PSR_c},
+  {"SPSR_scf", false, PSR_s | PSR_c | PSR_f},
+  {"SPSR_scx", false, PSR_s | PSR_c | PSR_x},
+  {"SPSR_xfs", false, PSR_x | PSR_f | PSR_s},
+  {"SPSR_xfc", false, PSR_x | PSR_f | PSR_c},
+  {"SPSR_xsf", false, PSR_x | PSR_s | PSR_f},
+  {"SPSR_xsc", false, PSR_x | PSR_s | PSR_c},
+  {"SPSR_xcf", false, PSR_x | PSR_c | PSR_f},
+  {"SPSR_xcs", false, PSR_x | PSR_c | PSR_s},
+  {"SPSR_cfs", false, PSR_c | PSR_f | PSR_s},
+  {"SPSR_cfx", false, PSR_c | PSR_f | PSR_x},
+  {"SPSR_csf", false, PSR_c | PSR_s | PSR_f},
+  {"SPSR_csx", false, PSR_c | PSR_s | PSR_x},
+  {"SPSR_cxf", false, PSR_c | PSR_x | PSR_f},
+  {"SPSR_cxs", false, PSR_c | PSR_x | PSR_s},
+  {"SPSR_fsxc",        false, PSR_f | PSR_s | PSR_x | PSR_c},
+  {"SPSR_fscx",        false, PSR_f | PSR_s | PSR_c | PSR_x},
+  {"SPSR_fxsc",        false, PSR_f | PSR_x | PSR_s | PSR_c},
+  {"SPSR_fxcs",        false, PSR_f | PSR_x | PSR_c | PSR_s},
+  {"SPSR_fcsx",        false, PSR_f | PSR_c | PSR_s | PSR_x},
+  {"SPSR_fcxs",        false, PSR_f | PSR_c | PSR_x | PSR_s},
+  {"SPSR_sfxc",        false, PSR_s | PSR_f | PSR_x | PSR_c},
+  {"SPSR_sfcx",        false, PSR_s | PSR_f | PSR_c | PSR_x},
+  {"SPSR_sxfc",        false, PSR_s | PSR_x | PSR_f | PSR_c},
+  {"SPSR_sxcf",        false, PSR_s | PSR_x | PSR_c | PSR_f},
+  {"SPSR_scfx",        false, PSR_s | PSR_c | PSR_f | PSR_x},
+  {"SPSR_scxf",        false, PSR_s | PSR_c | PSR_x | PSR_f},
+  {"SPSR_xfsc",        false, PSR_x | PSR_f | PSR_s | PSR_c},
+  {"SPSR_xfcs",        false, PSR_x | PSR_f | PSR_c | PSR_s},
+  {"SPSR_xsfc",        false, PSR_x | PSR_s | PSR_f | PSR_c},
+  {"SPSR_xscf",        false, PSR_x | PSR_s | PSR_c | PSR_f},
+  {"SPSR_xcfs",        false, PSR_x | PSR_c | PSR_f | PSR_s},
+  {"SPSR_xcsf",        false, PSR_x | PSR_c | PSR_s | PSR_f},
+  {"SPSR_cfsx",        false, PSR_c | PSR_f | PSR_s | PSR_x},
+  {"SPSR_cfxs",        false, PSR_c | PSR_f | PSR_x | PSR_s},
+  {"SPSR_csfx",        false, PSR_c | PSR_s | PSR_f | PSR_x},
+  {"SPSR_csxf",        false, PSR_c | PSR_s | PSR_x | PSR_f},
+  {"SPSR_cxfs",        false, PSR_c | PSR_x | PSR_f | PSR_s},
+  {"SPSR_cxsf",        false, PSR_c | PSR_x | PSR_s | PSR_f},
+  /* For backwards compatability with older toolchain we also
+     support lower case versions of some of these flags.  */
+  {"cpsr",     true,  PSR_c | PSR_f},
+  {"cpsr_all", true,  PSR_c | PSR_f},
+  {"spsr",     false, PSR_c | PSR_f},
+  {"spsr_all", false, PSR_c | PSR_f},
+  {"cpsr_flg", true,  PSR_f},
+  {"cpsr_f",    true,  PSR_f},
+  {"spsr_flg", false, PSR_f},
+  {"spsr_f",    false, PSR_f},
+  {"cpsr_c",   true,  PSR_c},
+  {"cpsr_ctl", true,  PSR_c},
+  {"spsr_c",   false, PSR_c},
+  {"spsr_ctl", false, PSR_c}
 };
 
-/* Functions called by parser */
-/* ARM instructions */
+/* Functions called by parser */
+/* ARM instructions */
 static void do_arit            PARAMS ((char *, unsigned long));
 static void do_cmp             PARAMS ((char *, unsigned long));
 static void do_mov             PARAMS ((char *, unsigned long));
@@ -423,24 +587,24 @@ static void do_ldst               PARAMS ((char *, unsigned long));
 static void do_ldmstm          PARAMS ((char *, unsigned long));
 static void do_branch          PARAMS ((char *, unsigned long));
 static void do_swi             PARAMS ((char *, unsigned long));
-/* Pseudo Op codes */                                        
+/* Pseudo Op codes.  */
 static void do_adr             PARAMS ((char *, unsigned long));
 static void do_adrl            PARAMS ((char *, unsigned long));
 static void do_nop             PARAMS ((char *, unsigned long));
-/* ARM 2 */                                                  
+/* ARM 2.  */
 static void do_mul             PARAMS ((char *, unsigned long));
 static void do_mla             PARAMS ((char *, unsigned long));
-/* ARM 3 */                                                  
+/* ARM 3.  */
 static void do_swap            PARAMS ((char *, unsigned long));
-/* ARM 6 */                                                  
+/* ARM 6.  */
 static void do_msr             PARAMS ((char *, unsigned long));
 static void do_mrs             PARAMS ((char *, unsigned long));
-/* ARM 7M */                                                 
+/* ARM 7M.  */
 static void do_mull            PARAMS ((char *, unsigned long));
-/* ARM THUMB */                                                      
+/* ARM THUMB.  */
 static void do_bx               PARAMS ((char *, unsigned long));
-                                                             
-/* Coprocessor Instructions */                               
+
+/* Coprocessor Instructions.  */
 static void do_cdp             PARAMS ((char *, unsigned long));
 static void do_lstc            PARAMS ((char *, unsigned long));
 static void do_co_reg          PARAMS ((char *, unsigned long));
@@ -455,7 +619,7 @@ static void do_fp_to_reg    PARAMS ((char *, unsigned long));
 
 static void fix_new_arm                PARAMS ((fragS *, int, short, expressionS *, int, int));
 static int arm_reg_parse       PARAMS ((char **));
-static int arm_psr_parse       PARAMS ((char **));
+static CONST struct asm_psr * arm_psr_parse PARAMS ((char **));
 static void symbol_locate      PARAMS ((symbolS *, CONST char *, segT, valueT, fragS *));
 static int add_to_lit_pool     PARAMS ((void));
 static unsigned validate_immediate PARAMS ((unsigned));
@@ -464,7 +628,7 @@ static int validate_offset_imm      PARAMS ((unsigned int, int));
 static void opcode_select      PARAMS ((int));
 static void end_of_line                PARAMS ((char *));
 static int reg_required_here   PARAMS ((char **, int));
-static int psr_required_here   PARAMS ((char **, int, int));
+static int psr_required_here   PARAMS ((char **));
 static int co_proc_number      PARAMS ((char **));
 static int cp_opc_expr         PARAMS ((char **, int, int));
 static int cp_reg_required_here        PARAMS ((char **, int));
@@ -494,30 +658,39 @@ static bfd_reloc_code_real_type   arm_parse_reloc PARAMS ((void));
 #endif
 
 /* ARM instructions take 4bytes in the object file, Thumb instructions
-   take 2: */
+   take 2:  */
 #define INSN_SIZE       4
 
-/* LONGEST_INST is the longest basic instruction name without conditions or 
- * flags.
- * ARM7M has 4 of length 5
- */
+/* LONGEST_INST is the longest basic instruction name without conditions or
+   flags.  ARM7M has 4 of length 5.  */
 
 #define LONGEST_INST 5
 
-struct asm_opcode 
+struct asm_opcode
 {
-  CONST char *           template;     /* Basic string to match */
-  unsigned long          value;                /* Basic instruction code */
-  CONST char *           comp_suffix;  /* Compulsory suffix that must follow conds */
-  CONST struct asm_flg * flags;                /* Bits to toggle if flag 'n' set */
-  unsigned long          variants;     /* Which CPU variants this exists for */
-  /* Function to call to parse args */
-  void (*                parms) PARAMS ((char *, unsigned long));
+  /* Basic string to match.  */
+  CONST char * template;
+
+  /* Basic instruction code.  */
+  unsigned long value;
+
+  /* Compulsory suffix that must follow conds.  If "", then the
+     instruction is not conditional and must have no suffix.  */
+  CONST char * comp_suffix;
+
+  /* Bits to toggle if flag 'n' set.  */
+  CONST struct asm_flg * flags;
+
+  /* Which CPU variants this exists for.  */
+  unsigned long variants;
+
+  /* Function to call to parse args.  */
+  void (* parms) PARAMS ((char *, unsigned long));
 };
 
-static CONST struct asm_opcode insns[] = 
+static CONST struct asm_opcode insns[] =
 {
-/* ARM Instructions */
+/* ARM Instructions */
   {"and",   0x00000000, NULL,   s_flag,      ARM_ANY,      do_arit},
   {"eor",   0x00200000, NULL,   s_flag,      ARM_ANY,      do_arit},
   {"sub",   0x00400000, NULL,   s_flag,      ARM_ANY,      do_arit},
@@ -539,38 +712,43 @@ static CONST struct asm_opcode insns[] =
   {"stm",   0x08000000, NULL,   stm_flags,   ARM_ANY,      do_ldmstm},
   {"ldm",   0x08100000, NULL,   ldm_flags,   ARM_ANY,      do_ldmstm},
   {"swi",   0x0f000000, NULL,   NULL,        ARM_ANY,      do_swi},
+#ifdef TE_WINCE
+  {"bl",    0x0b000000, NULL,   NULL,        ARM_ANY,      do_branch},
+  {"b",     0x0a000000, NULL,   NULL,        ARM_ANY,      do_branch},
+#else
   {"bl",    0x0bfffffe, NULL,   NULL,        ARM_ANY,      do_branch},
   {"b",     0x0afffffe, NULL,   NULL,        ARM_ANY,      do_branch},
+#endif
 
-/* Pseudo ops */
+/* Pseudo ops */
   {"adr",   0x028f0000, NULL,   NULL,        ARM_ANY,      do_adr},
   {"adrl",  0x028f0000, NULL,   NULL,        ARM_ANY,      do_adrl},
   {"nop",   0x01a00000, NULL,   NULL,        ARM_ANY,      do_nop},
 
-/* ARM 2 multiplies */
+/* ARM 2 multiplies */
   {"mul",   0x00000090, NULL,   s_flag,      ARM_2UP,      do_mul},
   {"mla",   0x00200090, NULL,   s_flag,      ARM_2UP,      do_mla},
 
-/* ARM 3 - swp instructions */
+/* ARM 3 - swp instructions */
   {"swp",   0x01000090, NULL,   byte_flag,   ARM_3UP,      do_swap},
 
-/* ARM 6 Coprocessor instructions */
+/* ARM 6 Coprocessor instructions */
   {"mrs",   0x010f0000, NULL,   NULL,        ARM_6UP,      do_mrs},
   {"msr",   0x0120f000, NULL,   NULL,        ARM_6UP,      do_msr},
 /* ScottB: our code uses 0x0128f000 for msr.
-   NickC:  but this is wrong because the bits 16 and 19 are handled
-           by the PSR_xxx defines above.  */
+   NickC:  but this is wrong because the bits 16 through 19 are
+           handled by the PSR_xxx defines above.  */
 
-/* ARM 7M long multiplies - need signed/unsigned flags! */
+/* ARM 7M long multiplies - need signed/unsigned flags!  */
   {"smull", 0x00c00090, NULL,   s_flag,      ARM_LONGMUL,  do_mull},
   {"umull", 0x00800090, NULL,   s_flag,      ARM_LONGMUL,  do_mull},
   {"smlal", 0x00e00090, NULL,   s_flag,      ARM_LONGMUL,  do_mull},
   {"umlal", 0x00a00090, NULL,   s_flag,      ARM_LONGMUL,  do_mull},
 
-/* ARM THUMB interworking */
+/* ARM THUMB interworking */
   {"bx",    0x012fff10, NULL,   NULL,        ARM_THUMB,    do_bx},
 
-/* Floating point instructions */
+/* Floating point instructions */
   {"wfs",   0x0e200110, NULL,   NULL,        FPU_ALL,      do_fp_ctrl},
   {"rfs",   0x0e300110, NULL,   NULL,        FPU_ALL,      do_fp_ctrl},
   {"wfc",   0x0e400110, NULL,   NULL,        FPU_ALL,      do_fp_ctrl},
@@ -618,7 +796,7 @@ static CONST struct asm_opcode insns[] =
   {"flt",   0x0e000110, "sde",  round_flags, FPU_ALL,      do_fp_from_reg},
   {"fix",   0x0e100110, NULL,   fix_flags,   FPU_ALL,      do_fp_to_reg},
 
-/* Generic copressor instructions */
+/* Generic copressor instructions */
   {"cdp",   0x0e000000, NULL,  NULL,         ARM_2UP,      do_cdp},
   {"ldc",   0x0c100000, NULL,  cplong_flag,  ARM_2UP,      do_lstc},
   {"stc",   0x0c000000, NULL,  cplong_flag,  ARM_2UP,      do_lstc},
@@ -626,8 +804,7 @@ static CONST struct asm_opcode insns[] =
   {"mrc",   0x0e100010, NULL,  NULL,         ARM_2UP,      do_co_reg},
 };
 
-/* defines for various bits that we will want to toggle */
-
+/* Defines for various bits that we will want to toggle.  */
 #define INST_IMMEDIATE 0x02000000
 #define OFFSET_REG     0x02000000
 #define HWOFFSET_IMM    0x00400000
@@ -635,15 +812,14 @@ static CONST struct asm_opcode insns[] =
 #define PRE_INDEX      0x01000000
 #define INDEX_UP       0x00800000
 #define WRITE_BACK     0x00200000
-#define MULTI_SET_PSR  0x00400000
+#define LDM_TYPE_2_OR_3        0x00400000
 
 #define LITERAL_MASK   0xf000f000
 #define COND_MASK      0xf0000000
 #define OPCODE_MASK    0xfe1fffff
 #define DATA_OP_SHIFT  21
 
-/* Codes to distinguish the arithmetic instructions */
-
+/* Codes to distinguish the arithmetic instructions.  */
 #define OPCODE_AND     0
 #define OPCODE_EOR     1
 #define OPCODE_SUB     2
@@ -740,7 +916,7 @@ static void do_t_adr                PARAMS ((char *));
 
 static int thumb_reg           PARAMS ((char ** str, int hi_lo));
 
-#define THUMB_SIZE     2       /* Size of thumb instruction */
+#define THUMB_SIZE     2       /* Size of thumb instruction */
 #define THUMB_REG_LO   0x1
 #define THUMB_REG_HI   0x2
 #define THUMB_REG_ANY  0x3
@@ -760,78 +936,88 @@ static int thumb_reg              PARAMS ((char ** str, int hi_lo));
 
 #define THUMB_PP_PC_LR 0x0100
 
-/* These three are used for immediate shifts, do not alter */
+/* These three are used for immediate shifts, do not alter */
 #define THUMB_WORD 2
 #define THUMB_HALFWORD 1
 #define THUMB_BYTE 0
 
-struct thumb_opcode 
+struct thumb_opcode
 {
-  CONST char *  template;      /* Basic string to match */
-  unsigned long value;         /* Basic instruction code */
-  int           size;
-  void (*       parms) PARAMS ((char *));  /* Function to call to parse args */
+  /* Basic string to match.  */
+  CONST char * template;
+
+  /* Basic instruction code.  */
+  unsigned long value;
+
+  int size;
+
+  /* Which CPU variants this exists for. */
+  unsigned long variants;
+
+  /* Function to call to parse args.  */
+  void (* parms) PARAMS ((char *));
 };
 
 static CONST struct thumb_opcode tinsns[] =
 {
-  {"adc",      0x4140,         2,      do_t_arit},
-  {"add",      0x0000,         2,      do_t_add},
-  {"and",      0x4000,         2,      do_t_arit},
-  {"asr",      0x0000,         2,      do_t_asr},
-  {"b",                T_OPCODE_BRANCH, 2,     do_t_branch12},
-  {"beq",      0xd0fe,         2,      do_t_branch9},
-  {"bne",      0xd1fe,         2,      do_t_branch9},
-  {"bcs",      0xd2fe,         2,      do_t_branch9},
-  {"bhs",      0xd2fe,         2,      do_t_branch9},
-  {"bcc",      0xd3fe,         2,      do_t_branch9},
-  {"bul",      0xd3fe,         2,      do_t_branch9},
-  {"blo",      0xd3fe,         2,      do_t_branch9},
-  {"bmi",      0xd4fe,         2,      do_t_branch9},
-  {"bpl",      0xd5fe,         2,      do_t_branch9},
-  {"bvs",      0xd6fe,         2,      do_t_branch9},
-  {"bvc",      0xd7fe,         2,      do_t_branch9},
-  {"bhi",      0xd8fe,         2,      do_t_branch9},
-  {"bls",      0xd9fe,         2,      do_t_branch9},
-  {"bge",      0xdafe,         2,      do_t_branch9},
-  {"blt",      0xdbfe,         2,      do_t_branch9},
-  {"bgt",      0xdcfe,         2,      do_t_branch9},
-  {"ble",      0xddfe,         2,      do_t_branch9},
-  {"bic",      0x4380,         2,      do_t_arit},
-  {"bl",       0xf7fffffe,     4,      do_t_branch23},
-  {"bx",       0x4700,         2,      do_t_bx},
-  {"cmn",      T_OPCODE_CMN,   2,      do_t_arit},
-  {"cmp",      0x0000,         2,      do_t_compare},
-  {"eor",      0x4040,         2,      do_t_arit},
-  {"ldmia",    0xc800,         2,      do_t_ldmstm},
-  {"ldr",      0x0000,         2,      do_t_ldr},
-  {"ldrb",     0x0000,         2,      do_t_ldrb},
-  {"ldrh",     0x0000,         2,      do_t_ldrh},
-  {"ldrsb",    0x5600,         2,      do_t_lds},
-  {"ldrsh",    0x5e00,         2,      do_t_lds},
-  {"ldsb",     0x5600,         2,      do_t_lds},
-  {"ldsh",     0x5e00,         2,      do_t_lds},
-  {"lsl",      0x0000,         2,      do_t_lsl},
-  {"lsr",      0x0000,         2,      do_t_lsr},
-  {"mov",      0x0000,         2,      do_t_mov},
-  {"mul",      T_OPCODE_MUL,   2,      do_t_arit},
-  {"mvn",      T_OPCODE_MVN,   2,      do_t_arit},
-  {"neg",      T_OPCODE_NEG,   2,      do_t_arit},
-  {"orr",      0x4300,         2,      do_t_arit},
-  {"pop",      0xbc00,         2,      do_t_push_pop},
-  {"push",     0xb400,         2,      do_t_push_pop},
-  {"ror",      0x41c0,         2,      do_t_arit},
-  {"sbc",      0x4180,         2,      do_t_arit},
-  {"stmia",    0xc000,         2,      do_t_ldmstm},
-  {"str",      0x0000,         2,      do_t_str},
-  {"strb",     0x0000,         2,      do_t_strb},
-  {"strh",     0x0000,         2,      do_t_strh},
-  {"swi",      0xdf00,         2,      do_t_swi},
-  {"sub",      0x0000,         2,      do_t_sub},
-  {"tst",      T_OPCODE_TST,   2,      do_t_arit},
-  /* Pseudo ops: */
-  {"adr",       0x0000,         2,      do_t_adr},
-  {"nop",       0x46C0,         2,      do_t_nop},      /* mov r8,r8 */
+  {"adc",      0x4140,         2,      ARM_THUMB, do_t_arit},
+  {"add",      0x0000,         2,      ARM_THUMB, do_t_add},
+  {"and",      0x4000,         2,      ARM_THUMB, do_t_arit},
+  {"asr",      0x0000,         2,      ARM_THUMB, do_t_asr},
+  {"b",                T_OPCODE_BRANCH, 2,     ARM_THUMB, do_t_branch12},
+  {"beq",      0xd0fe,         2,      ARM_THUMB, do_t_branch9},
+  {"bne",      0xd1fe,         2,      ARM_THUMB, do_t_branch9},
+  {"bcs",      0xd2fe,         2,      ARM_THUMB, do_t_branch9},
+  {"bhs",      0xd2fe,         2,      ARM_THUMB, do_t_branch9},
+  {"bcc",      0xd3fe,         2,      ARM_THUMB, do_t_branch9},
+  {"bul",      0xd3fe,         2,      ARM_THUMB, do_t_branch9},
+  {"blo",      0xd3fe,         2,      ARM_THUMB, do_t_branch9},
+  {"bmi",      0xd4fe,         2,      ARM_THUMB, do_t_branch9},
+  {"bpl",      0xd5fe,         2,      ARM_THUMB, do_t_branch9},
+  {"bvs",      0xd6fe,         2,      ARM_THUMB, do_t_branch9},
+  {"bvc",      0xd7fe,         2,      ARM_THUMB, do_t_branch9},
+  {"bhi",      0xd8fe,         2,      ARM_THUMB, do_t_branch9},
+  {"bls",      0xd9fe,         2,      ARM_THUMB, do_t_branch9},
+  {"bge",      0xdafe,         2,      ARM_THUMB, do_t_branch9},
+  {"blt",      0xdbfe,         2,      ARM_THUMB, do_t_branch9},
+  {"bgt",      0xdcfe,         2,      ARM_THUMB, do_t_branch9},
+  {"ble",      0xddfe,         2,      ARM_THUMB, do_t_branch9},
+  {"bal",      0xdefe,         2,      ARM_THUMB, do_t_branch9},
+  {"bic",      0x4380,         2,      ARM_THUMB, do_t_arit},
+  {"bl",       0xf7fffffe,     4,      ARM_THUMB, do_t_branch23},
+  {"bx",       0x4700,         2,      ARM_THUMB, do_t_bx},
+  {"cmn",      T_OPCODE_CMN,   2,      ARM_THUMB, do_t_arit},
+  {"cmp",      0x0000,         2,      ARM_THUMB, do_t_compare},
+  {"eor",      0x4040,         2,      ARM_THUMB, do_t_arit},
+  {"ldmia",    0xc800,         2,      ARM_THUMB, do_t_ldmstm},
+  {"ldr",      0x0000,         2,      ARM_THUMB, do_t_ldr},
+  {"ldrb",     0x0000,         2,      ARM_THUMB, do_t_ldrb},
+  {"ldrh",     0x0000,         2,      ARM_THUMB, do_t_ldrh},
+  {"ldrsb",    0x5600,         2,      ARM_THUMB, do_t_lds},
+  {"ldrsh",    0x5e00,         2,      ARM_THUMB, do_t_lds},
+  {"ldsb",     0x5600,         2,      ARM_THUMB, do_t_lds},
+  {"ldsh",     0x5e00,         2,      ARM_THUMB, do_t_lds},
+  {"lsl",      0x0000,         2,      ARM_THUMB, do_t_lsl},
+  {"lsr",      0x0000,         2,      ARM_THUMB, do_t_lsr},
+  {"mov",      0x0000,         2,      ARM_THUMB, do_t_mov},
+  {"mul",      T_OPCODE_MUL,   2,      ARM_THUMB, do_t_arit},
+  {"mvn",      T_OPCODE_MVN,   2,      ARM_THUMB, do_t_arit},
+  {"neg",      T_OPCODE_NEG,   2,      ARM_THUMB, do_t_arit},
+  {"orr",      0x4300,         2,      ARM_THUMB, do_t_arit},
+  {"pop",      0xbc00,         2,      ARM_THUMB, do_t_push_pop},
+  {"push",     0xb400,         2,      ARM_THUMB, do_t_push_pop},
+  {"ror",      0x41c0,         2,      ARM_THUMB, do_t_arit},
+  {"sbc",      0x4180,         2,      ARM_THUMB, do_t_arit},
+  {"stmia",    0xc000,         2,      ARM_THUMB, do_t_ldmstm},
+  {"str",      0x0000,         2,      ARM_THUMB, do_t_str},
+  {"strb",     0x0000,         2,      ARM_THUMB, do_t_strb},
+  {"strh",     0x0000,         2,      ARM_THUMB, do_t_strh},
+  {"swi",      0xdf00,         2,      ARM_THUMB, do_t_swi},
+  {"sub",      0x0000,         2,      ARM_THUMB, do_t_sub},
+  {"tst",      T_OPCODE_TST,   2,      ARM_THUMB, do_t_arit},
+  /* Pseudo ops:  */
+  {"adr",       0x0000,         2,      ARM_THUMB, do_t_adr},
+  {"nop",       0x46C0,         2,      ARM_THUMB, do_t_nop},      /* mov r8,r8  */
 };
 
 struct reg_entry
@@ -848,20 +1034,22 @@ struct reg_entry
 #define REG_LR  14
 #define REG_SP  13
 
-/* These are the standard names;  Users can add aliases with .req */
+/* These are the standard names.  Users can add aliases with .req.  */
 static CONST struct reg_entry reg_table[] =
 {
-  /* Processor Register Numbers */
+  /* Processor Register Numbers */
   {"r0", 0},    {"r1", 1},      {"r2", 2},      {"r3", 3},
   {"r4", 4},    {"r5", 5},      {"r6", 6},      {"r7", 7},
   {"r8", 8},    {"r9", 9},      {"r10", 10},    {"r11", 11},
   {"r12", 12},  {"r13", REG_SP},{"r14", REG_LR},{"r15", REG_PC},
-  /* APCS conventions */
+  /* APCS conventions */
   {"a1", 0},   {"a2", 1},    {"a3", 2},     {"a4", 3},
   {"v1", 4},   {"v2", 5},    {"v3", 6},     {"v4", 7},     {"v5", 8},
   {"v6", 9},   {"sb", 9},    {"v7", 10},    {"sl", 10},
   {"fp", 11},  {"ip", 12},   {"sp", REG_SP},{"lr", REG_LR},{"pc", REG_PC},
-  /* FP Registers */
+  /* ATPCS additions to APCS conventions.  */
+  {"wr", 7},    {"v8", 11},
+  /* FP Registers.  */
   {"f0", 16},   {"f1", 17},   {"f2", 18},   {"f3", 19},
   {"f4", 20},   {"f5", 21},   {"f6", 22},   {"f7", 23},
   {"c0", 32},   {"c1", 33},   {"c2", 34},   {"c3", 35},
@@ -872,25 +1060,33 @@ static CONST struct reg_entry reg_table[] =
   {"cr4", 36},  {"cr5", 37},  {"cr6", 38},  {"cr7", 39},
   {"cr8", 40},  {"cr9", 41},  {"cr10", 42}, {"cr11", 43},
   {"cr12", 44}, {"cr13", 45}, {"cr14", 46}, {"cr15", 47},
+  /* ATPCS additions to float register names.  */
+  {"s0",16},   {"s1",17},      {"s2",18},      {"s3",19},
+  {"s4",20},   {"s5",21},      {"s6",22},      {"s7",23},
+  {"d0",16},   {"d1",17},      {"d2",18},      {"d3",19},
+  {"d4",20},   {"d5",21},      {"d6",22},      {"d7",23},
+  /* FIXME: At some point we need to add VFP register names.  */
+  /* Array terminator.  */
   {NULL, 0}
 };
 
-#define bad_args       _("Bad arguments to instruction");
-#define bad_pc                 _("r15 not allowed here");
+#define BAD_ARGS       _("Bad arguments to instruction")
+#define BAD_PC                 _("r15 not allowed here")
+#define BAD_FLAGS      _("Instruction should not have flags")
+#define BAD_COND       _("Instruction is not conditional")
 
-static struct hash_control * arm_ops_hsh = NULL;
-static struct hash_control * arm_tops_hsh = NULL;
-static struct hash_control * arm_cond_hsh = NULL;
+static struct hash_control * arm_ops_hsh   = NULL;
+static struct hash_control * arm_tops_hsh  = NULL;
+static struct hash_control * arm_cond_hsh  = NULL;
 static struct hash_control * arm_shift_hsh = NULL;
-static struct hash_control * arm_reg_hsh = NULL;
-static struct hash_control * arm_psr_hsh = NULL;
+static struct hash_control * arm_reg_hsh   = NULL;
+static struct hash_control * arm_psr_hsh   = NULL;
 
 /* This table describes all the machine specific pseudo-ops the assembler
    has to support.  The fields are:
-   pseudo-op name without dot
-   function to call to execute this pseudo-op
-   Integer arg to pass to the function
-   */
+     pseudo-op name without dot
+     function to call to execute this pseudo-op
+     Integer arg to pass to the function.  */
 
 static void s_req PARAMS ((int));
 static void s_align PARAMS ((int));
@@ -914,7 +1110,8 @@ static int my_get_expression PARAMS ((expressionS *, char **));
 
 CONST pseudo_typeS md_pseudo_table[] =
 {
-  { "req",         s_req,         0 }, /* Never called becasue '.req' does not start line */
+  /* Never called becasue '.req' does not start line.  */
+  { "req",         s_req,         0 },
   { "bss",         s_bss,         0 },
   { "align",       s_align,       0 },
   { "arm",         s_arm,         0 },
@@ -929,7 +1126,7 @@ CONST pseudo_typeS md_pseudo_table[] =
   /* Allow for the effect of section changes.  */
   { "text",        arm_s_text,    0 },
   { "data",        arm_s_data,    0 },
-#ifdef OBJ_ELF  
+#ifdef OBJ_ELF
   { "section",     arm_s_section, 0 },
   { "section.s",   arm_s_section, 0 },
   { "sect",        arm_s_section, 0 },
@@ -958,19 +1155,24 @@ CONST pseudo_typeS md_pseudo_table[] =
 symbolS *  last_label_seen;
 static int label_is_thumb_function_name = false;
 
-/* Literal stuff */
+/* Literal stuff */
 
 #define MAX_LITERAL_POOL_SIZE 1024
 
 typedef struct literalS
 {
-  struct expressionS  exp;
-  struct arm_it *     inst;
+  struct expressionS exp;
+  struct arm_it *    inst;
 } literalT;
 
-literalT  literals[MAX_LITERAL_POOL_SIZE];
-int       next_literal_pool_place = 0; /* Next free entry in the pool */
-int       lit_pool_num = 1; /* Next literal pool number */
+literalT literals[MAX_LITERAL_POOL_SIZE];
+
+/* Next free entry in the pool.  */
+int next_literal_pool_place = 0;
+
+/* Next literal pool number.  */
+int lit_pool_num = 1;
+
 symbolS * current_poolP = NULL;
 
 static int
@@ -982,24 +1184,25 @@ add_to_lit_pool ()
     current_poolP = symbol_create (FAKE_LABEL_NAME, undefined_section,
                                   (valueT) 0, &zero_address_frag);
 
-  /* Check if this literal value is already in the pool: */
+  /* Check if this literal value is already in the pool:  */
   while (lit_count < next_literal_pool_place)
     {
       if (literals[lit_count].exp.X_op == inst.reloc.exp.X_op
-          && inst.reloc.exp.X_op == O_constant
-          && literals[lit_count].exp.X_add_number == inst.reloc.exp.X_add_number
-          && literals[lit_count].exp.X_unsigned == inst.reloc.exp.X_unsigned)
-        break;
+         && inst.reloc.exp.X_op == O_constant
+         && (literals[lit_count].exp.X_add_number
+             == inst.reloc.exp.X_add_number)
+         && literals[lit_count].exp.X_unsigned == inst.reloc.exp.X_unsigned)
+       break;
       lit_count++;
     }
 
-  if (lit_count == next_literal_pool_place) /* new entry */
+  if (lit_count == next_literal_pool_place) /* New entry.  */
     {
       if (next_literal_pool_place > MAX_LITERAL_POOL_SIZE)
-        {
-          inst.error = _("Literal Pool Overflow");
-          return FAIL;
-        }
+       {
+         inst.error = _("Literal Pool Overflow");
+         return FAIL;
+       }
 
       literals[next_literal_pool_place].exp = inst.reloc.exp;
       lit_count = next_literal_pool_place++;
@@ -1011,21 +1214,22 @@ add_to_lit_pool ()
 
   return SUCCESS;
 }
+
 /* Can't use symbol_new here, so have to create a symbol and then at
    a later date assign it a value. Thats what these functions do.  */
+
 static void
 symbol_locate (symbolP, name, segment, valu, frag)
      symbolS *    symbolP; 
-     CONST char * name;                /* It is copied, the caller can modify */
-     segT         segment;     /* Segment identifier (SEG_<something>) */
-     valueT       valu;                /* Symbol value */
-     fragS *      frag;                /* Associated fragment */
+     CONST char * name;                /* It is copied, the caller can modify */
+     segT         segment;     /* Segment identifier (SEG_<something>) */
+     valueT       valu;                /* Symbol value */
+     fragS *      frag;                /* Associated fragment */
 {
   unsigned int name_length;
   char * preserved_copy_of_name;
 
-  name_length = strlen (name) + 1;      /* +1 for \0 */
+  name_length = strlen (name) + 1;   /* +1 for \0.  */
   obstack_grow (&notes, name, name_length);
   preserved_copy_of_name = obstack_finish (&notes);
 #ifdef STRIP_UNDERSCORE
@@ -1060,13 +1264,14 @@ symbol_locate (symbolP, name, segment, valu, frag)
 #ifdef tc_symbol_new_hook
   tc_symbol_new_hook (symbolP);
 #endif
+
 #ifdef DEBUG_SYMS
   verify_symbol_chain (symbol_rootP, symbol_lastP);
-#endif /* DEBUG_SYMS */
+#endif /* DEBUG_SYMS  */
 }
 
-/* Check that an immediate is valid, and if so, convert it to the right format.  */
+/* Check that an immediate is valid.
+   If so, convert it to the right format.  */
 
 static unsigned int
 validate_immediate (val)
@@ -1074,13 +1279,13 @@ validate_immediate (val)
 {
   unsigned int a;
   unsigned int i;
-  
+
 #define rotate_left(v, n) (v << n | v >> (32 - n))
-  
+
   for (i = 0; i < 32; i += 2)
     if ((a = rotate_left (val, i)) <= 0xff)
-      return a | (i << 7); /* 12-bit pack: [shift-cnt,const] */
-  
+      return a | (i << 7); /* 12-bit pack: [shift-cnt,const] */
+
   return FAIL;
 }
 
@@ -1090,12 +1295,12 @@ validate_immediate (val)
 
 static unsigned int
 validate_immediate_twopart (val, highpart)
-     unsigned int val;
+     unsigned int   val;
      unsigned int * highpart;
 {
   unsigned int a;
   unsigned int i;
-  
+
   for (i = 0; i < 32; i += 2)
     if (((a = rotate_left (val, i)) & 0xff) != 0)
       {
@@ -1109,19 +1314,17 @@ validate_immediate_twopart (val, highpart)
          {
            if (a & 0xff000000)
              continue;
-
            * highpart = (a >> 16) | ((i + 16) << 7);
          }
        else
          {
            assert (a & 0xff000000);
-
            * highpart = (a >> 24) | ((i + 8) << 7);
          }
 
        return (a & 0xff) | (i << 7);
       }
-  
+
   return FAIL;
 }
 
@@ -1131,43 +1334,43 @@ validate_offset_imm (val, hwse)
      int hwse;
 {
   if ((hwse && val > 255) || val > 4095)
-     return FAIL;
+    return FAIL;
   return val;
 }
 
-    
 static void
 s_req (a)
-     int a;
+     int a ATTRIBUTE_UNUSED;
 {
   as_bad (_("Invalid syntax for .req directive."));
 }
 
 static void
 s_bss (ignore)
-     int ignore;
+     int ignore ATTRIBUTE_UNUSED;
 {
   /* We don't support putting frags in the BSS segment, we fake it by
-     marking in_bss, then looking at s_skip for clues?.. */
+     marking in_bss, then looking at s_skip for clues */
   subseg_set (bss_section, 0);
   demand_empty_rest_of_line ();
 }
 
 static void
 s_even (ignore)
-     int ignore;
+     int ignore ATTRIBUTE_UNUSED;
 {
-  if (!need_pass_2)            /* Never make frag if expect extra pass. */
+  /* Never make frag if expect extra pass.  */
+  if (!need_pass_2)
     frag_align (1, 0, 0);
-  
+
   record_alignment (now_seg, 1);
-  
+
   demand_empty_rest_of_line ();
 }
 
 static void
 s_ltorg (ignored)
-     int ignored;
+     int ignored ATTRIBUTE_UNUSED;
 {
   int lit_count = 0;
   char sym_name[20];
@@ -1175,8 +1378,8 @@ s_ltorg (ignored)
   if (current_poolP == NULL)
     return;
 
-  /* Align pool as you have word accesses */
-  /* Only make a frag if we have to ... */
+  /* Align pool as you have word accesses.
+     Only make a frag if we have to.  */
   if (!need_pass_2)
     frag_align (2, 0, 0);
 
@@ -1189,22 +1392,24 @@ s_ltorg (ignored)
   symbol_table_insert (current_poolP);
 
   ARM_SET_THUMB (current_poolP, thumb_mode);
-  
+
 #if defined OBJ_COFF || defined OBJ_ELF
   ARM_SET_INTERWORK (current_poolP, support_interwork);
 #endif
-  
+
   while (lit_count < next_literal_pool_place)
-    /* First output the expression in the instruction to the pool */
-    emit_expr (&(literals[lit_count++].exp), 4); /* .word */
+    /* First output the expression in the instruction to the pool */
+    emit_expr (&(literals[lit_count++].exp), 4); /* .word  */
 
   next_literal_pool_place = 0;
   current_poolP = NULL;
 }
 
+/* Same as s_align_ptwo but align 0 => align 2.  */
+
 static void
-s_align (unused)       /* Same as s_align_ptwo but align 0 => align 2 */
-     int unused;
+s_align (unused)
+     int unused ATTRIBUTE_UNUSED;
 {
   register int temp;
   register long temp_fill;
@@ -1230,7 +1435,7 @@ s_align (unused)  /* Same as s_align_ptwo but align 0 => align 2 */
   if (!temp)
     temp = 2;
 
-  /* Only make a frag if we HAVE to. . . */
+  /* Only make a frag if we HAVE to.  */
   if (temp && !need_pass_2)
     frag_align (temp, (int) temp_fill, 0);
   demand_empty_rest_of_line ();
@@ -1240,33 +1445,34 @@ s_align (unused)        /* Same as s_align_ptwo but align 0 => align 2 */
 
 static void
 s_force_thumb (ignore)
-     int ignore;
+     int ignore ATTRIBUTE_UNUSED;
 {
   /* If we are not already in thumb mode go into it, EVEN if
      the target processor does not support thumb instructions.
      This is used by gcc/config/arm/lib1funcs.asm for example
      to compile interworking support functions even if the
      target processor should not support interworking.  */
-     
   if (! thumb_mode)
     {
-      thumb_mode = 1;
-      
+      thumb_mode = 2;
+
       record_alignment (now_seg, 1);
     }
-  
+
   demand_empty_rest_of_line ();
 }
 
 static void
 s_thumb_func (ignore)
-     int ignore;
+     int ignore ATTRIBUTE_UNUSED;
 {
+  if (! thumb_mode)
+    opcode_select (16);
+
   /* The following label is the name/address of the start of a Thumb function.
      We need to know this for the interworking support.  */
-
   label_is_thumb_function_name = true;
-  
+
   demand_empty_rest_of_line ();
 }
 
@@ -1285,16 +1491,14 @@ s_thumb_set (equiv)
   register char *    end_name;
   register symbolS * symbolP;
 
-  /*
-   * Especial apologies for the random logic:
-   * this just grew, and could be parsed much more simply!
-   * Dean in haste.
-   */
+  /* Especial apologies for the random logic:
+     This just grew, and could be parsed much more simply!
+     Dean - in haste.  */
   name      = input_line_pointer;
   delim     = get_symbol_end ();
   end_name  = input_line_pointer;
   *end_name = delim;
-  
+
   SKIP_WHITESPACE ();
 
   if (*input_line_pointer != ',')
@@ -1311,7 +1515,7 @@ s_thumb_set (equiv)
 
   if (name[0] == '.' && name[1] == '\0')
     {
-      /* XXX - this should not happen to .thumb_set  */
+      /* XXX - this should not happen to .thumb_set.  */
       abort ();
     }
 
@@ -1325,8 +1529,9 @@ s_thumb_set (equiv)
       if (listing & LISTING_SYMBOLS)
        {
          extern struct list_info_struct * listing_tail;
-         fragS * dummy_frag = (fragS *) xmalloc (sizeof(fragS));
-         memset (dummy_frag, 0, sizeof(fragS));
+         fragS * dummy_frag = (fragS *) xmalloc (sizeof (fragS));
+         
+         memset (dummy_frag, 0, sizeof (fragS));
          dummy_frag->fr_type = rs_fill;
          dummy_frag->line = listing_tail;
          symbolP = symbol_new (name, undefined_section, 0, dummy_frag);
@@ -1334,13 +1539,13 @@ s_thumb_set (equiv)
        }
       else
 #endif
-        symbolP = symbol_new (name, undefined_section, 0, &zero_address_frag);
-                           
+       symbolP = symbol_new (name, undefined_section, 0, &zero_address_frag);
+
 #ifdef OBJ_COFF
-      /* "set" symbols are local unless otherwise specified. */
+      /* "set" symbols are local unless otherwise specified.  */
       SF_SET_LOCAL (symbolP);
-#endif /* OBJ_COFF */
-    }                          /* make a new symbol */
+#endif /* OBJ_COFF  */
+    }                          /* Make a new symbol.  */
 
   symbol_table_insert (symbolP);
 
@@ -1352,25 +1557,32 @@ s_thumb_set (equiv)
     as_bad (_("symbol `%s' already defined"), S_GET_NAME (symbolP));
 
   pseudo_set (symbolP);
-  
+
   demand_empty_rest_of_line ();
 
   /* XXX Now we come to the Thumb specific bit of code.  */
-  
+
   THUMB_SET_FUNC (symbolP, 1);
   ARM_SET_THUMB (symbolP, 1);
+#if defined OBJ_ELF || defined OBJ_COFF
   ARM_SET_INTERWORK (symbolP, support_interwork);
+#endif
 }
 
 /* If we change section we must dump the literal pool first.  */
+
 static void
 arm_s_text (ignore)
      int ignore;
 {
   if (now_seg != text_section)
     s_ltorg (0);
-  
+
+#ifdef OBJ_ELF
+  obj_elf_text (ignore);
+#else
   s_text (ignore);
+#endif
 }
 
 static void
@@ -1384,8 +1596,12 @@ arm_s_data (ignore)
     }
   else if (now_seg != data_section)
     s_ltorg (0);
-  
+
+#ifdef OBJ_ELF
+  obj_elf_data (ignore);
+#else
   s_data (ignore);
+#endif
 }
 
 #ifdef OBJ_ELF
@@ -1410,21 +1626,25 @@ opcode_select (width)
        {
          if (! (cpu_variant & ARM_THUMB))
            as_bad (_("selected processor does not support THUMB opcodes"));
+
          thumb_mode = 1;
-          /* No need to force the alignment, since we will have been
-             coming from ARM mode, which is word-aligned. */
-          record_alignment (now_seg, 1);
+         /* No need to force the alignment, since we will have been
+             coming from ARM mode, which is word-aligned.  */
+         record_alignment (now_seg, 1);
        }
       break;
 
     case 32:
       if (thumb_mode)
        {
-          if ((cpu_variant & ARM_ANY) == ARM_THUMB)
+         if ((cpu_variant & ARM_ANY) == ARM_THUMB)
            as_bad (_("selected processor does not support ARM opcodes"));
+
          thumb_mode = 0;
-          if (!need_pass_2)
+
+         if (!need_pass_2)
             frag_align (2, 0, 0);
+
           record_alignment (now_seg, 1);
        }
       break;
@@ -1436,7 +1656,7 @@ opcode_select (width)
 
 static void
 s_arm (ignore)
-     int ignore;
+     int ignore ATTRIBUTE_UNUSED;
 {
   opcode_select (32);
   demand_empty_rest_of_line ();
@@ -1444,7 +1664,7 @@ s_arm (ignore)
 
 static void
 s_thumb (ignore)
-     int ignore;
+     int ignore ATTRIBUTE_UNUSED;
 {
   opcode_select (16);
   demand_empty_rest_of_line ();
@@ -1452,7 +1672,7 @@ s_thumb (ignore)
 
 static void
 s_code (unused)
-     int unused;
+     int unused ATTRIBUTE_UNUSED;
 {
   register int temp;
 
@@ -1483,9 +1703,9 @@ static int
 skip_past_comma (str)
      char ** str;
 {
-  char *p = *str, c;
+  char * p = * str, c;
   int comma = 0;
-    
+
   while ((c = *p) == ' ' || c == ',')
     {
       p++;
@@ -1500,17 +1720,19 @@ skip_past_comma (str)
   return comma ? SUCCESS : FAIL;
 }
 
-/* A standard register must be given at this point.  Shift is the place to
-   put it in the instruction. */
+/* A standard register must be given at this point.
+   SHIFT is the place to put it in inst.instruction.
+   Restores input start point on error.
+   Returns the reg#, or FAIL.  */
 
 static int
 reg_required_here (str, shift)
      char ** str;
      int     shift;
 {
-  static char buff [128]; /* XXX */
-  int    reg;
-  char * start = *str;
+  static char buff [128]; /* XXX  */
+  int         reg;
+  char *      start = * str;
 
   if ((reg = arm_reg_parse (str)) != FAIL && int_register (reg))
     {
@@ -1521,7 +1743,7 @@ reg_required_here (str, shift)
 
   /* Restore the start point, we may have got a reg of the wrong class.  */
   *str = start;
-  
+
   /* In the few cases where we might be able to accept something else
      this error can be overridden.  */
   sprintf (buff, _("Register expected, not '%.100s'"), start);
@@ -1530,27 +1752,66 @@ reg_required_here (str, shift)
   return FAIL;
 }
 
+static CONST struct asm_psr *
+arm_psr_parse (ccp)
+     register char ** ccp;
+{
+  char * start = * ccp;
+  char   c;
+  char * p;
+  CONST struct asm_psr * psr;
+
+  p = start;
+
+  /* Skip to the end of the next word in the input stream.  */
+  do
+    {
+      c = *p++;
+    }
+  while (isalpha (c) || c == '_');
+
+  /* Terminate the word.  */
+  *--p = 0;
+
+  /* Now locate the word in the psr hash table.  */
+  psr = (CONST struct asm_psr *) hash_find (arm_psr_hsh, start);
+
+  /* Restore the input stream.  */
+  *p = c;
+
+  /* If we found a valid match, advance the
+     stream pointer past the end of the word.  */
+  *ccp = p;
+
+  return psr;
+}
+
+/* Parse the input looking for a PSR flag.  */
+
 static int
-psr_required_here (str, cpsr, spsr)
+psr_required_here (str)
      char ** str;
-     int     cpsr;
-     int     spsr;
 {
-  int    psr;
-  char * start = *str;
+  char * start = * str;
+  CONST struct asm_psr * psr;
+
   psr = arm_psr_parse (str);
-  
-  if  (psr == cpsr || psr == spsr)
+
+  if (psr)
     {
-      if (psr == spsr)
-       inst.instruction |= 1 << 22;
-      
+      /* If this is the SPSR that is being modified, set the R bit.  */
+      if (! psr->cpsr)
+       inst.instruction |= SPSR_BIT;
+
+      /* Set the psr flags in the MSR instruction.  */
+      inst.instruction |= psr->field << PSR_SHIFT;
+
       return SUCCESS;
     }
 
-  /* In the few cases where we might be able to accept something else
-     this error can be overridden.  */
-  inst.error = _("<psr(f)> expected");
+  /* In the few cases where we might be able to accept
+     something else this error can be overridden.  */
+  inst.error = _("flag for {c}psr instruction expected");
 
   /* Restore the start point.  */
   *str = start;
@@ -1654,8 +1915,8 @@ fp_reg_required_here (str, where)
      char ** str;
      int     where;
 {
-  int reg;
-  char * start = *str;
+  int    reg;
+  char * start = * str;
 
   if ((reg = arm_reg_parse (str)) != FAIL && fp_register (reg))
     {
@@ -1688,14 +1949,14 @@ cp_address_offset (str)
     }
 
   (*str)++;
-  
+
   if (my_get_expression (& inst.reloc.exp, str))
     return FAIL;
-  
+
   if (inst.reloc.exp.X_op == O_constant)
     {
       offset = inst.reloc.exp.X_add_number;
-      
+
       if (offset & 3)
        {
          inst.error = _("co-processor address must be word aligned");
@@ -1744,12 +2005,12 @@ cp_address_required_here (str)
       if (*p == ']')
        {
          p++;
-         
+
          if (skip_past_comma (& p) == SUCCESS)
            {
-             /* [Rn], #expr */
+             /* [Rn], #expr  */
              write_back = WRITE_BACK;
-             
+
              if (reg == REG_PC)
                {
                  inst.error = _("pc may not be used in post-increment");
@@ -1764,7 +2025,7 @@ cp_address_required_here (str)
        }
       else
        {
-         /* '['Rn, #expr']'[!] */
+         /* '['Rn, #expr']'[!]  */
 
          if (skip_past_comma (& p) == FAIL)
            {
@@ -1773,7 +2034,7 @@ cp_address_required_here (str)
            }
 
          pre_inc = PRE_INDEX;
-         
+
          if (cp_address_offset (& p) == FAIL)
            return FAIL;
 
@@ -1806,7 +2067,7 @@ cp_address_required_here (str)
        return FAIL;
 
       inst.reloc.type = BFD_RELOC_ARM_CP_OFF_IMM;
-      inst.reloc.exp.X_add_number -= 8;  /* PC rel adjust */
+      inst.reloc.exp.X_add_number -= 8;  /* PC rel adjust */
       inst.reloc.pc_rel = 1;
       inst.instruction |= (REG_PC << 16);
       pre_inc = PRE_INDEX;
@@ -1833,121 +2094,134 @@ do_mrs (str, flags)
      char *str;
      unsigned long flags;
 {
+  int skip = 0;
+
   /* Only one syntax.  */
   skip_whitespace (str);
 
   if (reg_required_here (&str, 12) == FAIL)
     {
-      inst.error = bad_args;
+      inst.error = BAD_ARGS;
       return;
     }
 
-  if (skip_past_comma (&str) == FAIL
-      || psr_required_here (& str, CPSR_ALL, SPSR_ALL) == FAIL)
+  if (skip_past_comma (&str) == FAIL)
+    {
+      inst.error = _("comma expected after register name");
+      return;
+    }
+
+  skip_whitespace (str);
+
+  if (   strcmp (str, "CPSR") == 0
+      || strcmp (str, "SPSR") == 0
+        /* Lower case versions for backwards compatability.  */
+      || strcmp (str, "cpsr") == 0
+      || strcmp (str, "spsr") == 0)
+    skip = 4;
+
+  /* This is for backwards compatability with older toolchains.  */
+  else if (   strcmp (str, "cpsr_all") == 0
+          || strcmp (str, "spsr_all") == 0)
+    skip = 8;
+  else
     {
-      inst.error = _("<psr> expected");
+      inst.error = _("{C|S}PSR expected");
       return;
     }
 
+  if (* str == 's' || * str == 'S')
+    inst.instruction |= SPSR_BIT;
+  str += skip;
+
   inst.instruction |= flags;
   end_of_line (str);
-  return;
 }
 
-/* Three possible forms: "<psr>, Rm", "<psrf>, Rm", "<psrf>, #expression".  */
+/* Two possible forms:
+      "{C|S}PSR_<field>, Rm",
+      "{C|S}PSR_f, #expression".  */
+
 static void
 do_msr (str, flags)
      char * str;
      unsigned long flags;
 {
-  int reg;
+  skip_whitespace (str);
+
+  if (psr_required_here (& str) == FAIL)
+    return;
+
+  if (skip_past_comma (& str) == FAIL)
+    {
+      inst.error = _("comma missing after psr flags");
+      return;
+    }
 
   skip_whitespace (str);
 
-  if (psr_required_here (&str, CPSR_ALL, SPSR_ALL) == SUCCESS)
+  if (reg_required_here (& str, 0) != FAIL)
     {
-      inst.instruction |= PSR_ALL;
+      inst.error = NULL;
+      inst.instruction |= flags;
+      end_of_line (str);
+      return;
+    }
 
-      /* Sytax should be "<psr>, Rm" */
-      if (skip_past_comma (&str) == FAIL
-         || (reg = reg_required_here (&str, 0)) == FAIL)
-       {
-         inst.error = bad_args;
-         return;
-       }
+  if (! is_immediate_prefix (* str))
+    {
+      inst.error =
+       _("only a register or immediate value can follow a psr flag");
+      return;
     }
-  else
+
+  str ++;
+  inst.error = NULL;
+
+  if (my_get_expression (& inst.reloc.exp, & str))
     {
-      if (psr_required_here (& str, CPSR_FLG, SPSR_FLG) == SUCCESS)
-       inst.instruction |= PSR_FLAGS;
-      else if (psr_required_here (& str, CPSR_CTL, SPSR_CTL) == SUCCESS)
-       inst.instruction |= PSR_CONTROL;
-      else
-       {
-         inst.error = bad_args;
-         return;
-       }
-      
-      if (skip_past_comma (&str) == FAIL)
-       {
-         inst.error = bad_args;
-         return;
-       }
-      
-      /* Syntax could be "<psrf>, rm", "<psrf>, #expression" */
-      
-      if ((reg = reg_required_here (& str, 0)) != FAIL)
-       ;
-      /* Immediate expression.  */
-      else if (is_immediate_prefix (* str))
-       {
-         str ++;
-         inst.error = NULL;
-         
-         if (my_get_expression (& inst.reloc.exp, & str))
-           {
-             inst.error = _("Register or shift expression expected");
-             return;
-           }
+      inst.error =
+       _("only a register or immediate value can follow a psr flag");
+      return;
+    }
 
-         if (inst.reloc.exp.X_add_symbol)
-           {
-             inst.reloc.type = BFD_RELOC_ARM_IMMEDIATE;
-             inst.reloc.pc_rel = 0;
-           }
-         else
-           {
-             unsigned value = validate_immediate (inst.reloc.exp.X_add_number);
-             if (value == FAIL)
-               {
-                 inst.error = _("Invalid constant");
-                 return;
-               }
+  if (inst.instruction & ((PSR_c | PSR_x | PSR_s) << PSR_SHIFT))
+    {
+      inst.error = _("can only set flag field with immediate value");
+      return;
+    }
 
-             inst.instruction |= value;
-           }
+  flags |= INST_IMMEDIATE;
 
-         flags |= INST_IMMEDIATE;
-       }
-      else
+  if (inst.reloc.exp.X_add_symbol)
+    {
+      inst.reloc.type = BFD_RELOC_ARM_IMMEDIATE;
+      inst.reloc.pc_rel = 0;
+    }
+  else
+    {
+      unsigned value = validate_immediate (inst.reloc.exp.X_add_number);
+
+      if (value == (unsigned) FAIL)
        {
-         inst.error = _("Error: unrecognised syntax for second argument to msr instruction");
+         inst.error = _("Invalid constant");
          return;
        }
+
+      inst.instruction |= value;
     }
 
-  inst.error = NULL; 
+  inst.error = NULL;
   inst.instruction |= flags;
   end_of_line (str);
-  return;
 }
 
 /* Long Multiply Parser
    UMULL RdLo, RdHi, Rm, Rs
    SMULL RdLo, RdHi, Rm, Rs
    UMLAL RdLo, RdHi, Rm, Rs
-   SMLAL RdLo, RdHi, Rm, Rs
-*/   
+   SMLAL RdLo, RdHi, Rm, Rs.  */
+
 static void
 do_mull (str, flags)
      char * str;
@@ -1955,46 +2229,46 @@ do_mull (str, flags)
 {
   int rdlo, rdhi, rm, rs;
 
-  /* Only one format "rdlo, rdhi, rm, rs" */
+  /* Only one format "rdlo, rdhi, rm, rs" */
   skip_whitespace (str);
 
   if ((rdlo = reg_required_here (&str, 12)) == FAIL)
     {
-      inst.error = bad_args;
+      inst.error = BAD_ARGS;
       return;
     }
 
   if (skip_past_comma (&str) == FAIL
       || (rdhi = reg_required_here (&str, 16)) == FAIL)
     {
-      inst.error = bad_args;
+      inst.error = BAD_ARGS;
       return;
     }
 
   if (skip_past_comma (&str) == FAIL
       || (rm = reg_required_here (&str, 0)) == FAIL)
     {
-      inst.error = bad_args;
+      inst.error = BAD_ARGS;
       return;
     }
 
-  /* rdhi, rdlo and rm must all be different */
+  /* rdhi, rdlo and rm must all be different */
   if (rdlo == rdhi || rdlo == rm || rdhi == rm)
     as_tsktsk (_("rdhi, rdlo and rm must all be different"));
 
   if (skip_past_comma (&str) == FAIL
       || (rs = reg_required_here (&str, 8)) == FAIL)
     {
-      inst.error = bad_args;
+      inst.error = BAD_ARGS;
       return;
     }
 
   if (rdhi == REG_PC || rdhi == REG_PC || rdhi == REG_PC || rdhi == REG_PC)
     {
-      inst.error = bad_pc;
+      inst.error = BAD_PC;
       return;
     }
-   
+
   inst.instruction |= flags;
   end_of_line (str);
   return;
@@ -2002,36 +2276,36 @@ do_mull (str, flags)
 
 static void
 do_mul (str, flags)
-     char *        str;
+     char * str;
      unsigned long flags;
 {
   int rd, rm;
-  
-  /* Only one format "rd, rm, rs" */
+
+  /* Only one format "rd, rm, rs" */
   skip_whitespace (str);
 
   if ((rd = reg_required_here (&str, 16)) == FAIL)
     {
-      inst.error = bad_args;
+      inst.error = BAD_ARGS;
       return;
     }
 
   if (rd == REG_PC)
     {
-      inst.error = bad_pc;
+      inst.error = BAD_PC;
       return;
     }
 
   if (skip_past_comma (&str) == FAIL
       || (rm = reg_required_here (&str, 0)) == FAIL)
     {
-      inst.error = bad_args;
+      inst.error = BAD_ARGS;
       return;
     }
 
   if (rm == REG_PC)
     {
-      inst.error = bad_pc;
+      inst.error = BAD_PC;
       return;
     }
 
@@ -2041,13 +2315,13 @@ do_mul (str, flags)
   if (skip_past_comma (&str) == FAIL
       || (rm = reg_required_here (&str, 8)) == FAIL)
     {
-      inst.error = bad_args;
+      inst.error = BAD_ARGS;
       return;
     }
 
   if (rm == REG_PC)
     {
-      inst.error = bad_pc;
+      inst.error = BAD_PC;
       return;
     }
 
@@ -2058,36 +2332,36 @@ do_mul (str, flags)
 
 static void
 do_mla (str, flags)
-     char *        str;
+     char * str;
      unsigned long flags;
 {
   int rd, rm;
 
-  /* Only one format "rd, rm, rs, rn" */
+  /* Only one format "rd, rm, rs, rn" */
   skip_whitespace (str);
 
   if ((rd = reg_required_here (&str, 16)) == FAIL)
     {
-      inst.error = bad_args;
+      inst.error = BAD_ARGS;
       return;
     }
 
   if (rd == REG_PC)
     {
-      inst.error = bad_pc;
+      inst.error = BAD_PC;
       return;
     }
 
   if (skip_past_comma (&str) == FAIL
       || (rm = reg_required_here (&str, 0)) == FAIL)
     {
-      inst.error = bad_args;
+      inst.error = BAD_ARGS;
       return;
     }
 
   if (rm == REG_PC)
     {
-      inst.error = bad_pc;
+      inst.error = BAD_PC;
       return;
     }
 
@@ -2099,13 +2373,13 @@ do_mla (str, flags)
       || skip_past_comma (&str) == FAIL
       || (rm = reg_required_here (&str, 12)) == FAIL)
     {
-      inst.error = bad_args;
+      inst.error = BAD_ARGS;
       return;
     }
 
   if (rd == REG_PC || rm == REG_PC)
     {
-      inst.error = bad_pc;
+      inst.error = BAD_PC;
       return;
     }
 
@@ -2114,8 +2388,9 @@ do_mla (str, flags)
   return;
 }
 
-/* Returns the index into fp_values of a floating point number, or -1 if
-   not in the table.  */
+/* Returns the index into fp_values of a floating point number,
+   or -1 if not in the table.  */
+
 static int
 my_get_float_expression (str)
      char ** str;
@@ -2127,9 +2402,10 @@ my_get_float_expression (str)
   int            j;
 
   memset (words, 0, MAX_LITTLENUMS * sizeof (LITTLENUM_TYPE));
-  /* Look for a raw floating point number */
+
+  /* Look for a raw floating point number.  */
   if ((save_in = atof_ieee (*str, 'x', words)) != NULL
-      && (is_end_of_line [(int)(*save_in)] || *save_in == '\0'))
+      && is_end_of_line[(unsigned char) *save_in])
     {
       for (i = 0; i < NUM_FLOAT_VALS; i++)
        {
@@ -2148,7 +2424,7 @@ my_get_float_expression (str)
     }
 
   /* Try and parse a more complex expression, this will probably fail
-     unless the code uses a floating point prefix (eg "0f") */
+     unless the code uses a floating point prefix (eg "0f") */
   save_in = input_line_pointer;
   input_line_pointer = *str;
   if (expression (&exp) == absolute_section
@@ -2157,7 +2433,7 @@ my_get_float_expression (str)
     {
       /* FIXME: 5 = X_PRECISION, should be #define'd where we can use it.
         Ditto for 15.  */
-      if (gen_to_words (words, 5, (long)15) == 0)
+      if (gen_to_words (words, 5, (long) 15) == 0)
        {
          for (i = 0; i < NUM_FLOAT_VALS; i++)
            {
@@ -2182,7 +2458,8 @@ my_get_float_expression (str)
   return -1;
 }
 
-/* Return true if anything in the expression is a bignum */
+/* Return true if anything in the expression is a bignum.  */
+
 static int
 walk_no_bignums (sp)
      symbolS * sp;
@@ -2207,7 +2484,7 @@ my_get_expression (ep, str)
 {
   char * save_in;
   segT   seg;
-  
+
   save_in = input_line_pointer;
   input_line_pointer = *str;
   seg = expression (ep);
@@ -2246,116 +2523,130 @@ my_get_expression (ep, str)
   return 0;
 }
 
-/* unrestrict should be one if <shift> <register> is permitted for this
-   instruction */
+/* UNRESTRICT should be one if <shift> <register> is permitted for this
+   instruction */
 
 static int
 decode_shift (str, unrestrict)
      char ** str;
      int     unrestrict;
 {
-  struct asm_shift * shft;
+  const struct asm_shift_name * shift;
   char * p;
   char   c;
-    
+
   skip_whitespace (* str);
-    
-  for (p = *str; isalpha (*p); p++)
+
+  for (p = * str; isalpha (* p); p ++)
     ;
 
-  if (p == *str)
+  if (p == * str)
     {
       inst.error = _("Shift expression expected");
       return FAIL;
     }
 
-  c = *p;
-  *p = '\0';
-  shft = (struct asm_shift *) hash_find (arm_shift_hsh, *str);
-  *p = c;
-  if (shft)
+  c = * p;
+  * p = '\0';
+  shift = (const struct asm_shift_name *) hash_find (arm_shift_hsh, * str);
+  * p = c;
+  
+  if (shift == NULL)
     {
-      if (!strncmp (*str, "rrx", 3)
-          || !strncmp (*str, "RRX", 3))
-       {
-         *str = p;
-         inst.instruction |= shft->value;
-         return SUCCESS;
-       }
-
-      skip_whitespace (p);
-      
-      if (unrestrict && reg_required_here (&p, 8) != FAIL)
-       {
-         inst.instruction |= shft->value | SHIFT_BY_REG;
-         *str = p;
-         return SUCCESS;
-       }
-      else if (is_immediate_prefix (* p))
-       {
-         inst.error = NULL;
-         p++;
-         if (my_get_expression (&inst.reloc.exp, &p))
-           return FAIL;
-
-         /* Validate some simple #expressions */
-         if (inst.reloc.exp.X_op == O_constant)
-           {
-             unsigned num = inst.reloc.exp.X_add_number;
-
-             /* Reject operations greater than 32, or lsl #32 */
-             if (num > 32 || (num == 32 && shft->value == 0))
-               {
-                 inst.error = _("Invalid immediate shift");
-                 return FAIL;
-               }
+      inst.error = _("Shift expression expected");
+      return FAIL;
+    }
 
-             /* Shifts of zero should be converted to lsl (which is zero)*/
-             if (num == 0)
-               {
-                 *str = p;
-                 return SUCCESS;
-               }
+  assert (shift->properties->index == shift_properties[shift->properties->index].index);
+  
+  if (shift->properties->index == SHIFT_RRX)
+    {
+      * str = p;
+      inst.instruction |= shift->properties->bit_field;
+      return SUCCESS;
+    }
 
-             /* Shifts of 32 are encoded as 0, for those shifts that
-                support it.  */
-             if (num == 32)
-               num = 0;
+  skip_whitespace (p);
 
-             inst.instruction |= (num << 7) | shft->value;
-             *str = p;
-             return SUCCESS;
-           }
+  if (unrestrict && reg_required_here (& p, 8) != FAIL)
+    {
+      inst.instruction |= shift->properties->bit_field | SHIFT_BY_REG;
+      * str = p;
+      return SUCCESS;
+    }
+  else if (! is_immediate_prefix (* p))
+    {
+      inst.error = (unrestrict
+                   ? _("shift requires register or #expression")
+                   : _("shift requires #expression"));
+      * str = p;
+      return FAIL;
+    }
+    
+  inst.error = NULL;
+  p ++;
+  
+  if (my_get_expression (& inst.reloc.exp, & p))
+    return FAIL;
+  
+  /* Validate some simple #expressions.  */
+  if (inst.reloc.exp.X_op == O_constant)
+    {
+      unsigned num = inst.reloc.exp.X_add_number;
 
-         inst.reloc.type = BFD_RELOC_ARM_SHIFT_IMM;
-         inst.reloc.pc_rel = 0;
-         inst.instruction |= shft->value;
-         *str = p;
-         return SUCCESS;
-       }
-      else
+      /* Reject operations greater than 32.  */
+      if (num > 32
+         /* Reject a shift of 0 unless the mode allows it.  */
+         || (num == 0 && shift->properties->allows_0 == 0)
+         /* Reject a shift of 32 unless the mode allows it.  */
+         || (num == 32 && shift->properties->allows_32 == 0)
+         )
        {
-         inst.error = unrestrict ? _("shift requires register or #expression")
-           : _("shift requires #expression");
-         *str = p;
-         return FAIL;
+         /* As a special case we allow a shift of zero for
+            modes that do not support it to be recoded as an
+            logical shift left of zero (ie nothing).  We warn
+            about this though.  */
+         if (num == 0)
+           {
+             as_warn (_("Shift of 0 ignored."));
+             shift = & shift_names[0];
+             assert (shift->properties->index == SHIFT_LSL);
+           }
+         else
+           {
+             inst.error = _("Invalid immediate shift");
+             return FAIL;
+           }
        }
-    }
 
-  inst.error = _("Shift expression expected");
-  return FAIL;
+      /* Shifts of 32 are encoded as 0, for those shifts that
+        support it.  */
+      if (num == 32)
+       num = 0;
+      
+      inst.instruction |= (num << 7) | shift->properties->bit_field;
+    }
+  else
+    {
+      inst.reloc.type   = BFD_RELOC_ARM_SHIFT_IMM;
+      inst.reloc.pc_rel = 0;
+      inst.instruction |= shift->properties->bit_field;
+    }
+  
+  * str = p;
+  return SUCCESS;
 }
 
-/* Do those data_ops which can take a negative immediate constant */
-/* by altering the instuction. A bit of a hack really */
-/*      MOV <-> MVN
+/* Do those data_ops which can take a negative immediate constant
+   by altering the instuction.  A bit of a hack really.
+        MOV <-> MVN
         AND <-> BIC
         ADC <-> SBC
         by inverting the second operand, and
         ADD <-> SUB
         CMP <-> CMN
-        by negating the second operand.
-*/
+        by negating the second operand.  */
+
 static int
 negate_data_op (instruction, value)
      unsigned long * instruction;
@@ -2370,69 +2661,69 @@ negate_data_op (instruction, value)
   op = (*instruction >> DATA_OP_SHIFT) & 0xf;
   switch (op)
     {
-      /* First negates */
-    case OPCODE_SUB:             /* ADD <-> SUB */
+      /* First negates */
+    case OPCODE_SUB:             /* ADD <-> SUB  */
       new_inst = OPCODE_ADD;
       value = negated;
       break;
 
-    case OPCODE_ADD: 
-      new_inst = OPCODE_SUB;               
+    case OPCODE_ADD:
+      new_inst = OPCODE_SUB;
       value = negated;
       break;
 
-    case OPCODE_CMP:             /* CMP <-> CMN */
+    case OPCODE_CMP:             /* CMP <-> CMN  */
       new_inst = OPCODE_CMN;
       value = negated;
       break;
 
-    case OPCODE_CMN: 
-      new_inst = OPCODE_CMP;               
+    case OPCODE_CMN:
+      new_inst = OPCODE_CMP;
       value = negated;
       break;
 
-      /* Now Inverted ops */
-    case OPCODE_MOV:             /* MOV <-> MVN */
-      new_inst = OPCODE_MVN;               
+      /* Now Inverted ops */
+    case OPCODE_MOV:             /* MOV <-> MVN  */
+      new_inst = OPCODE_MVN;
       value = inverted;
       break;
 
-    case OPCODE_MVN: 
+    case OPCODE_MVN:
       new_inst = OPCODE_MOV;
       value = inverted;
       break;
 
-    case OPCODE_AND:             /* AND <-> BIC */ 
-      new_inst = OPCODE_BIC;               
+    case OPCODE_AND:             /* AND <-> BIC  */
+      new_inst = OPCODE_BIC;
       value = inverted;
       break;
 
-    case OPCODE_BIC: 
+    case OPCODE_BIC:
       new_inst = OPCODE_AND;
       value = inverted;
       break;
 
-    case OPCODE_ADC:              /* ADC <-> SBC */
-      new_inst = OPCODE_SBC;               
+    case OPCODE_ADC:              /* ADC <-> SBC  */
+      new_inst = OPCODE_SBC;
       value = inverted;
       break;
 
-    case OPCODE_SBC: 
+    case OPCODE_SBC:
       new_inst = OPCODE_ADC;
       value = inverted;
       break;
 
-      /* We cannot do anything */
-    default:  
+      /* We cannot do anything */
+    default:
       return FAIL;
     }
 
-  if (value == FAIL)
+  if (value == (unsigned) FAIL)
     return FAIL;
 
   *instruction &= OPCODE_MASK;
   *instruction |= new_inst << DATA_OP_SHIFT;
-  return value; 
+  return value;
 }
 
 static int
@@ -2443,7 +2734,7 @@ data_op2 (str)
   expressionS expr;
 
   skip_whitespace (* str);
-    
+
   if (reg_required_here (str, 0) != FAIL)
     {
       if (skip_past_comma (str) == SUCCESS)
@@ -2454,12 +2745,12 @@ data_op2 (str)
     }
   else
     {
-      /* Immediate expression */
+      /* Immediate expression */
       if (is_immediate_prefix (**str))
        {
          (*str)++;
          inst.error = NULL;
-         
+
          if (my_get_expression (&inst.reloc.exp, str))
            return FAIL;
 
@@ -2472,7 +2763,7 @@ data_op2 (str)
            {
              if (skip_past_comma (str) == SUCCESS)
                {
-                 /* #x, y -- ie explicit rotation by Y  */
+                 /* #x, y -- ie explicit rotation by Y.  */
                  if (my_get_expression (&expr, str))
                    return FAIL;
 
@@ -2481,8 +2772,8 @@ data_op2 (str)
                      inst.error = _("Constant expression expected");
                      return FAIL;
                    }
-                 /* Rotate must be a multiple of 2 */
+
+                 /* Rotate must be a multiple of 2 */
                  if (((unsigned) expr.X_add_number) > 30
                      || (expr.X_add_number & 1) != 0
                      || ((unsigned) inst.reloc.exp.X_add_number) > 255)
@@ -2496,13 +2787,13 @@ data_op2 (str)
                  return SUCCESS;
                }
 
-             /* Implicit rotation, select a suitable one  */
+             /* Implicit rotation, select a suitable one.  */
              value = validate_immediate (inst.reloc.exp.X_add_number);
 
              if (value == FAIL)
                {
-                 /* Can't be done, perhaps the code reads something like
-                    "add Rd, Rn, #-n", where "sub Rd, Rn, #n" would be ok */
+                 /* Can't be done.  Perhaps the code reads something like
+                    "add Rd, Rn, #-n", where "sub Rd, Rn, #n" would be OK.  */
                  if ((value = negate_data_op (&inst.instruction,
                                               inst.reloc.exp.X_add_number))
                      == FAIL)
@@ -2535,7 +2826,7 @@ fp_op2 (str)
     return SUCCESS;
   else
     {
-      /* Immediate expression */
+      /* Immediate expression */
       if (*((*str)++) == '#')
        {
          int i;
@@ -2544,8 +2835,8 @@ fp_op2 (str)
 
          skip_whitespace (* str);
 
-         /* First try and match exact strings, this is to guarantee that
-            some formats will work even for cross assembly */
+         /* First try and match exact strings, this is to guarantee
+            that some formats will work even for cross assembly.  */
 
          for (i = 0; fp_const[i]; i++)
            {
@@ -2554,7 +2845,7 @@ fp_op2 (str)
                  char *start = *str;
 
                  *str += strlen (fp_const[i]);
-                 if (is_end_of_line[(int)**str] || **str == '\0')
+                 if (is_end_of_line[(unsigned char) **str])
                    {
                      inst.instruction |= i + 8;
                      return SUCCESS;
@@ -2576,14 +2867,15 @@ fp_op2 (str)
          inst.error = _("Invalid floating point immediate expression");
          return FAIL;
        }
-      inst.error = _("Floating point register or immediate expression expected");
+      inst.error =
+       _("Floating point register or immediate expression expected");
       return FAIL;
     }
 }
 
 static void
 do_arit (str, flags)
-     char *        str;
+     char * str;
      unsigned long flags;
 {
   skip_whitespace (str);
@@ -2595,7 +2887,7 @@ do_arit (str, flags)
       || data_op2 (&str) == FAIL)
     {
       if (!inst.error)
-       inst.error = bad_args;
+       inst.error = BAD_ARGS;
       return;
     }
 
@@ -2606,12 +2898,11 @@ do_arit (str, flags)
 
 static void
 do_adr (str, flags)
-     char *        str;
+     char * str;
      unsigned long flags;
 {
   /* This is a pseudo-op of the form "adr rd, label" to be converted
-     into a relative address of the form "add rd, pc, #label-.-8" */
-
+     into a relative address of the form "add rd, pc, #label-.-8".  */
   skip_whitespace (str);
 
   if (reg_required_here (&str, 12) == FAIL
@@ -2619,28 +2910,29 @@ do_adr (str, flags)
       || my_get_expression (&inst.reloc.exp, &str))
     {
       if (!inst.error)
-       inst.error = bad_args;
+       inst.error = BAD_ARGS;
       return;
     }
+
   /* Frag hacking will turn this into a sub instruction if the offset turns
      out to be negative.  */
   inst.reloc.type = BFD_RELOC_ARM_IMMEDIATE;
-  inst.reloc.exp.X_add_number -= 8; /* PC relative adjust */
+  inst.reloc.exp.X_add_number -= 8; /* PC relative adjust */
   inst.reloc.pc_rel = 1;
   inst.instruction |= flags;
+
   end_of_line (str);
-  return;
 }
 
 static void
 do_adrl (str, flags)
-     char *        str;
+     char * str;
      unsigned long flags;
 {
   /* This is a pseudo-op of the form "adrl rd, label" to be converted
      into a relative address of the form:
        add rd, pc, #low(label-.-8)"
-       add rd, rd, #high(label-.-8)"   */
+       add rd, rd, #high(label-.-8)"  */
 
   skip_whitespace (str);
 
@@ -2649,26 +2941,26 @@ do_adrl (str, flags)
       || my_get_expression (& inst.reloc.exp, & str))
     {
       if (!inst.error)
-       inst.error = bad_args;
+       inst.error = BAD_ARGS;
       return;
     }
-  
+
   end_of_line (str);
-  
+
   /* Frag hacking will turn this into a sub instruction if the offset turns
      out to be negative.  */
   inst.reloc.type              = BFD_RELOC_ARM_ADRL_IMMEDIATE;
-  inst.reloc.exp.X_add_number -= 8; /* PC relative adjust */
+  inst.reloc.exp.X_add_number -= 8; /* PC relative adjust  */
   inst.reloc.pc_rel            = 1;
   inst.instruction            |= flags;
   inst.size                    = INSN_SIZE * 2;
-  
+
   return;
 }
 
 static void
 do_cmp (str, flags)
-     char *        str;
+     char * str;
      unsigned long flags;
 {
   skip_whitespace (str);
@@ -2676,7 +2968,7 @@ do_cmp (str, flags)
   if (reg_required_here (&str, 16) == FAIL)
     {
       if (!inst.error)
-       inst.error = bad_args;
+       inst.error = BAD_ARGS;
       return;
     }
 
@@ -2684,7 +2976,7 @@ do_cmp (str, flags)
       || data_op2 (&str) == FAIL)
     {
       if (!inst.error)
-       inst.error = bad_args;
+       inst.error = BAD_ARGS;
       return;
     }
 
@@ -2698,7 +2990,7 @@ do_cmp (str, flags)
 
 static void
 do_mov (str, flags)
-     char *        str;
+     char * str;
      unsigned long flags;
 {
   skip_whitespace (str);
@@ -2706,7 +2998,7 @@ do_mov (str, flags)
   if (reg_required_here (&str, 12) == FAIL)
     {
       if (!inst.error)
-       inst.error = bad_args;
+       inst.error = BAD_ARGS;
       return;
     }
 
@@ -2714,7 +3006,7 @@ do_mov (str, flags)
       || data_op2 (&str) == FAIL)
     {
       if (!inst.error)
-       inst.error = bad_args;
+       inst.error = BAD_ARGS;
       return;
     }
 
@@ -2742,8 +3034,8 @@ ldst_extend (str, hwse)
        {
          int value = inst.reloc.exp.X_add_number;
 
-          if ((hwse && (value < -255 || value > 255))
-               || (value < -4095 || value > 4095))
+         if ((hwse && (value < -255 || value > 255))
+             || (value < -4095 || value > 4095))
            {
              inst.error = _("address offset too large");
              return FAIL;
@@ -2755,42 +3047,47 @@ ldst_extend (str, hwse)
              add = 0;
            }
 
-          /* Halfword and signextension instructions have the
-             immediate value split across bits 11..8 and bits 3..0 */
-          if (hwse)
-            inst.instruction |= add | HWOFFSET_IMM | ((value >> 4) << 8) | (value & 0xF);
-          else
-            inst.instruction |= add | value;
+         /* Halfword and signextension instructions have the
+             immediate value split across bits 11..8 and bits 3..0.  */
+         if (hwse)
+           inst.instruction |= (add | HWOFFSET_IMM
+                                | ((value >> 4) << 8) | (value & 0xF));
+         else
+           inst.instruction |= add | value;
        }
       else
        {
-          if (hwse)
-            {
-              inst.instruction |= HWOFFSET_IMM;
-              inst.reloc.type = BFD_RELOC_ARM_OFFSET_IMM8;
-            }
-          else
-            inst.reloc.type = BFD_RELOC_ARM_OFFSET_IMM;
+         if (hwse)
+           {
+             inst.instruction |= HWOFFSET_IMM;
+             inst.reloc.type = BFD_RELOC_ARM_OFFSET_IMM8;
+           }
+         else
+           inst.reloc.type = BFD_RELOC_ARM_OFFSET_IMM;
          inst.reloc.pc_rel = 0;
        }
       return SUCCESS;
 
     case '-':
-      add = 0; /* and fall through */
+      add = 0;
+      /* Fall through.  */
+
     case '+':
-      (*str)++;        /* and fall through */
+      (*str)++;
+      /* Fall through.  */
+
     default:
       if (reg_required_here (str, 0) == FAIL)
        return FAIL;
 
       if (hwse)
-        inst.instruction |= add;
+       inst.instruction |= add;
       else
-        {
-          inst.instruction |= add | OFFSET_REG;
-          if (skip_past_comma (str) == SUCCESS)
-            return decode_shift (str, SHIFT_RESTRICT);
-        }
+       {
+         inst.instruction |= add | OFFSET_REG;
+         if (skip_past_comma (str) == SUCCESS)
+           return decode_shift (str, SHIFT_RESTRICT);
+       }
 
       return SUCCESS;
     }
@@ -2798,7 +3095,7 @@ ldst_extend (str, hwse)
 
 static void
 do_ldst (str, flags)
-     char *        str;
+     char *str;
      unsigned long flags;
 {
   int halfword = 0;
@@ -2808,31 +3105,31 @@ do_ldst (str, flags)
 
   /* This is not ideal, but it is the simplest way of dealing with the
      ARM7T halfword instructions (since they use a different
-     encoding, but the same mnemonic): */
+     encoding, but the same mnemonic):  */
   halfword = (flags & 0x80000000) != 0;
   if (halfword)
     {
       /* This is actually a load/store of a halfword, or a
-         signed-extension load */
+         signed-extension load */
       if ((cpu_variant & ARM_HALFWORD) == 0)
-        {
-          inst.error
+       {
+         inst.error
            = _("Processor does not support halfwords or signed bytes");
-          return;
-        }
+         return;
+       }
 
-      inst.instruction = (inst.instruction & COND_MASK)
-                         | (flags & ~COND_MASK);
+      inst.instruction = ((inst.instruction & COND_MASK)
+                         | (flags & ~COND_MASK));
 
       flags = 0;
     }
 
   skip_whitespace (str);
-    
+
   if ((conflict_reg = reg_required_here (& str, 12)) == FAIL)
     {
       if (!inst.error)
-       inst.error = bad_args;
+       inst.error = BAD_ARGS;
       return;
     }
 
@@ -2861,32 +3158,34 @@ do_ldst (str, flags)
       if (*str == ']')
        {
          str ++;
-         
+
          if (skip_past_comma (&str) == SUCCESS)
            {
-             /* [Rn],... (post inc) */
+             /* [Rn],... (post inc)  */
              if (ldst_extend (&str, halfword) == FAIL)
                return;
              if (conflict_reg)
                as_warn (_("%s register same as write-back base"),
-                        (inst.instruction & LOAD_BIT) ? _("destination") : _("source") );
+                        ((inst.instruction & LOAD_BIT)
+                         ? _("destination") : _("source")));
            }
          else
            {
-             /* [Rn] */
-              if (halfword)
-                inst.instruction |= HWOFFSET_IMM;
+             /* [Rn]  */
+             if (halfword)
+               inst.instruction |= HWOFFSET_IMM;
 
-              skip_whitespace (str);
+             skip_whitespace (str);
 
-              if (*str == '!')
-               {
-                 if (conflict_reg)
-                  as_warn (_("%s register same as write-back base"),
-                           (inst.instruction & LOAD_BIT) ? _("destination") : _("source") );
-                 str++;
-                 inst.instruction |= WRITE_BACK;
-               }
+             if (*str == '!')
+               {
+                 if (conflict_reg)
+                   as_warn (_("%s register same as write-back base"),
+                            ((inst.instruction & LOAD_BIT)
+                             ? _("destination") : _("source")));
+                 str++;
+                 inst.instruction |= WRITE_BACK;
+               }
 
              flags |= INDEX_UP;
              if (! (flags & TRANS_BIT))
@@ -2895,7 +3194,7 @@ do_ldst (str, flags)
        }
       else
        {
-         /* [Rn,...] */
+         /* [Rn,...]  */
          if (skip_past_comma (&str) == FAIL)
            {
              inst.error = _("pre-indexed expression expected");
@@ -2920,7 +3219,8 @@ do_ldst (str, flags)
            {
              if (conflict_reg)
                as_warn (_("%s register same as write-back base"),
-                        (inst.instruction & LOAD_BIT) ? _("destination") : _("source") );
+                        ((inst.instruction & LOAD_BIT)
+                         ? _("destination") : _("source")));
              str++;
              inst.instruction |= WRITE_BACK;
            }
@@ -2928,7 +3228,7 @@ do_ldst (str, flags)
     }
   else if (*str == '=')
     {
-      /* Parse an "ldr Rd, =expr" instruction; this is another pseudo op */
+      /* Parse an "ldr Rd, =expr" instruction; this is another pseudo op */
       str++;
 
       skip_whitespace (str);
@@ -2944,36 +3244,36 @@ do_ldst (str, flags)
        }
 
       if (inst.reloc.exp.X_op == O_constant
-         && (value = validate_immediate(inst.reloc.exp.X_add_number)) != FAIL)
+         && (value = validate_immediate (inst.reloc.exp.X_add_number)) != FAIL)
        {
-         /* This can be done with a mov instruction */
+         /* This can be done with a mov instruction */
          inst.instruction &= LITERAL_MASK;
          inst.instruction |= INST_IMMEDIATE | (OPCODE_MOV << DATA_OP_SHIFT);
          inst.instruction |= (flags & COND_MASK) | (value & 0xfff);
-         end_of_line(str);
-         return; 
+         end_of_line (str);
+         return;
        }
       else
        {
-         /* Insert into literal pool */     
+         /* Insert into literal pool.  */
          if (add_to_lit_pool () == FAIL)
            {
              if (!inst.error)
-               inst.error = _("literal pool insertion failed"); 
+               inst.error = _("literal pool insertion failed");
              return;
            }
 
-         /* Change the instruction exp to point to the pool */
-          if (halfword)
-            {
-              inst.instruction |= HWOFFSET_IMM;
-              inst.reloc.type = BFD_RELOC_ARM_HWLITERAL;
-            }
-          else
+         /* Change the instruction exp to point to the pool */
+         if (halfword)
+           {
+             inst.instruction |= HWOFFSET_IMM;
+             inst.reloc.type = BFD_RELOC_ARM_HWLITERAL;
+           }
+         else
            inst.reloc.type = BFD_RELOC_ARM_LITERAL;
          inst.reloc.pc_rel = 1;
          inst.instruction |= (REG_PC << 16);
-         pre_inc = 1; 
+         pre_inc = 1;
        }
     }
   else
@@ -2982,18 +3282,21 @@ do_ldst (str, flags)
        return;
 
       if (halfword)
-        {
-          inst.instruction |= HWOFFSET_IMM;
-          inst.reloc.type = BFD_RELOC_ARM_OFFSET_IMM8;
-        }
+       {
+         inst.instruction |= HWOFFSET_IMM;
+         inst.reloc.type = BFD_RELOC_ARM_OFFSET_IMM8;
+       }
       else
-        inst.reloc.type = BFD_RELOC_ARM_OFFSET_IMM;
-      inst.reloc.exp.X_add_number -= 8;  /* PC rel adjust */
+       inst.reloc.type = BFD_RELOC_ARM_OFFSET_IMM;
+#ifndef TE_WINCE
+      /* PC rel adjust.  */
+      inst.reloc.exp.X_add_number -= 8;
+#endif
       inst.reloc.pc_rel = 1;
       inst.instruction |= (REG_PC << 16);
       pre_inc = 1;
     }
-    
+
   if (pre_inc && (flags & TRANS_BIT))
     inst.error = _("Pre-increment instruction with translate");
 
@@ -3006,11 +3309,11 @@ static long
 reg_list (strp)
      char ** strp;
 {
-  char * str = *strp;
+  char * str = * strp;
   long   range = 0;
   int    another_range;
 
-  /* We come back here if we get ranges concatenated by '+' or '|' */
+  /* We come back here if we get ranges concatenated by '+' or '|' */
   do
     {
       another_range = 0;
@@ -3019,21 +3322,21 @@ reg_list (strp)
        {
          int in_range = 0;
          int cur_reg = -1;
-      
+
          str++;
          do
            {
              int reg;
-           
+
              skip_whitespace (str);
 
              if ((reg = reg_required_here (& str, -1)) == FAIL)
                return FAIL;
-             
+
              if (in_range)
                {
                  int i;
-             
+
                  if (reg <= cur_reg)
                    {
                      inst.error = _("Bad range in register list");
@@ -3043,7 +3346,7 @@ reg_list (strp)
                  for (i = cur_reg + 1; i < reg; i++)
                    {
                      if (range & (1 << i))
-                       as_tsktsk 
+                       as_tsktsk
                          (_("Warning: Duplicated register (r%d) in register list"),
                           i);
                      else
@@ -3060,8 +3363,9 @@ reg_list (strp)
 
              range |= 1 << reg;
              cur_reg = reg;
-           } while (skip_past_comma (&str) != FAIL
-                    || (in_range = 1, *str++ == '-'));
+           }
+         while (skip_past_comma (&str) != FAIL
+                || (in_range = 1, *str++ == '-'));
          str--;
          skip_whitespace (str);
 
@@ -3080,7 +3384,7 @@ reg_list (strp)
 
          if (expr.X_op == O_constant)
            {
-             if (expr.X_add_number 
+             if (expr.X_add_number
                  != (expr.X_add_number & 0x0000ffff))
                {
                  inst.error = _("invalid register mask");
@@ -3093,7 +3397,7 @@ reg_list (strp)
 
                  regno &= -regno;
                  regno = (1 << regno) - 1;
-                 as_tsktsk 
+                 as_tsktsk
                    (_("Warning: Duplicated register (r%d) in register list"),
                     regno);
                }
@@ -3121,7 +3425,8 @@ reg_list (strp)
          str++;
          another_range = 1;
        }
-    } while (another_range);
+    }
+  while (another_range);
 
   *strp = str;
   return range;
@@ -3129,7 +3434,7 @@ reg_list (strp)
 
 static void
 do_ldmstm (str, flags)
-     char *        str;
+     char * str;
      unsigned long flags;
 {
   int base_reg;
@@ -3158,14 +3463,14 @@ do_ldmstm (str, flags)
       || (range = reg_list (&str)) == FAIL)
     {
       if (! inst.error)
-       inst.error = bad_args;
+       inst.error = BAD_ARGS;
       return;
     }
 
   if (*str == '^')
     {
       str++;
-      flags |= MULTI_SET_PSR;
+      flags |= LDM_TYPE_2_OR_3;
     }
 
   inst.instruction |= flags | range;
@@ -3175,11 +3480,11 @@ do_ldmstm (str, flags)
 
 static void
 do_swi (str, flags)
-     char *        str;
+     char * str;
      unsigned long flags;
 {
   skip_whitespace (str);
-  
+
   /* Allow optional leading '#'.  */
   if (is_immediate_prefix (*str))
     str++;
@@ -3190,19 +3495,19 @@ do_swi (str, flags)
   inst.reloc.type = BFD_RELOC_ARM_SWI;
   inst.reloc.pc_rel = 0;
   inst.instruction |= flags;
-  
+
   end_of_line (str);
-  
+
   return;
 }
 
 static void
 do_swap (str, flags)
-     char *        str;
+     char * str;
      unsigned long flags;
 {
   int reg;
-  
+
   skip_whitespace (str);
 
   if ((reg = reg_required_here (&str, 12)) == FAIL)
@@ -3218,7 +3523,7 @@ do_swap (str, flags)
       || (reg = reg_required_here (&str, 0)) == FAIL)
     {
       if (!inst.error)
-       inst.error = bad_args;
+       inst.error = BAD_ARGS;
       return;
     }
 
@@ -3231,7 +3536,7 @@ do_swap (str, flags)
   if (skip_past_comma (&str) == FAIL
       || *str++ != '[')
     {
-      inst.error = bad_args;
+      inst.error = BAD_ARGS;
       return;
     }
 
@@ -3242,7 +3547,7 @@ do_swap (str, flags)
 
   if (reg == REG_PC)
     {
-      inst.error = bad_pc;
+      inst.error = BAD_PC;
       return;
     }
 
@@ -3261,20 +3566,20 @@ do_swap (str, flags)
 
 static void
 do_branch (str, flags)
-     char *        str;
-     unsigned long flags;
+     char * str;
+     unsigned long flags ATTRIBUTE_UNUSED;
 {
   if (my_get_expression (&inst.reloc.exp, &str))
     return;
-  
+
 #ifdef OBJ_ELF
   {
     char * save_in;
-  
-    /* ScottB: February 5, 1998 */
-    /* Check to see of PLT32 reloc required for the instruction.  */
-    
-    /* arm_parse_reloc() works on input_line_pointer.
+
+    /* ScottB: February 5, 1998 - Check to see of PLT32 reloc
+       required for the instruction.  */
+
+    /* arm_parse_reloc () works on input_line_pointer.
        We actually want to parse the operands to the branch instruction
        passed in 'str'.  Save the input pointer and restore it later.  */
     save_in = input_line_pointer;
@@ -3299,35 +3604,38 @@ do_branch (str, flags)
 #else
   inst.reloc.type   = BFD_RELOC_ARM_PCREL_BRANCH;
   inst.reloc.pc_rel = 1;
-#endif /* OBJ_ELF */
-  
+#endif /* OBJ_ELF  */
+
   end_of_line (str);
   return;
 }
 
 static void
 do_bx (str, flags)
-     char *        str;
-     unsigned long flags;
+     char * str;
+     unsigned long flags ATTRIBUTE_UNUSED;
 {
   int reg;
 
   skip_whitespace (str);
 
   if ((reg = reg_required_here (&str, 0)) == FAIL)
-    return;
+    {
+      inst.error = BAD_ARGS;
+      return;
+    }
 
+  /* Note - it is not illegal to do a "bx pc".  Useless, but not illegal.  */
   if (reg == REG_PC)
-    as_tsktsk (_("Use of r15 in bx has undefined behaviour"));
+    as_tsktsk (_("Use of r15 in bx in ARM mode is not really useful"));
 
   end_of_line (str);
-  return;
 }
 
 static void
 do_cdp (str, flags)
-     char *        str;
-     unsigned long flags;
+     char * str;
+     unsigned long flags ATTRIBUTE_UNUSED;
 {
   /* Co-processor data operation.
      Format: CDP{cond} CP#,<expr>,CRd,CRn,CRm{,<expr>}  */
@@ -3336,7 +3644,7 @@ do_cdp (str, flags)
   if (co_proc_number (&str) == FAIL)
     {
       if (!inst.error)
-       inst.error = bad_args;
+       inst.error = BAD_ARGS;
       return;
     }
 
@@ -3344,7 +3652,7 @@ do_cdp (str, flags)
       || cp_opc_expr (&str, 20,4) == FAIL)
     {
       if (!inst.error)
-       inst.error = bad_args;
+       inst.error = BAD_ARGS;
       return;
     }
 
@@ -3352,7 +3660,7 @@ do_cdp (str, flags)
       || cp_reg_required_here (&str, 12) == FAIL)
     {
       if (!inst.error)
-       inst.error = bad_args;
+       inst.error = BAD_ARGS;
       return;
     }
 
@@ -3360,7 +3668,7 @@ do_cdp (str, flags)
       || cp_reg_required_here (&str, 16) == FAIL)
     {
       if (!inst.error)
-       inst.error = bad_args;
+       inst.error = BAD_ARGS;
       return;
     }
 
@@ -3368,7 +3676,7 @@ do_cdp (str, flags)
       || cp_reg_required_here (&str, 0) == FAIL)
     {
       if (!inst.error)
-       inst.error = bad_args;
+       inst.error = BAD_ARGS;
       return;
     }
 
@@ -3377,7 +3685,7 @@ do_cdp (str, flags)
       if (cp_opc_expr (&str, 5, 3) == FAIL)
        {
          if (!inst.error)
-           inst.error = bad_args;
+           inst.error = BAD_ARGS;
          return;
        }
     }
@@ -3388,7 +3696,7 @@ do_cdp (str, flags)
 
 static void
 do_lstc (str, flags)
-     char *        str;
+     char * str;
      unsigned long flags;
 {
   /* Co-processor register load/store.
@@ -3399,7 +3707,7 @@ do_lstc (str, flags)
   if (co_proc_number (&str) == FAIL)
     {
       if (!inst.error)
-       inst.error = bad_args;
+       inst.error = BAD_ARGS;
       return;
     }
 
@@ -3407,7 +3715,7 @@ do_lstc (str, flags)
       || cp_reg_required_here (&str, 12) == FAIL)
     {
       if (!inst.error)
-       inst.error = bad_args;
+       inst.error = BAD_ARGS;
       return;
     }
 
@@ -3415,7 +3723,7 @@ do_lstc (str, flags)
       || cp_address_required_here (&str) == FAIL)
     {
       if (! inst.error)
-       inst.error = bad_args;
+       inst.error = BAD_ARGS;
       return;
     }
 
@@ -3426,7 +3734,7 @@ do_lstc (str, flags)
 
 static void
 do_co_reg (str, flags)
-     char *        str;
+     char * str;
      unsigned long flags;
 {
   /* Co-processor register transfer.
@@ -3437,7 +3745,7 @@ do_co_reg (str, flags)
   if (co_proc_number (&str) == FAIL)
     {
       if (!inst.error)
-       inst.error = bad_args;
+       inst.error = BAD_ARGS;
       return;
     }
 
@@ -3445,7 +3753,7 @@ do_co_reg (str, flags)
       || cp_opc_expr (&str, 21, 3) == FAIL)
     {
       if (!inst.error)
-       inst.error = bad_args;
+       inst.error = BAD_ARGS;
       return;
     }
 
@@ -3453,7 +3761,7 @@ do_co_reg (str, flags)
       || reg_required_here (&str, 12) == FAIL)
     {
       if (!inst.error)
-       inst.error = bad_args;
+       inst.error = BAD_ARGS;
       return;
     }
 
@@ -3461,7 +3769,7 @@ do_co_reg (str, flags)
       || cp_reg_required_here (&str, 16) == FAIL)
     {
       if (!inst.error)
-       inst.error = bad_args;
+       inst.error = BAD_ARGS;
       return;
     }
 
@@ -3469,7 +3777,7 @@ do_co_reg (str, flags)
       || cp_reg_required_here (&str, 0) == FAIL)
     {
       if (!inst.error)
-       inst.error = bad_args;
+       inst.error = BAD_ARGS;
       return;
     }
 
@@ -3478,10 +3786,14 @@ do_co_reg (str, flags)
       if (cp_opc_expr (&str, 5, 3) == FAIL)
        {
          if (!inst.error)
-           inst.error = bad_args;
+           inst.error = BAD_ARGS;
          return;
        }
     }
+  if (flags)
+    {
+      inst.error = BAD_COND;
+    }
 
   end_of_line (str);
   return;
@@ -3489,8 +3801,8 @@ do_co_reg (str, flags)
 
 static void
 do_fp_ctrl (str, flags)
-     char *        str;
-     unsigned long flags;
+     char * str;
+     unsigned long flags ATTRIBUTE_UNUSED;
 {
   /* FP control registers.
      Format: <WFS|RFS|WFC|RFC>{cond} Rn  */
@@ -3500,7 +3812,7 @@ do_fp_ctrl (str, flags)
   if (reg_required_here (&str, 12) == FAIL)
     {
       if (!inst.error)
-       inst.error = bad_args;
+       inst.error = BAD_ARGS;
       return;
     }
 
@@ -3510,8 +3822,8 @@ do_fp_ctrl (str, flags)
 
 static void
 do_fp_ldst (str, flags)
-     char *        str;
-     unsigned long flags;
+     char * str;
+     unsigned long flags ATTRIBUTE_UNUSED;
 {
   skip_whitespace (str);
 
@@ -3535,7 +3847,7 @@ do_fp_ldst (str, flags)
   if (fp_reg_required_here (&str, 12) == FAIL)
     {
       if (!inst.error)
-       inst.error = bad_args;
+       inst.error = BAD_ARGS;
       return;
     }
 
@@ -3543,7 +3855,7 @@ do_fp_ldst (str, flags)
       || cp_address_required_here (&str) == FAIL)
     {
       if (!inst.error)
-       inst.error = bad_args;
+       inst.error = BAD_ARGS;
       return;
     }
 
@@ -3552,7 +3864,7 @@ do_fp_ldst (str, flags)
 
 static void
 do_fp_ldmstm (str, flags)
-     char *        str;
+     char * str;
      unsigned long flags;
 {
   int num_regs;
@@ -3562,11 +3874,11 @@ do_fp_ldmstm (str, flags)
   if (fp_reg_required_here (&str, 12) == FAIL)
     {
       if (! inst.error)
-       inst.error = bad_args;
+       inst.error = BAD_ARGS;
       return;
     }
 
-  /* Get Number of registers to transfer */
+  /* Get Number of registers to transfer */
   if (skip_past_comma (&str) == FAIL
       || my_get_expression (&inst.reloc.exp, &str))
     {
@@ -3620,7 +3932,7 @@ do_fp_ldmstm (str, flags)
          || *str != '[')
        {
          if (! inst.error)
-           inst.error = bad_args;
+           inst.error = BAD_ARGS;
          return;
        }
 
@@ -3634,7 +3946,7 @@ do_fp_ldmstm (str, flags)
 
       if (*str != ']')
        {
-         inst.error = bad_args;
+         inst.error = BAD_ARGS;
          return;
        }
 
@@ -3645,7 +3957,8 @@ do_fp_ldmstm (str, flags)
          str++;
          if (reg == REG_PC)
            {
-             inst.error = _("R15 not allowed as base register with write-back");
+             inst.error =
+               _("R15 not allowed as base register with write-back");
              return;
            }
        }
@@ -3654,14 +3967,14 @@ do_fp_ldmstm (str, flags)
 
       if (flags & CP_T_Pre)
        {
-         /* Pre-decrement */
+         /* Pre-decrement */
          offset = 3 * num_regs;
          if (write_back)
            flags |= CP_T_WB;
        }
       else
        {
-         /* Post-increment */
+         /* Post-increment */
          if (write_back)
            {
              flags |= CP_T_WB;
@@ -3682,7 +3995,7 @@ do_fp_ldmstm (str, flags)
           || cp_address_required_here (&str) == FAIL)
     {
       if (! inst.error)
-       inst.error = bad_args;
+       inst.error = BAD_ARGS;
       return;
     }
 
@@ -3691,7 +4004,7 @@ do_fp_ldmstm (str, flags)
 
 static void
 do_fp_dyadic (str, flags)
-     char *        str;
+     char * str;
      unsigned long flags;
 {
   skip_whitespace (str);
@@ -3713,7 +4026,7 @@ do_fp_dyadic (str, flags)
   if (fp_reg_required_here (&str, 12) == FAIL)
     {
       if (! inst.error)
-       inst.error = bad_args;
+       inst.error = BAD_ARGS;
       return;
     }
 
@@ -3721,7 +4034,7 @@ do_fp_dyadic (str, flags)
       || fp_reg_required_here (&str, 16) == FAIL)
     {
       if (! inst.error)
-       inst.error = bad_args;
+       inst.error = BAD_ARGS;
       return;
     }
 
@@ -3729,7 +4042,7 @@ do_fp_dyadic (str, flags)
       || fp_op2 (&str) == FAIL)
     {
       if (! inst.error)
-       inst.error = bad_args;
+       inst.error = BAD_ARGS;
       return;
     }
 
@@ -3740,7 +4053,7 @@ do_fp_dyadic (str, flags)
 
 static void
 do_fp_monadic (str, flags)
-     char *        str;
+     char * str;
      unsigned long flags;
 {
   skip_whitespace (str);
@@ -3762,7 +4075,7 @@ do_fp_monadic (str, flags)
   if (fp_reg_required_here (&str, 12) == FAIL)
     {
       if (! inst.error)
-       inst.error = bad_args;
+       inst.error = BAD_ARGS;
       return;
     }
 
@@ -3770,7 +4083,7 @@ do_fp_monadic (str, flags)
       || fp_op2 (&str) == FAIL)
     {
       if (! inst.error)
-       inst.error = bad_args;
+       inst.error = BAD_ARGS;
       return;
     }
 
@@ -3781,7 +4094,7 @@ do_fp_monadic (str, flags)
 
 static void
 do_fp_cmp (str, flags)
-     char *        str;
+     char * str;
      unsigned long flags;
 {
   skip_whitespace (str);
@@ -3789,7 +4102,7 @@ do_fp_cmp (str, flags)
   if (fp_reg_required_here (&str, 16) == FAIL)
     {
       if (! inst.error)
-       inst.error = bad_args;
+       inst.error = BAD_ARGS;
       return;
     }
 
@@ -3797,7 +4110,7 @@ do_fp_cmp (str, flags)
       || fp_op2 (&str) == FAIL)
     {
       if (! inst.error)
-       inst.error = bad_args;
+       inst.error = BAD_ARGS;
       return;
     }
 
@@ -3808,7 +4121,7 @@ do_fp_cmp (str, flags)
 
 static void
 do_fp_from_reg (str, flags)
-     char *        str;
+     char * str;
      unsigned long flags;
 {
   skip_whitespace (str);
@@ -3830,7 +4143,7 @@ do_fp_from_reg (str, flags)
   if (fp_reg_required_here (&str, 16) == FAIL)
     {
       if (! inst.error)
-       inst.error = bad_args;
+       inst.error = BAD_ARGS;
       return;
     }
 
@@ -3838,7 +4151,7 @@ do_fp_from_reg (str, flags)
       || reg_required_here (&str, 12) == FAIL)
     {
       if (! inst.error)
-       inst.error = bad_args;
+       inst.error = BAD_ARGS;
       return;
     }
 
@@ -3849,7 +4162,7 @@ do_fp_from_reg (str, flags)
 
 static void
 do_fp_to_reg (str, flags)
-     char *        str;
+     char * str;
      unsigned long flags;
 {
   skip_whitespace (str);
@@ -3861,7 +4174,7 @@ do_fp_to_reg (str, flags)
       || fp_reg_required_here (&str, 0) == FAIL)
     {
       if (! inst.error)
-       inst.error = bad_args;
+       inst.error = BAD_ARGS;
       return;
     }
 
@@ -3870,13 +4183,14 @@ do_fp_to_reg (str, flags)
   return;
 }
 
-/* Thumb specific routines */
+/* Thumb specific routines */
 
 /* Parse and validate that a register is of the right form, this saves
-   repeated checking of this information in many similar cases. 
-   Unlike the 32-bit case we do not insert the register into the opcode 
-   here, since the position is often unknown until the full instruction 
+   repeated checking of this information in many similar cases.
+   Unlike the 32-bit case we do not insert the register into the opcode
+   here, since the position is often unknown until the full instruction
    has been parsed.  */
+
 static int
 thumb_reg (strp, hi_lo)
      char ** strp;
@@ -3914,6 +4228,7 @@ thumb_reg (strp, hi_lo)
 
 /* Parse an add or subtract instruction, SUBTRACT is non-zero if the opcode
    was SUB.  */
+
 static void
 thumb_add_sub (str, subtract)
      char * str;
@@ -3927,7 +4242,7 @@ thumb_add_sub (str, subtract)
       || skip_past_comma (&str) == FAIL)
     {
       if (! inst.error)
-       inst.error = bad_args;
+       inst.error = BAD_ARGS;
       return;
     }
 
@@ -3945,8 +4260,8 @@ thumb_add_sub (str, subtract)
 
       if (skip_past_comma (&str) == FAIL)
        {
-         /* Two operand format, shuffle the registers and pretend there 
-            are 3 */
+         /* Two operand format, shuffle the registers
+            and pretend there are 3.  */
          Rn = Rs;
          Rs = Rd;
        }
@@ -3961,7 +4276,7 @@ thumb_add_sub (str, subtract)
     }
 
   /* We now have Rd and Rs set to registers, and Rn set to a register or FAIL;
-     for the latter case, EXPR contains the immediate that was found. */
+     for the latter case, EXPR contains the immediate that was found.  */
   if (Rn != FAIL)
     {
       /* All register format.  */
@@ -3973,7 +4288,7 @@ thumb_add_sub (str, subtract)
              return;
            }
 
-         /* Can't do this for SUB */
+         /* Can't do this for SUB */
          if (subtract)
            {
              inst.error = _("subtract valid only on lo regs");
@@ -4007,7 +4322,7 @@ thumb_add_sub (str, subtract)
       if (inst.reloc.exp.X_op != O_constant)
        {
          /* Value isn't known yet, all we can do is store all the fragments
-            we know about in the instruction and let the reloc hacking 
+            we know about in the instruction and let the reloc hacking
             work it all out.  */
          inst.instruction = (subtract ? 0x8000 : 0) | (Rd << 4) | Rs;
          inst.reloc.type = BFD_RELOC_ARM_THUMB_ADD;
@@ -4024,7 +4339,7 @@ thumb_add_sub (str, subtract)
              offset = -offset;
              subtract = 1;
 
-             /* Quick check, in case offset is MIN_INT */
+             /* Quick check, in case offset is MIN_INT */
              if (offset < 0)
                {
                  inst.error = _("immediate value out of range");
@@ -4078,6 +4393,7 @@ thumb_add_sub (str, subtract)
            }
        }
     }
+
   end_of_line (str);
 }
 
@@ -4094,7 +4410,7 @@ thumb_shift (str, shift)
       || skip_past_comma (&str) == FAIL)
     {
       if (! inst.error)
-       inst.error = bad_args;
+       inst.error = BAD_ARGS;
       return;
     }
 
@@ -4102,19 +4418,19 @@ thumb_shift (str, shift)
     {
       /* Two operand immediate format, set Rs to Rd.  */
       Rs = Rd;
-      str++;
+      str ++;
       if (my_get_expression (&inst.reloc.exp, &str))
        return;
     }
   else
     {
-      if ((Rs =  thumb_reg (&str, THUMB_REG_LO)) == FAIL)
+      if ((Rs = thumb_reg (&str, THUMB_REG_LO)) == FAIL)
        return;
 
       if (skip_past_comma (&str) == FAIL)
        {
-         /* Two operand format, shuffle the registers and pretend there
-            are 3 */
+         /* Two operand format, shuffle the registers
+            and pretend there are 3.  */
          Rn = Rs;
          Rs = Rd;
        }
@@ -4129,7 +4445,7 @@ thumb_shift (str, shift)
     }
 
   /* We now have Rd and Rs set to registers, and Rn set to a register or FAIL;
-     for the latter case, EXPR contains the immediate that was found. */
+     for the latter case, EXPR contains the immediate that was found.  */
 
   if (Rn != FAIL)
     {
@@ -4160,8 +4476,7 @@ thumb_shift (str, shift)
       if (inst.reloc.exp.X_op != O_constant)
        {
          /* Value isn't known yet, create a dummy reloc and let reloc
-            hacking fix it up */
-
+            hacking fix it up.  */
          inst.reloc.type = BFD_RELOC_ARM_THUMB_SHIFT;
        }
       else
@@ -4174,11 +4489,11 @@ thumb_shift (str, shift)
              return;
            }
 
-         /* Shifts of zero are handled by converting to LSL */
+         /* Shifts of zero are handled by converting to LSL */
          if (shift_value == 0)
            inst.instruction = T_OPCODE_LSL_I;
 
-         /* Shifts of 32 are encoded as a shift of zero */
+         /* Shifts of 32 are encoded as a shift of zero */
          if (shift_value == 32)
            shift_value = 0;
 
@@ -4187,6 +4502,7 @@ thumb_shift (str, shift)
 
       inst.instruction |= Rd | (Rs << 3);
     }
+
   end_of_line (str);
 }
 
@@ -4203,7 +4519,7 @@ thumb_mov_compare (str, move)
       || skip_past_comma (&str) == FAIL)
     {
       if (! inst.error)
-       inst.error = bad_args;
+       inst.error = BAD_ARGS;
       return;
     }
 
@@ -4222,7 +4538,7 @@ thumb_mov_compare (str, move)
        {
          if (move == THUMB_MOVE)
            /* A move of two lowregs is encoded as ADD Rd, Rs, #0
-              since a MOV instruction produces unpredictable results */
+              since a MOV instruction produces unpredictable results */
            inst.instruction = T_OPCODE_ADD_I3;
          else
            inst.instruction = T_OPCODE_CMP_LR;
@@ -4292,7 +4608,7 @@ thumb_load_store (str, load_store, size)
       || skip_past_comma (&str) == FAIL)
     {
       if (! inst.error)
-       inst.error = bad_args;
+       inst.error = BAD_ARGS;
       return;
     }
 
@@ -4328,7 +4644,7 @@ thumb_load_store (str, load_store, size)
     }
   else if (*str == '=')
     {
-      /* Parse an "ldr Rd, =expr" instruction; this is another pseudo op */
+      /* Parse an "ldr Rd, =expr" instruction; this is another pseudo op */
       str++;
 
       skip_whitespace (str);
@@ -4337,7 +4653,7 @@ thumb_load_store (str, load_store, size)
        return;
 
       end_of_line (str);
-      
+
       if (   inst.reloc.exp.X_op != O_constant
          && inst.reloc.exp.X_op != O_symbol)
        {
@@ -4348,25 +4664,26 @@ thumb_load_store (str, load_store, size)
       if (inst.reloc.exp.X_op == O_constant
          && ((inst.reloc.exp.X_add_number & ~0xFF) == 0))
        {
-         /* This can be done with a mov instruction */
+         /* This can be done with a mov instruction */
 
          inst.instruction  = T_OPCODE_MOV_I8 | (Rd << 8);
          inst.instruction |= inst.reloc.exp.X_add_number;
-         return; 
+         return;
        }
 
-      /* Insert into literal pool */     
+      /* Insert into literal pool.  */
       if (add_to_lit_pool () == FAIL)
        {
          if (!inst.error)
-           inst.error = "literal pool insertion failed"; 
+           inst.error = "literal pool insertion failed";
          return;
        }
 
       inst.reloc.type   = BFD_RELOC_ARM_THUMB_OFFSET;
       inst.reloc.pc_rel = 1;
       inst.instruction  = T_OPCODE_LDR_PC | (Rd << 8);
-      inst.reloc.exp.X_add_number += 4; /* Adjust ARM pipeline offset to Thumb */
+      /* Adjust ARM pipeline offset to Thumb.  */
+      inst.reloc.exp.X_add_number += 4;
 
       return;
     }
@@ -4377,7 +4694,7 @@ thumb_load_store (str, load_store, size)
 
       inst.instruction = T_OPCODE_LDR_PC | (Rd << 8);
       inst.reloc.pc_rel = 1;
-      inst.reloc.exp.X_add_number -= 4; /* Pipeline offset */
+      inst.reloc.exp.X_add_number -= 4; /* Pipeline offset */
       inst.reloc.type = BFD_RELOC_ARM_THUMB_OFFSET;
       end_of_line (str);
       return;
@@ -4431,7 +4748,7 @@ thumb_load_store (str, load_store, size)
     }
   else if (Ro == FAIL)
     {
-      /* Immediate offset */
+      /* Immediate offset */
       if (size == THUMB_WORD)
        inst.instruction = (load_store == THUMB_LOAD
                            ? T_OPCODE_LDR_IW : T_OPCODE_STR_IW);
@@ -4447,7 +4764,7 @@ thumb_load_store (str, load_store, size)
       if (inst.reloc.exp.X_op == O_constant)
        {
          unsigned offset = inst.reloc.exp.X_add_number;
-         
+
          if (offset & ~(0x1f << size))
            {
              inst.error = _("Invalid offset");
@@ -4460,7 +4777,7 @@ thumb_load_store (str, load_store, size)
     }
   else
     {
-      /* Register offset */
+      /* Register offset */
       if (size == THUMB_WORD)
        inst.instruction = (load_store == THUMB_LOAD
                            ? T_OPCODE_LDR_RW : T_OPCODE_STR_RW);
@@ -4481,14 +4798,15 @@ static void
 do_t_nop (str)
      char * str;
 {
-  /* Do nothing */
+  /* Do nothing */
   end_of_line (str);
   return;
 }
 
-/* Handle the Format 4 instructions that do not have equivalents in other 
+/* Handle the Format 4 instructions that do not have equivalents in other
    formats.  That is, ADC, AND, EOR, SBC, ROR, TST, NEG, CMN, ORR, MUL,
    BIC and MVN.  */
+
 static void
 do_t_arit (str)
      char * str;
@@ -4497,14 +4815,11 @@ do_t_arit (str)
 
   skip_whitespace (str);
 
-  if ((Rd = thumb_reg (&str, THUMB_REG_LO)) == FAIL)
-    return;
-
-  if (skip_past_comma (&str) == FAIL
+  if ((Rd = thumb_reg (&str, THUMB_REG_LO)) == FAIL
+      || skip_past_comma (&str) == FAIL
       || (Rs = thumb_reg (&str, THUMB_REG_LO)) == FAIL)
     {
-      if (! inst.error)
-       inst.error = bad_args;
+      inst.error = BAD_ARGS;
       return;
     }
 
@@ -4516,9 +4831,9 @@ do_t_arit (str)
       if (inst.instruction == T_OPCODE_TST
          || inst.instruction == T_OPCODE_CMN
          || inst.instruction == T_OPCODE_NEG
-         || inst.instruction == T_OPCODE_MVN)
+         || inst.instruction == T_OPCODE_MVN)
        {
-         inst.error = bad_args;
+         inst.error = BAD_ARGS;
          return;
        }
 
@@ -4587,23 +4902,23 @@ find_real_start (symbolP)
   const char * name = S_GET_NAME (symbolP);
   symbolS *    new_target;
 
-  /* This definiton must agree with the one in gcc/config/arm/thumb.c */
+  /* This definiton must agree with the one in gcc/config/arm/thumb.c */
 #define STUB_NAME ".real_start_of"
 
   if (name == NULL)
-    abort();
+    abort ();
 
   /* Names that start with '.' are local labels, not function entry points.
      The compiler may generate BL instructions to these labels because it
      needs to perform a branch to a far away location.  */
   if (name[0] == '.')
     return symbolP;
-  
+
   real_start = malloc (strlen (name) + strlen (STUB_NAME) + 1);
   sprintf (real_start, "%s%s", STUB_NAME, name);
 
   new_target = symbol_find (real_start);
-  
+
   if (new_target == NULL)
     {
       as_warn ("Failed to find real start of function: %s\n", name);
@@ -4615,14 +4930,13 @@ find_real_start (symbolP)
   return new_target;
 }
 
-
 static void
 do_t_branch23 (str)
      char * str;
 {
   if (my_get_expression (& inst.reloc.exp, & str))
     return;
-  
+
   inst.reloc.type   = BFD_RELOC_THUMB_PCREL_BRANCH23;
   inst.reloc.pc_rel = 1;
   end_of_line (str);
@@ -4635,7 +4949,8 @@ do_t_branch23 (str)
       && inst.reloc.exp.X_add_symbol != NULL
       && S_IS_DEFINED (inst.reloc.exp.X_add_symbol)
       && ! THUMB_IS_FUNC (inst.reloc.exp.X_add_symbol))
-    inst.reloc.exp.X_add_symbol = find_real_start (inst.reloc.exp.X_add_symbol);
+    inst.reloc.exp.X_add_symbol =
+      find_real_start (inst.reloc.exp.X_add_symbol);
 }
 
 static void
@@ -4687,13 +5002,13 @@ do_t_ldmstm (str)
       || (range = reg_list (&str)) == FAIL)
     {
       if (! inst.error)
-       inst.error = bad_args;
+       inst.error = BAD_ARGS;
       return;
     }
 
   if (inst.reloc.type != BFD_RELOC_NONE)
     {
-      /* This really doesn't seem worth it. */
+      /* This really doesn't seem worth it.  */
       inst.reloc.type = BFD_RELOC_NONE;
       inst.error = _("Expression too complex");
       return;
@@ -4787,13 +5102,13 @@ do_t_push_pop (str)
   if ((range = reg_list (&str)) == FAIL)
     {
       if (! inst.error)
-       inst.error = bad_args;
+       inst.error = BAD_ARGS;
       return;
     }
 
   if (inst.reloc.type != BFD_RELOC_NONE)
     {
-      /* This really doesn't seem worth it. */
+      /* This really doesn't seem worth it.  */
       inst.reloc.type = BFD_RELOC_NONE;
       inst.error = _("Expression too complex");
       return;
@@ -4866,23 +5181,28 @@ static void
 do_t_adr (str)
      char * str;
 {
+  int reg;
+
   /* This is a pseudo-op of the form "adr rd, label" to be converted
-     into a relative address of the form "add rd, pc, #label-.-4" */
+     into a relative address of the form "add rd, pc, #label-.-4" */
   skip_whitespace (str);
 
-  if (reg_required_here (&str, 4) == FAIL  /* Store Rd in temporary location inside instruction.  */
+  /* Store Rd in temporary location inside instruction.  */
+  if ((reg = reg_required_here (&str, 4)) == FAIL
+      || (reg > 7)  /* For Thumb reg must be r0..r7.  */
       || skip_past_comma (&str) == FAIL
       || my_get_expression (&inst.reloc.exp, &str))
     {
       if (!inst.error)
-       inst.error = bad_args;
+       inst.error = BAD_ARGS;
       return;
     }
 
   inst.reloc.type = BFD_RELOC_ARM_THUMB_ADD;
-  inst.reloc.exp.X_add_number -= 4; /* PC relative adjust */
+  inst.reloc.exp.X_add_number -= 4; /* PC relative adjust */
   inst.reloc.pc_rel = 1;
-  inst.instruction |= REG_PC; /* Rd is already placed into the instruction */
+  inst.instruction |= REG_PC; /* Rd is already placed into the instruction.  */
+
   end_of_line (str);
 }
 
@@ -4890,10 +5210,10 @@ static void
 insert_reg (entry)
      int entry;
 {
-  int    len = strlen (reg_table[entry].name) + 2;
-  char * buf = (char *) xmalloc (len);
+  int    len  = strlen (reg_table[entry].name) + 2;
+  char * buf  = (char *) xmalloc (len);
   char * buf2 = (char *) xmalloc (len);
-  int    i = 0;
+  int    i    = 0;
 
 #ifdef REGISTER_PREFIX
   buf[i++] = REGISTER_PREFIX;
@@ -4906,8 +5226,8 @@ insert_reg (entry)
 
   buf2[i] = '\0';
 
-  hash_insert (arm_reg_hsh, buf, (PTR) &reg_table[entry]);
-  hash_insert (arm_reg_hsh, buf2, (PTR) &reg_table[entry]);
+  hash_insert (arm_reg_hsh, buf,  (PTR) & reg_table[entry]);
+  hash_insert (arm_reg_hsh, buf2, (PTR) & reg_table[entry]);
 }
 
 static void
@@ -4916,7 +5236,7 @@ insert_reg_alias (str, regnum)
      int regnum;
 {
   struct reg_entry *new =
-    (struct reg_entry *)xmalloc (sizeof (struct reg_entry));
+    (struct reg_entry *) xmalloc (sizeof (struct reg_entry));
   char *name = xmalloc (strlen (str) + 1);
   strcpy (name, str);
 
@@ -4932,15 +5252,16 @@ set_constant_flonums ()
   int i;
 
   for (i = 0; i < NUM_FLOAT_VALS; i++)
-    if (atof_ieee ((char *)fp_const[i], 'x', fp_values[i]) == NULL)
+    if (atof_ieee ((char *) fp_const[i], 'x', fp_values[i]) == NULL)
       abort ();
 }
 
 void
 md_begin ()
 {
-  int i;
-  
+  unsigned mach;
+  unsigned int i;
+
   if (   (arm_ops_hsh = hash_new ()) == NULL
       || (arm_tops_hsh = hash_new ()) == NULL
       || (arm_cond_hsh = hash_new ()) == NULL
@@ -4948,15 +5269,15 @@ md_begin ()
       || (arm_reg_hsh = hash_new ()) == NULL
       || (arm_psr_hsh = hash_new ()) == NULL)
     as_fatal (_("Virtual memory exhausted"));
-    
+
   for (i = 0; i < sizeof (insns) / sizeof (struct asm_opcode); i++)
     hash_insert (arm_ops_hsh, insns[i].template, (PTR) (insns + i));
   for (i = 0; i < sizeof (tinsns) / sizeof (struct thumb_opcode); i++)
     hash_insert (arm_tops_hsh, tinsns[i].template, (PTR) (tinsns + i));
   for (i = 0; i < sizeof (conds) / sizeof (struct asm_cond); i++)
     hash_insert (arm_cond_hsh, conds[i].template, (PTR) (conds + i));
-  for (i = 0; i < sizeof (shift) / sizeof (struct asm_shift); i++)
-    hash_insert (arm_shift_hsh, shift[i].template, (PTR) (shift + i));
+  for (i = 0; i < sizeof (shift_names) / sizeof (struct asm_shift_name); i++)
+    hash_insert (arm_shift_hsh, shift_names[i].name, (PTR) (shift_names + i));
   for (i = 0; i < sizeof (psrs) / sizeof (struct asm_psr); i++)
     hash_insert (arm_psr_hsh, psrs[i].template, (PTR) (psrs + i));
 
@@ -4968,8 +5289,8 @@ md_begin ()
 #if defined OBJ_COFF || defined OBJ_ELF
   {
     unsigned int flags = 0;
-    
-    /* Set the flags in the private structure */
+
+    /* Set the flags in the private structure */
     if (uses_apcs_26)      flags |= F_APCS26;
     if (support_interwork) flags |= F_INTERWORK;
     if (uses_apcs_float)   flags |= F_APCS_FLOAT;
@@ -4979,48 +5300,44 @@ md_begin ()
     bfd_set_private_flags (stdoutput, flags);
   }
 #endif
-  
-  {
-    unsigned mach;
-    
-    /* Record the CPU type as well */
-    switch (cpu_variant & ARM_CPU_MASK)
-      {
-      case ARM_2:
-       mach = bfd_mach_arm_2;
-       break;
-       
-      case ARM_3: /* also ARM_250 */
-       mach = bfd_mach_arm_2a;
-       break;
 
-      default:
-      case ARM_6 | ARM_3 | ARM_2:      /* Actually no CPU type defined */
+  /* Record the CPU type as well.  */
+  switch (cpu_variant & ARM_CPU_MASK)
+    {
+    case ARM_2:
+      mach = bfd_mach_arm_2;
+      break;
+
+    case ARM_3:                /* Also ARM_250.  */
+      mach = bfd_mach_arm_2a;
+      break;
+
+    default:
+    case ARM_6 | ARM_3 | ARM_2:        /* Actually no CPU type defined.  */
+      mach = bfd_mach_arm_4;
+      break;
+
+    case ARM_7:                /* Also ARM_6.  */
+      mach = bfd_mach_arm_3;
+      break;
+    }
+
+  /* Catch special cases.  */
+  if (cpu_variant != (FPU_DEFAULT | CPU_DEFAULT))
+    {
+      if (cpu_variant & (ARM_EXT_V5 & ARM_THUMB))
+       mach = bfd_mach_arm_5T;
+      else if (cpu_variant & ARM_EXT_V5)
+       mach = bfd_mach_arm_5;
+      else if (cpu_variant & ARM_THUMB)
+       mach = bfd_mach_arm_4T;
+      else if ((cpu_variant & ARM_ARCH_V4) == ARM_ARCH_V4)
        mach = bfd_mach_arm_4;
-       break;
-       
-      case ARM_7:                      /* also ARM_6 */
-       mach = bfd_mach_arm_3;
-       break;
-      }
+      else if (cpu_variant & ARM_LONGMUL)
+       mach = bfd_mach_arm_3M;
+    }
 
-    /* Catch special cases.  */
-    if (cpu_variant != (FPU_DEFAULT | CPU_DEFAULT))
-      {
-       if (cpu_variant & (ARM_EXT_V5 & ARM_THUMB))
-         mach = bfd_mach_arm_5T;
-       else if (cpu_variant & ARM_EXT_V5)
-         mach = bfd_mach_arm_5;
-       else if (cpu_variant & ARM_THUMB)
-         mach = bfd_mach_arm_4T;
-       else if ((cpu_variant & ARM_ARCH_V4) == ARM_ARCH_V4)
-         mach = bfd_mach_arm_4;
-       else if (cpu_variant & ARM_LONGMUL)
-         mach = bfd_mach_arm_3M;
-      }
-       
-    bfd_set_arch_mach (stdoutput, TARGET_ARCH, mach);
-  }
+  bfd_set_arch_mach (stdoutput, TARGET_ARCH, mach);
 }
 
 /* Turn an integer of n bytes (in val) into a stream of bytes appropriate
@@ -5029,6 +5346,7 @@ md_begin ()
    THE RIGHT THING, whatever it is.  Possible values for n are 1 (byte)
    2 (short) and 4 (long)  Floating numbers are put out as a series of
    LITTLENUMS (shorts, here at least).  */
+
 void
 md_number_to_chars (buf, val, n)
      char * buf;
@@ -5041,10 +5359,10 @@ md_number_to_chars (buf, val, n)
     number_to_chars_littleendian (buf, val, n);
 }
 
-static valueT 
+static valueT
 md_chars_to_number (buf, n)
      char * buf;
-     int n;
+     int    n;
 {
   valueT result = 0;
   unsigned char * where = (unsigned char *) buf;
@@ -5070,8 +5388,8 @@ md_chars_to_number (buf, n)
 }
 
 /* Turn a string in input_line_pointer into a floating point constant
-   of type TYPE, and store the appropriate bytes in *litP.  The number
-   of LITTLENUMS emitted is stored in *sizeP .  An error message is
+   of type TYPE, and store the appropriate bytes in *LITP.  The number
+   of LITTLENUMS emitted is stored in *SIZEP.  An error message is
    returned, or NULL on OK.
 
    Note that fp constants aren't represent in the normal way on the ARM.
@@ -5153,16 +5471,18 @@ md_atof (type, litP, sizeP)
   return 0;
 }
 
-/* The knowledge of the PC's pipeline offset is built into the insns themselves.  */ 
+/* The knowledge of the PC's pipeline offset is built into the insns
+   themselves.  */
+
 long
 md_pcrel_from (fixP)
      fixS * fixP;
 {
-  if (   fixP->fx_addsy
+  if (fixP->fx_addsy
       && S_GET_SEGMENT (fixP->fx_addsy) == undefined_section
       && fixP->fx_subsy == NULL)
     return 0;
-  
+
   if (fixP->fx_pcrel && (fixP->fx_r_type == BFD_RELOC_ARM_THUMB_ADD))
     {
       /* PC relative addressing on the Thumb is slightly odd
@@ -5171,31 +5491,36 @@ md_pcrel_from (fixP)
       return (fixP->fx_where + fixP->fx_frag->fr_address) & ~3;
     }
 
+#ifdef TE_WINCE
+  /* The pattern was adjusted to accomodate CE's off-by-one fixups,
+     so we un-adjust here to compensate for the accomodation.  */
+  return fixP->fx_where + fixP->fx_frag->fr_address + 8;
+#else
   return fixP->fx_where + fixP->fx_frag->fr_address;
+#endif
 }
 
-/* Round up a section size to the appropriate boundary. */
+/* Round up a section size to the appropriate boundary.  */
+
 valueT
 md_section_align (segment, size)
-     segT   segment;
+     segT   segment ATTRIBUTE_UNUSED;
      valueT size;
 {
 #ifdef OBJ_ELF
-  /* Don't align the dwarf2 debug sections */
-  if (!strncmp (segment->name, ".debug", 5))
-    return size;
-#endif
-  /* Round all sects to multiple of 4 */
+  return size;
+#else
+  /* Round all sects to multiple of 4.  */
   return (size + 3) & ~3;
+#endif
 }
 
-/* Under ELF we need to default _GLOBAL_OFFSET_TABLE.  Otherwise 
-   we have no need to default values of symbols.  */
+/* Under ELF we need to default _GLOBAL_OFFSET_TABLE.
+   Otherwise we have no need to default values of symbols.  */
 
-/* ARGSUSED */
 symbolS *
 md_undefined_symbol (name)
-     char * name;
+     char * name ATTRIBUTE_UNUSED;
 {
 #ifdef OBJ_ELF
   if (name[0] == '_' && name[1] == 'G'
@@ -5205,20 +5530,20 @@ md_undefined_symbol (name)
        {
          if (symbol_find (name))
            as_bad ("GOT already in the symbol table");
-         
+
          GOT_symbol = symbol_new (name, undefined_section,
-                                  (valueT)0, & zero_address_frag);
+                                  (valueT) 0, & zero_address_frag);
        }
-      
+
       return GOT_symbol;
     }
 #endif
-  
+
   return 0;
 }
 
-/* arm_reg_parse () := if it looks like a register, return its token and 
-   advance the pointer. */
+/* arm_reg_parse () := if it looks like a register, return its token and
+   advance the pointer.  */
 
 static int
 arm_reg_parse (ccp)
@@ -5250,7 +5575,7 @@ arm_reg_parse (ccp)
   *--p = 0;
   reg = (struct reg_entry *) hash_find (arm_reg_hsh, start);
   *p = c;
-  
+
   if (reg)
     {
       *ccp = p;
@@ -5260,38 +5585,11 @@ arm_reg_parse (ccp)
   return FAIL;
 }
 
-static int
-arm_psr_parse (ccp)
-     register char ** ccp;
-{
-  char * start = * ccp;
-  char   c;
-  char * p;
-  CONST struct asm_psr * psr;
-
-  p = start;
-  c = *p++;
-  while (isalpha (c) || c == '_')
-    c = *p++;
-
-  *--p = 0;  
-  psr = (CONST struct asm_psr *) hash_find (arm_psr_hsh, start);
-  *p = c;
-
-  if (psr)
-    {
-      *ccp = p;
-      return psr->number;
-    }
-
-  return FAIL;
-}
-
 int
 md_apply_fix3 (fixP, val, seg)
-     fixS *      fixP;
-     valueT *    val;
-     segT        seg;
+     fixS *   fixP;
+     valueT * val;
+     segT     seg;
 {
   offsetT        value = * val;
   offsetT        newval;
@@ -5304,7 +5602,9 @@ md_apply_fix3 (fixP, val, seg)
   assert (fixP->fx_r_type < BFD_RELOC_UNUSED);
 
   /* Note whether this will delete the relocation.  */
-#if 0 /* patch from REarnshaw to JDavis (disabled for the moment, since it doesn't work fully) */
+#if 0
+  /* Patch from REarnshaw to JDavis (disabled for the moment, since it
+     doesn't work fully.)  */
   if ((fixP->fx_addsy == 0 || symbol_constant_p (fixP->fx_addsy))
       && !fixP->fx_pcrel)
 #else
@@ -5322,14 +5622,17 @@ md_apply_fix3 (fixP, val, seg)
          && S_GET_SEGMENT (fixP->fx_addsy) != seg)
        {
          if (target_oabi
-             && fixP->fx_r_type == BFD_RELOC_ARM_PCREL_BRANCH)
+             && (fixP->fx_r_type == BFD_RELOC_ARM_PCREL_BRANCH
+                 || fixP->fx_r_type == BFD_RELOC_ARM_PCREL_BLX
+                 ))
            value = 0;
          else
            value += md_pcrel_from (fixP);
        }
     }
 
-  fixP->fx_addnumber = value;  /* Remember value for emit_reloc.  */
+  /* Remember value for emit_reloc.  */
+  fixP->fx_addnumber = value;
 
   switch (fixP->fx_r_type)
     {
@@ -5355,7 +5658,7 @@ md_apply_fix3 (fixP, val, seg)
     case BFD_RELOC_ARM_ADRL_IMMEDIATE:
       {
        unsigned int highpart = 0;
-       unsigned int newinsn  = 0xe1a00000; /* nop */
+       unsigned int newinsn  = 0xe1a00000; /* nop */
        newimm = validate_immediate (value);
        temp = md_chars_to_number (buf, INSN_SIZE);
 
@@ -5364,26 +5667,30 @@ md_apply_fix3 (fixP, val, seg)
        if (newimm == (unsigned int) FAIL
            && (newimm = negate_data_op (& temp, value)) == (unsigned int) FAIL)
          {
-           /* No ?  OK - try using two ADD instructions to generate the value.  */
+           /* No ?  OK - try using two ADD instructions to generate
+               the value.  */
            newimm = validate_immediate_twopart (value, & highpart);
 
-           /* Yes - then make sure that the second instruction is also an add.  */
+           /* Yes - then make sure that the second instruction is
+               also an add.  */
            if (newimm != (unsigned int) FAIL)
              newinsn = temp;
            /* Still No ?  Try using a negated value.  */
            else if (validate_immediate_twopart (- value, & highpart) != (unsigned int) FAIL)
-               temp = newinsn = (temp & OPCODE_MASK) | OPCODE_SUB << DATA_OP_SHIFT;
+             temp = newinsn = (temp & OPCODE_MASK) | OPCODE_SUB << DATA_OP_SHIFT;
            /* Otherwise - give up.  */
            else
              {
                as_bad_where (fixP->fx_file, fixP->fx_line,
-                             _("Unable to compute ADRL instructions for PC offset of 0x%x"), value);
+                             _("Unable to compute ADRL instructions for PC offset of 0x%x"),
+                             value);
                break;
              }
 
-           /* Replace the first operand in the 2nd instruction (which is the PC)
-              with the destination register.  We have already added in the PC in the
-              first instruction and we do not want to do it again.  */
+           /* Replace the first operand in the 2nd instruction (which
+              is the PC) with the destination register.  We have
+              already added in the PC in the first instruction and we
+              do not want to do it again.  */
            newinsn &= ~ 0xf0000;
            newinsn |= ((newinsn & 0x0f000) << 4);
          }
@@ -5398,15 +5705,17 @@ md_apply_fix3 (fixP, val, seg)
 
     case BFD_RELOC_ARM_OFFSET_IMM:
       sign = value >= 0;
-      
+
       if (value < 0)
        value = - value;
-      
+
       if (validate_offset_imm (value, 0) == FAIL)
-        {
-          as_bad (_("bad immediate value for offset (%ld)"), (long) value);
-          break;
-        }
+       {
+         as_bad_where (fixP->fx_file, fixP->fx_line,
+                       _("bad immediate value for offset (%ld)"),
+                       (long) value);
+         break;
+       }
 
       newval = md_chars_to_number (buf, INSN_SIZE);
       newval &= 0xff7ff000;
@@ -5414,22 +5723,23 @@ md_apply_fix3 (fixP, val, seg)
       md_number_to_chars (buf, newval, INSN_SIZE);
       break;
 
-     case BFD_RELOC_ARM_OFFSET_IMM8:
-     case BFD_RELOC_ARM_HWLITERAL:
+    case BFD_RELOC_ARM_OFFSET_IMM8:
+    case BFD_RELOC_ARM_HWLITERAL:
       sign = value >= 0;
-      
+
       if (value < 0)
        value = - value;
 
       if (validate_offset_imm (value, 1) == FAIL)
-        {
-          if (fixP->fx_r_type == BFD_RELOC_ARM_HWLITERAL)
-           as_bad_where (fixP->fx_file, fixP->fx_line, 
-                       _("invalid literal constant: pool needs to be closer"));
-          else
-            as_bad (_("bad immediate value for half-word offset (%ld)"), (long) value);
-          break;
-        }
+       {
+         if (fixP->fx_r_type == BFD_RELOC_ARM_HWLITERAL)
+           as_bad_where (fixP->fx_file, fixP->fx_line,
+                         _("invalid literal constant: pool needs to be closer"));
+         else
+           as_bad (_("bad immediate value for half-word offset (%ld)"),
+                   (long) value);
+         break;
+       }
 
       newval = md_chars_to_number (buf, INSN_SIZE);
       newval &= 0xff7ff0f0;
@@ -5439,13 +5749,13 @@ md_apply_fix3 (fixP, val, seg)
 
     case BFD_RELOC_ARM_LITERAL:
       sign = value >= 0;
-      
+
       if (value < 0)
        value = - value;
 
       if (validate_offset_imm (value, 0) == FAIL)
        {
-         as_bad_where (fixP->fx_file, fixP->fx_line, 
+         as_bad_where (fixP->fx_file, fixP->fx_line,
                        _("invalid literal constant: pool needs to be closer"));
          break;
        }
@@ -5459,7 +5769,7 @@ md_apply_fix3 (fixP, val, seg)
     case BFD_RELOC_ARM_SHIFT_IMM:
       newval = md_chars_to_number (buf, INSN_SIZE);
       if (((unsigned long) value) > 32
-         || (value == 32 
+         || (value == 32
              && (((newval & 0x60) == 0) || (newval & 0x60) == 0x60)))
        {
          as_bad_where (fixP->fx_file, fixP->fx_line,
@@ -5468,12 +5778,13 @@ md_apply_fix3 (fixP, val, seg)
        }
 
       if (value == 0)
-       newval &= ~0x60;        /* Shifts of zero must be done as lsl */
+       /* Shifts of zero must be done as lsl.  */
+       newval &= ~0x60;
       else if (value == 32)
        value = 0;
       newval &= 0xfffff07f;
       newval |= (value & 0x1f) << 7;
-      md_number_to_chars (buf, newval , INSN_SIZE);
+      md_number_to_chars (buf, newval, INSN_SIZE);
       break;
 
     case BFD_RELOC_ARM_SWI:
@@ -5489,11 +5800,11 @@ md_apply_fix3 (fixP, val, seg)
       else
        {
          if (((unsigned long) value) > 0x00ffffff)
-           as_bad_where (fixP->fx_file, fixP->fx_line, 
+           as_bad_where (fixP->fx_file, fixP->fx_line,
                          _("Invalid swi expression"));
          newval = md_chars_to_number (buf, INSN_SIZE) & 0xff000000;
          newval |= value;
-         md_number_to_chars (buf, newval , INSN_SIZE);
+         md_number_to_chars (buf, newval, INSN_SIZE);
        }
       break;
 
@@ -5508,70 +5819,138 @@ md_apply_fix3 (fixP, val, seg)
     case BFD_RELOC_ARM_PCREL_BRANCH:
       newval = md_chars_to_number (buf, INSN_SIZE);
 
+      /* Sign-extend a 24-bit number.  */
+#define SEXT24(x)      ((((x) & 0xffffff) ^ (~ 0x7fffff)) + 0x800000)
+
 #ifdef OBJ_ELF
       if (! target_oabi)
-        value = fixP->fx_offset;
+       value = fixP->fx_offset;
 #endif
-      value  = (value >> 2) & 0x00ffffff;
-      value  = (value + (newval & 0x00ffffff)) & 0x00ffffff;
-      newval = value | (newval & 0xff000000);
+
+      /* We are going to store value (shifted right by two) in the
+        instruction, in a 24 bit, signed field.  Thus we need to check
+        that none of the top 8 bits of the shifted value (top 7 bits of
+         the unshifted, unsigned value) are set, or that they are all set.  */
+      if ((value & ~ ((offsetT) 0x1ffffff)) != 0
+         && ((value & ~ ((offsetT) 0x1ffffff)) != ~ ((offsetT) 0x1ffffff)))
+       {
+#ifdef OBJ_ELF
+         /* Normally we would be stuck at this point, since we cannot store
+            the absolute address that is the destination of the branch in the
+            24 bits of the branch instruction.  If however, we happen to know
+            that the destination of the branch is in the same section as the
+            branch instruciton itself, then we can compute the relocation for
+            ourselves and not have to bother the linker with it.
+
+            FIXME: The tests for OBJ_ELF and ! target_oabi are only here
+            because I have not worked out how to do this for OBJ_COFF or
+            target_oabi.  */
+         if (! target_oabi
+             && fixP->fx_addsy != NULL
+             && S_IS_DEFINED (fixP->fx_addsy)
+             && S_GET_SEGMENT (fixP->fx_addsy) == seg)
+           {
+             /* Get pc relative value to go into the branch.  */
+             value = * val;
+
+             /* Permit a backward branch provided that enough bits
+                are set.  Allow a forwards branch, provided that
+                enough bits are clear.  */
+             if (   (value & ~ ((offsetT) 0x1ffffff)) == ~ ((offsetT) 0x1ffffff)
+                 || (value & ~ ((offsetT) 0x1ffffff)) == 0)
+               fixP->fx_done = 1;
+           }
+
+         if (! fixP->fx_done)
+#endif
+           as_bad_where (fixP->fx_file, fixP->fx_line,
+                         _("gas can't handle same-section branch dest >= 0x04000000"));
+       }
+
+      value >>= 2;
+      value += SEXT24 (newval);
+
+      if (    (value & ~ ((offsetT) 0xffffff)) != 0
+         && ((value & ~ ((offsetT) 0xffffff)) != ~ ((offsetT) 0xffffff)))
+       as_bad_where (fixP->fx_file, fixP->fx_line,
+                     _("out of range branch"));
+
+      newval = (value & 0x00ffffff) | (newval & 0xff000000);
       md_number_to_chars (buf, newval, INSN_SIZE);
       break;
 
-    case BFD_RELOC_THUMB_PCREL_BRANCH9: /* conditional branch */
+    case BFD_RELOC_ARM_PCREL_BLX:
+      {
+       offsetT hbit;
+       newval = md_chars_to_number (buf, INSN_SIZE);
+
+#ifdef OBJ_ELF
+       if (! target_oabi)
+         value = fixP->fx_offset;
+#endif
+       hbit   = (value >> 1) & 1;
+       value  = (value >> 2) & 0x00ffffff;
+       value  = (value + (newval & 0x00ffffff)) & 0x00ffffff;
+       newval = value | (newval & 0xfe000000) | (hbit << 24);
+       md_number_to_chars (buf, newval, INSN_SIZE);
+      }
+      break;
+
+    case BFD_RELOC_THUMB_PCREL_BRANCH9: /* Conditional branch.  */
       newval = md_chars_to_number (buf, THUMB_SIZE);
       {
-        addressT diff = (newval & 0xff) << 1;
-        if (diff & 0x100)
-         diff |= ~0xff;
-
-        value += diff;
-        if ((value & ~0xff) && ((value & ~0xff) != ~0xff))
-         as_bad_where (fixP->fx_file, fixP->fx_line,
-                       _("Branch out of range"));
-        newval = (newval & 0xff00) | ((value & 0x1ff) >> 1);
+       addressT diff = (newval & 0xff) << 1;
+       if (diff & 0x100)
+         diff |= ~0xff;
+
+       value += diff;
+       if ((value & ~0xff) && ((value & ~0xff) != ~0xff))
+         as_bad_where (fixP->fx_file, fixP->fx_line,
+                       _("Branch out of range"));
+       newval = (newval & 0xff00) | ((value & 0x1ff) >> 1);
       }
       md_number_to_chars (buf, newval, THUMB_SIZE);
       break;
 
-    case BFD_RELOC_THUMB_PCREL_BRANCH12: /* unconditional branch */
+    case BFD_RELOC_THUMB_PCREL_BRANCH12: /* Unconditional branch.  */
       newval = md_chars_to_number (buf, THUMB_SIZE);
       {
-        addressT diff = (newval & 0x7ff) << 1;
-        if (diff & 0x800)
-         diff |= ~0x7ff;
-
-        value += diff;
-        if ((value & ~0x7ff) && ((value & ~0x7ff) != ~0x7ff))
-         as_bad_where (fixP->fx_file, fixP->fx_line,
-                       _("Branch out of range"));
-        newval = (newval & 0xf800) | ((value & 0xfff) >> 1);
+       addressT diff = (newval & 0x7ff) << 1;
+       if (diff & 0x800)
+         diff |= ~0x7ff;
+
+       value += diff;
+       if ((value & ~0x7ff) && ((value & ~0x7ff) != ~0x7ff))
+         as_bad_where (fixP->fx_file, fixP->fx_line,
+                       _("Branch out of range"));
+       newval = (newval & 0xf800) | ((value & 0xfff) >> 1);
       }
       md_number_to_chars (buf, newval, THUMB_SIZE);
       break;
 
+    case BFD_RELOC_THUMB_PCREL_BLX:
     case BFD_RELOC_THUMB_PCREL_BRANCH23:
       {
-        offsetT newval2;
-        addressT diff;
+       offsetT newval2;
+       addressT diff;
 
        newval  = md_chars_to_number (buf, THUMB_SIZE);
-        newval2 = md_chars_to_number (buf + THUMB_SIZE, THUMB_SIZE);
-        diff = ((newval & 0x7ff) << 12) | ((newval2 & 0x7ff) << 1);
-        if (diff & 0x400000)
+       newval2 = md_chars_to_number (buf + THUMB_SIZE, THUMB_SIZE);
+       diff = ((newval & 0x7ff) << 12) | ((newval2 & 0x7ff) << 1);
+       if (diff & 0x400000)
          diff |= ~0x3fffff;
 #ifdef OBJ_ELF
        value = fixP->fx_offset;
 #endif
-        value += diff;
-        if ((value & ~0x3fffff) && ((value & ~0x3fffff) != ~0x3fffff))
+       value += diff;
+       if ((value & ~0x3fffff) && ((value & ~0x3fffff) != ~0x3fffff))
          as_bad_where (fixP->fx_file, fixP->fx_line,
                        _("Branch with link out of range"));
 
-        newval  = (newval  & 0xf800) | ((value & 0x7fffff) >> 12);
-        newval2 = (newval2 & 0xf800) | ((value & 0xfff) >> 1);
-        md_number_to_chars (buf, newval, THUMB_SIZE);
-        md_number_to_chars (buf + THUMB_SIZE, newval2, THUMB_SIZE);
+       newval  = (newval  & 0xf800) | ((value & 0x7fffff) >> 12);
+       newval2 = (newval2 & 0xf800) | ((value & 0xfff) >> 1);
+       md_number_to_chars (buf, newval, THUMB_SIZE);
+       md_number_to_chars (buf + THUMB_SIZE, newval2, THUMB_SIZE);
       }
       break;
 
@@ -5580,10 +5959,10 @@ md_apply_fix3 (fixP, val, seg)
        md_number_to_chars (buf, value, 1);
 #ifdef OBJ_ELF
       else if (!target_oabi)
-        {
-          value = fixP->fx_offset;
-          md_number_to_chars (buf, value, 1);
-        }
+       {
+         value = fixP->fx_offset;
+         md_number_to_chars (buf, value, 1);
+       }
 #endif
       break;
 
@@ -5592,18 +5971,18 @@ md_apply_fix3 (fixP, val, seg)
        md_number_to_chars (buf, value, 2);
 #ifdef OBJ_ELF
       else if (!target_oabi)
-        {
-          value = fixP->fx_offset;
-          md_number_to_chars (buf, value, 2);
-        }
+       {
+         value = fixP->fx_offset;
+         md_number_to_chars (buf, value, 2);
+       }
 #endif
       break;
 
 #ifdef OBJ_ELF
     case BFD_RELOC_ARM_GOT32:
     case BFD_RELOC_ARM_GOTOFF:
-       md_number_to_chars (buf, 0, 4);
-       break;
+      md_number_to_chars (buf, 0, 4);
+      break;
 #endif
 
     case BFD_RELOC_RVA:
@@ -5612,23 +5991,23 @@ md_apply_fix3 (fixP, val, seg)
        md_number_to_chars (buf, value, 4);
 #ifdef OBJ_ELF
       else if (!target_oabi)
-        {
-          value = fixP->fx_offset;
-          md_number_to_chars (buf, value, 4);
-        }
+       {
+         value = fixP->fx_offset;
+         md_number_to_chars (buf, value, 4);
+       }
 #endif
       break;
 
 #ifdef OBJ_ELF
     case BFD_RELOC_ARM_PLT32:
-      /* It appears the instruction is fully prepared at this point. */
+      /* It appears the instruction is fully prepared at this point.  */
       break;
 #endif
 
     case BFD_RELOC_ARM_GOTPC:
       md_number_to_chars (buf, value, 4);
       break;
-      
+
     case BFD_RELOC_ARM_CP_OFF_IMM:
       sign = value >= 0;
       if (value < -1023 || value > 1023 || (value & 3))
@@ -5637,17 +6016,18 @@ md_apply_fix3 (fixP, val, seg)
       if (value < 0)
        value = -value;
       newval = md_chars_to_number (buf, INSN_SIZE) & 0xff7fff00;
-      newval |= (value >> 2) | (sign ?  INDEX_UP : 0);
-      md_number_to_chars (buf, newval , INSN_SIZE);
+      newval |= (value >> 2) | (sign ? INDEX_UP : 0);
+      md_number_to_chars (buf, newval, INSN_SIZE);
       break;
 
     case BFD_RELOC_ARM_THUMB_OFFSET:
       newval = md_chars_to_number (buf, THUMB_SIZE);
-      /* Exactly what ranges, and where the offset is inserted depends on
-        the type of instruction, we can establish this from the top 4 bits */
+      /* Exactly what ranges, and where the offset is inserted depends
+        on the type of instruction, we can establish this from the
+        top 4 bits.  */
       switch (newval >> 12)
        {
-       case 4: /* PC load */
+       case 4: /* PC load */
          /* Thumb PC loads are somewhat odd, bit 1 of the PC is
             forced to zero for these loads, so we will need to round
             up the offset if the instruction address is not word
@@ -5657,42 +6037,43 @@ md_apply_fix3 (fixP, val, seg)
          if ((fixP->fx_frag->fr_address + fixP->fx_where + value) & 3)
            as_bad_where (fixP->fx_file, fixP->fx_line,
                          _("Invalid offset, target not word aligned (0x%08X)"),
-                          (unsigned int)(fixP->fx_frag->fr_address + fixP->fx_where + value));
+                         (unsigned int) (fixP->fx_frag->fr_address
+                                         + fixP->fx_where + value));
 
          if ((value + 2) & ~0x3fe)
            as_bad_where (fixP->fx_file, fixP->fx_line,
-                         _("Invalid offset"));
+                         _("Invalid offset, value too big (0x%08X)"), value);
 
-          /* Round up, since pc will be rounded down.  */
+         /* Round up, since pc will be rounded down.  */
          newval |= (value + 2) >> 2;
          break;
 
-       case 9: /* SP load/store */
+       case 9: /* SP load/store */
          if (value & ~0x3fc)
            as_bad_where (fixP->fx_file, fixP->fx_line,
-                         _("Invalid offset"));
+                         _("Invalid offset, value too big (0x%08X)"), value);
          newval |= value >> 2;
          break;
 
-       case 6: /* Word load/store */
+       case 6: /* Word load/store */
          if (value & ~0x7c)
            as_bad_where (fixP->fx_file, fixP->fx_line,
-                         _("Invalid offset"));
-         newval |= value << 4; /* 6 - 2 */
+                         _("Invalid offset, value too big (0x%08X)"), value);
+         newval |= value << 4; /* 6 - 2 */
          break;
 
-       case 7: /* Byte load/store */
+       case 7: /* Byte load/store */
          if (value & ~0x1f)
            as_bad_where (fixP->fx_file, fixP->fx_line,
-                         _("Invalid offset"));
+                         _("Invalid offset, value too big (0x%08X)"), value);
          newval |= value << 6;
          break;
 
-       case 8: /* Halfword load/store */
+       case 8: /* Halfword load/store */
          if (value & ~0x3e)
            as_bad_where (fixP->fx_file, fixP->fx_line,
-                         _("Invalid offset"));
-         newval |= value << 5; /* 6 - 1 */
+                         _("Invalid offset, value too big (0x%08X)"), value);
+         newval |= value << 5; /* 6 - 1 */
          break;
 
        default:
@@ -5707,89 +6088,91 @@ md_apply_fix3 (fixP, val, seg)
     case BFD_RELOC_ARM_THUMB_ADD:
       /* This is a complicated relocation, since we use it for all of
          the following immediate relocations:
-            3bit ADD/SUB
-            8bit ADD/SUB
-            9bit ADD/SUB SP word-aligned
-           10bit ADD PC/SP word-aligned
+
+           3bit ADD/SUB
+           8bit ADD/SUB
+           9bit ADD/SUB SP word-aligned
+          10bit ADD PC/SP word-aligned
 
          The type of instruction being processed is encoded in the
          instruction field:
-           0x8000  SUB
-           0x00F0  Rd
-           0x000F  Rs
+
+          0x8000  SUB
+          0x00F0  Rd
+          0x000F  Rs
       */
       newval = md_chars_to_number (buf, THUMB_SIZE);
       {
-        int rd = (newval >> 4) & 0xf;
-        int rs = newval & 0xf;
-        int subtract = newval & 0x8000;
-
-        if (rd == REG_SP)
-          {
-            if (value & ~0x1fc)
-              as_bad_where (fixP->fx_file, fixP->fx_line,
-                            _("Invalid immediate for stack address calculation"));
-            newval = subtract ? T_OPCODE_SUB_ST : T_OPCODE_ADD_ST;
-            newval |= value >> 2;
-          }
-        else if (rs == REG_PC || rs == REG_SP)
-          {
-            if (subtract ||
-                value & ~0x3fc)
-              as_bad_where (fixP->fx_file, fixP->fx_line,
-                            _("Invalid immediate for address calculation (value = 0x%08lX)"),
+       int rd = (newval >> 4) & 0xf;
+       int rs = newval & 0xf;
+       int subtract = newval & 0x8000;
+
+       if (rd == REG_SP)
+         {
+           if (value & ~0x1fc)
+             as_bad_where (fixP->fx_file, fixP->fx_line,
+                           _("Invalid immediate for stack address calculation"));
+           newval = subtract ? T_OPCODE_SUB_ST : T_OPCODE_ADD_ST;
+           newval |= value >> 2;
+         }
+       else if (rs == REG_PC || rs == REG_SP)
+         {
+           if (subtract ||
+               value & ~0x3fc)
+             as_bad_where (fixP->fx_file, fixP->fx_line,
+                           _("Invalid immediate for address calculation (value = 0x%08lX)"),
                            (unsigned long) value);
-            newval = (rs == REG_PC ? T_OPCODE_ADD_PC : T_OPCODE_ADD_SP);
-            newval |= rd << 8;
-            newval |= value >> 2;
-          }
-        else if (rs == rd)
-          {
-            if (value & ~0xff)
-              as_bad_where (fixP->fx_file, fixP->fx_line,
-                            _("Invalid 8bit immediate"));
-            newval = subtract ? T_OPCODE_SUB_I8 : T_OPCODE_ADD_I8;
-            newval |= (rd << 8) | value;
-          }
-        else
-          {
-            if (value & ~0x7)
-              as_bad_where (fixP->fx_file, fixP->fx_line,
-                            _("Invalid 3bit immediate"));
-            newval = subtract ? T_OPCODE_SUB_I3 : T_OPCODE_ADD_I3;
-            newval |= rd | (rs << 3) | (value << 6);
-          }
+           newval = (rs == REG_PC ? T_OPCODE_ADD_PC : T_OPCODE_ADD_SP);
+           newval |= rd << 8;
+           newval |= value >> 2;
+         }
+       else if (rs == rd)
+         {
+           if (value & ~0xff)
+             as_bad_where (fixP->fx_file, fixP->fx_line,
+                           _("Invalid 8bit immediate"));
+           newval = subtract ? T_OPCODE_SUB_I8 : T_OPCODE_ADD_I8;
+           newval |= (rd << 8) | value;
+         }
+       else
+         {
+           if (value & ~0x7)
+             as_bad_where (fixP->fx_file, fixP->fx_line,
+                           _("Invalid 3bit immediate"));
+           newval = subtract ? T_OPCODE_SUB_I3 : T_OPCODE_ADD_I3;
+           newval |= rd | (rs << 3) | (value << 6);
+         }
       }
-      md_number_to_chars (buf, newval , THUMB_SIZE);
+      md_number_to_chars (buf, newval, THUMB_SIZE);
       break;
 
     case BFD_RELOC_ARM_THUMB_IMM:
       newval = md_chars_to_number (buf, THUMB_SIZE);
       switch (newval >> 11)
-        {
-        case 0x04: /* 8bit immediate MOV */
-        case 0x05: /* 8bit immediate CMP */
-          if (value < 0 || value > 255)
-            as_bad_where (fixP->fx_file, fixP->fx_line,
-                          _("Invalid immediate: %ld is too large"),
+       {
+       case 0x04: /* 8bit immediate MOV.  */
+       case 0x05: /* 8bit immediate CMP.  */
+         if (value < 0 || value > 255)
+           as_bad_where (fixP->fx_file, fixP->fx_line,
+                         _("Invalid immediate: %ld is too large"),
                          (long) value);
-          newval |= value;
-          break;
+         newval |= value;
+         break;
 
-        default:
-          abort ();
-        }
-      md_number_to_chars (buf, newval , THUMB_SIZE);
+       default:
+         abort ();
+       }
+      md_number_to_chars (buf, newval, THUMB_SIZE);
       break;
 
     case BFD_RELOC_ARM_THUMB_SHIFT:
-      /* 5bit shift value (0..31) */
+      /* 5bit shift value (0..31) */
       if (value < 0 || value > 31)
        as_bad_where (fixP->fx_file, fixP->fx_line,
                      _("Illegal Thumb shift value: %ld"), (long) value);
       newval = md_chars_to_number (buf, THUMB_SIZE) & 0xf03f;
       newval |= value << 6;
-      md_number_to_chars (buf, newval , THUMB_SIZE);
+      md_number_to_chars (buf, newval, THUMB_SIZE);
       break;
 
     case BFD_RELOC_VTABLE_INHERIT:
@@ -5808,9 +6191,10 @@ md_apply_fix3 (fixP, val, seg)
 
 /* Translate internal representation of relocation info to BFD target
    format.  */
+
 arelent *
 tc_gen_reloc (section, fixp)
-     asection * section;
+     asection * section ATTRIBUTE_UNUSED;
      fixS * fixp;
 {
   arelent * reloc;
@@ -5856,10 +6240,12 @@ tc_gen_reloc (section, fixp)
        }
 
     case BFD_RELOC_ARM_PCREL_BRANCH:
-    case BFD_RELOC_RVA:      
+    case BFD_RELOC_ARM_PCREL_BLX:
+    case BFD_RELOC_RVA:
     case BFD_RELOC_THUMB_PCREL_BRANCH9:
     case BFD_RELOC_THUMB_PCREL_BRANCH12:
     case BFD_RELOC_THUMB_PCREL_BRANCH23:
+    case BFD_RELOC_THUMB_PCREL_BLX:
     case BFD_RELOC_VTABLE_ENTRY:
     case BFD_RELOC_VTABLE_INHERIT:
       code = fixp->fx_r_type;
@@ -5868,7 +6254,7 @@ tc_gen_reloc (section, fixp)
     case BFD_RELOC_ARM_LITERAL:
     case BFD_RELOC_ARM_HWLITERAL:
       /* If this is called then the a literal has been referenced across
-        a section boundary - possibly due to an implicit dump */
+        a section boundary - possibly due to an implicit dump */
       as_bad_where (fixp->fx_file, fixp->fx_line,
                    _("Literal referenced across section boundary (Implicit dump?)"));
       return NULL;
@@ -5877,8 +6263,8 @@ tc_gen_reloc (section, fixp)
     case BFD_RELOC_ARM_GOT32:
     case BFD_RELOC_ARM_GOTOFF:
     case BFD_RELOC_ARM_PLT32:
-       code = fixp->fx_r_type;
-    break;
+      code = fixp->fx_r_type;
+      break;
 #endif
 
     case BFD_RELOC_ARM_IMMEDIATE:
@@ -5902,6 +6288,7 @@ tc_gen_reloc (section, fixp)
     default:
       {
        char * type;
+
        switch (fixp->fx_r_type)
          {
          case BFD_RELOC_ARM_IMMEDIATE:    type = "IMMEDIATE";    break;
@@ -5925,15 +6312,15 @@ tc_gen_reloc (section, fixp)
     }
 
 #ifdef OBJ_ELF
- if (code == BFD_RELOC_32_PCREL
-     && GOT_symbol
-     && fixp->fx_addsy == GOT_symbol)
-   {
-     code = BFD_RELOC_ARM_GOTPC;
-     reloc->addend = fixp->fx_offset = reloc->address;
-   }
 if (code == BFD_RELOC_32_PCREL
+      && GOT_symbol
+      && fixp->fx_addsy == GOT_symbol)
+    {
+      code = BFD_RELOC_ARM_GOTPC;
+      reloc->addend = fixp->fx_offset = reloc->address;
+    }
 #endif
-   
+
   reloc->howto = bfd_reloc_type_lookup (stdoutput, code);
 
   if (reloc->howto == NULL)
@@ -5944,18 +6331,18 @@ tc_gen_reloc (section, fixp)
       return NULL;
     }
 
-   /* HACK: Since arm ELF uses Rel instead of Rela, encode the
-      vtable entry to be used in the relocation's section offset.  */
-   if (fixp->fx_r_type == BFD_RELOC_VTABLE_ENTRY)
-     reloc->address = fixp->fx_offset;
+  /* HACK: Since arm ELF uses Rel instead of Rela, encode the
+     vtable entry to be used in the relocation's section offset.  */
+  if (fixp->fx_r_type == BFD_RELOC_VTABLE_ENTRY)
+    reloc->address = fixp->fx_offset;
 
   return reloc;
 }
 
 int
 md_estimate_size_before_relax (fragP, segtype)
-     fragS * fragP;
-     segT    segtype;
+     fragS * fragP ATTRIBUTE_UNUSED;
+     segT    segtype ATTRIBUTE_UNUSED;
 {
   as_fatal (_("md_estimate_size_before_relax\n"));
   return 1;
@@ -5965,7 +6352,7 @@ static void
 output_inst PARAMS ((void))
 {
   char * to = NULL;
-    
+
   if (inst.error)
     {
       as_bad (inst.error);
@@ -5973,7 +6360,7 @@ output_inst PARAMS ((void))
     }
 
   to = frag_more (inst.size);
-  
+
   if (thumb_mode && (inst.size > THUMB_SIZE))
     {
       assert (inst.size == (2 * THUMB_SIZE));
@@ -6007,9 +6394,11 @@ md_assemble (str)
   char * start;
 
   /* Align the instruction.
-     This may not be the right thing to do but ... */
-  /* arm_align (2, 0); */
-  listing_prev_line (); /* Defined in listing.h */
+     This may not be the right thing to do but ...  */
+#if 0
+  arm_align (2, 0);
+#endif
+  listing_prev_line (); /* Defined in listing.h.  */
 
   /* Align the previous label if needed.  */
   if (last_label_seen != NULL)
@@ -6023,13 +6412,13 @@ md_assemble (str)
   inst.reloc.type = BFD_RELOC_NONE;
 
   skip_whitespace (str);
-  
+
   /* Scan up to the end of the op-code, which must end in white space or
      end of string.  */
   for (start = p = str; *p != '\0'; p++)
     if (*p == ' ')
       break;
-    
+
   if (p == str)
     {
       as_bad (_("No operator -- statement `%s'\n"), str);
@@ -6044,12 +6433,19 @@ md_assemble (str)
       *p = '\0';
       opcode = (CONST struct thumb_opcode *) hash_find (arm_tops_hsh, str);
       *p = c;
-      
+
       if (opcode)
        {
+         /* Check that this instruction is supported for this CPU.  */
+         if (thumb_mode == 1 && (opcode->variants & cpu_variant) == 0)
+           {
+             as_bad (_("selected processor does not support this opcode"));
+             return;
+           }
+
          inst.instruction = opcode->value;
          inst.size = opcode->size;
-         (*opcode->parms)(p);
+         (*opcode->parms) (p);
          output_inst ();
          return;
        }
@@ -6057,20 +6453,23 @@ md_assemble (str)
   else
     {
       CONST struct asm_opcode * opcode;
+      unsigned long cond_code;
 
       inst.size = INSN_SIZE;
-      /* p now points to the end of the opcode, probably white space, but we
+      /* P now points to the end of the opcode, probably white space, but we
         have to break the opcode up in case it contains condionals and flags;
         keep trying with progressively smaller basic instructions until one
         matches, or we run out of opcode.  */
       q = (p - str > LONGEST_INST) ? str + LONGEST_INST : p;
+
       for (; q != str; q--)
        {
          c = *q;
          *q = '\0';
+
          opcode = (CONST struct asm_opcode *) hash_find (arm_ops_hsh, str);
          *q = c;
-         
+
          if (opcode && opcode->template)
            {
              unsigned long flag_bits = 0;
@@ -6083,19 +6482,27 @@ md_assemble (str)
              inst.instruction = opcode->value;
              if (q == p)               /* Just a simple opcode.  */
                {
-                 if (opcode->comp_suffix != 0)
-                   as_bad (_("Opcode `%s' must have suffix from <%s>\n"), str,
-                           opcode->comp_suffix);
+                 if (opcode->comp_suffix)
+                   {
+                     if (*opcode->comp_suffix != '\0')
+                       as_bad (_("Opcode `%s' must have suffix from list: <%s>"),
+                               str, opcode->comp_suffix);
+                     else
+                       /* Not a conditional instruction.  */
+                       (*opcode->parms) (q, 0);
+                   }
                  else
                    {
+                     /* A conditional instruction with default condition.  */
                      inst.instruction |= COND_ALWAYS;
-                     (*opcode->parms)(q, 0);
+                     (*opcode->parms) (q, 0);
                    }
                  output_inst ();
                  return;
                }
 
-             /* Now check for a conditional.  */
+             /* Not just a simple opcode.  Check if extra is a
+                 conditional.  */
              r = q;
              if (p - r >= 2)
                {
@@ -6111,18 +6518,32 @@ md_assemble (str)
                        as_tsktsk (
 _("Warning: Use of the 'nv' conditional is deprecated\n"));
 
-                     inst.instruction |= cond->value;
+                     cond_code = cond->value;
                      r += 2;
                    }
                  else
-                   inst.instruction |= COND_ALWAYS;
+                   cond_code = COND_ALWAYS;
                }
              else
-               inst.instruction |= COND_ALWAYS;
+               cond_code = COND_ALWAYS;
 
-             /* If there is a compulsory suffix, it should come here, before
-                any optional flags.  */
-             if (opcode->comp_suffix)
+             /* Apply the conditional, or complain it's not allowed.  */
+             if (opcode->comp_suffix && *opcode->comp_suffix == '\0')
+               {
+                 /* Instruction isn't conditional.  */
+                 if (cond_code != COND_ALWAYS)
+                   {
+                     as_bad (_("Opcode `%s' is unconditional\n"), str);
+                     return;
+                   }
+               }
+             else
+               /* Instruction is conditional: set the condition into it.  */
+               inst.instruction |= cond_code;
+
+             /* If there is a compulsory suffix, it should come here
+                before any optional flags.  */
+             if (opcode->comp_suffix && *opcode->comp_suffix != '\0')
                {
                  CONST char *s = opcode->comp_suffix;
 
@@ -6136,8 +6557,8 @@ _("Warning: Use of the 'nv' conditional is deprecated\n"));
 
                  if (*s == '\0')
                    {
-                     as_bad (_("Opcode `%s' must have suffix from <%s>\n"), str,
-                             opcode->comp_suffix);
+                     as_bad (_("Opcode `%s' must have suffix from <%s>\n"),
+                             str, opcode->comp_suffix);
                      return;
                    }
 
@@ -6186,26 +6607,26 @@ _("Warning: Use of the 'nv' conditional is deprecated\n"));
     }
 
   /* It wasn't an instruction, but it might be a register alias of the form
-     alias .req reg */
+     alias .req reg */
   q = p;
   skip_whitespace (q);
 
   c = *p;
   *p = '\0';
-    
+
   if (*q && !strncmp (q, ".req ", 4))
     {
       int    reg;
       char * copy_of_str = str;
       char * r;
-      
+
       q += 4;
       skip_whitespace (q);
 
       for (r = q; *r != '\0'; r++)
        if (*r == ' ')
          break;
-      
+
       if (r != q)
        {
          int regnum;
@@ -6216,19 +6637,20 @@ _("Warning: Use of the 'nv' conditional is deprecated\n"));
          *r = d;
 
          reg = arm_reg_parse (& str);
-         
+
          if (reg == FAIL)
            {
              if (regnum != FAIL)
                insert_reg_alias (str, regnum);
              else
-               as_warn (_("register '%s' does not exist"), q);
+               as_warn (_("register '%s' does not exist\n"), q);
            }
          else if (regnum != FAIL)
            {
              if (reg != regnum)
-               as_warn (_("ignoring redefinition of register alias '%s'"), copy_of_str );
-             
+               as_warn (_("ignoring redefinition of register alias '%s'"),
+                        copy_of_str);
+
              /* Do not warn about redefinitions to the same alias.  */
            }
          else
@@ -6237,7 +6659,7 @@ _("Warning: Use of the 'nv' conditional is deprecated\n"));
        }
       else
        as_warn (_("ignoring incomplete .req pseuso op"));
-      
+
       *p = c;
       return;
     }
@@ -6246,38 +6668,37 @@ _("Warning: Use of the 'nv' conditional is deprecated\n"));
   as_bad (_("bad instruction `%s'"), start);
 }
 
-/*
- * md_parse_option
- *    Invocation line includes a switch not recognized by the base assembler.
- *    See if it's a processor-specific option.  These are:
- *    Cpu variants, the arm part is optional:
- *            -m[arm]1                Currently not supported.
- *            -m[arm]2, -m[arm]250    Arm 2 and Arm 250 processor
- *            -m[arm]3                Arm 3 processor
- *            -m[arm]6[xx],           Arm 6 processors
- *            -m[arm]7[xx][t][[d]m]   Arm 7 processors
- *            -m[arm]8[10]            Arm 8 processors
- *            -m[arm]9[20][tdmi]      Arm 9 processors
- *            -mstrongarm[110[0]]     StrongARM processors
- *            -m[arm]v[2345]         Arm architecures
- *            -mall                   All (except the ARM1)
- *    FP variants:
- *            -mfpa10, -mfpa11        FPA10 and 11 co-processor instructions
- *            -mfpe-old               (No float load/store multiples)
- *            -mno-fpu                Disable all floating point instructions
- *    Run-time endian selection:
- *            -EB                     big endian cpu
- *            -EL                     little endian cpu
- *    ARM Procedure Calling Standard:
- *           -mapcs-32               32 bit APCS
- *           -mapcs-26               26 bit APCS
- *           -mapcs-float            Pass floats in float regs
- *           -mapcs-reentrant        Position independent code
- *            -mthumb-interwork       Code supports Arm/Thumb interworking
- *            -moabi                  Old ELF ABI
- */
+/* md_parse_option
+      Invocation line includes a switch not recognized by the base assembler.
+      See if it's a processor-specific option.  These are:
+      Cpu variants, the arm part is optional:
+              -m[arm]1                Currently not supported.
+              -m[arm]2, -m[arm]250    Arm 2 and Arm 250 processor
+              -m[arm]3                Arm 3 processor
+              -m[arm]6[xx],           Arm 6 processors
+              -m[arm]7[xx][t][[d]m]   Arm 7 processors
+              -m[arm]8[10]            Arm 8 processors
+              -m[arm]9[20][tdmi]      Arm 9 processors
+              -mstrongarm[110[0]]     StrongARM processors
+              -m[arm]v[2345[t]]       Arm architectures
+              -mall                   All (except the ARM1)
+      FP variants:
+              -mfpa10, -mfpa11        FPA10 and 11 co-processor instructions
+              -mfpe-old               (No float load/store multiples)
+              -mno-fpu                Disable all floating point instructions
+      Run-time endian selection:
+              -EB                     big endian cpu
+              -EL                     little endian cpu
+      ARM Procedure Calling Standard:
+             -mapcs-32               32 bit APCS
+             -mapcs-26               26 bit APCS
+             -mapcs-float            Pass floats in float regs
+             -mapcs-reentrant        Position independent code
+              -mthumb-interwork       Code supports Arm/Thumb interworking
+              -moabi                  Old ELF ABI  */
 
 CONST char * md_shortopts = "m:k";
+
 struct option md_longopts[] =
 {
 #ifdef ARM_BI_ENDIAN
@@ -6292,6 +6713,7 @@ struct option md_longopts[] =
 #endif
   {NULL, no_argument, NULL, 0}
 };
+
 size_t md_longopts_size = sizeof (md_longopts);
 
 int
@@ -6332,30 +6754,31 @@ md_parse_option (c, arg)
          break;
 
 #ifdef OBJ_ELF
-        case 'o':
-          if (streq (str, "oabi"))
-            target_oabi = true;
-          break;
+       case 'o':
+         if (streq (str, "oabi"))
+           target_oabi = true;
+         break;
 #endif
-         
-        case 't':
-          /* Limit assembler to generating only Thumb instructions: */
-          if (streq (str, "thumb"))
-            {
-              cpu_variant = (cpu_variant & ~ARM_ANY) | ARM_THUMB;
-              cpu_variant = (cpu_variant & ~FPU_ALL) | FPU_NONE;
-              thumb_mode = 1;
-            }
-          else if (streq (str, "thumb-interwork"))
-            {
-              cpu_variant = (cpu_variant & ~ARM_ANY) | ARM_THUMB | ARM_ARCH_V4;
+
+       case 't':
+         /* Limit assembler to generating only Thumb instructions:  */
+         if (streq (str, "thumb"))
+           {
+             cpu_variant = (cpu_variant & ~ARM_ANY) | ARM_THUMB;
+             cpu_variant = (cpu_variant & ~FPU_ALL) | FPU_NONE;
+             thumb_mode = 1;
+           }
+         else if (streq (str, "thumb-interwork"))
+           {
+             if ((cpu_variant & ARM_THUMB) == 0)
+               cpu_variant = (cpu_variant & ~ARM_ANY) | ARM_ARCH_V4T;
 #if defined OBJ_COFF || defined OBJ_ELF
-              support_interwork = true;
+             support_interwork = true;
 #endif
-            }
-          else
+           }
+         else
            goto bad;
-          break;
+         break;
 
        default:
          if (streq (str, "all"))
@@ -6370,7 +6793,7 @@ md_parse_option (c, arg)
                 to us, so we must parse them here.  */
 
              str += 5;
-             
+
              if (streq (str, "32"))
                {
                  uses_apcs_26 = false;
@@ -6410,16 +6833,16 @@ md_parse_option (c, arg)
                {
                  /* Reentrant code has been generated.  This does affect
                     linking, since there is no point in linking reentrant/
-                    position independent code with absolute position code. */
+                    position independent code with absolute position code.  */
                  pic_code = true;
                  return 1;
                }
-             
+
              as_bad (_("Unrecognised APCS switch -m%s"), arg);
              return 0;
-           }
+           }
 #endif
-         /* Strip off optional "arm" */
+         /* Strip off optional "arm" */
          if (! strncmp (str, "arm", 3))
            str += 3;
 
@@ -6464,130 +6887,150 @@ md_parse_option (c, arg)
              break;
 
            case '7':
-             switch (strtol (str, & str, 10))  /* Eat the processor name */
+             /* Eat the processor name.  */
+             switch (strtol (str, & str, 10))
                {
                case 7:
                case 70:
                case 700:
                case 710:
+               case 720:
                case 7100:
                case 7500:
                  break;
                default:
                  goto bad;
                }
-              cpu_variant = (cpu_variant & ~ARM_ANY) | ARM_7;
-              for (; *str; str++)
-                {
-                switch (* str)
-                  {
-                  case 't':
-                    cpu_variant |= (ARM_THUMB | ARM_ARCH_V4);
-                    break;
-
-                  case 'm':
-                    cpu_variant |= ARM_LONGMUL;
-                    break;
-
-                 case 'f': /* fe => fp enabled cpu.  */
-                   if (str[1] == 'e')
-                     ++ str;
-                   else
+             cpu_variant = (cpu_variant & ~ARM_ANY) | ARM_7;
+             for (; *str; str++)
+               {
+                 switch (*str)
+                   {
+                   case 't':
+                     cpu_variant |= (ARM_THUMB | ARM_ARCH_V4);
+                     break;
+
+                   case 'm':
+                     cpu_variant |= ARM_LONGMUL;
+                     break;
+
+                   case 'f': /* fe => fp enabled cpu.  */
+                     if (str[1] == 'e')
+                       ++ str;
+                     else
+                       goto bad;
+
+                   case 'c': /* Left over from 710c processor name.  */
+                   case 'd': /* Debug.  */
+                   case 'i': /* Embedded ICE.  */
+                     /* Included for completeness in ARM processor naming.  */
+                     break;
+
+                   default:
                      goto bad;
-                   
-                 case 'c': /* Left over from 710c processor name.  */
-                  case 'd': /* Debug */
-                  case 'i': /* Embedded ICE */
-                    /* Included for completeness in ARM processor naming. */
-                    break;
-
-                  default:
-                    goto bad;
-                  }
-                }
+                   }
+               }
              break;
 
            case '8':
              if (streq (str, "8") || streq (str, "810"))
-               cpu_variant = (cpu_variant & ~ARM_ANY) | ARM_8 | ARM_ARCH_V4 | ARM_LONGMUL;
+               cpu_variant = (cpu_variant & ~ARM_ANY)
+                 | ARM_8 | ARM_ARCH_V4 | ARM_LONGMUL;
              else
                goto bad;
              break;
-             
+
            case '9':
              if (streq (str, "9"))
-               cpu_variant = (cpu_variant & ~ARM_ANY) | ARM_9 | ARM_ARCH_V4 | ARM_LONGMUL | ARM_THUMB;
+               cpu_variant = (cpu_variant & ~ARM_ANY)
+                 | ARM_9 | ARM_ARCH_V4 | ARM_LONGMUL | ARM_THUMB;
              else if (streq (str, "920"))
-               cpu_variant = (cpu_variant & ~ARM_ANY) | ARM_9 | ARM_ARCH_V4 | ARM_LONGMUL;
+               cpu_variant = (cpu_variant & ~ARM_ANY)
+                 | ARM_9 | ARM_ARCH_V4 | ARM_LONGMUL;
              else if (streq (str, "920t"))
-               cpu_variant = (cpu_variant & ~ARM_ANY) | ARM_9 | ARM_ARCH_V4 | ARM_LONGMUL | ARM_THUMB;
+               cpu_variant = (cpu_variant & ~ARM_ANY)
+                 | ARM_9 | ARM_ARCH_V4 | ARM_LONGMUL | ARM_THUMB;
              else if (streq (str, "9tdmi"))
-               cpu_variant = (cpu_variant & ~ARM_ANY) | ARM_9 | ARM_ARCH_V4 | ARM_LONGMUL | ARM_THUMB;
+               cpu_variant = (cpu_variant & ~ARM_ANY)
+                 | ARM_9 | ARM_ARCH_V4 | ARM_LONGMUL | ARM_THUMB;
              else
                goto bad;
              break;
-             
+
            case 's':
              if (streq (str, "strongarm")
                  || streq (str, "strongarm110")
                  || streq (str, "strongarm1100"))
-               cpu_variant = (cpu_variant & ~ARM_ANY) | ARM_8 | ARM_ARCH_V4 | ARM_LONGMUL;
+               cpu_variant = (cpu_variant & ~ARM_ANY)
+                 | ARM_8 | ARM_ARCH_V4 | ARM_LONGMUL;
              else
                goto bad;
              break;
-               
+
            case 'v':
-             /* Select variant based on architecture rather than processor */
+             /* Select variant based on architecture rather than
+                 processor.  */
              switch (*++str)
                {
                case '2':
                  switch (*++str)
                    {
-                   case 'a': cpu_variant = (cpu_variant & ~ARM_ANY) | ARM_3; break;
-                   case 0:   cpu_variant = (cpu_variant & ~ARM_ANY) | ARM_2; break;
-                   default:  as_bad (_("Invalid architecture variant -m%s"), arg); break;
+                   case 'a':
+                     cpu_variant = (cpu_variant & ~ARM_ANY) | ARM_3;
+                     break;
+                   case 0:
+                     cpu_variant = (cpu_variant & ~ARM_ANY) | ARM_2;
+                     break;
+                   default:
+                     as_bad (_("Invalid architecture variant -m%s"), arg);
+                     break;
                    }
                  break;
-                 
+
                case '3':
-                   cpu_variant = (cpu_variant & ~ARM_ANY) | ARM_7;
-                    
+                 cpu_variant = (cpu_variant & ~ARM_ANY) | ARM_7;
+
                  switch (*++str)
                    {
                    case 'm': cpu_variant |= ARM_LONGMUL; break;
                    case 0:   break;
-                   default:  as_bad (_("Invalid architecture variant -m%s"), arg); break;
+                   default:
+                     as_bad (_("Invalid architecture variant -m%s"), arg);
+                     break;
                    }
                  break;
-                 
+
                case '4':
                  cpu_variant = (cpu_variant & ~ARM_ANY) | ARM_ARCH_V4;
-                 
+
                  switch (*++str)
                    {
                    case 't': cpu_variant |= ARM_THUMB; break;
                    case 0:   break;
-                   default:  as_bad (_("Invalid architecture variant -m%s"), arg); break;
+                   default:
+                     as_bad (_("Invalid architecture variant -m%s"), arg);
+                     break;
                    }
                  break;
-                 
+
                case '5':
                  cpu_variant = (cpu_variant & ~ARM_ANY) | ARM_ARCH_V5;
-                 
                  switch (*++str)
                    {
                    case 't': cpu_variant |= ARM_THUMB; break;
                    case 0:   break;
-                   default:  as_bad (_("Invalid architecture variant -m%s"), arg); break;
+                   default:
+                     as_bad (_("Invalid architecture variant -m%s"), arg);
+                     break;
                    }
                  break;
-                 
+
                default:
                  as_bad (_("Invalid architecture variant -m%s"), arg);
                  break;
                }
              break;
-             
+
            default:
            bad:
              as_bad (_("Invalid processor variant -m%s"), arg);
@@ -6596,54 +7039,46 @@ md_parse_option (c, arg)
        }
       break;
 
+#if defined OBJ_ELF || defined OBJ_COFF
     case 'k':
       pic_code = 1;
       break;
-      
+#endif
+
     default:
       return 0;
     }
 
-   return 1;
+  return 1;
 }
 
 void
 md_show_usage (fp)
      FILE * fp;
 {
-  fprintf (fp,
-_("\
+  fprintf (fp, _("\
  ARM Specific Assembler Options:\n\
   -m[arm][<processor name>] select processor variant\n\
-  -m[arm]v[2|2a|3|3m|4|4t|5]select architecture variant\n\
+  -m[arm]v[2|2a|3|3m|4|4t|5[t][e]] select architecture variant\n\
   -mthumb                   only allow Thumb instructions\n\
   -mthumb-interwork         mark the assembled code as supporting interworking\n\
   -mall                     allow any instruction\n\
   -mfpa10, -mfpa11          select floating point architecture\n\
   -mfpe-old                 don't allow floating-point multiple instructions\n\
-  -mno-fpu                  don't allow any floating-point instructions.\n"));
-  fprintf (fp,
-_("\
+  -mno-fpu                  don't allow any floating-point instructions.\n\
   -k                        generate PIC code.\n"));
 #if defined OBJ_COFF || defined OBJ_ELF
-  fprintf (fp,
-_("\
-  -mapcs-32, -mapcs-26      specify which ARM Procedure Calling Standard to use\n"));
-  fprintf (fp,
-_("\
-  -mapcs-float              floating point args are passed in FP regs\n"));
-  fprintf (fp,
-_("\
+  fprintf (fp, _("\
+  -mapcs-32, -mapcs-26      specify which ARM Procedure Calling Standard to use\n\
+  -mapcs-float              floating point args are passed in FP regs\n\
   -mapcs-reentrant          the code is position independent/reentrant\n"));
-  #endif
+#endif
 #ifdef OBJ_ELF
-  fprintf (fp,
-_("\
+  fprintf (fp, _("\
   -moabi                    support the old ELF ABI\n"));
 #endif
 #ifdef ARM_BI_ENDIAN
-  fprintf (fp,
-_("\
+  fprintf (fp, _("\
   -EB                       assemble code for a big endian cpu\n\
   -EL                       assemble code for a little endian cpu\n"));
 #endif
@@ -6665,8 +7100,8 @@ fix_new_arm (frag, where, size, exp, pc_rel, reloc)
      int           pc_rel;
      int           reloc;
 {
-  fixS *         new_fix;
-  arm_fix_data * arm_data;
+  fixS *           new_fix;
+  arm_fix_data *   arm_data;
 
   switch (exp->X_op)
     {
@@ -6683,7 +7118,8 @@ fix_new_arm (frag, where, size, exp, pc_rel, reloc)
       break;
     }
 
-  /* Mark whether the fix is to a THUMB instruction, or an ARM instruction */
+  /* Mark whether the fix is to a THUMB instruction, or an ARM
+     instruction.  */
   arm_data = (arm_fix_data *) obstack_alloc (& notes, sizeof (arm_fix_data));
   new_fix->tc_fix_data = (PTR) arm_data;
   arm_data->thumb_mode = thumb_mode;
@@ -6691,8 +7127,8 @@ fix_new_arm (frag, where, size, exp, pc_rel, reloc)
   return;
 }
 
-
 /* This fix_new is called by cons via TC_CONS_FIX_NEW.  */
+
 void
 cons_fix_new_arm (frag, where, size, exp)
      fragS *       frag;
@@ -6702,13 +7138,14 @@ cons_fix_new_arm (frag, where, size, exp)
 {
   bfd_reloc_code_real_type type;
   int pcrel = 0;
-  
-  /* Pick a reloc ...
-   *
-   * @@ Should look at CPU word size.
-   */
-  switch (size) 
+
+  /* Pick a reloc.
+     FIXME: @@ Should look at CPU word size.  */
+  switch (size)
     {
+    case 1:
+      type = BFD_RELOC_8;
+      break;
     case 2:
       type = BFD_RELOC_16;
       break;
@@ -6720,20 +7157,22 @@ cons_fix_new_arm (frag, where, size, exp)
       type = BFD_RELOC_64;
       break;
     }
-  
+
   fix_new_exp (frag, where, (int) size, exp, pcrel, type);
 }
 
 /* A good place to do this, although this was probably not intended
    for this kind of use.  We need to dump the literal pool before
    references are made to a null symbol pointer.  */
+
 void
 arm_cleanup ()
 {
   if (current_poolP == NULL)
     return;
-  
-  subseg_set (text_section, 0); /* Put it at the end of text section.  */
+
+  /* Put it at the end of text section.  */
+  subseg_set (text_section, 0);
   s_ltorg (0);
   listing_prev_line ();
 }
@@ -6749,13 +7188,13 @@ arm_frob_label (sym)
      symbolS * sym;
 {
   last_label_seen = sym;
-  
+
   ARM_SET_THUMB (sym, thumb_mode);
-  
+
 #if defined OBJ_COFF || defined OBJ_ELF
   ARM_SET_INTERWORK (sym, support_interwork);
 #endif
-  
+
   if (label_is_thumb_function_name)
     {
       /* When the address of a Thumb function is taken the bottom
@@ -6764,7 +7203,7 @@ arm_frob_label (sym)
         correctly.  */
 
       THUMB_SET_FUNC (sym, 1);
-      
+
       label_is_thumb_function_name = false;
     }
 }
@@ -6781,12 +7220,12 @@ arm_adjust_symtab ()
   for (sym = symbol_rootP; sym != NULL; sym = symbol_next (sym))
     {
       if (ARM_IS_THUMB (sym))
-        {
+       {
          if (THUMB_IS_FUNC (sym))
            {
              /* Mark the symbol as a Thumb function.  */
              if (   S_GET_STORAGE_CLASS (sym) == C_STAT
-                 || S_GET_STORAGE_CLASS (sym) == C_LABEL) /* This can happen! */
+                 || S_GET_STORAGE_CLASS (sym) == C_LABEL)  /* This can happen!  */
                S_SET_STORAGE_CLASS (sym, C_THUMBSTATFUNC);
 
              else if (S_GET_STORAGE_CLASS (sym) == C_EXT)
@@ -6796,42 +7235,49 @@ arm_adjust_symtab ()
                        S_GET_NAME (sym), S_GET_STORAGE_CLASS (sym));
            }
           else switch (S_GET_STORAGE_CLASS (sym))
-            {
-              case C_EXT:
-                S_SET_STORAGE_CLASS (sym, C_THUMBEXT);
-                break;
-              case C_STAT:
-                S_SET_STORAGE_CLASS (sym, C_THUMBSTAT);
-                break;
-              case C_LABEL:
-                S_SET_STORAGE_CLASS (sym, C_THUMBLABEL);
-                break;
-              default: /* do nothing */ 
-                break;
-            }
-        }
+           {
+           case C_EXT:
+             S_SET_STORAGE_CLASS (sym, C_THUMBEXT);
+             break;
+           case C_STAT:
+             S_SET_STORAGE_CLASS (sym, C_THUMBSTAT);
+             break;
+           case C_LABEL:
+             S_SET_STORAGE_CLASS (sym, C_THUMBLABEL);
+             break;
+           default:
+             /* Do nothing.  */
+             break;
+           }
+       }
 
       if (ARM_IS_INTERWORK (sym))
        coffsymbol (symbol_get_bfdsym (sym))->native->u.syment.n_flags = 0xFF;
     }
 #endif
 #ifdef OBJ_ELF
-  symbolS *         sym;
-  elf_symbol_type * elf_sym;
-  char              bind;
+  symbolS *sym;
+  char bind;
 
   for (sym = symbol_rootP; sym != NULL; sym = symbol_next (sym))
     {
       if (ARM_IS_THUMB (sym))
-        {
+       {
+         elf_symbol_type *elf_sym;
+
+         elf_sym = elf_symbol (symbol_get_bfdsym (sym));
+         bind = ELF_ST_BIND (elf_sym);
+
+         /* If it's a .thumb_func, declare it as so,
+            otherwise tag label as .code 16.  */
          if (THUMB_IS_FUNC (sym))
-           {
-             elf_sym = elf_symbol (symbol_get_bfdsym (sym));
-             bind = ELF_ST_BIND (elf_sym);
-             elf_sym->internal_elf_sym.st_info = ELF_ST_INFO (bind, STT_ARM_TFUNC);
-            }
-         }
-     }
+           elf_sym->internal_elf_sym.st_info =
+             ELF_ST_INFO (bind, STT_ARM_TFUNC);
+         else
+           elf_sym->internal_elf_sym.st_info =
+             ELF_ST_INFO (bind, STT_ARM_16BIT);
+       }
+    }
 #endif
 }
 
@@ -6845,13 +7291,13 @@ arm_data_in_code ()
       *input_line_pointer = 0;
       return 1;
     }
-  
+
   return 0;
 }
 
 char *
 arm_canonicalize_symbol_name (name)
-     char * name;
+     char *name;
 {
   int len;
 
@@ -6864,13 +7310,13 @@ arm_canonicalize_symbol_name (name)
 
 boolean
 arm_validate_fix (fixP)
-     fixS * fixP;
+     fixS *fixP;
 {
   /* If the destination of the branch is a defined symbol which does not have
      the THUMB_FUNC attribute, then we must be calling a function which has
      the (interfacearm) attribute.  We look for the Thumb entry point to that
      function and change the branch to refer to that function instead.  */
-  if (   fixP->fx_r_type == BFD_RELOC_THUMB_PCREL_BRANCH23
+  if (fixP->fx_r_type == BFD_RELOC_THUMB_PCREL_BRANCH23
       && fixP->fx_addsy != NULL
       && S_IS_DEFINED (fixP->fx_addsy)
       && ! THUMB_IS_FUNC (fixP->fx_addsy))
@@ -6895,26 +7341,26 @@ arm_validate_fix (fixP)
    than a function) and then later jumping to that address.  Such
    addresses also ought to have their bottom bit set (assuming that
    they reside in Thumb code), but at the moment they will not.  */
-   
+
 boolean
 arm_fix_adjustable (fixP)
-   fixS * fixP;
+   fixS *fixP;
 {
   if (fixP->fx_addsy == NULL)
     return 1;
-  
-  /* Prevent all adjustments to global symbols. */
+
+  /* Prevent all adjustments to global symbols.  */
   if (S_IS_EXTERN (fixP->fx_addsy))
     return 0;
-  
+
   if (S_IS_WEAK (fixP->fx_addsy))
     return 0;
 
   if (THUMB_IS_FUNC (fixP->fx_addsy)
       && fixP->fx_subsy == NULL)
     return 0;
-  
-  /* We need the symbol name for the VTABLE entries */
+
+  /* We need the symbol name for the VTABLE entries */
   if (   fixP->fx_r_type == BFD_RELOC_VTABLE_INHERIT
       || fixP->fx_r_type == BFD_RELOC_VTABLE_ENTRY)
     return 0;
@@ -6926,24 +7372,28 @@ const char *
 elf32_arm_target_format ()
 {
   if (target_big_endian)
-    if (target_oabi)
-      return "elf32-bigarm-oabi";
-    else
-      return "elf32-bigarm";
+    {
+      if (target_oabi)
+       return "elf32-bigarm-oabi";
+      else
+       return "elf32-bigarm";
+    }
   else
-    if (target_oabi)
-      return "elf32-littlearm-oabi";
-    else
-      return "elf32-littlearm";
+    {
+      if (target_oabi)
+       return "elf32-littlearm-oabi";
+      else
+       return "elf32-littlearm";
+    }
 }
 
 void
 armelf_frob_symbol (symp, puntp)
      symbolS * symp;
-     int * puntp;
+     int *     puntp;
 {
   elf_frob_symbol (symp, puntp);
-} 
+}
 
 int
 arm_force_relocation (fixp)
@@ -6952,18 +7402,20 @@ arm_force_relocation (fixp)
   if (   fixp->fx_r_type == BFD_RELOC_VTABLE_INHERIT
       || fixp->fx_r_type == BFD_RELOC_VTABLE_ENTRY
       || fixp->fx_r_type == BFD_RELOC_ARM_PCREL_BRANCH
-      || fixp->fx_r_type == BFD_RELOC_THUMB_PCREL_BRANCH23)    
+      || fixp->fx_r_type == BFD_RELOC_ARM_PCREL_BLX
+      || fixp->fx_r_type == BFD_RELOC_THUMB_PCREL_BLX
+      || fixp->fx_r_type == BFD_RELOC_THUMB_PCREL_BRANCH23)
     return 1;
-  
+
   return 0;
 }
 
 static bfd_reloc_code_real_type
 arm_parse_reloc ()
 {
-  char   id[16];
-  char * ip;
-  int    i;
+  char         id [16];
+  char *       ip;
+  unsigned int i;
   static struct
   {
     char * str;
@@ -6972,28 +7424,27 @@ arm_parse_reloc ()
   }
   reloc_map[] =
   {
-#define MAP(str,reloc) { str, sizeof (str)-1, reloc }
+#define MAP(str,reloc) { str, sizeof (str) - 1, reloc }
     MAP ("(got)",    BFD_RELOC_ARM_GOT32),
     MAP ("(gotoff)", BFD_RELOC_ARM_GOTOFF),
-    /* ScottB: Jan 30, 1998 */
-    /* Added support for parsing "var(PLT)" branch instructions */
-    /* generated by GCC for PLT relocs */
+    /* ScottB: Jan 30, 1998 - Added support for parsing "var(PLT)"
+       branch instructions generated by GCC for PLT relocs.  */
     MAP ("(plt)",    BFD_RELOC_ARM_PLT32),
-    NULL, 0,         BFD_RELOC_UNUSED
-#undef MAP    
+    { NULL, 0,         BFD_RELOC_UNUSED }
+#undef MAP
   };
 
   for (i = 0, ip = input_line_pointer;
        i < sizeof (id) && (isalnum (*ip) || ispunct (*ip));
        i++, ip++)
     id[i] = tolower (*ip);
-  
+
   for (i = 0; reloc_map[i].str; i++)
     if (strncmp (id, reloc_map[i].str, reloc_map[i].len) == 0)
       break;
-  
+
   input_line_pointer += reloc_map[i].len;
-  
+
   return reloc_map[i].reloc;
 }
 
@@ -7020,33 +7471,35 @@ s_arm_elf_cons (nbytes)
   do
     {
       bfd_reloc_code_real_type reloc;
-      
+
       expression (& exp);
 
       if (exp.X_op == O_symbol
-          && * input_line_pointer == '('
-          && (reloc = arm_parse_reloc()) != BFD_RELOC_UNUSED)
-        {
-          reloc_howto_type * howto = bfd_reloc_type_lookup (stdoutput, reloc);
-          int size = bfd_get_reloc_size (howto);
-
-          if (size > nbytes)
-            as_bad ("%s relocations do not fit in %d bytes", howto->name, nbytes);
-          else
-            {
-              register char * p = frag_more ((int) nbytes);
-              int offset = nbytes - size;
-
-              fix_new_exp (frag_now, p - frag_now->fr_literal + offset, size,
-                          & exp, 0, reloc);
-            }
-        }
+         && *input_line_pointer == '('
+         && (reloc = arm_parse_reloc ()) != BFD_RELOC_UNUSED)
+       {
+         reloc_howto_type *howto = bfd_reloc_type_lookup (stdoutput, reloc);
+         int size = bfd_get_reloc_size (howto);
+
+         if (size > nbytes)
+           as_bad ("%s relocations do not fit in %d bytes",
+                   howto->name, nbytes);
+         else
+           {
+             register char *p = frag_more ((int) nbytes);
+             int offset = nbytes - size;
+
+             fix_new_exp (frag_now, p - frag_now->fr_literal + offset, size,
+                          &exp, 0, reloc);
+           }
+       }
       else
-        emit_expr (& exp, (unsigned int) nbytes);
+       emit_expr (&exp, (unsigned int) nbytes);
     }
   while (*input_line_pointer++ == ',');
 
-  input_line_pointer--;                /* Put terminator back into stream. */
+  /* Put terminator back into stream.  */
+  input_line_pointer --;
   demand_empty_rest_of_line ();
 }
 
This page took 0.106926 seconds and 4 git commands to generate.