gas/config/tc-arm.c

   1 /* tc-arm.c -- Assemble for the ARM
   2    Copyright (C) 1994, 95, 96, 97, 98, 1999, 2000
   3    Free Software Foundation, Inc.
   4    Contributed by Richard Earnshaw (rwe@pegasus.esprit.ec.org)
   5         Modified by David Taylor (dtaylor@armltd.co.uk)
   6
   7    This file is part of GAS, the GNU Assembler.
   8
   9    GAS is free software; you can redistribute it and/or modify
  10    it under the terms of the GNU General Public License as published by
  11    the Free Software Foundation; either version 2, or (at your option)
  12    any later version.
  13
  14    GAS is distributed in the hope that it will be useful,
  15    but WITHOUT ANY WARRANTY; without even the implied warranty of
  16    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17    GNU General Public License for more details.
  18
  19    You should have received a copy of the GNU General Public License
  20    along with GAS; see the file COPYING.  If not, write to the Free
  21    Software Foundation, 59 Temple Place - Suite 330, Boston, MA
  22    02111-1307, USA.  */
  23
  24 #include <ctype.h>
  25 #include <string.h>
  26 #define  NO_RELOC 0
  27 #include "as.h"
  28
  29 /* Need TARGET_CPU.  */
  30 #include "config.h"
  31 #include "subsegs.h"
  32 #include "obstack.h"
  33 #include "symbols.h"
  34 #include "listing.h"
  35
  36 #ifdef OBJ_ELF
  37 #include "elf/arm.h"
  38 #endif
  39
  40 /* Types of processor to assemble for.  */
  41 #define ARM_1           0x00000001
  42 #define ARM_2           0x00000002
  43 #define ARM_3           0x00000004
  44 #define ARM_250         ARM_3
  45 #define ARM_6           0x00000008
  46 #define ARM_7           ARM_6           /* Same core instruction set.  */
  47 #define ARM_8           ARM_6           /* Same core instruction set.  */
  48 #define ARM_9           ARM_6           /* Same core instruction set.  */
  49 #define ARM_CPU_MASK    0x0000000f
  50
  51 /* The following bitmasks control CPU extensions (ARM7 onwards):   */
  52 #define ARM_LONGMUL     0x00000010      /* Allow long multiplies.  */
  53 #define ARM_HALFWORD    0x00000020      /* Allow half word loads.  */
  54 #define ARM_THUMB       0x00000040      /* Allow BX instruction.   */
  55 #define ARM_EXT_V5      0x00000080      /* Allow CLZ, etc.         */
  56
  57 /* Architectures are the sum of the base and extensions.  */
  58 #define ARM_ARCH_V4     (ARM_7 | ARM_LONGMUL | ARM_HALFWORD)
  59 #define ARM_ARCH_V4T    (ARM_ARCH_V4 | ARM_THUMB)
  60 #define ARM_ARCH_V5     (ARM_ARCH_V4 | ARM_EXT_V5)
  61 #define ARM_ARCH_V5T    (ARM_ARCH_V5 | ARM_THUMB)
  62
  63 /* Some useful combinations:  */
  64 #define ARM_ANY         0x00ffffff
  65 #define ARM_2UP         (ARM_ANY - ARM_1)
  66 #define ARM_ALL         ARM_2UP         /* Not arm1 only.  */
  67 #define ARM_3UP         0x00fffffc
  68 #define ARM_6UP         0x00fffff8      /* Includes ARM7.  */
  69
  70 #define FPU_CORE        0x80000000
  71 #define FPU_FPA10       0x40000000
  72 #define FPU_FPA11       0x40000000
  73 #define FPU_NONE        0
  74
  75 /* Some useful combinations.  */
  76 #define FPU_ALL         0xff000000      /* Note this is ~ARM_ANY.  */
  77 #define FPU_MEMMULTI    0x7f000000      /* Not fpu_core.  */
  78
  79 #ifndef CPU_DEFAULT
  80 #if defined __thumb__
  81 #define CPU_DEFAULT (ARM_ARCH_V4 | ARM_THUMB)
  82 #else
  83 #define CPU_DEFAULT ARM_ALL
  84 #endif
  85 #endif
  86
  87 #ifndef FPU_DEFAULT
  88 #define FPU_DEFAULT FPU_ALL
  89 #endif
  90
  91 #define streq(a, b)           (strcmp (a, b) == 0)
  92 #define skip_whitespace(str)  while (*(str) == ' ') ++(str)
  93
  94 static unsigned long cpu_variant = CPU_DEFAULT | FPU_DEFAULT;
  95 static int target_oabi = 0;
  96
  97 #if defined OBJ_COFF || defined OBJ_ELF
  98 /* Flags stored in private area of BFD structure.  */
  99 static boolean uses_apcs_26      = false;
 100 static boolean support_interwork = false;
 101 static boolean uses_apcs_float   = false;
 102 static boolean pic_code          = false;
 103 #endif
 104
 105 /* This array holds the chars that always start a comment.  If the
 106    pre-processor is disabled, these aren't very useful.  */
 107 CONST char comment_chars[] = "@";
 108
 109 /* This array holds the chars that only start a comment at the beginning of
 110    a line.  If the line seems to have the form '# 123 filename'
 111    .line and .file directives will appear in the pre-processed output.  */
 112 /* Note that input_file.c hand checks for '#' at the beginning of the
 113    first line of the input file.  This is because the compiler outputs
 114    #NO_APP at the beginning of its output.  */
 115 /* Also note that comments like this one will always work.  */
 116 CONST char line_comment_chars[] = "#";
 117
 118 CONST char line_separator_chars[] = ";";
 119
 120 /* Chars that can be used to separate mant
 121    from exp in floating point numbers.  */
 122 CONST char EXP_CHARS[] = "eE";
 123
 124 /* Chars that mean this number is a floating point constant.  */
 125 /* As in 0f12.456  */
 126 /* or    0d1.2345e12  */
 127
 128 CONST char FLT_CHARS[] = "rRsSfFdDxXeEpP";
 129
 130 /* Prefix characters that indicate the start of an immediate
 131    value.  */
 132 #define is_immediate_prefix(C) ((C) == '#' || (C) == '$')
 133
 134 #ifdef OBJ_ELF
 135 /* Pre-defined "_GLOBAL_OFFSET_TABLE_"  */
 136 symbolS * GOT_symbol;
 137 #endif
 138
 139 /* Size of relocation record.  */
 140 CONST int md_reloc_size = 8;
 141
 142 /* 0: assemble for ARM,
 143    1: assemble for Thumb,
 144    2: assemble for Thumb even though target CPU does not support thumb
 145       instructions.  */
 146 static int thumb_mode = 0;
 147
 148 typedef struct arm_fix
 149 {
 150   int thumb_mode;
 151 } arm_fix_data;
 152
 153 struct arm_it
 154 {
 155   CONST char *  error;
 156   unsigned long instruction;
 157   int           suffix;
 158   int           size;
 159   struct
 160   {
 161     bfd_reloc_code_real_type type;
 162     expressionS              exp;
 163     int                      pc_rel;
 164   } reloc;
 165 };
 166
 167 struct arm_it inst;
 168
 169 struct asm_shift
 170 {
 171   CONST char *  template;
 172   unsigned long value;
 173 };
 174
 175 static CONST struct asm_shift shift[] =
 176 {
 177   {"asl", 0},
 178   {"lsl", 0},
 179   {"lsr", 0x00000020},
 180   {"asr", 0x00000040},
 181   {"ror", 0x00000060},
 182   {"rrx", 0x00000060},
 183   {"ASL", 0},
 184   {"LSL", 0},
 185   {"LSR", 0x00000020},
 186   {"ASR", 0x00000040},
 187   {"ROR", 0x00000060},
 188   {"RRX", 0x00000060}
 189 };
 190
 191 #define NO_SHIFT_RESTRICT 1
 192 #define SHIFT_RESTRICT    0
 193
 194 #define NUM_FLOAT_VALS 8
 195
 196 CONST char * fp_const[] =
 197 {
 198   "0.0", "1.0", "2.0", "3.0", "4.0", "5.0", "0.5", "10.0", 0
 199 };
 200
 201 /* Number of littlenums required to hold an extended precision number.  */
 202 #define MAX_LITTLENUMS 6
 203
 204 LITTLENUM_TYPE fp_values[NUM_FLOAT_VALS][MAX_LITTLENUMS];
 205
 206 #define FAIL    (-1)
 207 #define SUCCESS (0)
 208
 209 #define SUFF_S 1
 210 #define SUFF_D 2
 211 #define SUFF_E 3
 212 #define SUFF_P 4
 213
 214 #define CP_T_X   0x00008000
 215 #define CP_T_Y   0x00400000
 216 #define CP_T_Pre 0x01000000
 217 #define CP_T_UD  0x00800000
 218 #define CP_T_WB  0x00200000
 219
 220 #define CONDS_BIT       (0x00100000)
 221 #define LOAD_BIT        (0x00100000)
 222 #define TRANS_BIT       (0x00200000)
 223
 224 struct asm_cond
 225 {
 226   CONST char *  template;
 227   unsigned long value;
 228 };
 229
 230 /* This is to save a hash look-up in the common case.  */
 231 #define COND_ALWAYS 0xe0000000
 232
 233 static CONST struct asm_cond conds[] =
 234 {
 235   {"eq", 0x00000000},
 236   {"ne", 0x10000000},
 237   {"cs", 0x20000000}, {"hs", 0x20000000},
 238   {"cc", 0x30000000}, {"ul", 0x30000000}, {"lo", 0x30000000},
 239   {"mi", 0x40000000},
 240   {"pl", 0x50000000},
 241   {"vs", 0x60000000},
 242   {"vc", 0x70000000},
 243   {"hi", 0x80000000},
 244   {"ls", 0x90000000},
 245   {"ge", 0xa0000000},
 246   {"lt", 0xb0000000},
 247   {"gt", 0xc0000000},
 248   {"le", 0xd0000000},
 249   {"al", 0xe0000000},
 250   {"nv", 0xf0000000}
 251 };
 252
 253 /* Warning: If the top bit of the set_bits is set, then the standard
 254    instruction bitmask is ignored, and the new bitmask is taken from
 255    the set_bits:  */
 256 struct asm_flg
 257 {
 258   CONST char *  template;       /* Basic flag string.  */
 259   unsigned long set_bits;       /* Bits to set.  */
 260 };
 261
 262 static CONST struct asm_flg s_flag[] =
 263 {
 264   {"s", CONDS_BIT},
 265   {NULL, 0}
 266 };
 267
 268 static CONST struct asm_flg ldr_flags[] =
 269 {
 270   {"b",  0x00400000},
 271   {"t",  TRANS_BIT},
 272   {"bt", 0x00400000 | TRANS_BIT},
 273   {"h",  0x801000b0},
 274   {"sh", 0x801000f0},
 275   {"sb", 0x801000d0},
 276   {NULL, 0}
 277 };
 278
 279 static CONST struct asm_flg str_flags[] =
 280 {
 281   {"b",  0x00400000},
 282   {"t",  TRANS_BIT},
 283   {"bt", 0x00400000 | TRANS_BIT},
 284   {"h",  0x800000b0},
 285   {NULL, 0}
 286 };
 287
 288 static CONST struct asm_flg byte_flag[] =
 289 {
 290   {"b", 0x00400000},
 291   {NULL, 0}
 292 };
 293
 294 static CONST struct asm_flg cmp_flags[] =
 295 {
 296   {"s", CONDS_BIT},
 297   {"p", 0x0010f000},
 298   {NULL, 0}
 299 };
 300
 301 static CONST struct asm_flg ldm_flags[] =
 302 {
 303   {"ed", 0x01800000},
 304   {"fd", 0x00800000},
 305   {"ea", 0x01000000},
 306   {"fa", 0x08000000},
 307   {"ib", 0x01800000},
 308   {"ia", 0x00800000},
 309   {"db", 0x01000000},
 310   {"da", 0x08000000},
 311   {NULL, 0}
 312 };
 313
 314 static CONST struct asm_flg stm_flags[] =
 315 {
 316   {"ed", 0x08000000},
 317   {"fd", 0x01000000},
 318   {"ea", 0x00800000},
 319   {"fa", 0x01800000},
 320   {"ib", 0x01800000},
 321   {"ia", 0x00800000},
 322   {"db", 0x01000000},
 323   {"da", 0x08000000},
 324   {NULL, 0}
 325 };
 326
 327 static CONST struct asm_flg lfm_flags[] =
 328 {
 329   {"fd", 0x00800000},
 330   {"ea", 0x01000000},
 331   {NULL, 0}
 332 };
 333
 334 static CONST struct asm_flg sfm_flags[] =
 335 {
 336   {"fd", 0x01000000},
 337   {"ea", 0x00800000},
 338   {NULL, 0}
 339 };
 340
 341 static CONST struct asm_flg round_flags[] =
 342 {
 343   {"p", 0x00000020},
 344   {"m", 0x00000040},
 345   {"z", 0x00000060},
 346   {NULL, 0}
 347 };
 348
 349 /* The implementation of the FIX instruction is broken on some assemblers,
 350    in that it accepts a precision specifier as well as a rounding specifier,
 351    despite the fact that this is meaningless.  To be more compatible, we
 352    accept it as well, though of course it does not set any bits.  */
 353 static CONST struct asm_flg fix_flags[] =
 354 {
 355   {"p", 0x00000020},
 356   {"m", 0x00000040},
 357   {"z", 0x00000060},
 358   {"sp", 0x00000020},
 359   {"sm", 0x00000040},
 360   {"sz", 0x00000060},
 361   {"dp", 0x00000020},
 362   {"dm", 0x00000040},
 363   {"dz", 0x00000060},
 364   {"ep", 0x00000020},
 365   {"em", 0x00000040},
 366   {"ez", 0x00000060},
 367   {NULL, 0}
 368 };
 369
 370 static CONST struct asm_flg except_flag[] =
 371 {
 372   {"e", 0x00400000},
 373   {NULL, 0}
 374 };
 375
 376 static CONST struct asm_flg cplong_flag[] =
 377 {
 378   {"l", 0x00400000},
 379   {NULL, 0}
 380 };
 381
 382 struct asm_psr
 383 {
 384   CONST char *  template;
 385   boolean       cpsr;
 386   unsigned long field;
 387 };
 388
 389 /* The bit that distnguishes CPSR and SPSR.  */
 390 #define SPSR_BIT   (1 << 22)
 391
 392 /* How many bits to shift the PSR_xxx bits up by.  */
 393 #define PSR_SHIFT  16
 394
 395 #define PSR_c   (1 << 0)
 396 #define PSR_x   (1 << 1)
 397 #define PSR_s   (1 << 2)
 398 #define PSR_f   (1 << 3)
 399
 400 static CONST struct asm_psr psrs[] =
 401 {
 402   {"CPSR",      true,  PSR_c | PSR_f},
 403   {"CPSR_all",  true,  PSR_c | PSR_f},
 404   {"SPSR",      false, PSR_c | PSR_f},
 405   {"SPSR_all",  false, PSR_c | PSR_f},
 406   {"CPSR_flg",  true,  PSR_f},
 407   {"CPSR_f",    true,  PSR_f},
 408   {"SPSR_flg",  false, PSR_f},
 409   {"SPSR_f",    false, PSR_f},
 410   {"CPSR_c",    true,  PSR_c},
 411   {"CPSR_ctl",  true,  PSR_c},
 412   {"SPSR_c",    false, PSR_c},
 413   {"SPSR_ctl",  false, PSR_c},
 414   {"CPSR_x",    true,  PSR_x},
 415   {"CPSR_s",    true,  PSR_s},
 416   {"SPSR_x",    false, PSR_x},
 417   {"SPSR_s",    false, PSR_s},
 418   /* Combinations of flags.  */
 419   {"CPSR_fs",   true, PSR_f | PSR_s},
 420   {"CPSR_fx",   true, PSR_f | PSR_x},
 421   {"CPSR_fc",   true, PSR_f | PSR_c},
 422   {"CPSR_sf",   true, PSR_s | PSR_f},
 423   {"CPSR_sx",   true, PSR_s | PSR_x},
 424   {"CPSR_sc",   true, PSR_s | PSR_c},
 425   {"CPSR_xf",   true, PSR_x | PSR_f},
 426   {"CPSR_xs",   true, PSR_x | PSR_s},
 427   {"CPSR_xc",   true, PSR_x | PSR_c},
 428   {"CPSR_cf",   true, PSR_c | PSR_f},
 429   {"CPSR_cs",   true, PSR_c | PSR_s},
 430   {"CPSR_cx",   true, PSR_c | PSR_x},
 431   {"CPSR_fsx",  true, PSR_f | PSR_s | PSR_x},
 432   {"CPSR_fsc",  true, PSR_f | PSR_s | PSR_c},
 433   {"CPSR_fxs",  true, PSR_f | PSR_x | PSR_s},
 434   {"CPSR_fxc",  true, PSR_f | PSR_x | PSR_c},
 435   {"CPSR_fcs",  true, PSR_f | PSR_c | PSR_s},
 436   {"CPSR_fcx",  true, PSR_f | PSR_c | PSR_x},
 437   {"CPSR_sfx",  true, PSR_s | PSR_f | PSR_x},
 438   {"CPSR_sfc",  true, PSR_s | PSR_f | PSR_c},
 439   {"CPSR_sxf",  true, PSR_s | PSR_x | PSR_f},
 440   {"CPSR_sxc",  true, PSR_s | PSR_x | PSR_c},
 441   {"CPSR_scf",  true, PSR_s | PSR_c | PSR_f},
 442   {"CPSR_scx",  true, PSR_s | PSR_c | PSR_x},
 443   {"CPSR_xfs",  true, PSR_x | PSR_f | PSR_s},
 444   {"CPSR_xfc",  true, PSR_x | PSR_f | PSR_c},
 445   {"CPSR_xsf",  true, PSR_x | PSR_s | PSR_f},
 446   {"CPSR_xsc",  true, PSR_x | PSR_s | PSR_c},
 447   {"CPSR_xcf",  true, PSR_x | PSR_c | PSR_f},
 448   {"CPSR_xcs",  true, PSR_x | PSR_c | PSR_s},
 449   {"CPSR_cfs",  true, PSR_c | PSR_f | PSR_s},
 450   {"CPSR_cfx",  true, PSR_c | PSR_f | PSR_x},
 451   {"CPSR_csf",  true, PSR_c | PSR_s | PSR_f},
 452   {"CPSR_csx",  true, PSR_c | PSR_s | PSR_x},
 453   {"CPSR_cxf",  true, PSR_c | PSR_x | PSR_f},
 454   {"CPSR_cxs",  true, PSR_c | PSR_x | PSR_s},
 455   {"CPSR_fsxc", true, PSR_f | PSR_s | PSR_x | PSR_c},
 456   {"CPSR_fscx", true, PSR_f | PSR_s | PSR_c | PSR_x},
 457   {"CPSR_fxsc", true, PSR_f | PSR_x | PSR_s | PSR_c},
 458   {"CPSR_fxcs", true, PSR_f | PSR_x | PSR_c | PSR_s},
 459   {"CPSR_fcsx", true, PSR_f | PSR_c | PSR_s | PSR_x},
 460   {"CPSR_fcxs", true, PSR_f | PSR_c | PSR_x | PSR_s},
 461   {"CPSR_sfxc", true, PSR_s | PSR_f | PSR_x | PSR_c},
 462   {"CPSR_sfcx", true, PSR_s | PSR_f | PSR_c | PSR_x},
 463   {"CPSR_sxfc", true, PSR_s | PSR_x | PSR_f | PSR_c},
 464   {"CPSR_sxcf", true, PSR_s | PSR_x | PSR_c | PSR_f},
 465   {"CPSR_scfx", true, PSR_s | PSR_c | PSR_f | PSR_x},
 466   {"CPSR_scxf", true, PSR_s | PSR_c | PSR_x | PSR_f},
 467   {"CPSR_xfsc", true, PSR_x | PSR_f | PSR_s | PSR_c},
 468   {"CPSR_xfcs", true, PSR_x | PSR_f | PSR_c | PSR_s},
 469   {"CPSR_xsfc", true, PSR_x | PSR_s | PSR_f | PSR_c},
 470   {"CPSR_xscf", true, PSR_x | PSR_s | PSR_c | PSR_f},
 471   {"CPSR_xcfs", true, PSR_x | PSR_c | PSR_f | PSR_s},
 472   {"CPSR_xcsf", true, PSR_x | PSR_c | PSR_s | PSR_f},
 473   {"CPSR_cfsx", true, PSR_c | PSR_f | PSR_s | PSR_x},
 474   {"CPSR_cfxs", true, PSR_c | PSR_f | PSR_x | PSR_s},
 475   {"CPSR_csfx", true, PSR_c | PSR_s | PSR_f | PSR_x},
 476   {"CPSR_csxf", true, PSR_c | PSR_s | PSR_x | PSR_f},
 477   {"CPSR_cxfs", true, PSR_c | PSR_x | PSR_f | PSR_s},
 478   {"CPSR_cxsf", true, PSR_c | PSR_x | PSR_s | PSR_f},
 479   {"SPSR_fs",   false, PSR_f | PSR_s},
 480   {"SPSR_fx",   false, PSR_f | PSR_x},
 481   {"SPSR_fc",   false, PSR_f | PSR_c},
 482   {"SPSR_sf",   false, PSR_s | PSR_f},
 483   {"SPSR_sx",   false, PSR_s | PSR_x},
 484   {"SPSR_sc",   false, PSR_s | PSR_c},
 485   {"SPSR_xf",   false, PSR_x | PSR_f},
 486   {"SPSR_xs",   false, PSR_x | PSR_s},
 487   {"SPSR_xc",   false, PSR_x | PSR_c},
 488   {"SPSR_cf",   false, PSR_c | PSR_f},
 489   {"SPSR_cs",   false, PSR_c | PSR_s},
 490   {"SPSR_cx",   false, PSR_c | PSR_x},
 491   {"SPSR_fsx",  false, PSR_f | PSR_s | PSR_x},
 492   {"SPSR_fsc",  false, PSR_f | PSR_s | PSR_c},
 493   {"SPSR_fxs",  false, PSR_f | PSR_x | PSR_s},
 494   {"SPSR_fxc",  false, PSR_f | PSR_x | PSR_c},
 495   {"SPSR_fcs",  false, PSR_f | PSR_c | PSR_s},
 496   {"SPSR_fcx",  false, PSR_f | PSR_c | PSR_x},
 497   {"SPSR_sfx",  false, PSR_s | PSR_f | PSR_x},
 498   {"SPSR_sfc",  false, PSR_s | PSR_f | PSR_c},
 499   {"SPSR_sxf",  false, PSR_s | PSR_x | PSR_f},
 500   {"SPSR_sxc",  false, PSR_s | PSR_x | PSR_c},
 501   {"SPSR_scf",  false, PSR_s | PSR_c | PSR_f},
 502   {"SPSR_scx",  false, PSR_s | PSR_c | PSR_x},
 503   {"SPSR_xfs",  false, PSR_x | PSR_f | PSR_s},
 504   {"SPSR_xfc",  false, PSR_x | PSR_f | PSR_c},
 505   {"SPSR_xsf",  false, PSR_x | PSR_s | PSR_f},
 506   {"SPSR_xsc",  false, PSR_x | PSR_s | PSR_c},
 507   {"SPSR_xcf",  false, PSR_x | PSR_c | PSR_f},
 508   {"SPSR_xcs",  false, PSR_x | PSR_c | PSR_s},
 509   {"SPSR_cfs",  false, PSR_c | PSR_f | PSR_s},
 510   {"SPSR_cfx",  false, PSR_c | PSR_f | PSR_x},
 511   {"SPSR_csf",  false, PSR_c | PSR_s | PSR_f},
 512   {"SPSR_csx",  false, PSR_c | PSR_s | PSR_x},
 513   {"SPSR_cxf",  false, PSR_c | PSR_x | PSR_f},
 514   {"SPSR_cxs",  false, PSR_c | PSR_x | PSR_s},
 515   {"SPSR_fsxc", false, PSR_f | PSR_s | PSR_x | PSR_c},
 516   {"SPSR_fscx", false, PSR_f | PSR_s | PSR_c | PSR_x},
 517   {"SPSR_fxsc", false, PSR_f | PSR_x | PSR_s | PSR_c},
 518   {"SPSR_fxcs", false, PSR_f | PSR_x | PSR_c | PSR_s},
 519   {"SPSR_fcsx", false, PSR_f | PSR_c | PSR_s | PSR_x},
 520   {"SPSR_fcxs", false, PSR_f | PSR_c | PSR_x | PSR_s},
 521   {"SPSR_sfxc", false, PSR_s | PSR_f | PSR_x | PSR_c},
 522   {"SPSR_sfcx", false, PSR_s | PSR_f | PSR_c | PSR_x},
 523   {"SPSR_sxfc", false, PSR_s | PSR_x | PSR_f | PSR_c},
 524   {"SPSR_sxcf", false, PSR_s | PSR_x | PSR_c | PSR_f},
 525   {"SPSR_scfx", false, PSR_s | PSR_c | PSR_f | PSR_x},
 526   {"SPSR_scxf", false, PSR_s | PSR_c | PSR_x | PSR_f},
 527   {"SPSR_xfsc", false, PSR_x | PSR_f | PSR_s | PSR_c},
 528   {"SPSR_xfcs", false, PSR_x | PSR_f | PSR_c | PSR_s},
 529   {"SPSR_xsfc", false, PSR_x | PSR_s | PSR_f | PSR_c},
 530   {"SPSR_xscf", false, PSR_x | PSR_s | PSR_c | PSR_f},
 531   {"SPSR_xcfs", false, PSR_x | PSR_c | PSR_f | PSR_s},
 532   {"SPSR_xcsf", false, PSR_x | PSR_c | PSR_s | PSR_f},
 533   {"SPSR_cfsx", false, PSR_c | PSR_f | PSR_s | PSR_x},
 534   {"SPSR_cfxs", false, PSR_c | PSR_f | PSR_x | PSR_s},
 535   {"SPSR_csfx", false, PSR_c | PSR_s | PSR_f | PSR_x},
 536   {"SPSR_csxf", false, PSR_c | PSR_s | PSR_x | PSR_f},
 537   {"SPSR_cxfs", false, PSR_c | PSR_x | PSR_f | PSR_s},
 538   {"SPSR_cxsf", false, PSR_c | PSR_x | PSR_s | PSR_f},
 539   /* For backwards compatability with older toolchain we also
 540      support lower case versions of some of these flags.  */
 541   {"cpsr",      true,  PSR_c | PSR_f},
 542   {"cpsr_all",  true,  PSR_c | PSR_f},
 543   {"spsr",      false, PSR_c | PSR_f},
 544   {"spsr_all",  false, PSR_c | PSR_f},
 545   {"cpsr_flg",  true,  PSR_f},
 546   {"cpsr_f",    true,  PSR_f},
 547   {"spsr_flg",  false, PSR_f},
 548   {"spsr_f",    false, PSR_f},
 549   {"cpsr_c",    true,  PSR_c},
 550   {"cpsr_ctl",  true,  PSR_c},
 551   {"spsr_c",    false, PSR_c},
 552   {"spsr_ctl",  false, PSR_c}
 553 };
 554
 555 /* Functions called by parser.  */
 556 /* ARM instructions.  */
 557 static void do_arit             PARAMS ((char *, unsigned long));
 558 static void do_cmp              PARAMS ((char *, unsigned long));
 559 static void do_mov              PARAMS ((char *, unsigned long));
 560 static void do_ldst             PARAMS ((char *, unsigned long));
 561 static void do_ldmstm           PARAMS ((char *, unsigned long));
 562 static void do_branch           PARAMS ((char *, unsigned long));
 563 static void do_swi              PARAMS ((char *, unsigned long));
 564 /* Pseudo Op codes.  */
 565 static void do_adr              PARAMS ((char *, unsigned long));
 566 static void do_adrl             PARAMS ((char *, unsigned long));
 567 static void do_nop              PARAMS ((char *, unsigned long));
 568 /* ARM 2.  */
 569 static void do_mul              PARAMS ((char *, unsigned long));
 570 static void do_mla              PARAMS ((char *, unsigned long));
 571 /* ARM 3.  */
 572 static void do_swap             PARAMS ((char *, unsigned long));
 573 /* ARM 6.  */
 574 static void do_msr              PARAMS ((char *, unsigned long));
 575 static void do_mrs              PARAMS ((char *, unsigned long));
 576 /* ARM 7M.  */
 577 static void do_mull             PARAMS ((char *, unsigned long));
 578 /* ARM THUMB.  */
 579 static void do_bx               PARAMS ((char *, unsigned long));
 580
 581 /* Coprocessor Instructions.  */
 582 static void do_cdp              PARAMS ((char *, unsigned long));
 583 static void do_lstc             PARAMS ((char *, unsigned long));
 584 static void do_co_reg           PARAMS ((char *, unsigned long));
 585 static void do_fp_ctrl          PARAMS ((char *, unsigned long));
 586 static void do_fp_ldst          PARAMS ((char *, unsigned long));
 587 static void do_fp_ldmstm        PARAMS ((char *, unsigned long));
 588 static void do_fp_dyadic        PARAMS ((char *, unsigned long));
 589 static void do_fp_monadic       PARAMS ((char *, unsigned long));
 590 static void do_fp_cmp           PARAMS ((char *, unsigned long));
 591 static void do_fp_from_reg      PARAMS ((char *, unsigned long));
 592 static void do_fp_to_reg        PARAMS ((char *, unsigned long));
 593
 594 static void fix_new_arm         PARAMS ((fragS *, int, short, expressionS *, int, int));
 595 static int arm_reg_parse        PARAMS ((char **));
 596 static CONST struct asm_psr * arm_psr_parse PARAMS ((char **));
 597 static void symbol_locate       PARAMS ((symbolS *, CONST char *, segT, valueT, fragS *));
 598 static int add_to_lit_pool      PARAMS ((void));
 599 static unsigned validate_immediate PARAMS ((unsigned));
 600 static unsigned validate_immediate_twopart PARAMS ((unsigned int, unsigned int *));
 601 static int validate_offset_imm  PARAMS ((unsigned int, int));
 602 static void opcode_select       PARAMS ((int));
 603 static void end_of_line         PARAMS ((char *));
 604 static int reg_required_here    PARAMS ((char **, int));
 605 static int psr_required_here    PARAMS ((char **));
 606 static int co_proc_number       PARAMS ((char **));
 607 static int cp_opc_expr          PARAMS ((char **, int, int));
 608 static int cp_reg_required_here PARAMS ((char **, int));
 609 static int fp_reg_required_here PARAMS ((char **, int));
 610 static int cp_address_offset    PARAMS ((char **));
 611 static int cp_address_required_here     PARAMS ((char **));
 612 static int my_get_float_expression      PARAMS ((char **));
 613 static int skip_past_comma      PARAMS ((char **));
 614 static int walk_no_bignums      PARAMS ((symbolS *));
 615 static int negate_data_op       PARAMS ((unsigned long *, unsigned long));
 616 static int data_op2             PARAMS ((char **));
 617 static int fp_op2               PARAMS ((char **));
 618 static long reg_list            PARAMS ((char **));
 619 static void thumb_load_store    PARAMS ((char *, int, int));
 620 static int decode_shift         PARAMS ((char **, int));
 621 static int ldst_extend          PARAMS ((char **, int));
 622 static void thumb_add_sub       PARAMS ((char *, int));
 623 static void insert_reg          PARAMS ((int));
 624 static void thumb_shift         PARAMS ((char *, int));
 625 static void thumb_mov_compare   PARAMS ((char *, int));
 626 static void set_constant_flonums        PARAMS ((void));
 627 static valueT md_chars_to_number        PARAMS ((char *, int));
 628 static void insert_reg_alias    PARAMS ((char *, int));
 629 static void output_inst         PARAMS ((void));
 630 #ifdef OBJ_ELF
 631 static bfd_reloc_code_real_type arm_parse_reloc PARAMS ((void));
 632 #endif
 633
 634 /* ARM instructions take 4bytes in the object file, Thumb instructions
 635    take 2:  */
 636 #define INSN_SIZE       4
 637
 638 /* LONGEST_INST is the longest basic instruction name without conditions or
 639    flags.  ARM7M has 4 of length 5.  */
 640
 641 #define LONGEST_INST 5
 642
 643 struct asm_opcode
 644 {
 645   /* Basic string to match.  */
 646   CONST char * template;
 647
 648   /* Basic instruction code.  */
 649   unsigned long value;
 650
 651   /* Compulsory suffix that must follow conds.  If "", then the
 652      instruction is not conditional and must have no suffix.  */
 653   CONST char * comp_suffix;
 654
 655   /* Bits to toggle if flag 'n' set.  */
 656   CONST struct asm_flg * flags;
 657
 658   /* Which CPU variants this exists for.  */
 659   unsigned long variants;
 660
 661   /* Function to call to parse args.  */
 662   void (* parms) PARAMS ((char *, unsigned long));
 663 };
 664
 665 static CONST struct asm_opcode insns[] =
 666 {
 667 /* ARM Instructions.  */
 668   {"and",   0x00000000, NULL,   s_flag,      ARM_ANY,      do_arit},
 669   {"eor",   0x00200000, NULL,   s_flag,      ARM_ANY,      do_arit},
 670   {"sub",   0x00400000, NULL,   s_flag,      ARM_ANY,      do_arit},
 671   {"rsb",   0x00600000, NULL,   s_flag,      ARM_ANY,      do_arit},
 672   {"add",   0x00800000, NULL,   s_flag,      ARM_ANY,      do_arit},
 673   {"adc",   0x00a00000, NULL,   s_flag,      ARM_ANY,      do_arit},
 674   {"sbc",   0x00c00000, NULL,   s_flag,      ARM_ANY,      do_arit},
 675   {"rsc",   0x00e00000, NULL,   s_flag,      ARM_ANY,      do_arit},
 676   {"orr",   0x01800000, NULL,   s_flag,      ARM_ANY,      do_arit},
 677   {"bic",   0x01c00000, NULL,   s_flag,      ARM_ANY,      do_arit},
 678   {"tst",   0x01000000, NULL,   cmp_flags,   ARM_ANY,      do_cmp},
 679   {"teq",   0x01200000, NULL,   cmp_flags,   ARM_ANY,      do_cmp},
 680   {"cmp",   0x01400000, NULL,   cmp_flags,   ARM_ANY,      do_cmp},
 681   {"cmn",   0x01600000, NULL,   cmp_flags,   ARM_ANY,      do_cmp},
 682   {"mov",   0x01a00000, NULL,   s_flag,      ARM_ANY,      do_mov},
 683   {"mvn",   0x01e00000, NULL,   s_flag,      ARM_ANY,      do_mov},
 684   {"str",   0x04000000, NULL,   str_flags,   ARM_ANY,      do_ldst},
 685   {"ldr",   0x04100000, NULL,   ldr_flags,   ARM_ANY,      do_ldst},
 686   {"stm",   0x08000000, NULL,   stm_flags,   ARM_ANY,      do_ldmstm},
 687   {"ldm",   0x08100000, NULL,   ldm_flags,   ARM_ANY,      do_ldmstm},
 688   {"swi",   0x0f000000, NULL,   NULL,        ARM_ANY,      do_swi},
 689 #ifdef TE_WINCE
 690   {"bl",    0x0b000000, NULL,   NULL,        ARM_ANY,      do_branch},
 691   {"b",     0x0a000000, NULL,   NULL,        ARM_ANY,      do_branch},
 692 #else
 693   {"bl",    0x0bfffffe, NULL,   NULL,        ARM_ANY,      do_branch},
 694   {"b",     0x0afffffe, NULL,   NULL,        ARM_ANY,      do_branch},
 695 #endif
 696
 697 /* Pseudo ops.  */
 698   {"adr",   0x028f0000, NULL,   NULL,        ARM_ANY,      do_adr},
 699   {"adrl",  0x028f0000, NULL,   NULL,        ARM_ANY,      do_adrl},
 700   {"nop",   0x01a00000, NULL,   NULL,        ARM_ANY,      do_nop},
 701
 702 /* ARM 2 multiplies.  */
 703   {"mul",   0x00000090, NULL,   s_flag,      ARM_2UP,      do_mul},
 704   {"mla",   0x00200090, NULL,   s_flag,      ARM_2UP,      do_mla},
 705
 706 /* ARM 3 - swp instructions.  */
 707   {"swp",   0x01000090, NULL,   byte_flag,   ARM_3UP,      do_swap},
 708
 709 /* ARM 6 Coprocessor instructions.  */
 710   {"mrs",   0x010f0000, NULL,   NULL,        ARM_6UP,      do_mrs},
 711   {"msr",   0x0120f000, NULL,   NULL,        ARM_6UP,      do_msr},
 712 /* ScottB: our code uses 0x0128f000 for msr.
 713    NickC:  but this is wrong because the bits 16 through 19 are
 714            handled by the PSR_xxx defines above.  */
 715
 716 /* ARM 7M long multiplies - need signed/unsigned flags!  */
 717   {"smull", 0x00c00090, NULL,   s_flag,      ARM_LONGMUL,  do_mull},
 718   {"umull", 0x00800090, NULL,   s_flag,      ARM_LONGMUL,  do_mull},
 719   {"smlal", 0x00e00090, NULL,   s_flag,      ARM_LONGMUL,  do_mull},
 720   {"umlal", 0x00a00090, NULL,   s_flag,      ARM_LONGMUL,  do_mull},
 721
 722 /* ARM THUMB interworking.  */
 723   {"bx",    0x012fff10, NULL,   NULL,        ARM_THUMB,    do_bx},
 724
 725 /* Floating point instructions.  */
 726   {"wfs",   0x0e200110, NULL,   NULL,        FPU_ALL,      do_fp_ctrl},
 727   {"rfs",   0x0e300110, NULL,   NULL,        FPU_ALL,      do_fp_ctrl},
 728   {"wfc",   0x0e400110, NULL,   NULL,        FPU_ALL,      do_fp_ctrl},
 729   {"rfc",   0x0e500110, NULL,   NULL,        FPU_ALL,      do_fp_ctrl},
 730   {"ldf",   0x0c100100, "sdep", NULL,        FPU_ALL,      do_fp_ldst},
 731   {"stf",   0x0c000100, "sdep", NULL,        FPU_ALL,      do_fp_ldst},
 732   {"lfm",   0x0c100200, NULL,   lfm_flags,   FPU_MEMMULTI, do_fp_ldmstm},
 733   {"sfm",   0x0c000200, NULL,   sfm_flags,   FPU_MEMMULTI, do_fp_ldmstm},
 734   {"mvf",   0x0e008100, "sde",  round_flags, FPU_ALL,      do_fp_monadic},
 735   {"mnf",   0x0e108100, "sde",  round_flags, FPU_ALL,      do_fp_monadic},
 736   {"abs",   0x0e208100, "sde",  round_flags, FPU_ALL,      do_fp_monadic},
 737   {"rnd",   0x0e308100, "sde",  round_flags, FPU_ALL,      do_fp_monadic},
 738   {"sqt",   0x0e408100, "sde",  round_flags, FPU_ALL,      do_fp_monadic},
 739   {"log",   0x0e508100, "sde",  round_flags, FPU_ALL,      do_fp_monadic},
 740   {"lgn",   0x0e608100, "sde",  round_flags, FPU_ALL,      do_fp_monadic},
 741   {"exp",   0x0e708100, "sde",  round_flags, FPU_ALL,      do_fp_monadic},
 742   {"sin",   0x0e808100, "sde",  round_flags, FPU_ALL,      do_fp_monadic},
 743   {"cos",   0x0e908100, "sde",  round_flags, FPU_ALL,      do_fp_monadic},
 744   {"tan",   0x0ea08100, "sde",  round_flags, FPU_ALL,      do_fp_monadic},
 745   {"asn",   0x0eb08100, "sde",  round_flags, FPU_ALL,      do_fp_monadic},
 746   {"acs",   0x0ec08100, "sde",  round_flags, FPU_ALL,      do_fp_monadic},
 747   {"atn",   0x0ed08100, "sde",  round_flags, FPU_ALL,      do_fp_monadic},
 748   {"urd",   0x0ee08100, "sde",  round_flags, FPU_ALL,      do_fp_monadic},
 749   {"nrm",   0x0ef08100, "sde",  round_flags, FPU_ALL,      do_fp_monadic},
 750   {"adf",   0x0e000100, "sde",  round_flags, FPU_ALL,      do_fp_dyadic},
 751   {"suf",   0x0e200100, "sde",  round_flags, FPU_ALL,      do_fp_dyadic},
 752   {"rsf",   0x0e300100, "sde",  round_flags, FPU_ALL,      do_fp_dyadic},
 753   {"muf",   0x0e100100, "sde",  round_flags, FPU_ALL,      do_fp_dyadic},
 754   {"dvf",   0x0e400100, "sde",  round_flags, FPU_ALL,      do_fp_dyadic},
 755   {"rdf",   0x0e500100, "sde",  round_flags, FPU_ALL,      do_fp_dyadic},
 756   {"pow",   0x0e600100, "sde",  round_flags, FPU_ALL,      do_fp_dyadic},
 757   {"rpw",   0x0e700100, "sde",  round_flags, FPU_ALL,      do_fp_dyadic},
 758   {"rmf",   0x0e800100, "sde",  round_flags, FPU_ALL,      do_fp_dyadic},
 759   {"fml",   0x0e900100, "sde",  round_flags, FPU_ALL,      do_fp_dyadic},
 760   {"fdv",   0x0ea00100, "sde",  round_flags, FPU_ALL,      do_fp_dyadic},
 761   {"frd",   0x0eb00100, "sde",  round_flags, FPU_ALL,      do_fp_dyadic},
 762   {"pol",   0x0ec00100, "sde",  round_flags, FPU_ALL,      do_fp_dyadic},
 763   {"cmf",   0x0e90f110, NULL,   except_flag, FPU_ALL,      do_fp_cmp},
 764   {"cnf",   0x0eb0f110, NULL,   except_flag, FPU_ALL,      do_fp_cmp},
 765 /* The FPA10 data sheet suggests that the 'E' of cmfe/cnfe should not
 766    be an optional suffix, but part of the instruction.  To be compatible,
 767    we accept either.  */
 768   {"cmfe",  0x0ed0f110, NULL,   NULL,        FPU_ALL,      do_fp_cmp},
 769   {"cnfe",  0x0ef0f110, NULL,   NULL,        FPU_ALL,      do_fp_cmp},
 770   {"flt",   0x0e000110, "sde",  round_flags, FPU_ALL,      do_fp_from_reg},
 771   {"fix",   0x0e100110, NULL,   fix_flags,   FPU_ALL,      do_fp_to_reg},
 772
 773 /* Generic copressor instructions.  */
 774   {"cdp",   0x0e000000, NULL,  NULL,         ARM_2UP,      do_cdp},
 775   {"ldc",   0x0c100000, NULL,  cplong_flag,  ARM_2UP,      do_lstc},
 776   {"stc",   0x0c000000, NULL,  cplong_flag,  ARM_2UP,      do_lstc},
 777   {"mcr",   0x0e000010, NULL,  NULL,         ARM_2UP,      do_co_reg},
 778   {"mrc",   0x0e100010, NULL,  NULL,         ARM_2UP,      do_co_reg},
 779 };
 780
 781 /* Defines for various bits that we will want to toggle.  */
 782 #define INST_IMMEDIATE  0x02000000
 783 #define OFFSET_REG      0x02000000
 784 #define HWOFFSET_IMM    0x00400000
 785 #define SHIFT_BY_REG    0x00000010
 786 #define PRE_INDEX       0x01000000
 787 #define INDEX_UP        0x00800000
 788 #define WRITE_BACK      0x00200000
 789 #define LDM_TYPE_2_OR_3 0x00400000
 790
 791 #define LITERAL_MASK    0xf000f000
 792 #define COND_MASK       0xf0000000
 793 #define OPCODE_MASK     0xfe1fffff
 794 #define DATA_OP_SHIFT   21
 795
 796 /* Codes to distinguish the arithmetic instructions.  */
 797 #define OPCODE_AND      0
 798 #define OPCODE_EOR      1
 799 #define OPCODE_SUB      2
 800 #define OPCODE_RSB      3
 801 #define OPCODE_ADD      4
 802 #define OPCODE_ADC      5
 803 #define OPCODE_SBC      6
 804 #define OPCODE_RSC      7
 805 #define OPCODE_TST      8
 806 #define OPCODE_TEQ      9
 807 #define OPCODE_CMP      10
 808 #define OPCODE_CMN      11
 809 #define OPCODE_ORR      12
 810 #define OPCODE_MOV      13
 811 #define OPCODE_BIC      14
 812 #define OPCODE_MVN      15
 813
 814 static void do_t_nop            PARAMS ((char *));
 815 static void do_t_arit           PARAMS ((char *));
 816 static void do_t_add            PARAMS ((char *));
 817 static void do_t_asr            PARAMS ((char *));
 818 static void do_t_branch9        PARAMS ((char *));
 819 static void do_t_branch12       PARAMS ((char *));
 820 static void do_t_branch23       PARAMS ((char *));
 821 static void do_t_bx             PARAMS ((char *));
 822 static void do_t_compare        PARAMS ((char *));
 823 static void do_t_ldmstm         PARAMS ((char *));
 824 static void do_t_ldr            PARAMS ((char *));
 825 static void do_t_ldrb           PARAMS ((char *));
 826 static void do_t_ldrh           PARAMS ((char *));
 827 static void do_t_lds            PARAMS ((char *));
 828 static void do_t_lsl            PARAMS ((char *));
 829 static void do_t_lsr            PARAMS ((char *));
 830 static void do_t_mov            PARAMS ((char *));
 831 static void do_t_push_pop       PARAMS ((char *));
 832 static void do_t_str            PARAMS ((char *));
 833 static void do_t_strb           PARAMS ((char *));
 834 static void do_t_strh           PARAMS ((char *));
 835 static void do_t_sub            PARAMS ((char *));
 836 static void do_t_swi            PARAMS ((char *));
 837 static void do_t_adr            PARAMS ((char *));
 838
 839 #define T_OPCODE_MUL 0x4340
 840 #define T_OPCODE_TST 0x4200
 841 #define T_OPCODE_CMN 0x42c0
 842 #define T_OPCODE_NEG 0x4240
 843 #define T_OPCODE_MVN 0x43c0
 844
 845 #define T_OPCODE_ADD_R3 0x1800
 846 #define T_OPCODE_SUB_R3 0x1a00
 847 #define T_OPCODE_ADD_HI 0x4400
 848 #define T_OPCODE_ADD_ST 0xb000
 849 #define T_OPCODE_SUB_ST 0xb080
 850 #define T_OPCODE_ADD_SP 0xa800
 851 #define T_OPCODE_ADD_PC 0xa000
 852 #define T_OPCODE_ADD_I8 0x3000
 853 #define T_OPCODE_SUB_I8 0x3800
 854 #define T_OPCODE_ADD_I3 0x1c00
 855 #define T_OPCODE_SUB_I3 0x1e00
 856
 857 #define T_OPCODE_ASR_R  0x4100
 858 #define T_OPCODE_LSL_R  0x4080
 859 #define T_OPCODE_LSR_R  0x40c0
 860 #define T_OPCODE_ASR_I  0x1000
 861 #define T_OPCODE_LSL_I  0x0000
 862 #define T_OPCODE_LSR_I  0x0800
 863
 864 #define T_OPCODE_MOV_I8 0x2000
 865 #define T_OPCODE_CMP_I8 0x2800
 866 #define T_OPCODE_CMP_LR 0x4280
 867 #define T_OPCODE_MOV_HR 0x4600
 868 #define T_OPCODE_CMP_HR 0x4500
 869
 870 #define T_OPCODE_LDR_PC 0x4800
 871 #define T_OPCODE_LDR_SP 0x9800
 872 #define T_OPCODE_STR_SP 0x9000
 873 #define T_OPCODE_LDR_IW 0x6800
 874 #define T_OPCODE_STR_IW 0x6000
 875 #define T_OPCODE_LDR_IH 0x8800
 876 #define T_OPCODE_STR_IH 0x8000
 877 #define T_OPCODE_LDR_IB 0x7800
 878 #define T_OPCODE_STR_IB 0x7000
 879 #define T_OPCODE_LDR_RW 0x5800
 880 #define T_OPCODE_STR_RW 0x5000
 881 #define T_OPCODE_LDR_RH 0x5a00
 882 #define T_OPCODE_STR_RH 0x5200
 883 #define T_OPCODE_LDR_RB 0x5c00
 884 #define T_OPCODE_STR_RB 0x5400
 885
 886 #define T_OPCODE_PUSH   0xb400
 887 #define T_OPCODE_POP    0xbc00
 888
 889 #define T_OPCODE_BRANCH 0xe7fe
 890
 891 static int thumb_reg            PARAMS ((char ** str, int hi_lo));
 892
 893 #define THUMB_SIZE      2       /* Size of thumb instruction.  */
 894 #define THUMB_REG_LO    0x1
 895 #define THUMB_REG_HI    0x2
 896 #define THUMB_REG_ANY   0x3
 897
 898 #define THUMB_H1        0x0080
 899 #define THUMB_H2        0x0040
 900
 901 #define THUMB_ASR 0
 902 #define THUMB_LSL 1
 903 #define THUMB_LSR 2
 904
 905 #define THUMB_MOVE 0
 906 #define THUMB_COMPARE 1
 907
 908 #define THUMB_LOAD 0
 909 #define THUMB_STORE 1
 910
 911 #define THUMB_PP_PC_LR 0x0100
 912
 913 /* These three are used for immediate shifts, do not alter.  */
 914 #define THUMB_WORD 2
 915 #define THUMB_HALFWORD 1
 916 #define THUMB_BYTE 0
 917
 918 struct thumb_opcode
 919 {
 920   /* Basic string to match.  */
 921   CONST char * template;
 922
 923   /* Basic instruction code.  */
 924   unsigned long value;
 925
 926   int size;
 927
 928   /* Which CPU variants this exists for. */
 929   unsigned long variants;
 930
 931   /* Function to call to parse args.  */
 932   void (* parms) PARAMS ((char *));
 933 };
 934
 935 static CONST struct thumb_opcode tinsns[] =
 936 {
 937   {"adc",       0x4140,         2,      ARM_THUMB, do_t_arit},
 938   {"add",       0x0000,         2,      ARM_THUMB, do_t_add},
 939   {"and",       0x4000,         2,      ARM_THUMB, do_t_arit},
 940   {"asr",       0x0000,         2,      ARM_THUMB, do_t_asr},
 941   {"b",         T_OPCODE_BRANCH, 2,     ARM_THUMB, do_t_branch12},
 942   {"beq",       0xd0fe,         2,      ARM_THUMB, do_t_branch9},
 943   {"bne",       0xd1fe,         2,      ARM_THUMB, do_t_branch9},
 944   {"bcs",       0xd2fe,         2,      ARM_THUMB, do_t_branch9},
 945   {"bhs",       0xd2fe,         2,      ARM_THUMB, do_t_branch9},
 946   {"bcc",       0xd3fe,         2,      ARM_THUMB, do_t_branch9},
 947   {"bul",       0xd3fe,         2,      ARM_THUMB, do_t_branch9},
 948   {"blo",       0xd3fe,         2,      ARM_THUMB, do_t_branch9},
 949   {"bmi",       0xd4fe,         2,      ARM_THUMB, do_t_branch9},
 950   {"bpl",       0xd5fe,         2,      ARM_THUMB, do_t_branch9},
 951   {"bvs",       0xd6fe,         2,      ARM_THUMB, do_t_branch9},
 952   {"bvc",       0xd7fe,         2,      ARM_THUMB, do_t_branch9},
 953   {"bhi",       0xd8fe,         2,      ARM_THUMB, do_t_branch9},
 954   {"bls",       0xd9fe,         2,      ARM_THUMB, do_t_branch9},
 955   {"bge",       0xdafe,         2,      ARM_THUMB, do_t_branch9},
 956   {"blt",       0xdbfe,         2,      ARM_THUMB, do_t_branch9},
 957   {"bgt",       0xdcfe,         2,      ARM_THUMB, do_t_branch9},
 958   {"ble",       0xddfe,         2,      ARM_THUMB, do_t_branch9},
 959   {"bal",       0xdefe,         2,      ARM_THUMB, do_t_branch9},
 960   {"bic",       0x4380,         2,      ARM_THUMB, do_t_arit},
 961   {"bl",        0xf7fffffe,     4,      ARM_THUMB, do_t_branch23},
 962   {"bx",        0x4700,         2,      ARM_THUMB, do_t_bx},
 963   {"cmn",       T_OPCODE_CMN,   2,      ARM_THUMB, do_t_arit},
 964   {"cmp",       0x0000,         2,      ARM_THUMB, do_t_compare},
 965   {"eor",       0x4040,         2,      ARM_THUMB, do_t_arit},
 966   {"ldmia",     0xc800,         2,      ARM_THUMB, do_t_ldmstm},
 967   {"ldr",       0x0000,         2,      ARM_THUMB, do_t_ldr},
 968   {"ldrb",      0x0000,         2,      ARM_THUMB, do_t_ldrb},
 969   {"ldrh",      0x0000,         2,      ARM_THUMB, do_t_ldrh},
 970   {"ldrsb",     0x5600,         2,      ARM_THUMB, do_t_lds},
 971   {"ldrsh",     0x5e00,         2,      ARM_THUMB, do_t_lds},
 972   {"ldsb",      0x5600,         2,      ARM_THUMB, do_t_lds},
 973   {"ldsh",      0x5e00,         2,      ARM_THUMB, do_t_lds},
 974   {"lsl",       0x0000,         2,      ARM_THUMB, do_t_lsl},
 975   {"lsr",       0x0000,         2,      ARM_THUMB, do_t_lsr},
 976   {"mov",       0x0000,         2,      ARM_THUMB, do_t_mov},
 977   {"mul",       T_OPCODE_MUL,   2,      ARM_THUMB, do_t_arit},
 978   {"mvn",       T_OPCODE_MVN,   2,      ARM_THUMB, do_t_arit},
 979   {"neg",       T_OPCODE_NEG,   2,      ARM_THUMB, do_t_arit},
 980   {"orr",       0x4300,         2,      ARM_THUMB, do_t_arit},
 981   {"pop",       0xbc00,         2,      ARM_THUMB, do_t_push_pop},
 982   {"push",      0xb400,         2,      ARM_THUMB, do_t_push_pop},
 983   {"ror",       0x41c0,         2,      ARM_THUMB, do_t_arit},
 984   {"sbc",       0x4180,         2,      ARM_THUMB, do_t_arit},
 985   {"stmia",     0xc000,         2,      ARM_THUMB, do_t_ldmstm},
 986   {"str",       0x0000,         2,      ARM_THUMB, do_t_str},
 987   {"strb",      0x0000,         2,      ARM_THUMB, do_t_strb},
 988   {"strh",      0x0000,         2,      ARM_THUMB, do_t_strh},
 989   {"swi",       0xdf00,         2,      ARM_THUMB, do_t_swi},
 990   {"sub",       0x0000,         2,      ARM_THUMB, do_t_sub},
 991   {"tst",       T_OPCODE_TST,   2,      ARM_THUMB, do_t_arit},
 992   /* Pseudo ops:  */
 993   {"adr",       0x0000,         2,      ARM_THUMB, do_t_adr},
 994   {"nop",       0x46C0,         2,      ARM_THUMB, do_t_nop},      /* mov r8,r8  */
 995 };
 996
 997 struct reg_entry
 998 {
 999   CONST char * name;
1000   int          number;
1001 };
1002
1003 #define int_register(reg) ((reg) >= 0 && (reg) <= 15)
1004 #define cp_register(reg) ((reg) >= 32 && (reg) <= 47)
1005 #define fp_register(reg) ((reg) >= 16 && (reg) <= 23)
1006
1007 #define REG_PC  15
1008 #define REG_LR  14
1009 #define REG_SP  13
1010
1011 /* These are the standard names.  Users can add aliases with .req.  */
1012 static CONST struct reg_entry reg_table[] =
1013 {
1014   /* Processor Register Numbers.  */
1015   {"r0", 0},    {"r1", 1},      {"r2", 2},      {"r3", 3},
1016   {"r4", 4},    {"r5", 5},      {"r6", 6},      {"r7", 7},
1017   {"r8", 8},    {"r9", 9},      {"r10", 10},    {"r11", 11},
1018   {"r12", 12},  {"r13", REG_SP},{"r14", REG_LR},{"r15", REG_PC},
1019   /* APCS conventions.  */
1020   {"a1", 0},    {"a2", 1},    {"a3", 2},     {"a4", 3},
1021   {"v1", 4},    {"v2", 5},    {"v3", 6},     {"v4", 7},     {"v5", 8},
1022   {"v6", 9},    {"sb", 9},    {"v7", 10},    {"sl", 10},
1023   {"fp", 11},   {"ip", 12},   {"sp", REG_SP},{"lr", REG_LR},{"pc", REG_PC},
1024   /* ATPCS additions to APCS conventions.  */
1025   {"wr", 7},    {"v8", 11},
1026   /* FP Registers.  */
1027   {"f0", 16},   {"f1", 17},   {"f2", 18},   {"f3", 19},
1028   {"f4", 20},   {"f5", 21},   {"f6", 22},   {"f7", 23},
1029   {"c0", 32},   {"c1", 33},   {"c2", 34},   {"c3", 35},
1030   {"c4", 36},   {"c5", 37},   {"c6", 38},   {"c7", 39},
1031   {"c8", 40},   {"c9", 41},   {"c10", 42},  {"c11", 43},
1032   {"c12", 44},  {"c13", 45},  {"c14", 46},  {"c15", 47},
1033   {"cr0", 32},  {"cr1", 33},  {"cr2", 34},  {"cr3", 35},
1034   {"cr4", 36},  {"cr5", 37},  {"cr6", 38},  {"cr7", 39},
1035   {"cr8", 40},  {"cr9", 41},  {"cr10", 42}, {"cr11", 43},
1036   {"cr12", 44}, {"cr13", 45}, {"cr14", 46}, {"cr15", 47},
1037   /* ATPCS additions to float register names.  */
1038   {"s0",16},    {"s1",17},      {"s2",18},      {"s3",19},
1039   {"s4",20},    {"s5",21},      {"s6",22},      {"s7",23},
1040   {"d0",16},    {"d1",17},      {"d2",18},      {"d3",19},
1041   {"d4",20},    {"d5",21},      {"d6",22},      {"d7",23},
1042   /* FIXME: At some point we need to add VFP register names.  */
1043   /* Array terminator.  */
1044   {NULL, 0}
1045 };
1046
1047 #define BAD_ARGS        _("Bad arguments to instruction")
1048 #define BAD_PC          _("r15 not allowed here")
1049 #define BAD_FLAGS       _("Instruction should not have flags")
1050 #define BAD_COND        _("Instruction is not conditional")
1051
1052 static struct hash_control * arm_ops_hsh   = NULL;
1053 static struct hash_control * arm_tops_hsh  = NULL;
1054 static struct hash_control * arm_cond_hsh  = NULL;
1055 static struct hash_control * arm_shift_hsh = NULL;
1056 static struct hash_control * arm_reg_hsh   = NULL;
1057 static struct hash_control * arm_psr_hsh   = NULL;
1058
1059 /* This table describes all the machine specific pseudo-ops the assembler
1060    has to support.  The fields are:
1061      pseudo-op name without dot
1062      function to call to execute this pseudo-op
1063      Integer arg to pass to the function.  */
1064
1065 static void s_req PARAMS ((int));
1066 static void s_align PARAMS ((int));
1067 static void s_bss PARAMS ((int));
1068 static void s_even PARAMS ((int));
1069 static void s_ltorg PARAMS ((int));
1070 static void s_arm PARAMS ((int));
1071 static void s_thumb PARAMS ((int));
1072 static void s_code PARAMS ((int));
1073 static void s_force_thumb PARAMS ((int));
1074 static void s_thumb_func PARAMS ((int));
1075 static void s_thumb_set PARAMS ((int));
1076 static void arm_s_text PARAMS ((int));
1077 static void arm_s_data PARAMS ((int));
1078 #ifdef OBJ_ELF
1079 static void arm_s_section PARAMS ((int));
1080 static void s_arm_elf_cons PARAMS ((int));
1081 #endif
1082
1083 static int my_get_expression PARAMS ((expressionS *, char **));
1084
1085 CONST pseudo_typeS md_pseudo_table[] =
1086 {
1087   /* Never called becasue '.req' does not start line.  */
1088   { "req",         s_req,         0 },
1089   { "bss",         s_bss,         0 },
1090   { "align",       s_align,       0 },
1091   { "arm",         s_arm,         0 },
1092   { "thumb",       s_thumb,       0 },
1093   { "code",        s_code,        0 },
1094   { "force_thumb", s_force_thumb, 0 },
1095   { "thumb_func",  s_thumb_func,  0 },
1096   { "thumb_set",   s_thumb_set,   0 },
1097   { "even",        s_even,        0 },
1098   { "ltorg",       s_ltorg,       0 },
1099   { "pool",        s_ltorg,       0 },
1100   /* Allow for the effect of section changes.  */
1101   { "text",        arm_s_text,    0 },
1102   { "data",        arm_s_data,    0 },
1103 #ifdef OBJ_ELF
1104   { "section",     arm_s_section, 0 },
1105   { "section.s",   arm_s_section, 0 },
1106   { "sect",        arm_s_section, 0 },
1107   { "sect.s",      arm_s_section, 0 },
1108   { "word",        s_arm_elf_cons, 4 },
1109   { "long",        s_arm_elf_cons, 4 },
1110 #else
1111   { "word",        cons, 4},
1112 #endif
1113   { "extend",      float_cons, 'x' },
1114   { "ldouble",     float_cons, 'x' },
1115   { "packed",      float_cons, 'p' },
1116   { 0, 0, 0 }
1117 };
1118
1119 /* Stuff needed to resolve the label ambiguity
1120    As:
1121      ...
1122      label:   <insn>
1123    may differ from:
1124      ...
1125      label:
1126               <insn>
1127 */
1128
1129 symbolS *  last_label_seen;
1130 static int label_is_thumb_function_name = false;
1131
1132 /* Literal stuff.  */
1133
1134 #define MAX_LITERAL_POOL_SIZE 1024
1135
1136 typedef struct literalS
1137 {
1138   struct expressionS exp;
1139   struct arm_it *    inst;
1140 } literalT;
1141
1142 literalT literals[MAX_LITERAL_POOL_SIZE];
1143
1144 /* Next free entry in the pool.  */
1145 int next_literal_pool_place = 0;
1146
1147 /* Next literal pool number.  */
1148 int lit_pool_num = 1;
1149
1150 symbolS * current_poolP = NULL;
1151
1152 static int
1153 add_to_lit_pool ()
1154 {
1155   int lit_count = 0;
1156
1157   if (current_poolP == NULL)
1158     current_poolP = symbol_create (FAKE_LABEL_NAME, undefined_section,
1159                                    (valueT) 0, &zero_address_frag);
1160
1161   /* Check if this literal value is already in the pool:  */
1162   while (lit_count < next_literal_pool_place)
1163     {
1164       if (literals[lit_count].exp.X_op == inst.reloc.exp.X_op
1165           && inst.reloc.exp.X_op == O_constant
1166           && (literals[lit_count].exp.X_add_number
1167               == inst.reloc.exp.X_add_number)
1168           && literals[lit_count].exp.X_unsigned == inst.reloc.exp.X_unsigned)
1169         break;
1170       lit_count++;
1171     }
1172
1173   if (lit_count == next_literal_pool_place) /* New entry.  */
1174     {
1175       if (next_literal_pool_place > MAX_LITERAL_POOL_SIZE)
1176         {
1177           inst.error = _("Literal Pool Overflow");
1178           return FAIL;
1179         }
1180
1181       literals[next_literal_pool_place].exp = inst.reloc.exp;
1182       lit_count = next_literal_pool_place++;
1183     }
1184
1185   inst.reloc.exp.X_op = O_symbol;
1186   inst.reloc.exp.X_add_number = (lit_count) * 4 - 8;
1187   inst.reloc.exp.X_add_symbol = current_poolP;
1188
1189   return SUCCESS;
1190 }
1191
1192 /* Can't use symbol_new here, so have to create a symbol and then at
1193    a later date assign it a value. Thats what these functions do.  */
1194
1195 static void
1196 symbol_locate (symbolP, name, segment, valu, frag)
1197      symbolS *    symbolP;
1198      CONST char * name;         /* It is copied, the caller can modify.  */
1199      segT         segment;      /* Segment identifier (SEG_<something>).  */
1200      valueT       valu;         /* Symbol value.  */
1201      fragS *      frag;         /* Associated fragment.  */
1202 {
1203   unsigned int name_length;
1204   char * preserved_copy_of_name;
1205
1206   name_length = strlen (name) + 1;   /* +1 for \0.  */
1207   obstack_grow (&notes, name, name_length);
1208   preserved_copy_of_name = obstack_finish (&notes);
1209 #ifdef STRIP_UNDERSCORE
1210   if (preserved_copy_of_name[0] == '_')
1211     preserved_copy_of_name++;
1212 #endif
1213
1214 #ifdef tc_canonicalize_symbol_name
1215   preserved_copy_of_name =
1216     tc_canonicalize_symbol_name (preserved_copy_of_name);
1217 #endif
1218
1219   S_SET_NAME (symbolP, preserved_copy_of_name);
1220
1221   S_SET_SEGMENT (symbolP, segment);
1222   S_SET_VALUE (symbolP, valu);
1223   symbol_clear_list_pointers(symbolP);
1224
1225   symbol_set_frag (symbolP, frag);
1226
1227   /* Link to end of symbol chain.  */
1228   {
1229     extern int symbol_table_frozen;
1230     if (symbol_table_frozen)
1231       abort ();
1232   }
1233
1234   symbol_append (symbolP, symbol_lastP, & symbol_rootP, & symbol_lastP);
1235
1236   obj_symbol_new_hook (symbolP);
1237
1238 #ifdef tc_symbol_new_hook
1239   tc_symbol_new_hook (symbolP);
1240 #endif
1241
1242 #ifdef DEBUG_SYMS
1243   verify_symbol_chain (symbol_rootP, symbol_lastP);
1244 #endif /* DEBUG_SYMS  */
1245 }
1246
1247 /* Check that an immediate is valid.
1248    If so, convert it to the right format.  */
1249
1250 static unsigned int
1251 validate_immediate (val)
1252      unsigned int val;
1253 {
1254   unsigned int a;
1255   unsigned int i;
1256
1257 #define rotate_left(v, n) (v << n | v >> (32 - n))
1258
1259   for (i = 0; i < 32; i += 2)
1260     if ((a = rotate_left (val, i)) <= 0xff)
1261       return a | (i << 7); /* 12-bit pack: [shift-cnt,const].  */
1262
1263   return FAIL;
1264 }
1265
1266 /* Check to see if an immediate can be computed as two seperate immediate
1267    values, added together.  We already know that this value cannot be
1268    computed by just one ARM instruction.  */
1269
1270 static unsigned int
1271 validate_immediate_twopart (val, highpart)
1272      unsigned int   val;
1273      unsigned int * highpart;
1274 {
1275   unsigned int a;
1276   unsigned int i;
1277
1278   for (i = 0; i < 32; i += 2)
1279     if (((a = rotate_left (val, i)) & 0xff) != 0)
1280       {
1281         if (a & 0xff00)
1282           {
1283             if (a & ~ 0xffff)
1284               continue;
1285             * highpart = (a  >> 8) | ((i + 24) << 7);
1286           }
1287         else if (a & 0xff0000)
1288           {
1289             if (a & 0xff000000)
1290               continue;
1291             * highpart = (a >> 16) | ((i + 16) << 7);
1292           }
1293         else
1294           {
1295             assert (a & 0xff000000);
1296             * highpart = (a >> 24) | ((i + 8) << 7);
1297           }
1298
1299         return (a & 0xff) | (i << 7);
1300       }
1301
1302   return FAIL;
1303 }
1304
1305 static int
1306 validate_offset_imm (val, hwse)
1307      unsigned int val;
1308      int hwse;
1309 {
1310   if ((hwse && val > 255) || val > 4095)
1311     return FAIL;
1312   return val;
1313 }
1314
1315 static void
1316 s_req (a)
1317      int a ATTRIBUTE_UNUSED;
1318 {
1319   as_bad (_("Invalid syntax for .req directive."));
1320 }
1321
1322 static void
1323 s_bss (ignore)
1324      int ignore ATTRIBUTE_UNUSED;
1325 {
1326   /* We don't support putting frags in the BSS segment, we fake it by
1327      marking in_bss, then looking at s_skip for clues.  */
1328   subseg_set (bss_section, 0);
1329   demand_empty_rest_of_line ();
1330 }
1331
1332 static void
1333 s_even (ignore)
1334      int ignore ATTRIBUTE_UNUSED;
1335 {
1336   /* Never make frag if expect extra pass.  */
1337   if (!need_pass_2)
1338     frag_align (1, 0, 0);
1339
1340   record_alignment (now_seg, 1);
1341
1342   demand_empty_rest_of_line ();
1343 }
1344
1345 static void
1346 s_ltorg (ignored)
1347      int ignored ATTRIBUTE_UNUSED;
1348 {
1349   int lit_count = 0;
1350   char sym_name[20];
1351
1352   if (current_poolP == NULL)
1353     return;
1354
1355   /* Align pool as you have word accesses.
1356      Only make a frag if we have to.  */
1357   if (!need_pass_2)
1358     frag_align (2, 0, 0);
1359
1360   record_alignment (now_seg, 2);
1361
1362   sprintf (sym_name, "$$lit_\002%x", lit_pool_num++);
1363
1364   symbol_locate (current_poolP, sym_name, now_seg,
1365                  (valueT) frag_now_fix (), frag_now);
1366   symbol_table_insert (current_poolP);
1367
1368   ARM_SET_THUMB (current_poolP, thumb_mode);
1369
1370 #if defined OBJ_COFF || defined OBJ_ELF
1371   ARM_SET_INTERWORK (current_poolP, support_interwork);
1372 #endif
1373
1374   while (lit_count < next_literal_pool_place)
1375     /* First output the expression in the instruction to the pool.  */
1376     emit_expr (&(literals[lit_count++].exp), 4); /* .word  */
1377
1378   next_literal_pool_place = 0;
1379   current_poolP = NULL;
1380 }
1381
1382 /* Same as s_align_ptwo but align 0 => align 2.  */
1383
1384 static void
1385 s_align (unused)
1386      int unused ATTRIBUTE_UNUSED;
1387 {
1388   register int temp;
1389   register long temp_fill;
1390   long max_alignment = 15;
1391
1392   temp = get_absolute_expression ();
1393   if (temp > max_alignment)
1394     as_bad (_("Alignment too large: %d. assumed."), temp = max_alignment);
1395   else if (temp < 0)
1396     {
1397       as_bad (_("Alignment negative. 0 assumed."));
1398       temp = 0;
1399     }
1400
1401   if (*input_line_pointer == ',')
1402     {
1403       input_line_pointer++;
1404       temp_fill = get_absolute_expression ();
1405     }
1406   else
1407     temp_fill = 0;
1408
1409   if (!temp)
1410     temp = 2;
1411
1412   /* Only make a frag if we HAVE to.  */
1413   if (temp && !need_pass_2)
1414     frag_align (temp, (int) temp_fill, 0);
1415   demand_empty_rest_of_line ();
1416
1417   record_alignment (now_seg, temp);
1418 }
1419
1420 static void
1421 s_force_thumb (ignore)
1422      int ignore ATTRIBUTE_UNUSED;
1423 {
1424   /* If we are not already in thumb mode go into it, EVEN if
1425      the target processor does not support thumb instructions.
1426      This is used by gcc/config/arm/lib1funcs.asm for example
1427      to compile interworking support functions even if the
1428      target processor should not support interworking.  */
1429   if (! thumb_mode)
1430     {
1431       thumb_mode = 2;
1432
1433       record_alignment (now_seg, 1);
1434     }
1435
1436   demand_empty_rest_of_line ();
1437 }
1438
1439 static void
1440 s_thumb_func (ignore)
1441      int ignore ATTRIBUTE_UNUSED;
1442 {
1443   if (! thumb_mode)
1444     opcode_select (16);
1445
1446   /* The following label is the name/address of the start of a Thumb function.
1447      We need to know this for the interworking support.  */
1448   label_is_thumb_function_name = true;
1449
1450   demand_empty_rest_of_line ();
1451 }
1452
1453 /* Perform a .set directive, but also mark the alias as
1454    being a thumb function.  */
1455
1456 static void
1457 s_thumb_set (equiv)
1458      int equiv;
1459 {
1460   /* XXX the following is a duplicate of the code for s_set() in read.c
1461      We cannot just call that code as we need to get at the symbol that
1462      is created.  */
1463   register char *    name;
1464   register char      delim;
1465   register char *    end_name;
1466   register symbolS * symbolP;
1467
1468   /* Especial apologies for the random logic:
1469      This just grew, and could be parsed much more simply!
1470      Dean - in haste.  */
1471   name      = input_line_pointer;
1472   delim     = get_symbol_end ();
1473   end_name  = input_line_pointer;
1474   *end_name = delim;
1475
1476   SKIP_WHITESPACE ();
1477
1478   if (*input_line_pointer != ',')
1479     {
1480       *end_name = 0;
1481       as_bad (_("Expected comma after name \"%s\""), name);
1482       *end_name = delim;
1483       ignore_rest_of_line ();
1484       return;
1485     }
1486
1487   input_line_pointer++;
1488   *end_name = 0;
1489
1490   if (name[0] == '.' && name[1] == '\0')
1491     {
1492       /* XXX - this should not happen to .thumb_set.  */
1493       abort ();
1494     }
1495
1496   if ((symbolP = symbol_find (name)) == NULL
1497       && (symbolP = md_undefined_symbol (name)) == NULL)
1498     {
1499 #ifndef NO_LISTING
1500       /* When doing symbol listings, play games with dummy fragments living
1501          outside the normal fragment chain to record the file and line info
1502          for this symbol.  */
1503       if (listing & LISTING_SYMBOLS)
1504         {
1505           extern struct list_info_struct * listing_tail;
1506           fragS * dummy_frag = (fragS *) xmalloc (sizeof (fragS));
1507
1508           memset (dummy_frag, 0, sizeof (fragS));
1509           dummy_frag->fr_type = rs_fill;
1510           dummy_frag->line = listing_tail;
1511           symbolP = symbol_new (name, undefined_section, 0, dummy_frag);
1512           dummy_frag->fr_symbol = symbolP;
1513         }
1514       else
1515 #endif
1516         symbolP = symbol_new (name, undefined_section, 0, &zero_address_frag);
1517
1518 #ifdef OBJ_COFF
1519       /* "set" symbols are local unless otherwise specified.  */
1520       SF_SET_LOCAL (symbolP);
1521 #endif /* OBJ_COFF  */
1522     }                           /* Make a new symbol.  */
1523
1524   symbol_table_insert (symbolP);
1525
1526   * end_name = delim;
1527
1528   if (equiv
1529       && S_IS_DEFINED (symbolP)
1530       && S_GET_SEGMENT (symbolP) != reg_section)
1531     as_bad (_("symbol `%s' already defined"), S_GET_NAME (symbolP));
1532
1533   pseudo_set (symbolP);
1534
1535   demand_empty_rest_of_line ();
1536
1537   /* XXX Now we come to the Thumb specific bit of code.  */
1538
1539   THUMB_SET_FUNC (symbolP, 1);
1540   ARM_SET_THUMB (symbolP, 1);
1541 #if defined OBJ_ELF || defined OBJ_COFF
1542   ARM_SET_INTERWORK (symbolP, support_interwork);
1543 #endif
1544 }
1545
1546 /* If we change section we must dump the literal pool first.  */
1547
1548 static void
1549 arm_s_text (ignore)
1550      int ignore;
1551 {
1552   if (now_seg != text_section)
1553     s_ltorg (0);
1554
1555 #ifdef OBJ_ELF
1556   obj_elf_text (ignore);
1557 #else
1558   s_text (ignore);
1559 #endif
1560 }
1561
1562 static void
1563 arm_s_data (ignore)
1564      int ignore;
1565 {
1566   if (flag_readonly_data_in_text)
1567     {
1568       if (now_seg != text_section)
1569         s_ltorg (0);
1570     }
1571   else if (now_seg != data_section)
1572     s_ltorg (0);
1573
1574 #ifdef OBJ_ELF
1575   obj_elf_data (ignore);
1576 #else
1577   s_data (ignore);
1578 #endif
1579 }
1580
1581 #ifdef OBJ_ELF
1582 static void
1583 arm_s_section (ignore)
1584      int ignore;
1585 {
1586   s_ltorg (0);
1587
1588   obj_elf_section (ignore);
1589 }
1590 #endif
1591
1592 static void
1593 opcode_select (width)
1594      int width;
1595 {
1596   switch (width)
1597     {
1598     case 16:
1599       if (! thumb_mode)
1600         {
1601           if (! (cpu_variant & ARM_THUMB))
1602             as_bad (_("selected processor does not support THUMB opcodes"));
1603
1604           thumb_mode = 1;
1605           /* No need to force the alignment, since we will have been
1606              coming from ARM mode, which is word-aligned.  */
1607           record_alignment (now_seg, 1);
1608         }
1609       break;
1610
1611     case 32:
1612       if (thumb_mode)
1613         {
1614           if ((cpu_variant & ARM_ANY) == ARM_THUMB)
1615             as_bad (_("selected processor does not support ARM opcodes"));
1616
1617           thumb_mode = 0;
1618
1619           if (!need_pass_2)
1620             frag_align (2, 0, 0);
1621
1622           record_alignment (now_seg, 1);
1623         }
1624       break;
1625
1626     default:
1627       as_bad (_("invalid instruction size selected (%d)"), width);
1628     }
1629 }
1630
1631 static void
1632 s_arm (ignore)
1633      int ignore ATTRIBUTE_UNUSED;
1634 {
1635   opcode_select (32);
1636   demand_empty_rest_of_line ();
1637 }
1638
1639 static void
1640 s_thumb (ignore)
1641      int ignore ATTRIBUTE_UNUSED;
1642 {
1643   opcode_select (16);
1644   demand_empty_rest_of_line ();
1645 }
1646
1647 static void
1648 s_code (unused)
1649      int unused ATTRIBUTE_UNUSED;
1650 {
1651   register int temp;
1652
1653   temp = get_absolute_expression ();
1654   switch (temp)
1655     {
1656     case 16:
1657     case 32:
1658       opcode_select (temp);
1659       break;
1660
1661     default:
1662       as_bad (_("invalid operand to .code directive (%d) (expecting 16 or 32)"), temp);
1663     }
1664 }
1665
1666 static void
1667 end_of_line (str)
1668      char * str;
1669 {
1670   skip_whitespace (str);
1671
1672   if (* str != '\0')
1673     inst.error = _("Garbage following instruction");
1674 }
1675
1676 static int
1677 skip_past_comma (str)
1678      char ** str;
1679 {
1680   char * p = * str, c;
1681   int comma = 0;
1682
1683   while ((c = *p) == ' ' || c == ',')
1684     {
1685       p++;
1686       if (c == ',' && comma++)
1687         return FAIL;
1688     }
1689
1690   if (c == '\0')
1691     return FAIL;
1692
1693   *str = p;
1694   return comma ? SUCCESS : FAIL;
1695 }
1696
1697 /* A standard register must be given at this point.
1698    SHIFT is the place to put it in inst.instruction.
1699    Restores input start point on error.
1700    Returns the reg#, or FAIL.  */
1701
1702 static int
1703 reg_required_here (str, shift)
1704      char ** str;
1705      int     shift;
1706 {
1707   static char buff [128]; /* XXX  */
1708   int         reg;
1709   char *      start = * str;
1710
1711   if ((reg = arm_reg_parse (str)) != FAIL && int_register (reg))
1712     {
1713       if (shift >= 0)
1714         inst.instruction |= reg << shift;
1715       return reg;
1716     }
1717
1718   /* Restore the start point, we may have got a reg of the wrong class.  */
1719   *str = start;
1720
1721   /* In the few cases where we might be able to accept something else
1722      this error can be overridden.  */
1723   sprintf (buff, _("Register expected, not '%.100s'"), start);
1724   inst.error = buff;
1725
1726   return FAIL;
1727 }
1728
1729 static CONST struct asm_psr *
1730 arm_psr_parse (ccp)
1731      register char ** ccp;
1732 {
1733   char * start = * ccp;
1734   char   c;
1735   char * p;
1736   CONST struct asm_psr * psr;
1737
1738   p = start;
1739
1740   /* Skip to the end of the next word in the input stream.  */
1741   do
1742     {
1743       c = *p++;
1744     }
1745   while (isalpha (c) || c == '_');
1746
1747   /* Terminate the word.  */
1748   *--p = 0;
1749
1750   /* Now locate the word in the psr hash table.  */
1751   psr = (CONST struct asm_psr *) hash_find (arm_psr_hsh, start);
1752
1753   /* Restore the input stream.  */
1754   *p = c;
1755
1756   /* If we found a valid match, advance the
1757      stream pointer past the end of the word.  */
1758   *ccp = p;
1759
1760   return psr;
1761 }
1762
1763 /* Parse the input looking for a PSR flag.  */
1764
1765 static int
1766 psr_required_here (str)
1767      char ** str;
1768 {
1769   char * start = * str;
1770   CONST struct asm_psr * psr;
1771
1772   psr = arm_psr_parse (str);
1773
1774   if (psr)
1775     {
1776       /* If this is the SPSR that is being modified, set the R bit.  */
1777       if (! psr->cpsr)
1778         inst.instruction |= SPSR_BIT;
1779
1780       /* Set the psr flags in the MSR instruction.  */
1781       inst.instruction |= psr->field << PSR_SHIFT;
1782
1783       return SUCCESS;
1784     }
1785
1786   /* In the few cases where we might be able to accept
1787      something else this error can be overridden.  */
1788   inst.error = _("flag for {c}psr instruction expected");
1789
1790   /* Restore the start point.  */
1791   *str = start;
1792   return FAIL;
1793 }
1794
1795 static int
1796 co_proc_number (str)
1797      char ** str;
1798 {
1799   int processor, pchar;
1800
1801   skip_whitespace (* str);
1802
1803   /* The data sheet seems to imply that just a number on its own is valid
1804      here, but the RISC iX assembler seems to accept a prefix 'p'.  We will
1805      accept either.  */
1806   if (**str == 'p' || **str == 'P')
1807     (*str)++;
1808
1809   pchar = *(*str)++;
1810   if (pchar >= '0' && pchar <= '9')
1811     {
1812       processor = pchar - '0';
1813       if (**str >= '0' && **str <= '9')
1814         {
1815           processor = processor * 10 + *(*str)++ - '0';
1816           if (processor > 15)
1817             {
1818               inst.error = _("Illegal co-processor number");
1819               return FAIL;
1820             }
1821         }
1822     }
1823   else
1824     {
1825       inst.error = _("Bad or missing co-processor number");
1826       return FAIL;
1827     }
1828
1829   inst.instruction |= processor << 8;
1830   return SUCCESS;
1831 }
1832
1833 static int
1834 cp_opc_expr (str, where, length)
1835      char ** str;
1836      int where;
1837      int length;
1838 {
1839   expressionS expr;
1840
1841   skip_whitespace (* str);
1842
1843   memset (&expr, '\0', sizeof (expr));
1844
1845   if (my_get_expression (&expr, str))
1846     return FAIL;
1847   if (expr.X_op != O_constant)
1848     {
1849       inst.error = _("bad or missing expression");
1850       return FAIL;
1851     }
1852
1853   if ((expr.X_add_number & ((1 << length) - 1)) != expr.X_add_number)
1854     {
1855       inst.error = _("immediate co-processor expression too large");
1856       return FAIL;
1857     }
1858
1859   inst.instruction |= expr.X_add_number << where;
1860   return SUCCESS;
1861 }
1862
1863 static int
1864 cp_reg_required_here (str, where)
1865      char ** str;
1866      int     where;
1867 {
1868   int    reg;
1869   char * start = *str;
1870
1871   if ((reg = arm_reg_parse (str)) != FAIL && cp_register (reg))
1872     {
1873       reg &= 15;
1874       inst.instruction |= reg << where;
1875       return reg;
1876     }
1877
1878   /* In the few cases where we might be able to accept something else
1879      this error can be overridden.  */
1880   inst.error = _("Co-processor register expected");
1881
1882   /* Restore the start point.  */
1883   *str = start;
1884   return FAIL;
1885 }
1886
1887 static int
1888 fp_reg_required_here (str, where)
1889      char ** str;
1890      int     where;
1891 {
1892   int    reg;
1893   char * start = * str;
1894
1895   if ((reg = arm_reg_parse (str)) != FAIL && fp_register (reg))
1896     {
1897       reg &= 7;
1898       inst.instruction |= reg << where;
1899       return reg;
1900     }
1901
1902   /* In the few cases where we might be able to accept something else
1903      this error can be overridden.  */
1904   inst.error = _("Floating point register expected");
1905
1906   /* Restore the start point.  */
1907   *str = start;
1908   return FAIL;
1909 }
1910
1911 static int
1912 cp_address_offset (str)
1913      char ** str;
1914 {
1915   int offset;
1916
1917   skip_whitespace (* str);
1918
1919   if (! is_immediate_prefix (**str))
1920     {
1921       inst.error = _("immediate expression expected");
1922       return FAIL;
1923     }
1924
1925   (*str)++;
1926
1927   if (my_get_expression (& inst.reloc.exp, str))
1928     return FAIL;
1929
1930   if (inst.reloc.exp.X_op == O_constant)
1931     {
1932       offset = inst.reloc.exp.X_add_number;
1933
1934       if (offset & 3)
1935         {
1936           inst.error = _("co-processor address must be word aligned");
1937           return FAIL;
1938         }
1939
1940       if (offset > 1023 || offset < -1023)
1941         {
1942           inst.error = _("offset too large");
1943           return FAIL;
1944         }
1945
1946       if (offset >= 0)
1947         inst.instruction |= INDEX_UP;
1948       else
1949         offset = -offset;
1950
1951       inst.instruction |= offset >> 2;
1952     }
1953   else
1954     inst.reloc.type = BFD_RELOC_ARM_CP_OFF_IMM;
1955
1956   return SUCCESS;
1957 }
1958
1959 static int
1960 cp_address_required_here (str)
1961      char ** str;
1962 {
1963   char * p = * str;
1964   int    pre_inc = 0;
1965   int    write_back = 0;
1966
1967   if (*p == '[')
1968     {
1969       int reg;
1970
1971       p++;
1972       skip_whitespace (p);
1973
1974       if ((reg = reg_required_here (& p, 16)) == FAIL)
1975         return FAIL;
1976
1977       skip_whitespace (p);
1978
1979       if (*p == ']')
1980         {
1981           p++;
1982
1983           if (skip_past_comma (& p) == SUCCESS)
1984             {
1985               /* [Rn], #expr  */
1986               write_back = WRITE_BACK;
1987
1988               if (reg == REG_PC)
1989                 {
1990                   inst.error = _("pc may not be used in post-increment");
1991                   return FAIL;
1992                 }
1993
1994               if (cp_address_offset (& p) == FAIL)
1995                 return FAIL;
1996             }
1997           else
1998             pre_inc = PRE_INDEX | INDEX_UP;
1999         }
2000       else
2001         {
2002           /* '['Rn, #expr']'[!]  */
2003
2004           if (skip_past_comma (& p) == FAIL)
2005             {
2006               inst.error = _("pre-indexed expression expected");
2007               return FAIL;
2008             }
2009
2010           pre_inc = PRE_INDEX;
2011
2012           if (cp_address_offset (& p) == FAIL)
2013             return FAIL;
2014
2015           skip_whitespace (p);
2016
2017           if (*p++ != ']')
2018             {
2019               inst.error = _("missing ]");
2020               return FAIL;
2021             }
2022
2023           skip_whitespace (p);
2024
2025           if (*p == '!')
2026             {
2027               if (reg == REG_PC)
2028                 {
2029                   inst.error = _("pc may not be used with write-back");
2030                   return FAIL;
2031                 }
2032
2033               p++;
2034               write_back = WRITE_BACK;
2035             }
2036         }
2037     }
2038   else
2039     {
2040       if (my_get_expression (&inst.reloc.exp, &p))
2041         return FAIL;
2042
2043       inst.reloc.type = BFD_RELOC_ARM_CP_OFF_IMM;
2044       inst.reloc.exp.X_add_number -= 8;  /* PC rel adjust.  */
2045       inst.reloc.pc_rel = 1;
2046       inst.instruction |= (REG_PC << 16);
2047       pre_inc = PRE_INDEX;
2048     }
2049
2050   inst.instruction |= write_back | pre_inc;
2051   *str = p;
2052   return SUCCESS;
2053 }
2054
2055 static void
2056 do_nop (str, flags)
2057      char * str;
2058      unsigned long flags;
2059 {
2060   /* Do nothing really.  */
2061   inst.instruction |= flags; /* This is pointless.  */
2062   end_of_line (str);
2063   return;
2064 }
2065
2066 static void
2067 do_mrs (str, flags)
2068      char *str;
2069      unsigned long flags;
2070 {
2071   int skip = 0;
2072
2073   /* Only one syntax.  */
2074   skip_whitespace (str);
2075
2076   if (reg_required_here (&str, 12) == FAIL)
2077     {
2078       inst.error = BAD_ARGS;
2079       return;
2080     }
2081
2082   if (skip_past_comma (&str) == FAIL)
2083     {
2084       inst.error = _("comma expected after register name");
2085       return;
2086     }
2087
2088   skip_whitespace (str);
2089
2090   if (   strcmp (str, "CPSR") == 0
2091       || strcmp (str, "SPSR") == 0
2092          /* Lower case versions for backwards compatability.  */
2093       || strcmp (str, "cpsr") == 0
2094       || strcmp (str, "spsr") == 0)
2095     skip = 4;
2096
2097   /* This is for backwards compatability with older toolchains.  */
2098   else if (   strcmp (str, "cpsr_all") == 0
2099            || strcmp (str, "spsr_all") == 0)
2100     skip = 8;
2101   else
2102     {
2103       inst.error = _("{C|S}PSR expected");
2104       return;
2105     }
2106
2107   if (* str == 's' || * str == 'S')
2108     inst.instruction |= SPSR_BIT;
2109   str += skip;
2110
2111   inst.instruction |= flags;
2112   end_of_line (str);
2113 }
2114
2115 /* Two possible forms:
2116       "{C|S}PSR_<field>, Rm",
2117       "{C|S}PSR_f, #expression".  */
2118
2119 static void
2120 do_msr (str, flags)
2121      char * str;
2122      unsigned long flags;
2123 {
2124   skip_whitespace (str);
2125
2126   if (psr_required_here (& str) == FAIL)
2127     return;
2128
2129   if (skip_past_comma (& str) == FAIL)
2130     {
2131       inst.error = _("comma missing after psr flags");
2132       return;
2133     }
2134
2135   skip_whitespace (str);
2136
2137   if (reg_required_here (& str, 0) != FAIL)
2138     {
2139       inst.error = NULL;
2140       inst.instruction |= flags;
2141       end_of_line (str);
2142       return;
2143     }
2144
2145   if (! is_immediate_prefix (* str))
2146     {
2147       inst.error =
2148         _("only a register or immediate value can follow a psr flag");
2149       return;
2150     }
2151
2152   str ++;
2153   inst.error = NULL;
2154
2155   if (my_get_expression (& inst.reloc.exp, & str))
2156     {
2157       inst.error =
2158         _("only a register or immediate value can follow a psr flag");
2159       return;
2160     }
2161
2162   if (inst.instruction & ((PSR_c | PSR_x | PSR_s) << PSR_SHIFT))
2163     {
2164       inst.error = _("can only set flag field with immediate value");
2165       return;
2166     }
2167
2168   flags |= INST_IMMEDIATE;
2169
2170   if (inst.reloc.exp.X_add_symbol)
2171     {
2172       inst.reloc.type = BFD_RELOC_ARM_IMMEDIATE;
2173       inst.reloc.pc_rel = 0;
2174     }
2175   else
2176     {
2177       unsigned value = validate_immediate (inst.reloc.exp.X_add_number);
2178
2179       if (value == (unsigned) FAIL)
2180         {
2181           inst.error = _("Invalid constant");
2182           return;
2183         }
2184
2185       inst.instruction |= value;
2186     }
2187
2188   inst.error = NULL;
2189   inst.instruction |= flags;
2190   end_of_line (str);
2191 }
2192
2193 /* Long Multiply Parser
2194    UMULL RdLo, RdHi, Rm, Rs
2195    SMULL RdLo, RdHi, Rm, Rs
2196    UMLAL RdLo, RdHi, Rm, Rs
2197    SMLAL RdLo, RdHi, Rm, Rs.  */
2198
2199 static void
2200 do_mull (str, flags)
2201      char * str;
2202      unsigned long flags;
2203 {
2204   int rdlo, rdhi, rm, rs;
2205
2206   /* Only one format "rdlo, rdhi, rm, rs".  */
2207   skip_whitespace (str);
2208
2209   if ((rdlo = reg_required_here (&str, 12)) == FAIL)
2210     {
2211       inst.error = BAD_ARGS;
2212       return;
2213     }
2214
2215   if (skip_past_comma (&str) == FAIL
2216       || (rdhi = reg_required_here (&str, 16)) == FAIL)
2217     {
2218       inst.error = BAD_ARGS;
2219       return;
2220     }
2221
2222   if (skip_past_comma (&str) == FAIL
2223       || (rm = reg_required_here (&str, 0)) == FAIL)
2224     {
2225       inst.error = BAD_ARGS;
2226       return;
2227     }
2228
2229   /* rdhi, rdlo and rm must all be different.  */
2230   if (rdlo == rdhi || rdlo == rm || rdhi == rm)
2231     as_tsktsk (_("rdhi, rdlo and rm must all be different"));
2232
2233   if (skip_past_comma (&str) == FAIL
2234       || (rs = reg_required_here (&str, 8)) == FAIL)
2235     {
2236       inst.error = BAD_ARGS;
2237       return;
2238     }
2239
2240   if (rdhi == REG_PC || rdhi == REG_PC || rdhi == REG_PC || rdhi == REG_PC)
2241     {
2242       inst.error = BAD_PC;
2243       return;
2244     }
2245
2246   inst.instruction |= flags;
2247   end_of_line (str);
2248   return;
2249 }
2250
2251 static void
2252 do_mul (str, flags)
2253      char * str;
2254      unsigned long flags;
2255 {
2256   int rd, rm;
2257
2258   /* Only one format "rd, rm, rs".  */
2259   skip_whitespace (str);
2260
2261   if ((rd = reg_required_here (&str, 16)) == FAIL)
2262     {
2263       inst.error = BAD_ARGS;
2264       return;
2265     }
2266
2267   if (rd == REG_PC)
2268     {
2269       inst.error = BAD_PC;
2270       return;
2271     }
2272
2273   if (skip_past_comma (&str) == FAIL
2274       || (rm = reg_required_here (&str, 0)) == FAIL)
2275     {
2276       inst.error = BAD_ARGS;
2277       return;
2278     }
2279
2280   if (rm == REG_PC)
2281     {
2282       inst.error = BAD_PC;
2283       return;
2284     }
2285
2286   if (rm == rd)
2287     as_tsktsk (_("rd and rm should be different in mul"));
2288
2289   if (skip_past_comma (&str) == FAIL
2290       || (rm = reg_required_here (&str, 8)) == FAIL)
2291     {
2292       inst.error = BAD_ARGS;
2293       return;
2294     }
2295
2296   if (rm == REG_PC)
2297     {
2298       inst.error = BAD_PC;
2299       return;
2300     }
2301
2302   inst.instruction |= flags;
2303   end_of_line (str);
2304   return;
2305 }
2306
2307 static void
2308 do_mla (str, flags)
2309      char * str;
2310      unsigned long flags;
2311 {
2312   int rd, rm;
2313
2314   /* Only one format "rd, rm, rs, rn".  */
2315   skip_whitespace (str);
2316
2317   if ((rd = reg_required_here (&str, 16)) == FAIL)
2318     {
2319       inst.error = BAD_ARGS;
2320       return;
2321     }
2322
2323   if (rd == REG_PC)
2324     {
2325       inst.error = BAD_PC;
2326       return;
2327     }
2328
2329   if (skip_past_comma (&str) == FAIL
2330       || (rm = reg_required_here (&str, 0)) == FAIL)
2331     {
2332       inst.error = BAD_ARGS;
2333       return;
2334     }
2335
2336   if (rm == REG_PC)
2337     {
2338       inst.error = BAD_PC;
2339       return;
2340     }
2341
2342   if (rm == rd)
2343     as_tsktsk (_("rd and rm should be different in mla"));
2344
2345   if (skip_past_comma (&str) == FAIL
2346       || (rd = reg_required_here (&str, 8)) == FAIL
2347       || skip_past_comma (&str) == FAIL
2348       || (rm = reg_required_here (&str, 12)) == FAIL)
2349     {
2350       inst.error = BAD_ARGS;
2351       return;
2352     }
2353
2354   if (rd == REG_PC || rm == REG_PC)
2355     {
2356       inst.error = BAD_PC;
2357       return;
2358     }
2359
2360   inst.instruction |= flags;
2361   end_of_line (str);
2362   return;
2363 }
2364
2365 /* Returns the index into fp_values of a floating point number,
2366    or -1 if not in the table.  */
2367
2368 static int
2369 my_get_float_expression (str)
2370      char ** str;
2371 {
2372   LITTLENUM_TYPE words[MAX_LITTLENUMS];
2373   char *         save_in;
2374   expressionS    exp;
2375   int            i;
2376   int            j;
2377
2378   memset (words, 0, MAX_LITTLENUMS * sizeof (LITTLENUM_TYPE));
2379
2380   /* Look for a raw floating point number.  */
2381   if ((save_in = atof_ieee (*str, 'x', words)) != NULL
2382       && is_end_of_line[(unsigned char) *save_in])
2383     {
2384       for (i = 0; i < NUM_FLOAT_VALS; i++)
2385         {
2386           for (j = 0; j < MAX_LITTLENUMS; j++)
2387             {
2388               if (words[j] != fp_values[i][j])
2389                 break;
2390             }
2391
2392           if (j == MAX_LITTLENUMS)
2393             {
2394               *str = save_in;
2395               return i;
2396             }
2397         }
2398     }
2399
2400   /* Try and parse a more complex expression, this will probably fail
2401      unless the code uses a floating point prefix (eg "0f").  */
2402   save_in = input_line_pointer;
2403   input_line_pointer = *str;
2404   if (expression (&exp) == absolute_section
2405       && exp.X_op == O_big
2406       && exp.X_add_number < 0)
2407     {
2408       /* FIXME: 5 = X_PRECISION, should be #define'd where we can use it.
2409          Ditto for 15.  */
2410       if (gen_to_words (words, 5, (long) 15) == 0)
2411         {
2412           for (i = 0; i < NUM_FLOAT_VALS; i++)
2413             {
2414               for (j = 0; j < MAX_LITTLENUMS; j++)
2415                 {
2416                   if (words[j] != fp_values[i][j])
2417                     break;
2418                 }
2419
2420               if (j == MAX_LITTLENUMS)
2421                 {
2422                   *str = input_line_pointer;
2423                   input_line_pointer = save_in;
2424                   return i;
2425                 }
2426             }
2427         }
2428     }
2429
2430   *str = input_line_pointer;
2431   input_line_pointer = save_in;
2432   return -1;
2433 }
2434
2435 /* Return true if anything in the expression is a bignum.  */
2436
2437 static int
2438 walk_no_bignums (sp)
2439      symbolS * sp;
2440 {
2441   if (symbol_get_value_expression (sp)->X_op == O_big)
2442     return 1;
2443
2444   if (symbol_get_value_expression (sp)->X_add_symbol)
2445     {
2446       return (walk_no_bignums (symbol_get_value_expression (sp)->X_add_symbol)
2447               || (symbol_get_value_expression (sp)->X_op_symbol
2448                   && walk_no_bignums (symbol_get_value_expression (sp)->X_op_symbol)));
2449     }
2450
2451   return 0;
2452 }
2453
2454 static int
2455 my_get_expression (ep, str)
2456      expressionS * ep;
2457      char ** str;
2458 {
2459   char * save_in;
2460   segT   seg;
2461
2462   save_in = input_line_pointer;
2463   input_line_pointer = *str;
2464   seg = expression (ep);
2465
2466 #ifdef OBJ_AOUT
2467   if (seg != absolute_section
2468       && seg != text_section
2469       && seg != data_section
2470       && seg != bss_section
2471       && seg != undefined_section)
2472     {
2473       inst.error = _("bad_segment");
2474       *str = input_line_pointer;
2475       input_line_pointer = save_in;
2476       return 1;
2477     }
2478 #endif
2479
2480   /* Get rid of any bignums now, so that we don't generate an error for which
2481      we can't establish a line number later on.  Big numbers are never valid
2482      in instructions, which is where this routine is always called.  */
2483   if (ep->X_op == O_big
2484       || (ep->X_add_symbol
2485           && (walk_no_bignums (ep->X_add_symbol)
2486               || (ep->X_op_symbol
2487                   && walk_no_bignums (ep->X_op_symbol)))))
2488     {
2489       inst.error = _("Invalid constant");
2490       *str = input_line_pointer;
2491       input_line_pointer = save_in;
2492       return 1;
2493     }
2494
2495   *str = input_line_pointer;
2496   input_line_pointer = save_in;
2497   return 0;
2498 }
2499
2500 /* UNRESTRICT should be one if <shift> <register> is permitted for this
2501    instruction.  */
2502
2503 static int
2504 decode_shift (str, unrestrict)
2505      char ** str;
2506      int     unrestrict;
2507 {
2508   struct asm_shift * shft;
2509   char * p;
2510   char   c;
2511
2512   skip_whitespace (* str);
2513
2514   for (p = * str; isalpha (* p); p ++)
2515     ;
2516
2517   if (p == * str)
2518     {
2519       inst.error = _("Shift expression expected");
2520       return FAIL;
2521     }
2522
2523   c = * p;
2524   * p = '\0';
2525   shft = (struct asm_shift *) hash_find (arm_shift_hsh, * str);
2526   * p = c;
2527   if (shft)
2528     {
2529       if (   ! strncmp (* str, "rrx", 3)
2530           || ! strncmp (* str, "RRX", 3))
2531         {
2532           * str = p;
2533           inst.instruction |= shft->value;
2534           return SUCCESS;
2535         }
2536
2537       skip_whitespace (p);
2538
2539       if (unrestrict && reg_required_here (& p, 8) != FAIL)
2540         {
2541           inst.instruction |= shft->value | SHIFT_BY_REG;
2542           * str = p;
2543           return SUCCESS;
2544         }
2545       else if (is_immediate_prefix (* p))
2546         {
2547           inst.error = NULL;
2548           p ++;
2549
2550           if (my_get_expression (& inst.reloc.exp, & p))
2551             return FAIL;
2552
2553           /* Validate some simple #expressions.  */
2554           if (inst.reloc.exp.X_op == O_constant)
2555             {
2556               unsigned num = inst.reloc.exp.X_add_number;
2557
2558               /* Reject operations greater than 32, or lsl #32.  */
2559               if (num > 32 || (num == 32 && shft->value == 0))
2560                 {
2561                   inst.error = _("Invalid immediate shift");
2562                   return FAIL;
2563                 }
2564
2565               /* Shifts of zero should be converted to lsl
2566                  (which is zero).  */
2567               if (num == 0)
2568                 {
2569                   * str = p;
2570                   return SUCCESS;
2571                 }
2572
2573               /* Shifts of 32 are encoded as 0, for those shifts that
2574                  support it.  */
2575               if (num == 32)
2576                 num = 0;
2577
2578               inst.instruction |= (num << 7) | shft->value;
2579               * str = p;
2580               return SUCCESS;
2581             }
2582
2583           inst.reloc.type   = BFD_RELOC_ARM_SHIFT_IMM;
2584           inst.reloc.pc_rel = 0;
2585           inst.instruction |= shft->value;
2586
2587           * str = p;
2588           return SUCCESS;
2589         }
2590       else
2591         {
2592           inst.error = (unrestrict
2593                         ? _("shift requires register or #expression")
2594                         : _("shift requires #expression"));
2595           * str = p;
2596           return FAIL;
2597         }
2598     }
2599
2600   inst.error = _("Shift expression expected");
2601   return FAIL;
2602 }
2603
2604 /* Do those data_ops which can take a negative immediate constant
2605    by altering the instuction.  A bit of a hack really.
2606         MOV <-> MVN
2607         AND <-> BIC
2608         ADC <-> SBC
2609         by inverting the second operand, and
2610         ADD <-> SUB
2611         CMP <-> CMN
2612         by negating the second operand.  */
2613
2614 static int
2615 negate_data_op (instruction, value)
2616      unsigned long * instruction;
2617      unsigned long   value;
2618 {
2619   int op, new_inst;
2620   unsigned long negated, inverted;
2621
2622   negated = validate_immediate (-value);
2623   inverted = validate_immediate (~value);
2624
2625   op = (*instruction >> DATA_OP_SHIFT) & 0xf;
2626   switch (op)
2627     {
2628       /* First negates.  */
2629     case OPCODE_SUB:             /* ADD <-> SUB  */
2630       new_inst = OPCODE_ADD;
2631       value = negated;
2632       break;
2633
2634     case OPCODE_ADD:
2635       new_inst = OPCODE_SUB;
2636       value = negated;
2637       break;
2638
2639     case OPCODE_CMP:             /* CMP <-> CMN  */
2640       new_inst = OPCODE_CMN;
2641       value = negated;
2642       break;
2643
2644     case OPCODE_CMN:
2645       new_inst = OPCODE_CMP;
2646       value = negated;
2647       break;
2648
2649       /* Now Inverted ops.  */
2650     case OPCODE_MOV:             /* MOV <-> MVN  */
2651       new_inst = OPCODE_MVN;
2652       value = inverted;
2653       break;
2654
2655     case OPCODE_MVN:
2656       new_inst = OPCODE_MOV;
2657       value = inverted;
2658       break;
2659
2660     case OPCODE_AND:             /* AND <-> BIC  */
2661       new_inst = OPCODE_BIC;
2662       value = inverted;
2663       break;
2664
2665     case OPCODE_BIC:
2666       new_inst = OPCODE_AND;
2667       value = inverted;
2668       break;
2669
2670     case OPCODE_ADC:              /* ADC <-> SBC  */
2671       new_inst = OPCODE_SBC;
2672       value = inverted;
2673       break;
2674
2675     case OPCODE_SBC:
2676       new_inst = OPCODE_ADC;
2677       value = inverted;
2678       break;
2679
2680       /* We cannot do anything.  */
2681     default:
2682       return FAIL;
2683     }
2684
2685   if (value == (unsigned) FAIL)
2686     return FAIL;
2687
2688   *instruction &= OPCODE_MASK;
2689   *instruction |= new_inst << DATA_OP_SHIFT;
2690   return value;
2691 }
2692
2693 static int
2694 data_op2 (str)
2695      char ** str;
2696 {
2697   int value;
2698   expressionS expr;
2699
2700   skip_whitespace (* str);
2701
2702   if (reg_required_here (str, 0) != FAIL)
2703     {
2704       if (skip_past_comma (str) == SUCCESS)
2705         /* Shift operation on register.  */
2706         return decode_shift (str, NO_SHIFT_RESTRICT);
2707
2708       return SUCCESS;
2709     }
2710   else
2711     {
2712       /* Immediate expression.  */
2713       if (is_immediate_prefix (**str))
2714         {
2715           (*str)++;
2716           inst.error = NULL;
2717
2718           if (my_get_expression (&inst.reloc.exp, str))
2719             return FAIL;
2720
2721           if (inst.reloc.exp.X_add_symbol)
2722             {
2723               inst.reloc.type = BFD_RELOC_ARM_IMMEDIATE;
2724               inst.reloc.pc_rel = 0;
2725             }
2726           else
2727             {
2728               if (skip_past_comma (str) == SUCCESS)
2729                 {
2730                   /* #x, y -- ie explicit rotation by Y.  */
2731                   if (my_get_expression (&expr, str))
2732                     return FAIL;
2733
2734                   if (expr.X_op != O_constant)
2735                     {
2736                       inst.error = _("Constant expression expected");
2737                       return FAIL;
2738                     }
2739
2740                   /* Rotate must be a multiple of 2.  */
2741                   if (((unsigned) expr.X_add_number) > 30
2742                       || (expr.X_add_number & 1) != 0
2743                       || ((unsigned) inst.reloc.exp.X_add_number) > 255)
2744                     {
2745                       inst.error = _("Invalid constant");
2746                       return FAIL;
2747                     }
2748                   inst.instruction |= INST_IMMEDIATE;
2749                   inst.instruction |= inst.reloc.exp.X_add_number;
2750                   inst.instruction |= expr.X_add_number << 7;
2751                   return SUCCESS;
2752                 }
2753
2754               /* Implicit rotation, select a suitable one.  */
2755               value = validate_immediate (inst.reloc.exp.X_add_number);
2756
2757               if (value == FAIL)
2758                 {
2759                   /* Can't be done.  Perhaps the code reads something like
2760                      "add Rd, Rn, #-n", where "sub Rd, Rn, #n" would be OK.  */
2761                   if ((value = negate_data_op (&inst.instruction,
2762                                                inst.reloc.exp.X_add_number))
2763                       == FAIL)
2764                     {
2765                       inst.error = _("Invalid constant");
2766                       return FAIL;
2767                     }
2768                 }
2769
2770               inst.instruction |= value;
2771             }
2772
2773           inst.instruction |= INST_IMMEDIATE;
2774           return SUCCESS;
2775         }
2776
2777       (*str)++;
2778       inst.error = _("Register or shift expression expected");
2779       return FAIL;
2780     }
2781 }
2782
2783 static int
2784 fp_op2 (str)
2785      char ** str;
2786 {
2787   skip_whitespace (* str);
2788
2789   if (fp_reg_required_here (str, 0) != FAIL)
2790     return SUCCESS;
2791   else
2792     {
2793       /* Immediate expression.  */
2794       if (*((*str)++) == '#')
2795         {
2796           int i;
2797
2798           inst.error = NULL;
2799
2800           skip_whitespace (* str);
2801
2802           /* First try and match exact strings, this is to guarantee
2803              that some formats will work even for cross assembly.  */
2804
2805           for (i = 0; fp_const[i]; i++)
2806             {
2807               if (strncmp (*str, fp_const[i], strlen (fp_const[i])) == 0)
2808                 {
2809                   char *start = *str;
2810
2811                   *str += strlen (fp_const[i]);
2812                   if (is_end_of_line[(unsigned char) **str])
2813                     {
2814                       inst.instruction |= i + 8;
2815                       return SUCCESS;
2816                     }
2817                   *str = start;
2818                 }
2819             }
2820
2821           /* Just because we didn't get a match doesn't mean that the
2822              constant isn't valid, just that it is in a format that we
2823              don't automatically recognize.  Try parsing it with
2824              the standard expression routines.  */
2825           if ((i = my_get_float_expression (str)) >= 0)
2826             {
2827               inst.instruction |= i + 8;
2828               return SUCCESS;
2829             }
2830
2831           inst.error = _("Invalid floating point immediate expression");
2832           return FAIL;
2833         }
2834       inst.error =
2835         _("Floating point register or immediate expression expected");
2836       return FAIL;
2837     }
2838 }
2839
2840 static void
2841 do_arit (str, flags)
2842      char * str;
2843      unsigned long flags;
2844 {
2845   skip_whitespace (str);
2846
2847   if (reg_required_here (&str, 12) == FAIL
2848       || skip_past_comma (&str) == FAIL
2849       || reg_required_here (&str, 16) == FAIL
2850       || skip_past_comma (&str) == FAIL
2851       || data_op2 (&str) == FAIL)
2852     {
2853       if (!inst.error)
2854         inst.error = BAD_ARGS;
2855       return;
2856     }
2857
2858   inst.instruction |= flags;
2859   end_of_line (str);
2860   return;
2861 }
2862
2863 static void
2864 do_adr (str, flags)
2865      char * str;
2866      unsigned long flags;
2867 {
2868   /* This is a pseudo-op of the form "adr rd, label" to be converted
2869      into a relative address of the form "add rd, pc, #label-.-8".  */
2870   skip_whitespace (str);
2871
2872   if (reg_required_here (&str, 12) == FAIL
2873       || skip_past_comma (&str) == FAIL
2874       || my_get_expression (&inst.reloc.exp, &str))
2875     {
2876       if (!inst.error)
2877         inst.error = BAD_ARGS;
2878       return;
2879     }
2880
2881   /* Frag hacking will turn this into a sub instruction if the offset turns
2882      out to be negative.  */
2883   inst.reloc.type = BFD_RELOC_ARM_IMMEDIATE;
2884   inst.reloc.exp.X_add_number -= 8; /* PC relative adjust.  */
2885   inst.reloc.pc_rel = 1;
2886   inst.instruction |= flags;
2887
2888   end_of_line (str);
2889 }
2890
2891 static void
2892 do_adrl (str, flags)
2893      char * str;
2894      unsigned long flags;
2895 {
2896   /* This is a pseudo-op of the form "adrl rd, label" to be converted
2897      into a relative address of the form:
2898         add rd, pc, #low(label-.-8)"
2899         add rd, rd, #high(label-.-8)"  */
2900
2901   skip_whitespace (str);
2902
2903   if (reg_required_here (& str, 12) == FAIL
2904       || skip_past_comma (& str) == FAIL
2905       || my_get_expression (& inst.reloc.exp, & str))
2906     {
2907       if (!inst.error)
2908         inst.error = BAD_ARGS;
2909       return;
2910     }
2911
2912   end_of_line (str);
2913
2914   /* Frag hacking will turn this into a sub instruction if the offset turns
2915      out to be negative.  */
2916   inst.reloc.type              = BFD_RELOC_ARM_ADRL_IMMEDIATE;
2917   inst.reloc.exp.X_add_number -= 8; /* PC relative adjust  */
2918   inst.reloc.pc_rel            = 1;
2919   inst.instruction            |= flags;
2920   inst.size                    = INSN_SIZE * 2;
2921
2922   return;
2923 }
2924
2925 static void
2926 do_cmp (str, flags)
2927      char * str;
2928      unsigned long flags;
2929 {
2930   skip_whitespace (str);
2931
2932   if (reg_required_here (&str, 16) == FAIL)
2933     {
2934       if (!inst.error)
2935         inst.error = BAD_ARGS;
2936       return;
2937     }
2938
2939   if (skip_past_comma (&str) == FAIL
2940       || data_op2 (&str) == FAIL)
2941     {
2942       if (!inst.error)
2943         inst.error = BAD_ARGS;
2944       return;
2945     }
2946
2947   inst.instruction |= flags;
2948   if ((flags & 0x0000f000) == 0)
2949     inst.instruction |= CONDS_BIT;
2950
2951   end_of_line (str);
2952   return;
2953 }
2954
2955 static void
2956 do_mov (str, flags)
2957      char * str;
2958      unsigned long flags;
2959 {
2960   skip_whitespace (str);
2961
2962   if (reg_required_here (&str, 12) == FAIL)
2963     {
2964       if (!inst.error)
2965         inst.error = BAD_ARGS;
2966       return;
2967     }
2968
2969   if (skip_past_comma (&str) == FAIL
2970       || data_op2 (&str) == FAIL)
2971     {
2972       if (!inst.error)
2973         inst.error = BAD_ARGS;
2974       return;
2975     }
2976
2977   inst.instruction |= flags;
2978   end_of_line (str);
2979   return;
2980 }
2981
2982 static int
2983 ldst_extend (str, hwse)
2984      char ** str;
2985      int     hwse;
2986 {
2987   int add = INDEX_UP;
2988
2989   switch (**str)
2990     {
2991     case '#':
2992     case '$':
2993       (*str)++;
2994       if (my_get_expression (& inst.reloc.exp, str))
2995         return FAIL;
2996
2997       if (inst.reloc.exp.X_op == O_constant)
2998         {
2999           int value = inst.reloc.exp.X_add_number;
3000
3001           if ((hwse && (value < -255 || value > 255))
3002               || (value < -4095 || value > 4095))
3003             {
3004               inst.error = _("address offset too large");
3005               return FAIL;
3006             }
3007
3008           if (value < 0)
3009             {
3010               value = -value;
3011               add = 0;
3012             }
3013
3014           /* Halfword and signextension instructions have the
3015              immediate value split across bits 11..8 and bits 3..0.  */
3016           if (hwse)
3017             inst.instruction |= (add | HWOFFSET_IMM
3018                                  | ((value >> 4) << 8) | (value & 0xF));
3019           else
3020             inst.instruction |= add | value;
3021         }
3022       else
3023         {
3024           if (hwse)
3025             {
3026               inst.instruction |= HWOFFSET_IMM;
3027               inst.reloc.type = BFD_RELOC_ARM_OFFSET_IMM8;
3028             }
3029           else
3030             inst.reloc.type = BFD_RELOC_ARM_OFFSET_IMM;
3031           inst.reloc.pc_rel = 0;
3032         }
3033       return SUCCESS;
3034
3035     case '-':
3036       add = 0;
3037       /* Fall through.  */
3038
3039     case '+':
3040       (*str)++;
3041       /* Fall through.  */
3042
3043     default:
3044       if (reg_required_here (str, 0) == FAIL)
3045         return FAIL;
3046
3047       if (hwse)
3048         inst.instruction |= add;
3049       else
3050         {
3051           inst.instruction |= add | OFFSET_REG;
3052           if (skip_past_comma (str) == SUCCESS)
3053             return decode_shift (str, SHIFT_RESTRICT);
3054         }
3055
3056       return SUCCESS;
3057     }
3058 }
3059
3060 static void
3061 do_ldst (str, flags)
3062      char *str;
3063      unsigned long flags;
3064 {
3065   int halfword = 0;
3066   int pre_inc = 0;
3067   int conflict_reg;
3068   int value;
3069
3070   /* This is not ideal, but it is the simplest way of dealing with the
3071      ARM7T halfword instructions (since they use a different
3072      encoding, but the same mnemonic):  */
3073   halfword = (flags & 0x80000000) != 0;
3074   if (halfword)
3075     {
3076       /* This is actually a load/store of a halfword, or a
3077          signed-extension load.  */
3078       if ((cpu_variant & ARM_HALFWORD) == 0)
3079         {
3080           inst.error
3081             = _("Processor does not support halfwords or signed bytes");
3082           return;
3083         }
3084
3085       inst.instruction = ((inst.instruction & COND_MASK)
3086                           | (flags & ~COND_MASK));
3087
3088       flags = 0;
3089     }
3090
3091   skip_whitespace (str);
3092
3093   if ((conflict_reg = reg_required_here (& str, 12)) == FAIL)
3094     {
3095       if (!inst.error)
3096         inst.error = BAD_ARGS;
3097       return;
3098     }
3099
3100   if (skip_past_comma (& str) == FAIL)
3101     {
3102       inst.error = _("Address expected");
3103       return;
3104     }
3105
3106   if (*str == '[')
3107     {
3108       int reg;
3109
3110       str++;
3111
3112       skip_whitespace (str);
3113
3114       if ((reg = reg_required_here (&str, 16)) == FAIL)
3115         return;
3116
3117       /* Conflicts can occur on stores as well as loads.  */
3118       conflict_reg = (conflict_reg == reg);
3119
3120       skip_whitespace (str);
3121
3122       if (*str == ']')
3123         {
3124           str ++;
3125
3126           if (skip_past_comma (&str) == SUCCESS)
3127             {
3128               /* [Rn],... (post inc)  */
3129               if (ldst_extend (&str, halfword) == FAIL)
3130                 return;
3131               if (conflict_reg)
3132                 as_warn (_("%s register same as write-back base"),
3133                          ((inst.instruction & LOAD_BIT)
3134                           ? _("destination") : _("source")));
3135             }
3136           else
3137             {
3138               /* [Rn]  */
3139               if (halfword)
3140                 inst.instruction |= HWOFFSET_IMM;
3141
3142               skip_whitespace (str);
3143
3144               if (*str == '!')
3145                 {
3146                   if (conflict_reg)
3147                     as_warn (_("%s register same as write-back base"),
3148                              ((inst.instruction & LOAD_BIT)
3149                               ? _("destination") : _("source")));
3150                   str++;
3151                   inst.instruction |= WRITE_BACK;
3152                 }
3153
3154               flags |= INDEX_UP;
3155               if (! (flags & TRANS_BIT))
3156                 pre_inc = 1;
3157             }
3158         }
3159       else
3160         {
3161           /* [Rn,...]  */
3162           if (skip_past_comma (&str) == FAIL)
3163             {
3164               inst.error = _("pre-indexed expression expected");
3165               return;
3166             }
3167
3168           pre_inc = 1;
3169           if (ldst_extend (&str, halfword) == FAIL)
3170             return;
3171
3172           skip_whitespace (str);
3173
3174           if (*str++ != ']')
3175             {
3176               inst.error = _("missing ]");
3177               return;
3178             }
3179
3180           skip_whitespace (str);
3181
3182           if (*str == '!')
3183             {
3184               if (conflict_reg)
3185                 as_warn (_("%s register same as write-back base"),
3186                          ((inst.instruction & LOAD_BIT)
3187                           ? _("destination") : _("source")));
3188               str++;
3189               inst.instruction |= WRITE_BACK;
3190             }
3191         }
3192     }
3193   else if (*str == '=')
3194     {
3195       /* Parse an "ldr Rd, =expr" instruction; this is another pseudo op.  */
3196       str++;
3197
3198       skip_whitespace (str);
3199
3200       if (my_get_expression (&inst.reloc.exp, &str))
3201         return;
3202
3203       if (inst.reloc.exp.X_op != O_constant
3204           && inst.reloc.exp.X_op != O_symbol)
3205         {
3206           inst.error = _("Constant expression expected");
3207           return;
3208         }
3209
3210       if (inst.reloc.exp.X_op == O_constant
3211           && (value = validate_immediate (inst.reloc.exp.X_add_number)) != FAIL)
3212         {
3213           /* This can be done with a mov instruction.  */
3214           inst.instruction &= LITERAL_MASK;
3215           inst.instruction |= INST_IMMEDIATE | (OPCODE_MOV << DATA_OP_SHIFT);
3216           inst.instruction |= (flags & COND_MASK) | (value & 0xfff);
3217           end_of_line (str);
3218           return;
3219         }
3220       else
3221         {
3222           /* Insert into literal pool.  */
3223           if (add_to_lit_pool () == FAIL)
3224             {
3225               if (!inst.error)
3226                 inst.error = _("literal pool insertion failed");
3227               return;
3228             }
3229
3230           /* Change the instruction exp to point to the pool.  */
3231           if (halfword)
3232             {
3233               inst.instruction |= HWOFFSET_IMM;
3234               inst.reloc.type = BFD_RELOC_ARM_HWLITERAL;
3235             }
3236           else
3237             inst.reloc.type = BFD_RELOC_ARM_LITERAL;
3238           inst.reloc.pc_rel = 1;
3239           inst.instruction |= (REG_PC << 16);
3240           pre_inc = 1;
3241         }
3242     }
3243   else
3244     {
3245       if (my_get_expression (&inst.reloc.exp, &str))
3246         return;
3247
3248       if (halfword)
3249         {
3250           inst.instruction |= HWOFFSET_IMM;
3251           inst.reloc.type = BFD_RELOC_ARM_OFFSET_IMM8;
3252         }
3253       else
3254         inst.reloc.type = BFD_RELOC_ARM_OFFSET_IMM;
3255 #ifndef TE_WINCE
3256       /* PC rel adjust.  */
3257       inst.reloc.exp.X_add_number -= 8;
3258 #endif
3259       inst.reloc.pc_rel = 1;
3260       inst.instruction |= (REG_PC << 16);
3261       pre_inc = 1;
3262     }
3263
3264   if (pre_inc && (flags & TRANS_BIT))
3265     inst.error = _("Pre-increment instruction with translate");
3266
3267   inst.instruction |= flags | (pre_inc ? PRE_INDEX : 0);
3268   end_of_line (str);
3269   return;
3270 }
3271
3272 static long
3273 reg_list (strp)
3274      char ** strp;
3275 {
3276   char * str = * strp;
3277   long   range = 0;
3278   int    another_range;
3279
3280   /* We come back here if we get ranges concatenated by '+' or '|'.  */
3281   do
3282     {
3283       another_range = 0;
3284
3285       if (*str == '{')
3286         {
3287           int in_range = 0;
3288           int cur_reg = -1;
3289
3290           str++;
3291           do
3292             {
3293               int reg;
3294
3295               skip_whitespace (str);
3296
3297               if ((reg = reg_required_here (& str, -1)) == FAIL)
3298                 return FAIL;
3299
3300               if (in_range)
3301                 {
3302                   int i;
3303
3304                   if (reg <= cur_reg)
3305                     {
3306                       inst.error = _("Bad range in register list");
3307                       return FAIL;
3308                     }
3309
3310                   for (i = cur_reg + 1; i < reg; i++)
3311                     {
3312                       if (range & (1 << i))
3313                         as_tsktsk
3314                           (_("Warning: Duplicated register (r%d) in register list"),
3315                            i);
3316                       else
3317                         range |= 1 << i;
3318                     }
3319                   in_range = 0;
3320                 }
3321
3322               if (range & (1 << reg))
3323                 as_tsktsk (_("Warning: Duplicated register (r%d) in register list"),
3324                            reg);
3325               else if (reg <= cur_reg)
3326                 as_tsktsk (_("Warning: Register range not in ascending order"));
3327
3328               range |= 1 << reg;
3329               cur_reg = reg;
3330             }
3331           while (skip_past_comma (&str) != FAIL
3332                  || (in_range = 1, *str++ == '-'));
3333           str--;
3334           skip_whitespace (str);
3335
3336           if (*str++ != '}')
3337             {
3338               inst.error = _("Missing `}'");
3339               return FAIL;
3340             }
3341         }
3342       else
3343         {
3344           expressionS expr;
3345
3346           if (my_get_expression (&expr, &str))
3347             return FAIL;
3348
3349           if (expr.X_op == O_constant)
3350             {
3351               if (expr.X_add_number
3352                   != (expr.X_add_number & 0x0000ffff))
3353                 {
3354                   inst.error = _("invalid register mask");
3355                   return FAIL;
3356                 }
3357
3358               if ((range & expr.X_add_number) != 0)
3359                 {
3360                   int regno = range & expr.X_add_number;
3361
3362                   regno &= -regno;
3363                   regno = (1 << regno) - 1;
3364                   as_tsktsk
3365                     (_("Warning: Duplicated register (r%d) in register list"),
3366                      regno);
3367                 }
3368
3369               range |= expr.X_add_number;
3370             }
3371           else
3372             {
3373               if (inst.reloc.type != 0)
3374                 {
3375                   inst.error = _("expression too complex");
3376                   return FAIL;
3377                 }
3378
3379               memcpy (&inst.reloc.exp, &expr, sizeof (expressionS));
3380               inst.reloc.type = BFD_RELOC_ARM_MULTI;
3381               inst.reloc.pc_rel = 0;
3382             }
3383         }
3384
3385       skip_whitespace (str);
3386
3387       if (*str == '|' || *str == '+')
3388         {
3389           str++;
3390           another_range = 1;
3391         }
3392     }
3393   while (another_range);
3394
3395   *strp = str;
3396   return range;
3397 }
3398
3399 static void
3400 do_ldmstm (str, flags)
3401      char * str;
3402      unsigned long flags;
3403 {
3404   int base_reg;
3405   long range;
3406
3407   skip_whitespace (str);
3408
3409   if ((base_reg = reg_required_here (&str, 16)) == FAIL)
3410     return;
3411
3412   if (base_reg == REG_PC)
3413     {
3414       inst.error = _("r15 not allowed as base register");
3415       return;
3416     }
3417
3418   skip_whitespace (str);
3419
3420   if (*str == '!')
3421     {
3422       flags |= WRITE_BACK;
3423       str++;
3424     }
3425
3426   if (skip_past_comma (&str) == FAIL
3427       || (range = reg_list (&str)) == FAIL)
3428     {
3429       if (! inst.error)
3430         inst.error = BAD_ARGS;
3431       return;
3432     }
3433
3434   if (*str == '^')
3435     {
3436       str++;
3437       flags |= LDM_TYPE_2_OR_3;
3438     }
3439
3440   inst.instruction |= flags | range;
3441   end_of_line (str);
3442   return;
3443 }
3444
3445 static void
3446 do_swi (str, flags)
3447      char * str;
3448      unsigned long flags;
3449 {
3450   skip_whitespace (str);
3451
3452   /* Allow optional leading '#'.  */
3453   if (is_immediate_prefix (*str))
3454     str++;
3455
3456   if (my_get_expression (& inst.reloc.exp, & str))
3457     return;
3458
3459   inst.reloc.type = BFD_RELOC_ARM_SWI;
3460   inst.reloc.pc_rel = 0;
3461   inst.instruction |= flags;
3462
3463   end_of_line (str);
3464
3465   return;
3466 }
3467
3468 static void
3469 do_swap (str, flags)
3470      char * str;
3471      unsigned long flags;
3472 {
3473   int reg;
3474
3475   skip_whitespace (str);
3476
3477   if ((reg = reg_required_here (&str, 12)) == FAIL)
3478     return;
3479
3480   if (reg == REG_PC)
3481     {
3482       inst.error = _("r15 not allowed in swap");
3483       return;
3484     }
3485
3486   if (skip_past_comma (&str) == FAIL
3487       || (reg = reg_required_here (&str, 0)) == FAIL)
3488     {
3489       if (!inst.error)
3490         inst.error = BAD_ARGS;
3491       return;
3492     }
3493
3494   if (reg == REG_PC)
3495     {
3496       inst.error = _("r15 not allowed in swap");
3497       return;
3498     }
3499
3500   if (skip_past_comma (&str) == FAIL
3501       || *str++ != '[')
3502     {
3503       inst.error = BAD_ARGS;
3504       return;
3505     }
3506
3507   skip_whitespace (str);
3508
3509   if ((reg = reg_required_here (&str, 16)) == FAIL)
3510     return;
3511
3512   if (reg == REG_PC)
3513     {
3514       inst.error = BAD_PC;
3515       return;
3516     }
3517
3518   skip_whitespace (str);
3519
3520   if (*str++ != ']')
3521     {
3522       inst.error = _("missing ]");
3523       return;
3524     }
3525
3526   inst.instruction |= flags;
3527   end_of_line (str);
3528   return;
3529 }
3530
3531 static void
3532 do_branch (str, flags)
3533      char * str;
3534      unsigned long flags ATTRIBUTE_UNUSED;
3535 {
3536   if (my_get_expression (&inst.reloc.exp, &str))
3537     return;
3538
3539 #ifdef OBJ_ELF
3540   {
3541     char * save_in;
3542
3543     /* ScottB: February 5, 1998 - Check to see of PLT32 reloc
3544        required for the instruction.  */
3545
3546     /* arm_parse_reloc () works on input_line_pointer.
3547        We actually want to parse the operands to the branch instruction
3548        passed in 'str'.  Save the input pointer and restore it later.  */
3549     save_in = input_line_pointer;
3550     input_line_pointer = str;
3551     if (inst.reloc.exp.X_op == O_symbol
3552         && *str == '('
3553         && arm_parse_reloc () == BFD_RELOC_ARM_PLT32)
3554       {
3555         inst.reloc.type   = BFD_RELOC_ARM_PLT32;
3556         inst.reloc.pc_rel = 0;
3557         /* Modify str to point to after parsed operands, otherwise
3558            end_of_line() will complain about the (PLT) left in str.  */
3559         str = input_line_pointer;
3560       }
3561     else
3562       {
3563         inst.reloc.type   = BFD_RELOC_ARM_PCREL_BRANCH;
3564         inst.reloc.pc_rel = 1;
3565       }
3566     input_line_pointer = save_in;
3567   }
3568 #else
3569   inst.reloc.type   = BFD_RELOC_ARM_PCREL_BRANCH;
3570   inst.reloc.pc_rel = 1;
3571 #endif /* OBJ_ELF  */
3572
3573   end_of_line (str);
3574   return;
3575 }
3576
3577 static void
3578 do_bx (str, flags)
3579      char * str;
3580      unsigned long flags ATTRIBUTE_UNUSED;
3581 {
3582   int reg;
3583
3584   skip_whitespace (str);
3585
3586   if ((reg = reg_required_here (&str, 0)) == FAIL)
3587     {
3588       inst.error = BAD_ARGS;
3589       return;
3590     }
3591
3592   /* Note - it is not illegal to do a "bx pc".  Useless, but not illegal.  */
3593
3594   end_of_line (str);
3595 }
3596
3597 static void
3598 do_cdp (str, flags)
3599      char * str;
3600      unsigned long flags ATTRIBUTE_UNUSED;
3601 {
3602   /* Co-processor data operation.
3603      Format: CDP{cond} CP#,<expr>,CRd,CRn,CRm{,<expr>}  */
3604   skip_whitespace (str);
3605
3606   if (co_proc_number (&str) == FAIL)
3607     {
3608       if (!inst.error)
3609         inst.error = BAD_ARGS;
3610       return;
3611     }
3612
3613   if (skip_past_comma (&str) == FAIL
3614       || cp_opc_expr (&str, 20,4) == FAIL)
3615     {
3616       if (!inst.error)
3617         inst.error = BAD_ARGS;
3618       return;
3619     }
3620
3621   if (skip_past_comma (&str) == FAIL
3622       || cp_reg_required_here (&str, 12) == FAIL)
3623     {
3624       if (!inst.error)
3625         inst.error = BAD_ARGS;
3626       return;
3627     }
3628
3629   if (skip_past_comma (&str) == FAIL
3630       || cp_reg_required_here (&str, 16) == FAIL)
3631     {
3632       if (!inst.error)
3633         inst.error = BAD_ARGS;
3634       return;
3635     }
3636
3637   if (skip_past_comma (&str) == FAIL
3638       || cp_reg_required_here (&str, 0) == FAIL)
3639     {
3640       if (!inst.error)
3641         inst.error = BAD_ARGS;
3642       return;
3643     }
3644
3645   if (skip_past_comma (&str) == SUCCESS)
3646     {
3647       if (cp_opc_expr (&str, 5, 3) == FAIL)
3648         {
3649           if (!inst.error)
3650             inst.error = BAD_ARGS;
3651           return;
3652         }
3653     }
3654
3655   end_of_line (str);
3656   return;
3657 }
3658
3659 static void
3660 do_lstc (str, flags)
3661      char * str;
3662      unsigned long flags;
3663 {
3664   /* Co-processor register load/store.
3665      Format: <LDC|STC{cond}[L] CP#,CRd,<address>  */
3666
3667   skip_whitespace (str);
3668
3669   if (co_proc_number (&str) == FAIL)
3670     {
3671       if (!inst.error)
3672         inst.error = BAD_ARGS;
3673       return;
3674     }
3675
3676   if (skip_past_comma (&str) == FAIL
3677       || cp_reg_required_here (&str, 12) == FAIL)
3678     {
3679       if (!inst.error)
3680         inst.error = BAD_ARGS;
3681       return;
3682     }
3683
3684   if (skip_past_comma (&str) == FAIL
3685       || cp_address_required_here (&str) == FAIL)
3686     {
3687       if (! inst.error)
3688         inst.error = BAD_ARGS;
3689       return;
3690     }
3691
3692   inst.instruction |= flags;
3693   end_of_line (str);
3694   return;
3695 }
3696
3697 static void
3698 do_co_reg (str, flags)
3699      char * str;
3700      unsigned long flags;
3701 {
3702   /* Co-processor register transfer.
3703      Format: <MCR|MRC>{cond} CP#,<expr1>,Rd,CRn,CRm{,<expr2>}  */
3704
3705   skip_whitespace (str);
3706
3707   if (co_proc_number (&str) == FAIL)
3708     {
3709       if (!inst.error)
3710         inst.error = BAD_ARGS;
3711       return;
3712     }
3713
3714   if (skip_past_comma (&str) == FAIL
3715       || cp_opc_expr (&str, 21, 3) == FAIL)
3716     {
3717       if (!inst.error)
3718         inst.error = BAD_ARGS;
3719       return;
3720     }
3721
3722   if (skip_past_comma (&str) == FAIL
3723       || reg_required_here (&str, 12) == FAIL)
3724     {
3725       if (!inst.error)
3726         inst.error = BAD_ARGS;
3727       return;
3728     }
3729
3730   if (skip_past_comma (&str) == FAIL
3731       || cp_reg_required_here (&str, 16) == FAIL)
3732     {
3733       if (!inst.error)
3734         inst.error = BAD_ARGS;
3735       return;
3736     }
3737
3738   if (skip_past_comma (&str) == FAIL
3739       || cp_reg_required_here (&str, 0) == FAIL)
3740     {
3741       if (!inst.error)
3742         inst.error = BAD_ARGS;
3743       return;
3744     }
3745
3746   if (skip_past_comma (&str) == SUCCESS)
3747     {
3748       if (cp_opc_expr (&str, 5, 3) == FAIL)
3749         {
3750           if (!inst.error)
3751             inst.error = BAD_ARGS;
3752           return;
3753         }
3754     }
3755   if (flags)
3756     {
3757       inst.error = BAD_COND;
3758     }
3759
3760   end_of_line (str);
3761   return;
3762 }
3763
3764 static void
3765 do_fp_ctrl (str, flags)
3766      char * str;
3767      unsigned long flags ATTRIBUTE_UNUSED;
3768 {
3769   /* FP control registers.
3770      Format: <WFS|RFS|WFC|RFC>{cond} Rn  */
3771
3772   skip_whitespace (str);
3773
3774   if (reg_required_here (&str, 12) == FAIL)
3775     {
3776       if (!inst.error)
3777         inst.error = BAD_ARGS;
3778       return;
3779     }
3780
3781   end_of_line (str);
3782   return;
3783 }
3784
3785 static void
3786 do_fp_ldst (str, flags)
3787      char * str;
3788      unsigned long flags ATTRIBUTE_UNUSED;
3789 {
3790   skip_whitespace (str);
3791
3792   switch (inst.suffix)
3793     {
3794     case SUFF_S:
3795       break;
3796     case SUFF_D:
3797       inst.instruction |= CP_T_X;
3798       break;
3799     case SUFF_E:
3800       inst.instruction |= CP_T_Y;
3801       break;
3802     case SUFF_P:
3803       inst.instruction |= CP_T_X | CP_T_Y;
3804       break;
3805     default:
3806       abort ();
3807     }
3808
3809   if (fp_reg_required_here (&str, 12) == FAIL)
3810     {
3811       if (!inst.error)
3812         inst.error = BAD_ARGS;
3813       return;
3814     }
3815
3816   if (skip_past_comma (&str) == FAIL
3817       || cp_address_required_here (&str) == FAIL)
3818     {
3819       if (!inst.error)
3820         inst.error = BAD_ARGS;
3821       return;
3822     }
3823
3824   end_of_line (str);
3825 }
3826
3827 static void
3828 do_fp_ldmstm (str, flags)
3829      char * str;
3830      unsigned long flags;
3831 {
3832   int num_regs;
3833
3834   skip_whitespace (str);
3835
3836   if (fp_reg_required_here (&str, 12) == FAIL)
3837     {
3838       if (! inst.error)
3839         inst.error = BAD_ARGS;
3840       return;
3841     }
3842
3843   /* Get Number of registers to transfer.  */
3844   if (skip_past_comma (&str) == FAIL
3845       || my_get_expression (&inst.reloc.exp, &str))
3846     {
3847       if (! inst.error)
3848         inst.error = _("constant expression expected");
3849       return;
3850     }
3851
3852   if (inst.reloc.exp.X_op != O_constant)
3853     {
3854       inst.error = _("Constant value required for number of registers");
3855       return;
3856     }
3857
3858   num_regs = inst.reloc.exp.X_add_number;
3859
3860   if (num_regs < 1 || num_regs > 4)
3861     {
3862       inst.error = _("number of registers must be in the range [1:4]");
3863       return;
3864     }
3865
3866   switch (num_regs)
3867     {
3868     case 1:
3869       inst.instruction |= CP_T_X;
3870       break;
3871     case 2:
3872       inst.instruction |= CP_T_Y;
3873       break;
3874     case 3:
3875       inst.instruction |= CP_T_Y | CP_T_X;
3876       break;
3877     case 4:
3878       break;
3879     default:
3880       abort ();
3881     }
3882
3883   if (flags)
3884     {
3885       int reg;
3886       int write_back;
3887       int offset;
3888
3889       /* The instruction specified "ea" or "fd", so we can only accept
3890          [Rn]{!}.  The instruction does not really support stacking or
3891          unstacking, so we have to emulate these by setting appropriate
3892          bits and offsets.  */
3893       if (skip_past_comma (&str) == FAIL
3894           || *str != '[')
3895         {
3896           if (! inst.error)
3897             inst.error = BAD_ARGS;
3898           return;
3899         }
3900
3901       str++;
3902       skip_whitespace (str);
3903
3904       if ((reg = reg_required_here (&str, 16)) == FAIL)
3905         return;
3906
3907       skip_whitespace (str);
3908
3909       if (*str != ']')
3910         {
3911           inst.error = BAD_ARGS;
3912           return;
3913         }
3914
3915       str++;
3916       if (*str == '!')
3917         {
3918           write_back = 1;
3919           str++;
3920           if (reg == REG_PC)
3921             {
3922               inst.error =
3923                 _("R15 not allowed as base register with write-back");
3924               return;
3925             }
3926         }
3927       else
3928         write_back = 0;
3929
3930       if (flags & CP_T_Pre)
3931         {
3932           /* Pre-decrement.  */
3933           offset = 3 * num_regs;
3934           if (write_back)
3935             flags |= CP_T_WB;
3936         }
3937       else
3938         {
3939           /* Post-increment.  */
3940           if (write_back)
3941             {
3942               flags |= CP_T_WB;
3943               offset = 3 * num_regs;
3944             }
3945           else
3946             {
3947               /* No write-back, so convert this into a standard pre-increment
3948                  instruction -- aesthetically more pleasing.  */
3949               flags = CP_T_Pre | CP_T_UD;
3950               offset = 0;
3951             }
3952         }
3953
3954       inst.instruction |= flags | offset;
3955     }
3956   else if (skip_past_comma (&str) == FAIL
3957            || cp_address_required_here (&str) == FAIL)
3958     {
3959       if (! inst.error)
3960         inst.error = BAD_ARGS;
3961       return;
3962     }
3963
3964   end_of_line (str);
3965 }
3966
3967 static void
3968 do_fp_dyadic (str, flags)
3969      char * str;
3970      unsigned long flags;
3971 {
3972   skip_whitespace (str);
3973
3974   switch (inst.suffix)
3975     {
3976     case SUFF_S:
3977       break;
3978     case SUFF_D:
3979       inst.instruction |= 0x00000080;
3980       break;
3981     case SUFF_E:
3982       inst.instruction |= 0x00080000;
3983       break;
3984     default:
3985       abort ();
3986     }
3987
3988   if (fp_reg_required_here (&str, 12) == FAIL)
3989     {
3990       if (! inst.error)
3991         inst.error = BAD_ARGS;
3992       return;
3993     }
3994
3995   if (skip_past_comma (&str) == FAIL
3996       || fp_reg_required_here (&str, 16) == FAIL)
3997     {
3998       if (! inst.error)
3999         inst.error = BAD_ARGS;
4000       return;
4001     }
4002
4003   if (skip_past_comma (&str) == FAIL
4004       || fp_op2 (&str) == FAIL)
4005     {
4006       if (! inst.error)
4007         inst.error = BAD_ARGS;
4008       return;
4009     }
4010
4011   inst.instruction |= flags;
4012   end_of_line (str);
4013   return;
4014 }
4015
4016 static void
4017 do_fp_monadic (str, flags)
4018      char * str;
4019      unsigned long flags;
4020 {
4021   skip_whitespace (str);
4022
4023   switch (inst.suffix)
4024     {
4025     case SUFF_S:
4026       break;
4027     case SUFF_D:
4028       inst.instruction |= 0x00000080;
4029       break;
4030     case SUFF_E:
4031       inst.instruction |= 0x00080000;
4032       break;
4033     default:
4034       abort ();
4035     }
4036
4037   if (fp_reg_required_here (&str, 12) == FAIL)
4038     {
4039       if (! inst.error)
4040         inst.error = BAD_ARGS;
4041       return;
4042     }
4043
4044   if (skip_past_comma (&str) == FAIL
4045       || fp_op2 (&str) == FAIL)
4046     {
4047       if (! inst.error)
4048         inst.error = BAD_ARGS;
4049       return;
4050     }
4051
4052   inst.instruction |= flags;
4053   end_of_line (str);
4054   return;
4055 }
4056
4057 static void
4058 do_fp_cmp (str, flags)
4059      char * str;
4060      unsigned long flags;
4061 {
4062   skip_whitespace (str);
4063
4064   if (fp_reg_required_here (&str, 16) == FAIL)
4065     {
4066       if (! inst.error)
4067         inst.error = BAD_ARGS;
4068       return;
4069     }
4070
4071   if (skip_past_comma (&str) == FAIL
4072       || fp_op2 (&str) == FAIL)
4073     {
4074       if (! inst.error)
4075         inst.error = BAD_ARGS;
4076       return;
4077     }
4078
4079   inst.instruction |= flags;
4080   end_of_line (str);
4081   return;
4082 }
4083
4084 static void
4085 do_fp_from_reg (str, flags)
4086      char * str;
4087      unsigned long flags;
4088 {
4089   skip_whitespace (str);
4090
4091   switch (inst.suffix)
4092     {
4093     case SUFF_S:
4094       break;
4095     case SUFF_D:
4096       inst.instruction |= 0x00000080;
4097       break;
4098     case SUFF_E:
4099       inst.instruction |= 0x00080000;
4100       break;
4101     default:
4102       abort ();
4103     }
4104
4105   if (fp_reg_required_here (&str, 16) == FAIL)
4106     {
4107       if (! inst.error)
4108         inst.error = BAD_ARGS;
4109       return;
4110     }
4111
4112   if (skip_past_comma (&str) == FAIL
4113       || reg_required_here (&str, 12) == FAIL)
4114     {
4115       if (! inst.error)
4116         inst.error = BAD_ARGS;
4117       return;
4118     }
4119
4120   inst.instruction |= flags;
4121   end_of_line (str);
4122   return;
4123 }
4124
4125 static void
4126 do_fp_to_reg (str, flags)
4127      char * str;
4128      unsigned long flags;
4129 {
4130   skip_whitespace (str);
4131
4132   if (reg_required_here (&str, 12) == FAIL)
4133     return;
4134
4135   if (skip_past_comma (&str) == FAIL
4136       || fp_reg_required_here (&str, 0) == FAIL)
4137     {
4138       if (! inst.error)
4139         inst.error = BAD_ARGS;
4140       return;
4141     }
4142
4143   inst.instruction |= flags;
4144   end_of_line (str);
4145   return;
4146 }
4147
4148 /* Thumb specific routines.  */
4149
4150 /* Parse and validate that a register is of the right form, this saves
4151    repeated checking of this information in many similar cases.
4152    Unlike the 32-bit case we do not insert the register into the opcode
4153    here, since the position is often unknown until the full instruction
4154    has been parsed.  */
4155
4156 static int
4157 thumb_reg (strp, hi_lo)
4158      char ** strp;
4159      int     hi_lo;
4160 {
4161   int reg;
4162
4163   if ((reg = reg_required_here (strp, -1)) == FAIL)
4164     return FAIL;
4165
4166   switch (hi_lo)
4167     {
4168     case THUMB_REG_LO:
4169       if (reg > 7)
4170         {
4171           inst.error = _("lo register required");
4172           return FAIL;
4173         }
4174       break;
4175
4176     case THUMB_REG_HI:
4177       if (reg < 8)
4178         {
4179           inst.error = _("hi register required");
4180           return FAIL;
4181         }
4182       break;
4183
4184     default:
4185       break;
4186     }
4187
4188   return reg;
4189 }
4190
4191 /* Parse an add or subtract instruction, SUBTRACT is non-zero if the opcode
4192    was SUB.  */
4193
4194 static void
4195 thumb_add_sub (str, subtract)
4196      char * str;
4197      int    subtract;
4198 {
4199   int Rd, Rs, Rn = FAIL;
4200
4201   skip_whitespace (str);
4202
4203   if ((Rd = thumb_reg (&str, THUMB_REG_ANY)) == FAIL
4204       || skip_past_comma (&str) == FAIL)
4205     {
4206       if (! inst.error)
4207         inst.error = BAD_ARGS;
4208       return;
4209     }
4210
4211   if (is_immediate_prefix (*str))
4212     {
4213       Rs = Rd;
4214       str++;
4215       if (my_get_expression (&inst.reloc.exp, &str))
4216         return;
4217     }
4218   else
4219     {
4220       if ((Rs = thumb_reg (&str, THUMB_REG_ANY)) == FAIL)
4221         return;
4222
4223       if (skip_past_comma (&str) == FAIL)
4224         {
4225           /* Two operand format, shuffle the registers
4226              and pretend there are 3.  */
4227           Rn = Rs;
4228           Rs = Rd;
4229         }
4230       else if (is_immediate_prefix (*str))
4231         {
4232           str++;
4233           if (my_get_expression (&inst.reloc.exp, &str))
4234             return;
4235         }
4236       else if ((Rn = thumb_reg (&str, THUMB_REG_ANY)) == FAIL)
4237         return;
4238     }
4239
4240   /* We now have Rd and Rs set to registers, and Rn set to a register or FAIL;
4241      for the latter case, EXPR contains the immediate that was found.  */
4242   if (Rn != FAIL)
4243     {
4244       /* All register format.  */
4245       if (Rd > 7 || Rs > 7 || Rn > 7)
4246         {
4247           if (Rs != Rd)
4248             {
4249               inst.error = _("dest and source1 must be the same register");
4250               return;
4251             }
4252
4253           /* Can't do this for SUB.  */
4254           if (subtract)
4255             {
4256               inst.error = _("subtract valid only on lo regs");
4257               return;
4258             }
4259
4260           inst.instruction = (T_OPCODE_ADD_HI
4261                               | (Rd > 7 ? THUMB_H1 : 0)
4262                               | (Rn > 7 ? THUMB_H2 : 0));
4263           inst.instruction |= (Rd & 7) | ((Rn & 7) << 3);
4264         }
4265       else
4266         {
4267           inst.instruction = subtract ? T_OPCODE_SUB_R3 : T_OPCODE_ADD_R3;
4268           inst.instruction |= Rd | (Rs << 3) | (Rn << 6);
4269         }
4270     }
4271   else
4272     {
4273       /* Immediate expression, now things start to get nasty.  */
4274
4275       /* First deal with HI regs, only very restricted cases allowed:
4276          Adjusting SP, and using PC or SP to get an address.  */
4277       if ((Rd > 7 && (Rd != REG_SP || Rs != REG_SP))
4278           || (Rs > 7 && Rs != REG_SP && Rs != REG_PC))
4279         {
4280           inst.error = _("invalid Hi register with immediate");
4281           return;
4282         }
4283
4284       if (inst.reloc.exp.X_op != O_constant)
4285         {
4286           /* Value isn't known yet, all we can do is store all the fragments
4287              we know about in the instruction and let the reloc hacking
4288              work it all out.  */
4289           inst.instruction = (subtract ? 0x8000 : 0) | (Rd << 4) | Rs;
4290           inst.reloc.type = BFD_RELOC_ARM_THUMB_ADD;
4291         }
4292       else
4293         {
4294           int offset = inst.reloc.exp.X_add_number;
4295
4296           if (subtract)
4297             offset = -offset;
4298
4299           if (offset < 0)
4300             {
4301               offset = -offset;
4302               subtract = 1;
4303
4304               /* Quick check, in case offset is MIN_INT.  */
4305               if (offset < 0)
4306                 {
4307                   inst.error = _("immediate value out of range");
4308                   return;
4309                 }
4310             }
4311           else
4312             subtract = 0;
4313
4314           if (Rd == REG_SP)
4315             {
4316               if (offset & ~0x1fc)
4317                 {
4318                   inst.error = _("invalid immediate value for stack adjust");
4319                   return;
4320                 }
4321               inst.instruction = subtract ? T_OPCODE_SUB_ST : T_OPCODE_ADD_ST;
4322               inst.instruction |= offset >> 2;
4323             }
4324           else if (Rs == REG_PC || Rs == REG_SP)
4325             {
4326               if (subtract
4327                   || (offset & ~0x3fc))
4328                 {
4329                   inst.error = _("invalid immediate for address calculation");
4330                   return;
4331                 }
4332               inst.instruction = (Rs == REG_PC ? T_OPCODE_ADD_PC
4333                                   : T_OPCODE_ADD_SP);
4334               inst.instruction |= (Rd << 8) | (offset >> 2);
4335             }
4336           else if (Rs == Rd)
4337             {
4338               if (offset & ~0xff)
4339                 {
4340                   inst.error = _("immediate value out of range");
4341                   return;
4342                 }
4343               inst.instruction = subtract ? T_OPCODE_SUB_I8 : T_OPCODE_ADD_I8;
4344               inst.instruction |= (Rd << 8) | offset;
4345             }
4346           else
4347             {
4348               if (offset & ~0x7)
4349                 {
4350                   inst.error = _("immediate value out of range");
4351                   return;
4352                 }
4353               inst.instruction = subtract ? T_OPCODE_SUB_I3 : T_OPCODE_ADD_I3;
4354               inst.instruction |= Rd | (Rs << 3) | (offset << 6);
4355             }
4356         }
4357     }
4358
4359   end_of_line (str);
4360 }
4361
4362 static void
4363 thumb_shift (str, shift)
4364      char * str;
4365      int    shift;
4366 {
4367   int Rd, Rs, Rn = FAIL;
4368
4369   skip_whitespace (str);
4370
4371   if ((Rd = thumb_reg (&str, THUMB_REG_LO)) == FAIL
4372       || skip_past_comma (&str) == FAIL)
4373     {
4374       if (! inst.error)
4375         inst.error = BAD_ARGS;
4376       return;
4377     }
4378
4379   if (is_immediate_prefix (*str))
4380     {
4381       /* Two operand immediate format, set Rs to Rd.  */
4382       Rs = Rd;
4383       str ++;
4384       if (my_get_expression (&inst.reloc.exp, &str))
4385         return;
4386     }
4387   else
4388     {
4389       if ((Rs = thumb_reg (&str, THUMB_REG_LO)) == FAIL)
4390         return;
4391
4392       if (skip_past_comma (&str) == FAIL)
4393         {
4394           /* Two operand format, shuffle the registers
4395              and pretend there are 3.  */
4396           Rn = Rs;
4397           Rs = Rd;
4398         }
4399       else if (is_immediate_prefix (*str))
4400         {
4401           str++;
4402           if (my_get_expression (&inst.reloc.exp, &str))
4403             return;
4404         }
4405       else if ((Rn = thumb_reg (&str, THUMB_REG_LO)) == FAIL)
4406         return;
4407     }
4408
4409   /* We now have Rd and Rs set to registers, and Rn set to a register or FAIL;
4410      for the latter case, EXPR contains the immediate that was found.  */
4411
4412   if (Rn != FAIL)
4413     {
4414       if (Rs != Rd)
4415         {
4416           inst.error = _("source1 and dest must be same register");
4417           return;
4418         }
4419
4420       switch (shift)
4421         {
4422         case THUMB_ASR: inst.instruction = T_OPCODE_ASR_R; break;
4423         case THUMB_LSL: inst.instruction = T_OPCODE_LSL_R; break;
4424         case THUMB_LSR: inst.instruction = T_OPCODE_LSR_R; break;
4425         }
4426
4427       inst.instruction |= Rd | (Rn << 3);
4428     }
4429   else
4430     {
4431       switch (shift)
4432         {
4433         case THUMB_ASR: inst.instruction = T_OPCODE_ASR_I; break;
4434         case THUMB_LSL: inst.instruction = T_OPCODE_LSL_I; break;
4435         case THUMB_LSR: inst.instruction = T_OPCODE_LSR_I; break;
4436         }
4437
4438       if (inst.reloc.exp.X_op != O_constant)
4439         {
4440           /* Value isn't known yet, create a dummy reloc and let reloc
4441              hacking fix it up.  */
4442           inst.reloc.type = BFD_RELOC_ARM_THUMB_SHIFT;
4443         }
4444       else
4445         {
4446           unsigned shift_value = inst.reloc.exp.X_add_number;
4447
4448           if (shift_value > 32 || (shift_value == 32 && shift == THUMB_LSL))
4449             {
4450               inst.error = _("Invalid immediate for shift");
4451               return;
4452             }
4453
4454           /* Shifts of zero are handled by converting to LSL.  */
4455           if (shift_value == 0)
4456             inst.instruction = T_OPCODE_LSL_I;
4457
4458           /* Shifts of 32 are encoded as a shift of zero.  */
4459           if (shift_value == 32)
4460             shift_value = 0;
4461
4462           inst.instruction |= shift_value << 6;
4463         }
4464
4465       inst.instruction |= Rd | (Rs << 3);
4466     }
4467
4468   end_of_line (str);
4469 }
4470
4471 static void
4472 thumb_mov_compare (str, move)
4473      char * str;
4474      int    move;
4475 {
4476   int Rd, Rs = FAIL;
4477
4478   skip_whitespace (str);
4479
4480   if ((Rd = thumb_reg (&str, THUMB_REG_ANY)) == FAIL
4481       || skip_past_comma (&str) == FAIL)
4482     {
4483       if (! inst.error)
4484         inst.error = BAD_ARGS;
4485       return;
4486     }
4487
4488   if (is_immediate_prefix (*str))
4489     {
4490       str++;
4491       if (my_get_expression (&inst.reloc.exp, &str))
4492         return;
4493     }
4494   else if ((Rs = thumb_reg (&str, THUMB_REG_ANY)) == FAIL)
4495     return;
4496
4497   if (Rs != FAIL)
4498     {
4499       if (Rs < 8 && Rd < 8)
4500         {
4501           if (move == THUMB_MOVE)
4502             /* A move of two lowregs is encoded as ADD Rd, Rs, #0
4503                since a MOV instruction produces unpredictable results.  */
4504             inst.instruction = T_OPCODE_ADD_I3;
4505           else
4506             inst.instruction = T_OPCODE_CMP_LR;
4507           inst.instruction |= Rd | (Rs << 3);
4508         }
4509       else
4510         {
4511           if (move == THUMB_MOVE)
4512             inst.instruction = T_OPCODE_MOV_HR;
4513           else
4514             inst.instruction = T_OPCODE_CMP_HR;
4515
4516           if (Rd > 7)
4517             inst.instruction |= THUMB_H1;
4518
4519           if (Rs > 7)
4520             inst.instruction |= THUMB_H2;
4521
4522           inst.instruction |= (Rd & 7) | ((Rs & 7) << 3);
4523         }
4524     }
4525   else
4526     {
4527       if (Rd > 7)
4528         {
4529           inst.error = _("only lo regs allowed with immediate");
4530           return;
4531         }
4532
4533       if (move == THUMB_MOVE)
4534         inst.instruction = T_OPCODE_MOV_I8;
4535       else
4536         inst.instruction = T_OPCODE_CMP_I8;
4537
4538       inst.instruction |= Rd << 8;
4539
4540       if (inst.reloc.exp.X_op != O_constant)
4541         inst.reloc.type = BFD_RELOC_ARM_THUMB_IMM;
4542       else
4543         {
4544           unsigned value = inst.reloc.exp.X_add_number;
4545
4546           if (value > 255)
4547             {
4548               inst.error = _("invalid immediate");
4549               return;
4550             }
4551
4552           inst.instruction |= value;
4553         }
4554     }
4555
4556   end_of_line (str);
4557 }
4558
4559 static void
4560 thumb_load_store (str, load_store, size)
4561      char * str;
4562      int    load_store;
4563      int    size;
4564 {
4565   int Rd, Rb, Ro = FAIL;
4566
4567   skip_whitespace (str);
4568
4569   if ((Rd = thumb_reg (&str, THUMB_REG_LO)) == FAIL
4570       || skip_past_comma (&str) == FAIL)
4571     {
4572       if (! inst.error)
4573         inst.error = BAD_ARGS;
4574       return;
4575     }
4576
4577   if (*str == '[')
4578     {
4579       str++;
4580       if ((Rb = thumb_reg (&str, THUMB_REG_ANY)) == FAIL)
4581         return;
4582
4583       if (skip_past_comma (&str) != FAIL)
4584         {
4585           if (is_immediate_prefix (*str))
4586             {
4587               str++;
4588               if (my_get_expression (&inst.reloc.exp, &str))
4589                 return;
4590             }
4591           else if ((Ro = thumb_reg (&str, THUMB_REG_LO)) == FAIL)
4592             return;
4593         }
4594       else
4595         {
4596           inst.reloc.exp.X_op = O_constant;
4597           inst.reloc.exp.X_add_number = 0;
4598         }
4599
4600       if (*str != ']')
4601         {
4602           inst.error = _("expected ']'");
4603           return;
4604         }
4605       str++;
4606     }
4607   else if (*str == '=')
4608     {
4609       /* Parse an "ldr Rd, =expr" instruction; this is another pseudo op.  */
4610       str++;
4611
4612       skip_whitespace (str);
4613
4614       if (my_get_expression (& inst.reloc.exp, & str))
4615         return;
4616
4617       end_of_line (str);
4618
4619       if (   inst.reloc.exp.X_op != O_constant
4620           && inst.reloc.exp.X_op != O_symbol)
4621         {
4622           inst.error = "Constant expression expected";
4623           return;
4624         }
4625
4626       if (inst.reloc.exp.X_op == O_constant
4627           && ((inst.reloc.exp.X_add_number & ~0xFF) == 0))
4628         {
4629           /* This can be done with a mov instruction.  */
4630
4631           inst.instruction  = T_OPCODE_MOV_I8 | (Rd << 8);
4632           inst.instruction |= inst.reloc.exp.X_add_number;
4633           return;
4634         }
4635
4636       /* Insert into literal pool.  */
4637       if (add_to_lit_pool () == FAIL)
4638         {
4639           if (!inst.error)
4640             inst.error = "literal pool insertion failed";
4641           return;
4642         }
4643
4644       inst.reloc.type   = BFD_RELOC_ARM_THUMB_OFFSET;
4645       inst.reloc.pc_rel = 1;
4646       inst.instruction  = T_OPCODE_LDR_PC | (Rd << 8);
4647       /* Adjust ARM pipeline offset to Thumb.  */
4648       inst.reloc.exp.X_add_number += 4;
4649
4650       return;
4651     }
4652   else
4653     {
4654       if (my_get_expression (&inst.reloc.exp, &str))
4655         return;
4656
4657       inst.instruction = T_OPCODE_LDR_PC | (Rd << 8);
4658       inst.reloc.pc_rel = 1;
4659       inst.reloc.exp.X_add_number -= 4; /* Pipeline offset.  */
4660       inst.reloc.type = BFD_RELOC_ARM_THUMB_OFFSET;
4661       end_of_line (str);
4662       return;
4663     }
4664
4665   if (Rb == REG_PC || Rb == REG_SP)
4666     {
4667       if (size != THUMB_WORD)
4668         {
4669           inst.error = _("byte or halfword not valid for base register");
4670           return;
4671         }
4672       else if (Rb == REG_PC && load_store != THUMB_LOAD)
4673         {
4674           inst.error = _("R15 based store not allowed");
4675           return;
4676         }
4677       else if (Ro != FAIL)
4678         {
4679           inst.error = _("Invalid base register for register offset");
4680           return;
4681         }
4682
4683       if (Rb == REG_PC)
4684         inst.instruction = T_OPCODE_LDR_PC;
4685       else if (load_store == THUMB_LOAD)
4686         inst.instruction = T_OPCODE_LDR_SP;
4687       else
4688         inst.instruction = T_OPCODE_STR_SP;
4689
4690       inst.instruction |= Rd << 8;
4691       if (inst.reloc.exp.X_op == O_constant)
4692         {
4693           unsigned offset = inst.reloc.exp.X_add_number;
4694
4695           if (offset & ~0x3fc)
4696             {
4697               inst.error = _("invalid offset");
4698               return;
4699             }
4700
4701           inst.instruction |= offset >> 2;
4702         }
4703       else
4704         inst.reloc.type = BFD_RELOC_ARM_THUMB_OFFSET;
4705     }
4706   else if (Rb > 7)
4707     {
4708       inst.error = _("invalid base register in load/store");
4709       return;
4710     }
4711   else if (Ro == FAIL)
4712     {
4713       /* Immediate offset.  */
4714       if (size == THUMB_WORD)
4715         inst.instruction = (load_store == THUMB_LOAD
4716                             ? T_OPCODE_LDR_IW : T_OPCODE_STR_IW);
4717       else if (size == THUMB_HALFWORD)
4718         inst.instruction = (load_store == THUMB_LOAD
4719                             ? T_OPCODE_LDR_IH : T_OPCODE_STR_IH);
4720       else
4721         inst.instruction = (load_store == THUMB_LOAD
4722                             ? T_OPCODE_LDR_IB : T_OPCODE_STR_IB);
4723
4724       inst.instruction |= Rd | (Rb << 3);
4725
4726       if (inst.reloc.exp.X_op == O_constant)
4727         {
4728           unsigned offset = inst.reloc.exp.X_add_number;
4729
4730           if (offset & ~(0x1f << size))
4731             {
4732               inst.error = _("Invalid offset");
4733               return;
4734             }
4735           inst.instruction |= (offset >> size) << 6;
4736         }
4737       else
4738         inst.reloc.type = BFD_RELOC_ARM_THUMB_OFFSET;
4739     }
4740   else
4741     {
4742       /* Register offset.  */
4743       if (size == THUMB_WORD)
4744         inst.instruction = (load_store == THUMB_LOAD
4745                             ? T_OPCODE_LDR_RW : T_OPCODE_STR_RW);
4746       else if (size == THUMB_HALFWORD)
4747         inst.instruction = (load_store == THUMB_LOAD
4748                             ? T_OPCODE_LDR_RH : T_OPCODE_STR_RH);
4749       else
4750         inst.instruction = (load_store == THUMB_LOAD
4751                             ? T_OPCODE_LDR_RB : T_OPCODE_STR_RB);
4752
4753       inst.instruction |= Rd | (Rb << 3) | (Ro << 6);
4754     }
4755
4756   end_of_line (str);
4757 }
4758
4759 static void
4760 do_t_nop (str)
4761      char * str;
4762 {
4763   /* Do nothing.  */
4764   end_of_line (str);
4765   return;
4766 }
4767
4768 /* Handle the Format 4 instructions that do not have equivalents in other
4769    formats.  That is, ADC, AND, EOR, SBC, ROR, TST, NEG, CMN, ORR, MUL,
4770    BIC and MVN.  */
4771
4772 static void
4773 do_t_arit (str)
4774      char * str;
4775 {
4776   int Rd, Rs, Rn;
4777
4778   skip_whitespace (str);
4779
4780   if ((Rd = thumb_reg (&str, THUMB_REG_LO)) == FAIL
4781       || skip_past_comma (&str) == FAIL
4782       || (Rs = thumb_reg (&str, THUMB_REG_LO)) == FAIL)
4783     {
4784       inst.error = BAD_ARGS;
4785       return;
4786     }
4787
4788   if (skip_past_comma (&str) != FAIL)
4789     {
4790       /* Three operand format not allowed for TST, CMN, NEG and MVN.
4791          (It isn't allowed for CMP either, but that isn't handled by this
4792          function.)  */
4793       if (inst.instruction == T_OPCODE_TST
4794           || inst.instruction == T_OPCODE_CMN
4795           || inst.instruction == T_OPCODE_NEG
4796           || inst.instruction == T_OPCODE_MVN)
4797         {
4798           inst.error = BAD_ARGS;
4799           return;
4800         }
4801
4802       if ((Rn = thumb_reg (&str, THUMB_REG_LO)) == FAIL)
4803         return;
4804
4805       if (Rs != Rd)
4806         {
4807           inst.error = _("dest and source1 one must be the same register");
4808           return;
4809         }
4810       Rs = Rn;
4811     }
4812
4813   if (inst.instruction == T_OPCODE_MUL
4814       && Rs == Rd)
4815     as_tsktsk (_("Rs and Rd must be different in MUL"));
4816
4817   inst.instruction |= Rd | (Rs << 3);
4818   end_of_line (str);
4819 }
4820
4821 static void
4822 do_t_add (str)
4823      char * str;
4824 {
4825   thumb_add_sub (str, 0);
4826 }
4827
4828 static void
4829 do_t_asr (str)
4830      char * str;
4831 {
4832   thumb_shift (str, THUMB_ASR);
4833 }
4834
4835 static void
4836 do_t_branch9 (str)
4837      char * str;
4838 {
4839   if (my_get_expression (&inst.reloc.exp, &str))
4840     return;
4841   inst.reloc.type = BFD_RELOC_THUMB_PCREL_BRANCH9;
4842   inst.reloc.pc_rel = 1;
4843   end_of_line (str);
4844 }
4845
4846 static void
4847 do_t_branch12 (str)
4848      char * str;
4849 {
4850   if (my_get_expression (&inst.reloc.exp, &str))
4851     return;
4852   inst.reloc.type = BFD_RELOC_THUMB_PCREL_BRANCH12;
4853   inst.reloc.pc_rel = 1;
4854   end_of_line (str);
4855 }
4856
4857 /* Find the real, Thumb encoded start of a Thumb function.  */
4858
4859 static symbolS *
4860 find_real_start (symbolP)
4861      symbolS * symbolP;
4862 {
4863   char *       real_start;
4864   const char * name = S_GET_NAME (symbolP);
4865   symbolS *    new_target;
4866
4867   /* This definiton must agree with the one in gcc/config/arm/thumb.c.  */
4868 #define STUB_NAME ".real_start_of"
4869
4870   if (name == NULL)
4871     abort ();
4872
4873   /* Names that start with '.' are local labels, not function entry points.
4874      The compiler may generate BL instructions to these labels because it
4875      needs to perform a branch to a far away location.  */
4876   if (name[0] == '.')
4877     return symbolP;
4878
4879   real_start = malloc (strlen (name) + strlen (STUB_NAME) + 1);
4880   sprintf (real_start, "%s%s", STUB_NAME, name);
4881
4882   new_target = symbol_find (real_start);
4883
4884   if (new_target == NULL)
4885     {
4886       as_warn ("Failed to find real start of function: %s\n", name);
4887       new_target = symbolP;
4888     }
4889
4890   free (real_start);
4891
4892   return new_target;
4893 }
4894
4895 static void
4896 do_t_branch23 (str)
4897      char * str;
4898 {
4899   if (my_get_expression (& inst.reloc.exp, & str))
4900     return;
4901
4902   inst.reloc.type   = BFD_RELOC_THUMB_PCREL_BRANCH23;
4903   inst.reloc.pc_rel = 1;
4904   end_of_line (str);
4905
4906   /* If the destination of the branch is a defined symbol which does not have
4907      the THUMB_FUNC attribute, then we must be calling a function which has
4908      the (interfacearm) attribute.  We look for the Thumb entry point to that
4909      function and change the branch to refer to that function instead.  */
4910   if (   inst.reloc.exp.X_op == O_symbol
4911       && inst.reloc.exp.X_add_symbol != NULL
4912       && S_IS_DEFINED (inst.reloc.exp.X_add_symbol)
4913       && ! THUMB_IS_FUNC (inst.reloc.exp.X_add_symbol))
4914     inst.reloc.exp.X_add_symbol =
4915       find_real_start (inst.reloc.exp.X_add_symbol);
4916 }
4917
4918 static void
4919 do_t_bx (str)
4920      char * str;
4921 {
4922   int reg;
4923
4924   skip_whitespace (str);
4925
4926   if ((reg = thumb_reg (&str, THUMB_REG_ANY)) == FAIL)
4927     return;
4928
4929   /* This sets THUMB_H2 from the top bit of reg.  */
4930   inst.instruction |= reg << 3;
4931
4932   /* ??? FIXME: Should add a hacky reloc here if reg is REG_PC.  The reloc
4933      should cause the alignment to be checked once it is known.  This is
4934      because BX PC only works if the instruction is word aligned.  */
4935
4936   end_of_line (str);
4937 }
4938
4939 static void
4940 do_t_compare (str)
4941      char * str;
4942 {
4943   thumb_mov_compare (str, THUMB_COMPARE);
4944 }
4945
4946 static void
4947 do_t_ldmstm (str)
4948      char * str;
4949 {
4950   int Rb;
4951   long range;
4952
4953   skip_whitespace (str);
4954
4955   if ((Rb = thumb_reg (&str, THUMB_REG_LO)) == FAIL)
4956     return;
4957
4958   if (*str != '!')
4959     as_warn (_("Inserted missing '!': load/store multiple always writes back base register"));
4960   else
4961     str++;
4962
4963   if (skip_past_comma (&str) == FAIL
4964       || (range = reg_list (&str)) == FAIL)
4965     {
4966       if (! inst.error)
4967         inst.error = BAD_ARGS;
4968       return;
4969     }
4970
4971   if (inst.reloc.type != BFD_RELOC_NONE)
4972     {
4973       /* This really doesn't seem worth it.  */
4974       inst.reloc.type = BFD_RELOC_NONE;
4975       inst.error = _("Expression too complex");
4976       return;
4977     }
4978
4979   if (range & ~0xff)
4980     {
4981       inst.error = _("only lo-regs valid in load/store multiple");
4982       return;
4983     }
4984
4985   inst.instruction |= (Rb << 8) | range;
4986   end_of_line (str);
4987 }
4988
4989 static void
4990 do_t_ldr (str)
4991      char * str;
4992 {
4993   thumb_load_store (str, THUMB_LOAD, THUMB_WORD);
4994 }
4995
4996 static void
4997 do_t_ldrb (str)
4998      char * str;
4999 {
5000   thumb_load_store (str, THUMB_LOAD, THUMB_BYTE);
5001 }
5002
5003 static void
5004 do_t_ldrh (str)
5005      char * str;
5006 {
5007   thumb_load_store (str, THUMB_LOAD, THUMB_HALFWORD);
5008 }
5009
5010 static void
5011 do_t_lds (str)
5012      char * str;
5013 {
5014   int Rd, Rb, Ro;
5015
5016   skip_whitespace (str);
5017
5018   if ((Rd = thumb_reg (&str, THUMB_REG_LO)) == FAIL
5019       || skip_past_comma (&str) == FAIL
5020       || *str++ != '['
5021       || (Rb = thumb_reg (&str, THUMB_REG_LO)) == FAIL
5022       || skip_past_comma (&str) == FAIL
5023       || (Ro = thumb_reg (&str, THUMB_REG_LO)) == FAIL
5024       || *str++ != ']')
5025     {
5026       if (! inst.error)
5027         inst.error = _("Syntax: ldrs[b] Rd, [Rb, Ro]");
5028       return;
5029     }
5030
5031   inst.instruction |= Rd | (Rb << 3) | (Ro << 6);
5032   end_of_line (str);
5033 }
5034
5035 static void
5036 do_t_lsl (str)
5037      char * str;
5038 {
5039   thumb_shift (str, THUMB_LSL);
5040 }
5041
5042 static void
5043 do_t_lsr (str)
5044      char * str;
5045 {
5046   thumb_shift (str, THUMB_LSR);
5047 }
5048
5049 static void
5050 do_t_mov (str)
5051      char * str;
5052 {
5053   thumb_mov_compare (str, THUMB_MOVE);
5054 }
5055
5056 static void
5057 do_t_push_pop (str)
5058      char * str;
5059 {
5060   long range;
5061
5062   skip_whitespace (str);
5063
5064   if ((range = reg_list (&str)) == FAIL)
5065     {
5066       if (! inst.error)
5067         inst.error = BAD_ARGS;
5068       return;
5069     }
5070
5071   if (inst.reloc.type != BFD_RELOC_NONE)
5072     {
5073       /* This really doesn't seem worth it.  */
5074       inst.reloc.type = BFD_RELOC_NONE;
5075       inst.error = _("Expression too complex");
5076       return;
5077     }
5078
5079   if (range & ~0xff)
5080     {
5081       if ((inst.instruction == T_OPCODE_PUSH
5082            && (range & ~0xff) == 1 << REG_LR)
5083           || (inst.instruction == T_OPCODE_POP
5084               && (range & ~0xff) == 1 << REG_PC))
5085         {
5086           inst.instruction |= THUMB_PP_PC_LR;
5087           range &= 0xff;
5088         }
5089       else
5090         {
5091           inst.error = _("invalid register list to push/pop instruction");
5092           return;
5093         }
5094     }
5095
5096   inst.instruction |= range;
5097   end_of_line (str);
5098 }
5099
5100 static void
5101 do_t_str (str)
5102      char * str;
5103 {
5104   thumb_load_store (str, THUMB_STORE, THUMB_WORD);
5105 }
5106
5107 static void
5108 do_t_strb (str)
5109      char * str;
5110 {
5111   thumb_load_store (str, THUMB_STORE, THUMB_BYTE);
5112 }
5113
5114 static void
5115 do_t_strh (str)
5116      char * str;
5117 {
5118   thumb_load_store (str, THUMB_STORE, THUMB_HALFWORD);
5119 }
5120
5121 static void
5122 do_t_sub (str)
5123      char * str;
5124 {
5125   thumb_add_sub (str, 1);
5126 }
5127
5128 static void
5129 do_t_swi (str)
5130      char * str;
5131 {
5132   skip_whitespace (str);
5133
5134   if (my_get_expression (&inst.reloc.exp, &str))
5135     return;
5136
5137   inst.reloc.type = BFD_RELOC_ARM_SWI;
5138   end_of_line (str);
5139   return;
5140 }
5141
5142 static void
5143 do_t_adr (str)
5144      char * str;
5145 {
5146   int reg;
5147
5148   /* This is a pseudo-op of the form "adr rd, label" to be converted
5149      into a relative address of the form "add rd, pc, #label-.-4".  */
5150   skip_whitespace (str);
5151
5152   /* Store Rd in temporary location inside instruction.  */
5153   if ((reg = reg_required_here (&str, 4)) == FAIL
5154       || (reg > 7)  /* For Thumb reg must be r0..r7.  */
5155       || skip_past_comma (&str) == FAIL
5156       || my_get_expression (&inst.reloc.exp, &str))
5157     {
5158       if (!inst.error)
5159         inst.error = BAD_ARGS;
5160       return;
5161     }
5162
5163   inst.reloc.type = BFD_RELOC_ARM_THUMB_ADD;
5164   inst.reloc.exp.X_add_number -= 4; /* PC relative adjust.  */
5165   inst.reloc.pc_rel = 1;
5166   inst.instruction |= REG_PC; /* Rd is already placed into the instruction.  */
5167
5168   end_of_line (str);
5169 }
5170
5171 static void
5172 insert_reg (entry)
5173      int entry;
5174 {
5175   int    len  = strlen (reg_table[entry].name) + 2;
5176   char * buf  = (char *) xmalloc (len);
5177   char * buf2 = (char *) xmalloc (len);
5178   int    i    = 0;
5179
5180 #ifdef REGISTER_PREFIX
5181   buf[i++] = REGISTER_PREFIX;
5182 #endif
5183
5184   strcpy (buf + i, reg_table[entry].name);
5185
5186   for (i = 0; buf[i]; i++)
5187     buf2[i] = islower (buf[i]) ? toupper (buf[i]) : buf[i];
5188
5189   buf2[i] = '\0';
5190
5191   hash_insert (arm_reg_hsh, buf,  (PTR) & reg_table[entry]);
5192   hash_insert (arm_reg_hsh, buf2, (PTR) & reg_table[entry]);
5193 }
5194
5195 static void
5196 insert_reg_alias (str, regnum)
5197      char *str;
5198      int regnum;
5199 {
5200   struct reg_entry *new =
5201     (struct reg_entry *) xmalloc (sizeof (struct reg_entry));
5202   char *name = xmalloc (strlen (str) + 1);
5203   strcpy (name, str);
5204
5205   new->name = name;
5206   new->number = regnum;
5207
5208   hash_insert (arm_reg_hsh, name, (PTR) new);
5209 }
5210
5211 static void
5212 set_constant_flonums ()
5213 {
5214   int i;
5215
5216   for (i = 0; i < NUM_FLOAT_VALS; i++)
5217     if (atof_ieee ((char *) fp_const[i], 'x', fp_values[i]) == NULL)
5218       abort ();
5219 }
5220
5221 void
5222 md_begin ()
5223 {
5224   unsigned mach;
5225   unsigned int i;
5226
5227   if (   (arm_ops_hsh = hash_new ()) == NULL
5228       || (arm_tops_hsh = hash_new ()) == NULL
5229       || (arm_cond_hsh = hash_new ()) == NULL
5230       || (arm_shift_hsh = hash_new ()) == NULL
5231       || (arm_reg_hsh = hash_new ()) == NULL
5232       || (arm_psr_hsh = hash_new ()) == NULL)
5233     as_fatal (_("Virtual memory exhausted"));
5234
5235   for (i = 0; i < sizeof (insns) / sizeof (struct asm_opcode); i++)
5236     hash_insert (arm_ops_hsh, insns[i].template, (PTR) (insns + i));
5237   for (i = 0; i < sizeof (tinsns) / sizeof (struct thumb_opcode); i++)
5238     hash_insert (arm_tops_hsh, tinsns[i].template, (PTR) (tinsns + i));
5239   for (i = 0; i < sizeof (conds) / sizeof (struct asm_cond); i++)
5240     hash_insert (arm_cond_hsh, conds[i].template, (PTR) (conds + i));
5241   for (i = 0; i < sizeof (shift) / sizeof (struct asm_shift); i++)
5242     hash_insert (arm_shift_hsh, shift[i].template, (PTR) (shift + i));
5243   for (i = 0; i < sizeof (psrs) / sizeof (struct asm_psr); i++)
5244     hash_insert (arm_psr_hsh, psrs[i].template, (PTR) (psrs + i));
5245
5246   for (i = 0; reg_table[i].name; i++)
5247     insert_reg (i);
5248
5249   set_constant_flonums ();
5250
5251 #if defined OBJ_COFF || defined OBJ_ELF
5252   {
5253     unsigned int flags = 0;
5254
5255     /* Set the flags in the private structure.  */
5256     if (uses_apcs_26)      flags |= F_APCS26;
5257     if (support_interwork) flags |= F_INTERWORK;
5258     if (uses_apcs_float)   flags |= F_APCS_FLOAT;
5259     if (pic_code)          flags |= F_PIC;
5260     if ((cpu_variant & FPU_ALL) == FPU_NONE) flags |= F_SOFT_FLOAT;
5261
5262     bfd_set_private_flags (stdoutput, flags);
5263   }
5264 #endif
5265
5266   /* Record the CPU type as well.  */
5267   switch (cpu_variant & ARM_CPU_MASK)
5268     {
5269     case ARM_2:
5270       mach = bfd_mach_arm_2;
5271       break;
5272
5273     case ARM_3:                 /* Also ARM_250.  */
5274       mach = bfd_mach_arm_2a;
5275       break;
5276
5277     default:
5278     case ARM_6 | ARM_3 | ARM_2: /* Actually no CPU type defined.  */
5279       mach = bfd_mach_arm_4;
5280       break;
5281
5282     case ARM_7:                 /* Also ARM_6.  */
5283       mach = bfd_mach_arm_3;
5284       break;
5285     }
5286
5287   /* Catch special cases.  */
5288   if (cpu_variant != (FPU_DEFAULT | CPU_DEFAULT))
5289     {
5290       if (cpu_variant & (ARM_EXT_V5 & ARM_THUMB))
5291         mach = bfd_mach_arm_5T;
5292       else if (cpu_variant & ARM_EXT_V5)
5293         mach = bfd_mach_arm_5;
5294       else if (cpu_variant & ARM_THUMB)
5295         mach = bfd_mach_arm_4T;
5296       else if ((cpu_variant & ARM_ARCH_V4) == ARM_ARCH_V4)
5297         mach = bfd_mach_arm_4;
5298       else if (cpu_variant & ARM_LONGMUL)
5299         mach = bfd_mach_arm_3M;
5300     }
5301
5302   bfd_set_arch_mach (stdoutput, TARGET_ARCH, mach);
5303 }
5304
5305 /* Turn an integer of n bytes (in val) into a stream of bytes appropriate
5306    for use in the a.out file, and stores them in the array pointed to by buf.
5307    This knows about the endian-ness of the target machine and does
5308    THE RIGHT THING, whatever it is.  Possible values for n are 1 (byte)
5309    2 (short) and 4 (long)  Floating numbers are put out as a series of
5310    LITTLENUMS (shorts, here at least).  */
5311
5312 void
5313 md_number_to_chars (buf, val, n)
5314      char * buf;
5315      valueT val;
5316      int    n;
5317 {
5318   if (target_big_endian)
5319     number_to_chars_bigendian (buf, val, n);
5320   else
5321     number_to_chars_littleendian (buf, val, n);
5322 }
5323
5324 static valueT
5325 md_chars_to_number (buf, n)
5326      char * buf;
5327      int    n;
5328 {
5329   valueT result = 0;
5330   unsigned char * where = (unsigned char *) buf;
5331
5332   if (target_big_endian)
5333     {
5334       while (n--)
5335         {
5336           result <<= 8;
5337           result |= (*where++ & 255);
5338         }
5339     }
5340   else
5341     {
5342       while (n--)
5343         {
5344           result <<= 8;
5345           result |= (where[n] & 255);
5346         }
5347     }
5348
5349   return result;
5350 }
5351
5352 /* Turn a string in input_line_pointer into a floating point constant
5353    of type TYPE, and store the appropriate bytes in *LITP.  The number
5354    of LITTLENUMS emitted is stored in *SIZEP.  An error message is
5355    returned, or NULL on OK.
5356
5357    Note that fp constants aren't represent in the normal way on the ARM.
5358    In big endian mode, things are as expected.  However, in little endian
5359    mode fp constants are big-endian word-wise, and little-endian byte-wise
5360    within the words.  For example, (double) 1.1 in big endian mode is
5361    the byte sequence 3f f1 99 99 99 99 99 9a, and in little endian mode is
5362    the byte sequence 99 99 f1 3f 9a 99 99 99.
5363
5364    ??? The format of 12 byte floats is uncertain according to gcc's arm.h.  */
5365
5366 char *
5367 md_atof (type, litP, sizeP)
5368      char   type;
5369      char * litP;
5370      int *  sizeP;
5371 {
5372   int prec;
5373   LITTLENUM_TYPE words[MAX_LITTLENUMS];
5374   char *t;
5375   int i;
5376
5377   switch (type)
5378     {
5379     case 'f':
5380     case 'F':
5381     case 's':
5382     case 'S':
5383       prec = 2;
5384       break;
5385
5386     case 'd':
5387     case 'D':
5388     case 'r':
5389     case 'R':
5390       prec = 4;
5391       break;
5392
5393     case 'x':
5394     case 'X':
5395       prec = 6;
5396       break;
5397
5398     case 'p':
5399     case 'P':
5400       prec = 6;
5401       break;
5402
5403     default:
5404       *sizeP = 0;
5405       return _("Bad call to MD_ATOF()");
5406     }
5407
5408   t = atof_ieee (input_line_pointer, type, words);
5409   if (t)
5410     input_line_pointer = t;
5411   *sizeP = prec * 2;
5412
5413   if (target_big_endian)
5414     {
5415       for (i = 0; i < prec; i++)
5416         {
5417           md_number_to_chars (litP, (valueT) words[i], 2);
5418           litP += 2;
5419         }
5420     }
5421   else
5422     {
5423       /* For a 4 byte float the order of elements in `words' is 1 0.  For an
5424          8 byte float the order is 1 0 3 2.  */
5425       for (i = 0; i < prec; i += 2)
5426         {
5427           md_number_to_chars (litP, (valueT) words[i + 1], 2);
5428           md_number_to_chars (litP + 2, (valueT) words[i], 2);
5429           litP += 4;
5430         }
5431     }
5432
5433   return 0;
5434 }
5435
5436 /* The knowledge of the PC's pipeline offset is built into the insns
5437    themselves.  */
5438
5439 long
5440 md_pcrel_from (fixP)
5441      fixS * fixP;
5442 {
5443   if (fixP->fx_addsy
5444       && S_GET_SEGMENT (fixP->fx_addsy) == undefined_section
5445       && fixP->fx_subsy == NULL)
5446     return 0;
5447
5448   if (fixP->fx_pcrel && (fixP->fx_r_type == BFD_RELOC_ARM_THUMB_ADD))
5449     {
5450       /* PC relative addressing on the Thumb is slightly odd
5451          as the bottom two bits of the PC are forced to zero
5452          for the calculation.  */
5453       return (fixP->fx_where + fixP->fx_frag->fr_address) & ~3;
5454     }
5455
5456 #ifdef TE_WINCE
5457   /* The pattern was adjusted to accomodate CE's off-by-one fixups,
5458      so we un-adjust here to compensate for the accomodation.  */
5459   return fixP->fx_where + fixP->fx_frag->fr_address + 8;
5460 #else
5461   return fixP->fx_where + fixP->fx_frag->fr_address;
5462 #endif
5463 }
5464
5465 /* Round up a section size to the appropriate boundary.  */
5466
5467 valueT
5468 md_section_align (segment, size)
5469      segT   segment ATTRIBUTE_UNUSED;
5470      valueT size;
5471 {
5472 #ifdef OBJ_ELF
5473   return size;
5474 #else
5475   /* Round all sects to multiple of 4.  */
5476   return (size + 3) & ~3;
5477 #endif
5478 }
5479
5480 /* Under ELF we need to default _GLOBAL_OFFSET_TABLE.
5481    Otherwise we have no need to default values of symbols.  */
5482
5483 symbolS *
5484 md_undefined_symbol (name)
5485      char * name ATTRIBUTE_UNUSED;
5486 {
5487 #ifdef OBJ_ELF
5488   if (name[0] == '_' && name[1] == 'G'
5489       && streq (name, GLOBAL_OFFSET_TABLE_NAME))
5490     {
5491       if (!GOT_symbol)
5492         {
5493           if (symbol_find (name))
5494             as_bad ("GOT already in the symbol table");
5495
5496           GOT_symbol = symbol_new (name, undefined_section,
5497                                    (valueT) 0, & zero_address_frag);
5498         }
5499
5500       return GOT_symbol;
5501     }
5502 #endif
5503
5504   return 0;
5505 }
5506
5507 /* arm_reg_parse () := if it looks like a register, return its token and
5508    advance the pointer.  */
5509
5510 static int
5511 arm_reg_parse (ccp)
5512      register char ** ccp;
5513 {
5514   char * start = * ccp;
5515   char   c;
5516   char * p;
5517   struct reg_entry * reg;
5518
5519 #ifdef REGISTER_PREFIX
5520   if (*start != REGISTER_PREFIX)
5521     return FAIL;
5522   p = start + 1;
5523 #else
5524   p = start;
5525 #ifdef OPTIONAL_REGISTER_PREFIX
5526   if (*p == OPTIONAL_REGISTER_PREFIX)
5527     p++, start++;
5528 #endif
5529 #endif
5530   if (!isalpha (*p) || !is_name_beginner (*p))
5531     return FAIL;
5532
5533   c = *p++;
5534   while (isalpha (c) || isdigit (c) || c == '_')
5535     c = *p++;
5536
5537   *--p = 0;
5538   reg = (struct reg_entry *) hash_find (arm_reg_hsh, start);
5539   *p = c;
5540
5541   if (reg)
5542     {
5543       *ccp = p;
5544       return reg->number;
5545     }
5546
5547   return FAIL;
5548 }
5549
5550 int
5551 md_apply_fix3 (fixP, val, seg)
5552      fixS *   fixP;
5553      valueT * val;
5554      segT     seg;
5555 {
5556   offsetT        value = * val;
5557   offsetT        newval;
5558   unsigned int   newimm;
5559   unsigned long  temp;
5560   int            sign;
5561   char *         buf = fixP->fx_where + fixP->fx_frag->fr_literal;
5562   arm_fix_data * arm_data = (arm_fix_data *) fixP->tc_fix_data;
5563
5564   assert (fixP->fx_r_type < BFD_RELOC_UNUSED);
5565
5566   /* Note whether this will delete the relocation.  */
5567 #if 0
5568   /* Patch from REarnshaw to JDavis (disabled for the moment, since it
5569      doesn't work fully.)  */
5570   if ((fixP->fx_addsy == 0 || symbol_constant_p (fixP->fx_addsy))
5571       && !fixP->fx_pcrel)
5572 #else
5573   if (fixP->fx_addsy == 0 && !fixP->fx_pcrel)
5574 #endif
5575     fixP->fx_done = 1;
5576
5577   /* If this symbol is in a different section then we need to leave it for
5578      the linker to deal with.  Unfortunately, md_pcrel_from can't tell,
5579      so we have to undo it's effects here.  */
5580   if (fixP->fx_pcrel)
5581     {
5582       if (fixP->fx_addsy != NULL
5583           && S_IS_DEFINED (fixP->fx_addsy)
5584           && S_GET_SEGMENT (fixP->fx_addsy) != seg)
5585         {
5586           if (target_oabi
5587               && (fixP->fx_r_type == BFD_RELOC_ARM_PCREL_BRANCH
5588                   || fixP->fx_r_type == BFD_RELOC_ARM_PCREL_BLX
5589                   ))
5590             value = 0;
5591           else
5592             value += md_pcrel_from (fixP);
5593         }
5594     }
5595
5596   /* Remember value for emit_reloc.  */
5597   fixP->fx_addnumber = value;
5598
5599   switch (fixP->fx_r_type)
5600     {
5601     case BFD_RELOC_ARM_IMMEDIATE:
5602       newimm = validate_immediate (value);
5603       temp = md_chars_to_number (buf, INSN_SIZE);
5604
5605       /* If the instruction will fail, see if we can fix things up by
5606          changing the opcode.  */
5607       if (newimm == (unsigned int) FAIL
5608           && (newimm = negate_data_op (&temp, value)) == (unsigned int) FAIL)
5609         {
5610           as_bad_where (fixP->fx_file, fixP->fx_line,
5611                         _("invalid constant (%lx) after fixup"),
5612                         (unsigned long) value);
5613           break;
5614         }
5615
5616       newimm |= (temp & 0xfffff000);
5617       md_number_to_chars (buf, (valueT) newimm, INSN_SIZE);
5618       break;
5619
5620     case BFD_RELOC_ARM_ADRL_IMMEDIATE:
5621       {
5622         unsigned int highpart = 0;
5623         unsigned int newinsn  = 0xe1a00000; /* nop.  */
5624         newimm = validate_immediate (value);
5625         temp = md_chars_to_number (buf, INSN_SIZE);
5626
5627         /* If the instruction will fail, see if we can fix things up by
5628            changing the opcode.  */
5629         if (newimm == (unsigned int) FAIL
5630             && (newimm = negate_data_op (& temp, value)) == (unsigned int) FAIL)
5631           {
5632             /* No ?  OK - try using two ADD instructions to generate
5633                the value.  */
5634             newimm = validate_immediate_twopart (value, & highpart);
5635
5636             /* Yes - then make sure that the second instruction is
5637                also an add.  */
5638             if (newimm != (unsigned int) FAIL)
5639               newinsn = temp;
5640             /* Still No ?  Try using a negated value.  */
5641             else if (validate_immediate_twopart (- value, & highpart) != (unsigned int) FAIL)
5642               temp = newinsn = (temp & OPCODE_MASK) | OPCODE_SUB << DATA_OP_SHIFT;
5643             /* Otherwise - give up.  */
5644             else
5645               {
5646                 as_bad_where (fixP->fx_file, fixP->fx_line,
5647                               _("Unable to compute ADRL instructions for PC offset of 0x%x"),
5648                               value);
5649                 break;
5650               }
5651
5652             /* Replace the first operand in the 2nd instruction (which
5653                is the PC) with the destination register.  We have
5654                already added in the PC in the first instruction and we
5655                do not want to do it again.  */
5656             newinsn &= ~0xf0000;
5657             newinsn |= ((newinsn & 0x0f000) << 4);
5658           }
5659
5660         newimm |= (temp & 0xfffff000);
5661         md_number_to_chars (buf, (valueT) newimm, INSN_SIZE);
5662
5663         highpart |= (newinsn & 0xfffff000);
5664         md_number_to_chars (buf + INSN_SIZE, (valueT) highpart, INSN_SIZE);
5665       }
5666       break;
5667
5668     case BFD_RELOC_ARM_OFFSET_IMM:
5669       sign = value >= 0;
5670
5671       if (value < 0)
5672         value = -value;
5673
5674       if (validate_offset_imm (value, 0) == FAIL)
5675         {
5676           as_bad_where (fixP->fx_file, fixP->fx_line,
5677                         _("bad immediate value for offset (%ld)"),
5678                         (long) value);
5679           break;
5680         }
5681
5682       newval = md_chars_to_number (buf, INSN_SIZE);
5683       newval &= 0xff7ff000;
5684       newval |= value | (sign ? INDEX_UP : 0);
5685       md_number_to_chars (buf, newval, INSN_SIZE);
5686       break;
5687
5688     case BFD_RELOC_ARM_OFFSET_IMM8:
5689     case BFD_RELOC_ARM_HWLITERAL:
5690       sign = value >= 0;
5691
5692       if (value < 0)
5693         value = -value;
5694
5695       if (validate_offset_imm (value, 1) == FAIL)
5696         {
5697           if (fixP->fx_r_type == BFD_RELOC_ARM_HWLITERAL)
5698             as_bad_where (fixP->fx_file, fixP->fx_line,
5699                           _("invalid literal constant: pool needs to be closer"));
5700           else
5701             as_bad (_("bad immediate value for half-word offset (%ld)"),
5702                     (long) value);
5703           break;
5704         }
5705
5706       newval = md_chars_to_number (buf, INSN_SIZE);
5707       newval &= 0xff7ff0f0;
5708       newval |= ((value >> 4) << 8) | (value & 0xf) | (sign ? INDEX_UP : 0);
5709       md_number_to_chars (buf, newval, INSN_SIZE);
5710       break;
5711
5712     case BFD_RELOC_ARM_LITERAL:
5713       sign = value >= 0;
5714
5715       if (value < 0)
5716         value = -value;
5717
5718       if (validate_offset_imm (value, 0) == FAIL)
5719         {
5720           as_bad_where (fixP->fx_file, fixP->fx_line,
5721                         _("invalid literal constant: pool needs to be closer"));
5722           break;
5723         }
5724
5725       newval = md_chars_to_number (buf, INSN_SIZE);
5726       newval &= 0xff7ff000;
5727       newval |= value | (sign ? INDEX_UP : 0);
5728       md_number_to_chars (buf, newval, INSN_SIZE);
5729       break;
5730
5731     case BFD_RELOC_ARM_SHIFT_IMM:
5732       newval = md_chars_to_number (buf, INSN_SIZE);
5733       if (((unsigned long) value) > 32
5734           || (value == 32
5735               && (((newval & 0x60) == 0) || (newval & 0x60) == 0x60)))
5736         {
5737           as_bad_where (fixP->fx_file, fixP->fx_line,
5738                         _("shift expression is too large"));
5739           break;
5740         }
5741
5742       if (value == 0)
5743         /* Shifts of zero must be done as lsl.  */
5744         newval &= ~0x60;
5745       else if (value == 32)
5746         value = 0;
5747       newval &= 0xfffff07f;
5748       newval |= (value & 0x1f) << 7;
5749       md_number_to_chars (buf, newval, INSN_SIZE);
5750       break;
5751
5752     case BFD_RELOC_ARM_SWI:
5753       if (arm_data->thumb_mode)
5754         {
5755           if (((unsigned long) value) > 0xff)
5756             as_bad_where (fixP->fx_file, fixP->fx_line,
5757                           _("Invalid swi expression"));
5758           newval = md_chars_to_number (buf, THUMB_SIZE) & 0xff00;
5759           newval |= value;
5760           md_number_to_chars (buf, newval, THUMB_SIZE);
5761         }
5762       else
5763         {
5764           if (((unsigned long) value) > 0x00ffffff)
5765             as_bad_where (fixP->fx_file, fixP->fx_line,
5766                           _("Invalid swi expression"));
5767           newval = md_chars_to_number (buf, INSN_SIZE) & 0xff000000;
5768           newval |= value;
5769           md_number_to_chars (buf, newval, INSN_SIZE);
5770         }
5771       break;
5772
5773     case BFD_RELOC_ARM_MULTI:
5774       if (((unsigned long) value) > 0xffff)
5775         as_bad_where (fixP->fx_file, fixP->fx_line,
5776                       _("Invalid expression in load/store multiple"));
5777       newval = value | md_chars_to_number (buf, INSN_SIZE);
5778       md_number_to_chars (buf, newval, INSN_SIZE);
5779       break;
5780
5781     case BFD_RELOC_ARM_PCREL_BRANCH:
5782       newval = md_chars_to_number (buf, INSN_SIZE);
5783
5784       /* Sign-extend a 24-bit number.  */
5785 #define SEXT24(x)       ((((x) & 0xffffff) ^ (~ 0x7fffff)) + 0x800000)
5786
5787 #ifdef OBJ_ELF
5788       if (! target_oabi)
5789         value = fixP->fx_offset;
5790 #endif
5791
5792       /* We are going to store value (shifted right by two) in the
5793          instruction, in a 24 bit, signed field.  Thus we need to check
5794          that none of the top 8 bits of the shifted value (top 7 bits of
5795          the unshifted, unsigned value) are set, or that they are all set.  */
5796       if ((value & ~ ((offsetT) 0x1ffffff)) != 0
5797           && ((value & ~ ((offsetT) 0x1ffffff)) != ~ ((offsetT) 0x1ffffff)))
5798         {
5799 #ifdef OBJ_ELF
5800           /* Normally we would be stuck at this point, since we cannot store
5801              the absolute address that is the destination of the branch in the
5802              24 bits of the branch instruction.  If however, we happen to know
5803              that the destination of the branch is in the same section as the
5804              branch instruciton itself, then we can compute the relocation for
5805              ourselves and not have to bother the linker with it.
5806
5807              FIXME: The tests for OBJ_ELF and ! target_oabi are only here
5808              because I have not worked out how to do this for OBJ_COFF or
5809              target_oabi.  */
5810           if (! target_oabi
5811               && fixP->fx_addsy != NULL
5812               && S_IS_DEFINED (fixP->fx_addsy)
5813               && S_GET_SEGMENT (fixP->fx_addsy) == seg)
5814             {
5815               /* Get pc relative value to go into the branch.  */
5816               value = * val;
5817
5818               /* Permit a backward branch provided that enough bits
5819                  are set.  Allow a forwards branch, provided that
5820                  enough bits are clear.  */
5821               if (   (value & ~ ((offsetT) 0x1ffffff)) == ~ ((offsetT) 0x1ffffff)
5822                   || (value & ~ ((offsetT) 0x1ffffff)) == 0)
5823                 fixP->fx_done = 1;
5824             }
5825
5826           if (! fixP->fx_done)
5827 #endif
5828             as_bad_where (fixP->fx_file, fixP->fx_line,
5829                           _("gas can't handle same-section branch dest >= 0x04000000"));
5830         }
5831
5832       value >>= 2;
5833       value += SEXT24 (newval);
5834
5835       if (    (value & ~ ((offsetT) 0xffffff)) != 0
5836           && ((value & ~ ((offsetT) 0xffffff)) != ~ ((offsetT) 0xffffff)))
5837         as_bad_where (fixP->fx_file, fixP->fx_line,
5838                       _("out of range branch"));
5839
5840       newval = (value & 0x00ffffff) | (newval & 0xff000000);
5841       md_number_to_chars (buf, newval, INSN_SIZE);
5842       break;
5843
5844     case BFD_RELOC_ARM_PCREL_BLX:
5845       {
5846         offsetT hbit;
5847         newval = md_chars_to_number (buf, INSN_SIZE);
5848
5849 #ifdef OBJ_ELF
5850         if (! target_oabi)
5851           value = fixP->fx_offset;
5852 #endif
5853         hbit   = (value >> 1) & 1;
5854         value  = (value >> 2) & 0x00ffffff;
5855         value  = (value + (newval & 0x00ffffff)) & 0x00ffffff;
5856         newval = value | (newval & 0xfe000000) | (hbit << 24);
5857         md_number_to_chars (buf, newval, INSN_SIZE);
5858       }
5859       break;
5860
5861     case BFD_RELOC_THUMB_PCREL_BRANCH9: /* Conditional branch.  */
5862       newval = md_chars_to_number (buf, THUMB_SIZE);
5863       {
5864         addressT diff = (newval & 0xff) << 1;
5865         if (diff & 0x100)
5866           diff |= ~0xff;
5867
5868         value += diff;
5869         if ((value & ~0xff) && ((value & ~0xff) != ~0xff))
5870           as_bad_where (fixP->fx_file, fixP->fx_line,
5871                         _("Branch out of range"));
5872         newval = (newval & 0xff00) | ((value & 0x1ff) >> 1);
5873       }
5874       md_number_to_chars (buf, newval, THUMB_SIZE);
5875       break;
5876
5877     case BFD_RELOC_THUMB_PCREL_BRANCH12: /* Unconditional branch.  */
5878       newval = md_chars_to_number (buf, THUMB_SIZE);
5879       {
5880         addressT diff = (newval & 0x7ff) << 1;
5881         if (diff & 0x800)
5882           diff |= ~0x7ff;
5883
5884         value += diff;
5885         if ((value & ~0x7ff) && ((value & ~0x7ff) != ~0x7ff))
5886           as_bad_where (fixP->fx_file, fixP->fx_line,
5887                         _("Branch out of range"));
5888         newval = (newval & 0xf800) | ((value & 0xfff) >> 1);
5889       }
5890       md_number_to_chars (buf, newval, THUMB_SIZE);
5891       break;
5892
5893     case BFD_RELOC_THUMB_PCREL_BLX:
5894     case BFD_RELOC_THUMB_PCREL_BRANCH23:
5895       {
5896         offsetT newval2;
5897         addressT diff;
5898
5899         newval  = md_chars_to_number (buf, THUMB_SIZE);
5900         newval2 = md_chars_to_number (buf + THUMB_SIZE, THUMB_SIZE);
5901         diff = ((newval & 0x7ff) << 12) | ((newval2 & 0x7ff) << 1);
5902         if (diff & 0x400000)
5903           diff |= ~0x3fffff;
5904 #ifdef OBJ_ELF
5905         value = fixP->fx_offset;
5906 #endif
5907         value += diff;
5908         if ((value & ~0x3fffff) && ((value & ~0x3fffff) != ~0x3fffff))
5909           as_bad_where (fixP->fx_file, fixP->fx_line,
5910                         _("Branch with link out of range"));
5911
5912         newval  = (newval  & 0xf800) | ((value & 0x7fffff) >> 12);
5913         newval2 = (newval2 & 0xf800) | ((value & 0xfff) >> 1);
5914         md_number_to_chars (buf, newval, THUMB_SIZE);
5915         md_number_to_chars (buf + THUMB_SIZE, newval2, THUMB_SIZE);
5916       }
5917       break;
5918
5919     case BFD_RELOC_8:
5920       if (fixP->fx_done || fixP->fx_pcrel)
5921         md_number_to_chars (buf, value, 1);
5922 #ifdef OBJ_ELF
5923       else if (!target_oabi)
5924         {
5925           value = fixP->fx_offset;
5926           md_number_to_chars (buf, value, 1);
5927         }
5928 #endif
5929       break;
5930
5931     case BFD_RELOC_16:
5932       if (fixP->fx_done || fixP->fx_pcrel)
5933         md_number_to_chars (buf, value, 2);
5934 #ifdef OBJ_ELF
5935       else if (!target_oabi)
5936         {
5937           value = fixP->fx_offset;
5938           md_number_to_chars (buf, value, 2);
5939         }
5940 #endif
5941       break;
5942
5943 #ifdef OBJ_ELF
5944     case BFD_RELOC_ARM_GOT32:
5945     case BFD_RELOC_ARM_GOTOFF:
5946       md_number_to_chars (buf, 0, 4);
5947       break;
5948 #endif
5949
5950     case BFD_RELOC_RVA:
5951     case BFD_RELOC_32:
5952       if (fixP->fx_done || fixP->fx_pcrel)
5953         md_number_to_chars (buf, value, 4);
5954 #ifdef OBJ_ELF
5955       else if (!target_oabi)
5956         {
5957           value = fixP->fx_offset;
5958           md_number_to_chars (buf, value, 4);
5959         }
5960 #endif
5961       break;
5962
5963 #ifdef OBJ_ELF
5964     case BFD_RELOC_ARM_PLT32:
5965       /* It appears the instruction is fully prepared at this point.  */
5966       break;
5967 #endif
5968
5969     case BFD_RELOC_ARM_GOTPC:
5970       md_number_to_chars (buf, value, 4);
5971       break;
5972
5973     case BFD_RELOC_ARM_CP_OFF_IMM:
5974       sign = value >= 0;
5975       if (value < -1023 || value > 1023 || (value & 3))
5976         as_bad_where (fixP->fx_file, fixP->fx_line,
5977                       _("Illegal value for co-processor offset"));
5978       if (value < 0)
5979         value = -value;
5980       newval = md_chars_to_number (buf, INSN_SIZE) & 0xff7fff00;
5981       newval |= (value >> 2) | (sign ? INDEX_UP : 0);
5982       md_number_to_chars (buf, newval, INSN_SIZE);
5983       break;
5984
5985     case BFD_RELOC_ARM_THUMB_OFFSET:
5986       newval = md_chars_to_number (buf, THUMB_SIZE);
5987       /* Exactly what ranges, and where the offset is inserted depends
5988          on the type of instruction, we can establish this from the
5989          top 4 bits.  */
5990       switch (newval >> 12)
5991         {
5992         case 4: /* PC load.  */
5993           /* Thumb PC loads are somewhat odd, bit 1 of the PC is
5994              forced to zero for these loads, so we will need to round
5995              up the offset if the instruction address is not word
5996              aligned (since the final address produced must be, and
5997              we can only describe word-aligned immediate offsets).  */
5998
5999           if ((fixP->fx_frag->fr_address + fixP->fx_where + value) & 3)
6000             as_bad_where (fixP->fx_file, fixP->fx_line,
6001                           _("Invalid offset, target not word aligned (0x%08X)"),
6002                           (unsigned int) (fixP->fx_frag->fr_address
6003                                           + fixP->fx_where + value));
6004
6005           if ((value + 2) & ~0x3fe)
6006             as_bad_where (fixP->fx_file, fixP->fx_line,
6007                           _("Invalid offset, value too big (0x%08X)"), value);
6008
6009           /* Round up, since pc will be rounded down.  */
6010           newval |= (value + 2) >> 2;
6011           break;
6012
6013         case 9: /* SP load/store.  */
6014           if (value & ~0x3fc)
6015             as_bad_where (fixP->fx_file, fixP->fx_line,
6016                           _("Invalid offset, value too big (0x%08X)"), value);
6017           newval |= value >> 2;
6018           break;
6019
6020         case 6: /* Word load/store.  */
6021           if (value & ~0x7c)
6022             as_bad_where (fixP->fx_file, fixP->fx_line,
6023                           _("Invalid offset, value too big (0x%08X)"), value);
6024           newval |= value << 4; /* 6 - 2.  */
6025           break;
6026
6027         case 7: /* Byte load/store.  */
6028           if (value & ~0x1f)
6029             as_bad_where (fixP->fx_file, fixP->fx_line,
6030                           _("Invalid offset, value too big (0x%08X)"), value);
6031           newval |= value << 6;
6032           break;
6033
6034         case 8: /* Halfword load/store.  */
6035           if (value & ~0x3e)
6036             as_bad_where (fixP->fx_file, fixP->fx_line,
6037                           _("Invalid offset, value too big (0x%08X)"), value);
6038           newval |= value << 5; /* 6 - 1.  */
6039           break;
6040
6041         default:
6042           as_bad_where (fixP->fx_file, fixP->fx_line,
6043                         "Unable to process relocation for thumb opcode: %lx",
6044                         (unsigned long) newval);
6045           break;
6046         }
6047       md_number_to_chars (buf, newval, THUMB_SIZE);
6048       break;
6049
6050     case BFD_RELOC_ARM_THUMB_ADD:
6051       /* This is a complicated relocation, since we use it for all of
6052          the following immediate relocations:
6053
6054             3bit ADD/SUB
6055             8bit ADD/SUB
6056             9bit ADD/SUB SP word-aligned
6057            10bit ADD PC/SP word-aligned
6058
6059          The type of instruction being processed is encoded in the
6060          instruction field:
6061
6062            0x8000  SUB
6063            0x00F0  Rd
6064            0x000F  Rs
6065       */
6066       newval = md_chars_to_number (buf, THUMB_SIZE);
6067       {
6068         int rd = (newval >> 4) & 0xf;
6069         int rs = newval & 0xf;
6070         int subtract = newval & 0x8000;
6071
6072         if (rd == REG_SP)
6073           {
6074             if (value & ~0x1fc)
6075               as_bad_where (fixP->fx_file, fixP->fx_line,
6076                             _("Invalid immediate for stack address calculation"));
6077             newval = subtract ? T_OPCODE_SUB_ST : T_OPCODE_ADD_ST;
6078             newval |= value >> 2;
6079           }
6080         else if (rs == REG_PC || rs == REG_SP)
6081           {
6082             if (subtract ||
6083                 value & ~0x3fc)
6084               as_bad_where (fixP->fx_file, fixP->fx_line,
6085                             _("Invalid immediate for address calculation (value = 0x%08lX)"),
6086                             (unsigned long) value);
6087             newval = (rs == REG_PC ? T_OPCODE_ADD_PC : T_OPCODE_ADD_SP);
6088             newval |= rd << 8;
6089             newval |= value >> 2;
6090           }
6091         else if (rs == rd)
6092           {
6093             if (value & ~0xff)
6094               as_bad_where (fixP->fx_file, fixP->fx_line,
6095                             _("Invalid 8bit immediate"));
6096             newval = subtract ? T_OPCODE_SUB_I8 : T_OPCODE_ADD_I8;
6097             newval |= (rd << 8) | value;
6098           }
6099         else
6100           {
6101             if (value & ~0x7)
6102               as_bad_where (fixP->fx_file, fixP->fx_line,
6103                             _("Invalid 3bit immediate"));
6104             newval = subtract ? T_OPCODE_SUB_I3 : T_OPCODE_ADD_I3;
6105             newval |= rd | (rs << 3) | (value << 6);
6106           }
6107       }
6108       md_number_to_chars (buf, newval, THUMB_SIZE);
6109       break;
6110
6111     case BFD_RELOC_ARM_THUMB_IMM:
6112       newval = md_chars_to_number (buf, THUMB_SIZE);
6113       switch (newval >> 11)
6114         {
6115         case 0x04: /* 8bit immediate MOV.  */
6116         case 0x05: /* 8bit immediate CMP.  */
6117           if (value < 0 || value > 255)
6118             as_bad_where (fixP->fx_file, fixP->fx_line,
6119                           _("Invalid immediate: %ld is too large"),
6120                           (long) value);
6121           newval |= value;
6122           break;
6123
6124         default:
6125           abort ();
6126         }
6127       md_number_to_chars (buf, newval, THUMB_SIZE);
6128       break;
6129
6130     case BFD_RELOC_ARM_THUMB_SHIFT:
6131       /* 5bit shift value (0..31).  */
6132       if (value < 0 || value > 31)
6133         as_bad_where (fixP->fx_file, fixP->fx_line,
6134                       _("Illegal Thumb shift value: %ld"), (long) value);
6135       newval = md_chars_to_number (buf, THUMB_SIZE) & 0xf03f;
6136       newval |= value << 6;
6137       md_number_to_chars (buf, newval, THUMB_SIZE);
6138       break;
6139
6140     case BFD_RELOC_VTABLE_INHERIT:
6141     case BFD_RELOC_VTABLE_ENTRY:
6142       fixP->fx_done = 0;
6143       return 1;
6144
6145     case BFD_RELOC_NONE:
6146     default:
6147       as_bad_where (fixP->fx_file, fixP->fx_line,
6148                     _("Bad relocation fixup type (%d)"), fixP->fx_r_type);
6149     }
6150
6151   return 1;
6152 }
6153
6154 /* Translate internal representation of relocation info to BFD target
6155    format.  */
6156
6157 arelent *
6158 tc_gen_reloc (section, fixp)
6159      asection * section ATTRIBUTE_UNUSED;
6160      fixS * fixp;
6161 {
6162   arelent * reloc;
6163   bfd_reloc_code_real_type code;
6164
6165   reloc = (arelent *) xmalloc (sizeof (arelent));
6166
6167   reloc->sym_ptr_ptr = (asymbol **) xmalloc (sizeof (asymbol *));
6168   *reloc->sym_ptr_ptr = symbol_get_bfdsym (fixp->fx_addsy);
6169   reloc->address = fixp->fx_frag->fr_address + fixp->fx_where;
6170
6171   /* @@ Why fx_addnumber sometimes and fx_offset other times?  */
6172 #ifndef OBJ_ELF
6173   if (fixp->fx_pcrel == 0)
6174     reloc->addend = fixp->fx_offset;
6175   else
6176     reloc->addend = fixp->fx_offset = reloc->address;
6177 #else  /* OBJ_ELF */
6178   reloc->addend = fixp->fx_offset;
6179 #endif
6180
6181   switch (fixp->fx_r_type)
6182     {
6183     case BFD_RELOC_8:
6184       if (fixp->fx_pcrel)
6185         {
6186           code = BFD_RELOC_8_PCREL;
6187           break;
6188         }
6189
6190     case BFD_RELOC_16:
6191       if (fixp->fx_pcrel)
6192         {
6193           code = BFD_RELOC_16_PCREL;
6194           break;
6195         }
6196
6197     case BFD_RELOC_32:
6198       if (fixp->fx_pcrel)
6199         {
6200           code = BFD_RELOC_32_PCREL;
6201           break;
6202         }
6203
6204     case BFD_RELOC_ARM_PCREL_BRANCH:
6205     case BFD_RELOC_ARM_PCREL_BLX:
6206     case BFD_RELOC_RVA:
6207     case BFD_RELOC_THUMB_PCREL_BRANCH9:
6208     case BFD_RELOC_THUMB_PCREL_BRANCH12:
6209     case BFD_RELOC_THUMB_PCREL_BRANCH23:
6210     case BFD_RELOC_THUMB_PCREL_BLX:
6211     case BFD_RELOC_VTABLE_ENTRY:
6212     case BFD_RELOC_VTABLE_INHERIT:
6213       code = fixp->fx_r_type;
6214       break;
6215
6216     case BFD_RELOC_ARM_LITERAL:
6217     case BFD_RELOC_ARM_HWLITERAL:
6218       /* If this is called then the a literal has been referenced across
6219          a section boundary - possibly due to an implicit dump.  */
6220       as_bad_where (fixp->fx_file, fixp->fx_line,
6221                     _("Literal referenced across section boundary (Implicit dump?)"));
6222       return NULL;
6223
6224 #ifdef OBJ_ELF
6225     case BFD_RELOC_ARM_GOT32:
6226     case BFD_RELOC_ARM_GOTOFF:
6227     case BFD_RELOC_ARM_PLT32:
6228       code = fixp->fx_r_type;
6229       break;
6230 #endif
6231
6232     case BFD_RELOC_ARM_IMMEDIATE:
6233       as_bad_where (fixp->fx_file, fixp->fx_line,
6234                     _("Internal_relocation (type %d) not fixed up (IMMEDIATE)"),
6235                     fixp->fx_r_type);
6236       return NULL;
6237
6238     case BFD_RELOC_ARM_ADRL_IMMEDIATE:
6239       as_bad_where (fixp->fx_file, fixp->fx_line,
6240                     _("ADRL used for a symbol not defined in the same file"),
6241                     fixp->fx_r_type);
6242       return NULL;
6243
6244     case BFD_RELOC_ARM_OFFSET_IMM:
6245       as_bad_where (fixp->fx_file, fixp->fx_line,
6246                     _("Internal_relocation (type %d) not fixed up (OFFSET_IMM)"),
6247                     fixp->fx_r_type);
6248       return NULL;
6249
6250     default:
6251       {
6252         char * type;
6253
6254         switch (fixp->fx_r_type)
6255           {
6256           case BFD_RELOC_ARM_IMMEDIATE:    type = "IMMEDIATE";    break;
6257           case BFD_RELOC_ARM_OFFSET_IMM:   type = "OFFSET_IMM";   break;
6258           case BFD_RELOC_ARM_OFFSET_IMM8:  type = "OFFSET_IMM8";  break;
6259           case BFD_RELOC_ARM_SHIFT_IMM:    type = "SHIFT_IMM";    break;
6260           case BFD_RELOC_ARM_SWI:          type = "SWI";          break;
6261           case BFD_RELOC_ARM_MULTI:        type = "MULTI";        break;
6262           case BFD_RELOC_ARM_CP_OFF_IMM:   type = "CP_OFF_IMM";   break;
6263           case BFD_RELOC_ARM_THUMB_ADD:    type = "THUMB_ADD";    break;
6264           case BFD_RELOC_ARM_THUMB_SHIFT:  type = "THUMB_SHIFT";  break;
6265           case BFD_RELOC_ARM_THUMB_IMM:    type = "THUMB_IMM";    break;
6266           case BFD_RELOC_ARM_THUMB_OFFSET: type = "THUMB_OFFSET"; break;
6267           default:                         type = _("<unknown>"); break;
6268           }
6269         as_bad_where (fixp->fx_file, fixp->fx_line,
6270                       _("Can not represent %s relocation in this object file format (%d)"),
6271                       type, fixp->fx_pcrel);
6272         return NULL;
6273       }
6274     }
6275
6276 #ifdef OBJ_ELF
6277   if (code == BFD_RELOC_32_PCREL
6278       && GOT_symbol
6279       && fixp->fx_addsy == GOT_symbol)
6280     {
6281       code = BFD_RELOC_ARM_GOTPC;
6282       reloc->addend = fixp->fx_offset = reloc->address;
6283     }
6284 #endif
6285
6286   reloc->howto = bfd_reloc_type_lookup (stdoutput, code);
6287
6288   if (reloc->howto == NULL)
6289     {
6290       as_bad_where (fixp->fx_file, fixp->fx_line,
6291                     _("Can not represent %s relocation in this object file format"),
6292                     bfd_get_reloc_code_name (code));
6293       return NULL;
6294     }
6295
6296   /* HACK: Since arm ELF uses Rel instead of Rela, encode the
6297      vtable entry to be used in the relocation's section offset.  */
6298   if (fixp->fx_r_type == BFD_RELOC_VTABLE_ENTRY)
6299     reloc->address = fixp->fx_offset;
6300
6301   return reloc;
6302 }
6303
6304 int
6305 md_estimate_size_before_relax (fragP, segtype)
6306      fragS * fragP ATTRIBUTE_UNUSED;
6307      segT    segtype ATTRIBUTE_UNUSED;
6308 {
6309   as_fatal (_("md_estimate_size_before_relax\n"));
6310   return 1;
6311 }
6312
6313 static void
6314 output_inst PARAMS ((void))
6315 {
6316   char * to = NULL;
6317
6318   if (inst.error)
6319     {
6320       as_bad (inst.error);
6321       return;
6322     }
6323
6324   to = frag_more (inst.size);
6325
6326   if (thumb_mode && (inst.size > THUMB_SIZE))
6327     {
6328       assert (inst.size == (2 * THUMB_SIZE));
6329       md_number_to_chars (to, inst.instruction >> 16, THUMB_SIZE);
6330       md_number_to_chars (to + THUMB_SIZE, inst.instruction, THUMB_SIZE);
6331     }
6332   else if (inst.size > INSN_SIZE)
6333     {
6334       assert (inst.size == (2 * INSN_SIZE));
6335       md_number_to_chars (to, inst.instruction, INSN_SIZE);
6336       md_number_to_chars (to + INSN_SIZE, inst.instruction, INSN_SIZE);
6337     }
6338   else
6339     md_number_to_chars (to, inst.instruction, inst.size);
6340
6341   if (inst.reloc.type != BFD_RELOC_NONE)
6342     fix_new_arm (frag_now, to - frag_now->fr_literal,
6343                  inst.size, & inst.reloc.exp, inst.reloc.pc_rel,
6344                  inst.reloc.type);
6345
6346   return;
6347 }
6348
6349 void
6350 md_assemble (str)
6351      char * str;
6352 {
6353   char   c;
6354   char * p;
6355   char * q;
6356   char * start;
6357
6358   /* Align the instruction.
6359      This may not be the right thing to do but ...  */
6360 #if 0
6361   arm_align (2, 0);
6362 #endif
6363   listing_prev_line (); /* Defined in listing.h.  */
6364
6365   /* Align the previous label if needed.  */
6366   if (last_label_seen != NULL)
6367     {
6368       symbol_set_frag (last_label_seen, frag_now);
6369       S_SET_VALUE (last_label_seen, (valueT) frag_now_fix ());
6370       S_SET_SEGMENT (last_label_seen, now_seg);
6371     }
6372
6373   memset (&inst, '\0', sizeof (inst));
6374   inst.reloc.type = BFD_RELOC_NONE;
6375
6376   skip_whitespace (str);
6377
6378   /* Scan up to the end of the op-code, which must end in white space or
6379      end of string.  */
6380   for (start = p = str; *p != '\0'; p++)
6381     if (*p == ' ')
6382       break;
6383
6384   if (p == str)
6385     {
6386       as_bad (_("No operator -- statement `%s'\n"), str);
6387       return;
6388     }
6389
6390   if (thumb_mode)
6391     {
6392       CONST struct thumb_opcode * opcode;
6393
6394       c = *p;
6395       *p = '\0';
6396       opcode = (CONST struct thumb_opcode *) hash_find (arm_tops_hsh, str);
6397       *p = c;
6398
6399       if (opcode)
6400         {
6401           /* Check that this instruction is supported for this CPU.  */
6402           if (thumb_mode == 1 && (opcode->variants & cpu_variant) == 0)
6403             {
6404               as_bad (_("selected processor does not support this opcode"));
6405               return;
6406             }
6407
6408           inst.instruction = opcode->value;
6409           inst.size = opcode->size;
6410           (*opcode->parms) (p);
6411           output_inst ();
6412           return;
6413         }
6414     }
6415   else
6416     {
6417       CONST struct asm_opcode * opcode;
6418       unsigned long cond_code;
6419
6420       inst.size = INSN_SIZE;
6421       /* P now points to the end of the opcode, probably white space, but we
6422          have to break the opcode up in case it contains condionals and flags;
6423          keep trying with progressively smaller basic instructions until one
6424          matches, or we run out of opcode.  */
6425       q = (p - str > LONGEST_INST) ? str + LONGEST_INST : p;
6426
6427       for (; q != str; q--)
6428         {
6429           c = *q;
6430           *q = '\0';
6431
6432           opcode = (CONST struct asm_opcode *) hash_find (arm_ops_hsh, str);
6433           *q = c;
6434
6435           if (opcode && opcode->template)
6436             {
6437               unsigned long flag_bits = 0;
6438               char * r;
6439
6440               /* Check that this instruction is supported for this CPU.  */
6441               if ((opcode->variants & cpu_variant) == 0)
6442                 goto try_shorter;
6443
6444               inst.instruction = opcode->value;
6445               if (q == p)               /* Just a simple opcode.  */
6446                 {
6447                   if (opcode->comp_suffix)
6448                     {
6449                       if (*opcode->comp_suffix != '\0')
6450                         as_bad (_("Opcode `%s' must have suffix from list: <%s>"),
6451                                 str, opcode->comp_suffix);
6452                       else
6453                         /* Not a conditional instruction.  */
6454                         (*opcode->parms) (q, 0);
6455                     }
6456                   else
6457                     {
6458                       /* A conditional instruction with default condition.  */
6459                       inst.instruction |= COND_ALWAYS;
6460                       (*opcode->parms) (q, 0);
6461                     }
6462                   output_inst ();
6463                   return;
6464                 }
6465
6466               /* Not just a simple opcode.  Check if extra is a
6467                  conditional.  */
6468               r = q;
6469               if (p - r >= 2)
6470                 {
6471                   CONST struct asm_cond *cond;
6472                   char d = *(r + 2);
6473
6474                   *(r + 2) = '\0';
6475                   cond = (CONST struct asm_cond *) hash_find (arm_cond_hsh, r);
6476                   *(r + 2) = d;
6477                   if (cond)
6478                     {
6479                       if (cond->value == 0xf0000000)
6480                         as_tsktsk (
6481 _("Warning: Use of the 'nv' conditional is deprecated\n"));
6482
6483                       cond_code = cond->value;
6484                       r += 2;
6485                     }
6486                   else
6487                     cond_code = COND_ALWAYS;
6488                 }
6489               else
6490                 cond_code = COND_ALWAYS;
6491
6492               /* Apply the conditional, or complain it's not allowed.  */
6493               if (opcode->comp_suffix && *opcode->comp_suffix == '\0')
6494                 {
6495                   /* Instruction isn't conditional.  */
6496                   if (cond_code != COND_ALWAYS)
6497                     {
6498                       as_bad (_("Opcode `%s' is unconditional\n"), str);
6499                       return;
6500                     }
6501                 }
6502               else
6503                 /* Instruction is conditional: set the condition into it.  */
6504                 inst.instruction |= cond_code;
6505
6506               /* If there is a compulsory suffix, it should come here
6507                  before any optional flags.  */
6508               if (opcode->comp_suffix && *opcode->comp_suffix != '\0')
6509                 {
6510                   CONST char *s = opcode->comp_suffix;
6511
6512                   while (*s)
6513                     {
6514                       inst.suffix++;
6515                       if (*r == *s)
6516                         break;
6517                       s++;
6518                     }
6519
6520                   if (*s == '\0')
6521                     {
6522                       as_bad (_("Opcode `%s' must have suffix from <%s>\n"),
6523                               str, opcode->comp_suffix);
6524                       return;
6525                     }
6526
6527                   r++;
6528                 }
6529
6530               /* The remainder, if any should now be flags for the instruction;
6531                  Scan these checking each one found with the opcode.  */
6532               if (r != p)
6533                 {
6534                   char d;
6535                   CONST struct asm_flg *flag = opcode->flags;
6536
6537                   if (flag)
6538                     {
6539                       int flagno;
6540
6541                       d = *p;
6542                       *p = '\0';
6543
6544                       for (flagno = 0; flag[flagno].template; flagno++)
6545                         {
6546                           if (streq (r, flag[flagno].template))
6547                             {
6548                               flag_bits |= flag[flagno].set_bits;
6549                               break;
6550                             }
6551                         }
6552
6553                       *p = d;
6554                       if (! flag[flagno].template)
6555                         goto try_shorter;
6556                     }
6557                   else
6558                     goto try_shorter;
6559                 }
6560
6561               (*opcode->parms) (p, flag_bits);
6562               output_inst ();
6563               return;
6564             }
6565
6566         try_shorter:
6567           ;
6568         }
6569     }
6570
6571   /* It wasn't an instruction, but it might be a register alias of the form
6572      alias .req reg.  */
6573   q = p;
6574   skip_whitespace (q);
6575
6576   c = *p;
6577   *p = '\0';
6578
6579   if (*q && !strncmp (q, ".req ", 4))
6580     {
6581       int    reg;
6582       char * copy_of_str = str;
6583       char * r;
6584
6585       q += 4;
6586       skip_whitespace (q);
6587
6588       for (r = q; *r != '\0'; r++)
6589         if (*r == ' ')
6590           break;
6591
6592       if (r != q)
6593         {
6594           int regnum;
6595           char d = *r;
6596
6597           *r = '\0';
6598           regnum = arm_reg_parse (& q);
6599           *r = d;
6600
6601           reg = arm_reg_parse (& str);
6602
6603           if (reg == FAIL)
6604             {
6605               if (regnum != FAIL)
6606                 insert_reg_alias (str, regnum);
6607               else
6608                 as_warn (_("register '%s' does not exist\n"), q);
6609             }
6610           else if (regnum != FAIL)
6611             {
6612               if (reg != regnum)
6613                 as_warn (_("ignoring redefinition of register alias '%s'"),
6614                          copy_of_str);
6615
6616               /* Do not warn about redefinitions to the same alias.  */
6617             }
6618           else
6619             as_warn (_("ignoring redefinition of register alias '%s' to non-existant register '%s'"),
6620                      copy_of_str, q);
6621         }
6622       else
6623         as_warn (_("ignoring incomplete .req pseuso op"));
6624
6625       *p = c;
6626       return;
6627     }
6628
6629   *p = c;
6630   as_bad (_("bad instruction `%s'"), start);
6631 }
6632
6633 /* md_parse_option
6634       Invocation line includes a switch not recognized by the base assembler.
6635       See if it's a processor-specific option.  These are:
6636       Cpu variants, the arm part is optional:
6637               -m[arm]1                Currently not supported.
6638               -m[arm]2, -m[arm]250    Arm 2 and Arm 250 processor
6639               -m[arm]3                Arm 3 processor
6640               -m[arm]6[xx],           Arm 6 processors
6641               -m[arm]7[xx][t][[d]m]   Arm 7 processors
6642               -m[arm]8[10]            Arm 8 processors
6643               -m[arm]9[20][tdmi]      Arm 9 processors
6644               -mstrongarm[110[0]]     StrongARM processors
6645               -m[arm]v[2345[t]]       Arm architectures
6646               -mall                   All (except the ARM1)
6647       FP variants:
6648               -mfpa10, -mfpa11        FPA10 and 11 co-processor instructions
6649               -mfpe-old               (No float load/store multiples)
6650               -mno-fpu                Disable all floating point instructions
6651       Run-time endian selection:
6652               -EB                     big endian cpu
6653               -EL                     little endian cpu
6654       ARM Procedure Calling Standard:
6655               -mapcs-32               32 bit APCS
6656               -mapcs-26               26 bit APCS
6657               -mapcs-float            Pass floats in float regs
6658               -mapcs-reentrant        Position independent code
6659               -mthumb-interwork       Code supports Arm/Thumb interworking
6660               -moabi                  Old ELF ABI  */
6661
6662 CONST char * md_shortopts = "m:k";
6663
6664 struct option md_longopts[] =
6665 {
6666 #ifdef ARM_BI_ENDIAN
6667 #define OPTION_EB (OPTION_MD_BASE + 0)
6668   {"EB", no_argument, NULL, OPTION_EB},
6669 #define OPTION_EL (OPTION_MD_BASE + 1)
6670   {"EL", no_argument, NULL, OPTION_EL},
6671 #ifdef OBJ_ELF
6672 #define OPTION_OABI (OPTION_MD_BASE +2)
6673   {"oabi", no_argument, NULL, OPTION_OABI},
6674 #endif
6675 #endif
6676   {NULL, no_argument, NULL, 0}
6677 };
6678
6679 size_t md_longopts_size = sizeof (md_longopts);
6680
6681 int
6682 md_parse_option (c, arg)
6683      int    c;
6684      char * arg;
6685 {
6686   char * str = arg;
6687
6688   switch (c)
6689     {
6690 #ifdef ARM_BI_ENDIAN
6691     case OPTION_EB:
6692       target_big_endian = 1;
6693       break;
6694     case OPTION_EL:
6695       target_big_endian = 0;
6696       break;
6697 #endif
6698
6699     case 'm':
6700       switch (*str)
6701         {
6702         case 'f':
6703           if (streq (str, "fpa10"))
6704             cpu_variant = (cpu_variant & ~FPU_ALL) | FPU_FPA10;
6705           else if (streq (str, "fpa11"))
6706             cpu_variant = (cpu_variant & ~FPU_ALL) | FPU_FPA11;
6707           else if (streq (str, "fpe-old"))
6708             cpu_variant = (cpu_variant & ~FPU_ALL) | FPU_CORE;
6709           else
6710             goto bad;
6711           break;
6712
6713         case 'n':
6714           if (streq (str, "no-fpu"))
6715             cpu_variant &= ~FPU_ALL;
6716           break;
6717
6718 #ifdef OBJ_ELF
6719         case 'o':
6720           if (streq (str, "oabi"))
6721             target_oabi = true;
6722           break;
6723 #endif
6724
6725         case 't':
6726           /* Limit assembler to generating only Thumb instructions:  */
6727           if (streq (str, "thumb"))
6728             {
6729               cpu_variant = (cpu_variant & ~ARM_ANY) | ARM_THUMB;
6730               cpu_variant = (cpu_variant & ~FPU_ALL) | FPU_NONE;
6731               thumb_mode = 1;
6732             }
6733           else if (streq (str, "thumb-interwork"))
6734             {
6735               if ((cpu_variant & ARM_THUMB) == 0)
6736                 cpu_variant = (cpu_variant & ~ARM_ANY) | ARM_ARCH_V4T;
6737 #if defined OBJ_COFF || defined OBJ_ELF
6738               support_interwork = true;
6739 #endif
6740             }
6741           else
6742             goto bad;
6743           break;
6744
6745         default:
6746           if (streq (str, "all"))
6747             {
6748               cpu_variant = ARM_ALL | FPU_ALL;
6749               return 1;
6750             }
6751 #if defined OBJ_COFF || defined OBJ_ELF
6752           if (! strncmp (str, "apcs-", 5))
6753             {
6754               /* GCC passes on all command line options starting "-mapcs-..."
6755                  to us, so we must parse them here.  */
6756
6757               str += 5;
6758
6759               if (streq (str, "32"))
6760                 {
6761                   uses_apcs_26 = false;
6762                   return 1;
6763                 }
6764               else if (streq (str, "26"))
6765                 {
6766                   uses_apcs_26 = true;
6767                   return 1;
6768                 }
6769               else if (streq (str, "frame"))
6770                 {
6771                   /* Stack frames are being generated - does not affect
6772                      linkage of code.  */
6773                   return 1;
6774                 }
6775               else if (streq (str, "stack-check"))
6776                 {
6777                   /* Stack checking is being performed - does not affect
6778                      linkage, but does require that the functions
6779                      __rt_stkovf_split_small and __rt_stkovf_split_big be
6780                      present in the final link.  */
6781
6782                   return 1;
6783                 }
6784               else if (streq (str, "float"))
6785                 {
6786                   /* Floating point arguments are being passed in the floating
6787                      point registers.  This does affect linking, since this
6788                      version of the APCS is incompatible with the version that
6789                      passes floating points in the integer registers.  */
6790
6791                   uses_apcs_float = true;
6792                   return 1;
6793                 }
6794               else if (streq (str, "reentrant"))
6795                 {
6796                   /* Reentrant code has been generated.  This does affect
6797                      linking, since there is no point in linking reentrant/
6798                      position independent code with absolute position code.  */
6799                   pic_code = true;
6800                   return 1;
6801                 }
6802
6803               as_bad (_("Unrecognised APCS switch -m%s"), arg);
6804               return 0;
6805             }
6806 #endif
6807           /* Strip off optional "arm".  */
6808           if (! strncmp (str, "arm", 3))
6809             str += 3;
6810
6811           switch (*str)
6812             {
6813             case '1':
6814               if (streq (str, "1"))
6815                 cpu_variant = (cpu_variant & ~ARM_ANY) | ARM_1;
6816               else
6817                 goto bad;
6818               break;
6819
6820             case '2':
6821               if (streq (str, "2"))
6822                 cpu_variant = (cpu_variant & ~ARM_ANY) | ARM_2;
6823               else if (streq (str, "250"))
6824                 cpu_variant = (cpu_variant & ~ARM_ANY) | ARM_250;
6825               else
6826                 goto bad;
6827               break;
6828
6829             case '3':
6830               if (streq (str, "3"))
6831                 cpu_variant = (cpu_variant & ~ARM_ANY) | ARM_3;
6832               else
6833                 goto bad;
6834               break;
6835
6836             case '6':
6837               switch (strtol (str, NULL, 10))
6838                 {
6839                 case 6:
6840                 case 60:
6841                 case 600:
6842                 case 610:
6843                 case 620:
6844                   cpu_variant = (cpu_variant & ~ARM_ANY) | ARM_6;
6845                   break;
6846                 default:
6847                   goto bad;
6848                 }
6849               break;
6850
6851             case '7':
6852               /* Eat the processor name.  */
6853               switch (strtol (str, & str, 10))
6854                 {
6855                 case 7:
6856                 case 70:
6857                 case 700:
6858                 case 710:
6859                 case 720:
6860                 case 7100:
6861                 case 7500:
6862                   break;
6863                 default:
6864                   goto bad;
6865                 }
6866               cpu_variant = (cpu_variant & ~ARM_ANY) | ARM_7;
6867               for (; *str; str++)
6868                 {
6869                   switch (*str)
6870                     {
6871                     case 't':
6872                       cpu_variant |= (ARM_THUMB | ARM_ARCH_V4);
6873                       break;
6874
6875                     case 'm':
6876                       cpu_variant |= ARM_LONGMUL;
6877                       break;
6878
6879                     case 'f': /* fe => fp enabled cpu.  */
6880                       if (str[1] == 'e')
6881                         ++ str;
6882                       else
6883                         goto bad;
6884
6885                     case 'c': /* Left over from 710c processor name.  */
6886                     case 'd': /* Debug.  */
6887                     case 'i': /* Embedded ICE.  */
6888                       /* Included for completeness in ARM processor naming.  */
6889                       break;
6890
6891                     default:
6892                       goto bad;
6893                     }
6894                 }
6895               break;
6896
6897             case '8':
6898               if (streq (str, "8") || streq (str, "810"))
6899                 cpu_variant = (cpu_variant & ~ARM_ANY)
6900                   | ARM_8 | ARM_ARCH_V4 | ARM_LONGMUL;
6901               else
6902                 goto bad;
6903               break;
6904
6905             case '9':
6906               if (streq (str, "9"))
6907                 cpu_variant = (cpu_variant & ~ARM_ANY)
6908                   | ARM_9 | ARM_ARCH_V4 | ARM_LONGMUL | ARM_THUMB;
6909               else if (streq (str, "920"))
6910                 cpu_variant = (cpu_variant & ~ARM_ANY)
6911                   | ARM_9 | ARM_ARCH_V4 | ARM_LONGMUL;
6912               else if (streq (str, "920t"))
6913                 cpu_variant = (cpu_variant & ~ARM_ANY)
6914                   | ARM_9 | ARM_ARCH_V4 | ARM_LONGMUL | ARM_THUMB;
6915               else if (streq (str, "9tdmi"))
6916                 cpu_variant = (cpu_variant & ~ARM_ANY)
6917                   | ARM_9 | ARM_ARCH_V4 | ARM_LONGMUL | ARM_THUMB;
6918               else
6919                 goto bad;
6920               break;
6921
6922             case 's':
6923               if (streq (str, "strongarm")
6924                   || streq (str, "strongarm110")
6925                   || streq (str, "strongarm1100"))
6926                 cpu_variant = (cpu_variant & ~ARM_ANY)
6927                   | ARM_8 | ARM_ARCH_V4 | ARM_LONGMUL;
6928               else
6929                 goto bad;
6930               break;
6931
6932             case 'v':
6933               /* Select variant based on architecture rather than
6934                  processor.  */
6935               switch (*++str)
6936                 {
6937                 case '2':
6938                   switch (*++str)
6939                     {
6940                     case 'a':
6941                       cpu_variant = (cpu_variant & ~ARM_ANY) | ARM_3;
6942                       break;
6943                     case 0:
6944                       cpu_variant = (cpu_variant & ~ARM_ANY) | ARM_2;
6945                       break;
6946                     default:
6947                       as_bad (_("Invalid architecture variant -m%s"), arg);
6948                       break;
6949                     }
6950                   break;
6951
6952                 case '3':
6953                   cpu_variant = (cpu_variant & ~ARM_ANY) | ARM_7;
6954
6955                   switch (*++str)
6956                     {
6957                     case 'm': cpu_variant |= ARM_LONGMUL; break;
6958                     case 0:   break;
6959                     default:
6960                       as_bad (_("Invalid architecture variant -m%s"), arg);
6961                       break;
6962                     }
6963                   break;
6964
6965                 case '4':
6966                   cpu_variant = (cpu_variant & ~ARM_ANY) | ARM_ARCH_V4;
6967
6968                   switch (*++str)
6969                     {
6970                     case 't': cpu_variant |= ARM_THUMB; break;
6971                     case 0:   break;
6972                     default:
6973                       as_bad (_("Invalid architecture variant -m%s"), arg);
6974                       break;
6975                     }
6976                   break;
6977
6978                 case '5':
6979                   cpu_variant = (cpu_variant & ~ARM_ANY) | ARM_ARCH_V5;
6980                   switch (*++str)
6981                     {
6982                     case 't': cpu_variant |= ARM_THUMB; break;
6983                     case 0:   break;
6984                     default:
6985                       as_bad (_("Invalid architecture variant -m%s"), arg);
6986                       break;
6987                     }
6988                   break;
6989
6990                 default:
6991                   as_bad (_("Invalid architecture variant -m%s"), arg);
6992                   break;
6993                 }
6994               break;
6995
6996             default:
6997             bad:
6998               as_bad (_("Invalid processor variant -m%s"), arg);
6999               return 0;
7000             }
7001         }
7002       break;
7003
7004 #if defined OBJ_ELF || defined OBJ_COFF
7005     case 'k':
7006       pic_code = 1;
7007       break;
7008 #endif
7009
7010     default:
7011       return 0;
7012     }
7013
7014   return 1;
7015 }
7016
7017 void
7018 md_show_usage (fp)
7019      FILE * fp;
7020 {
7021   fprintf (fp, _("\
7022  ARM Specific Assembler Options:\n\
7023   -m[arm][<processor name>] select processor variant\n\
7024   -m[arm]v[2|2a|3|3m|4|4t|5[t][e]] select architecture variant\n\
7025   -mthumb                   only allow Thumb instructions\n\
7026   -mthumb-interwork         mark the assembled code as supporting interworking\n\
7027   -mall                     allow any instruction\n\
7028   -mfpa10, -mfpa11          select floating point architecture\n\
7029   -mfpe-old                 don't allow floating-point multiple instructions\n\
7030   -mno-fpu                  don't allow any floating-point instructions.\n\
7031   -k                        generate PIC code.\n"));
7032 #if defined OBJ_COFF || defined OBJ_ELF
7033   fprintf (fp, _("\
7034   -mapcs-32, -mapcs-26      specify which ARM Procedure Calling Standard to use\n\
7035   -mapcs-float              floating point args are passed in FP regs\n\
7036   -mapcs-reentrant          the code is position independent/reentrant\n"));
7037 #endif
7038 #ifdef OBJ_ELF
7039   fprintf (fp, _("\
7040   -moabi                    support the old ELF ABI\n"));
7041 #endif
7042 #ifdef ARM_BI_ENDIAN
7043   fprintf (fp, _("\
7044   -EB                       assemble code for a big endian cpu\n\
7045   -EL                       assemble code for a little endian cpu\n"));
7046 #endif
7047 }
7048
7049 /* We need to be able to fix up arbitrary expressions in some statements.
7050    This is so that we can handle symbols that are an arbitrary distance from
7051    the pc.  The most common cases are of the form ((+/-sym -/+ . - 8) & mask),
7052    which returns part of an address in a form which will be valid for
7053    a data instruction.  We do this by pushing the expression into a symbol
7054    in the expr_section, and creating a fix for that.  */
7055
7056 static void
7057 fix_new_arm (frag, where, size, exp, pc_rel, reloc)
7058      fragS *       frag;
7059      int           where;
7060      short int     size;
7061      expressionS * exp;
7062      int           pc_rel;
7063      int           reloc;
7064 {
7065   fixS *           new_fix;
7066   arm_fix_data *   arm_data;
7067
7068   switch (exp->X_op)
7069     {
7070     case O_constant:
7071     case O_symbol:
7072     case O_add:
7073     case O_subtract:
7074       new_fix = fix_new_exp (frag, where, size, exp, pc_rel, reloc);
7075       break;
7076
7077     default:
7078       new_fix = fix_new (frag, where, size, make_expr_symbol (exp), 0,
7079                          pc_rel, reloc);
7080       break;
7081     }
7082
7083   /* Mark whether the fix is to a THUMB instruction, or an ARM
7084      instruction.  */
7085   arm_data = (arm_fix_data *) obstack_alloc (& notes, sizeof (arm_fix_data));
7086   new_fix->tc_fix_data = (PTR) arm_data;
7087   arm_data->thumb_mode = thumb_mode;
7088
7089   return;
7090 }
7091
7092 /* This fix_new is called by cons via TC_CONS_FIX_NEW.  */
7093
7094 void
7095 cons_fix_new_arm (frag, where, size, exp)
7096      fragS *       frag;
7097      int           where;
7098      int           size;
7099      expressionS * exp;
7100 {
7101   bfd_reloc_code_real_type type;
7102   int pcrel = 0;
7103
7104   /* Pick a reloc.
7105      FIXME: @@ Should look at CPU word size.  */
7106   switch (size)
7107     {
7108     case 1:
7109       type = BFD_RELOC_8;
7110       break;
7111     case 2:
7112       type = BFD_RELOC_16;
7113       break;
7114     case 4:
7115     default:
7116       type = BFD_RELOC_32;
7117       break;
7118     case 8:
7119       type = BFD_RELOC_64;
7120       break;
7121     }
7122
7123   fix_new_exp (frag, where, (int) size, exp, pcrel, type);
7124 }
7125
7126 /* A good place to do this, although this was probably not intended
7127    for this kind of use.  We need to dump the literal pool before
7128    references are made to a null symbol pointer.  */
7129
7130 void
7131 arm_cleanup ()
7132 {
7133   if (current_poolP == NULL)
7134     return;
7135
7136   /* Put it at the end of text section.  */
7137   subseg_set (text_section, 0);
7138   s_ltorg (0);
7139   listing_prev_line ();
7140 }
7141
7142 void
7143 arm_start_line_hook ()
7144 {
7145   last_label_seen = NULL;
7146 }
7147
7148 void
7149 arm_frob_label (sym)
7150      symbolS * sym;
7151 {
7152   last_label_seen = sym;
7153
7154   ARM_SET_THUMB (sym, thumb_mode);
7155
7156 #if defined OBJ_COFF || defined OBJ_ELF
7157   ARM_SET_INTERWORK (sym, support_interwork);
7158 #endif
7159
7160   if (label_is_thumb_function_name)
7161     {
7162       /* When the address of a Thumb function is taken the bottom
7163          bit of that address should be set.  This will allow
7164          interworking between Arm and Thumb functions to work
7165          correctly.  */
7166
7167       THUMB_SET_FUNC (sym, 1);
7168
7169       label_is_thumb_function_name = false;
7170     }
7171 }
7172
7173 /* Adjust the symbol table.  This marks Thumb symbols as distinct from
7174    ARM ones.  */
7175
7176 void
7177 arm_adjust_symtab ()
7178 {
7179 #ifdef OBJ_COFF
7180   symbolS * sym;
7181
7182   for (sym = symbol_rootP; sym != NULL; sym = symbol_next (sym))
7183     {
7184       if (ARM_IS_THUMB (sym))
7185         {
7186           if (THUMB_IS_FUNC (sym))
7187             {
7188               /* Mark the symbol as a Thumb function.  */
7189               if (   S_GET_STORAGE_CLASS (sym) == C_STAT
7190                   || S_GET_STORAGE_CLASS (sym) == C_LABEL)  /* This can happen!  */
7191                 S_SET_STORAGE_CLASS (sym, C_THUMBSTATFUNC);
7192
7193               else if (S_GET_STORAGE_CLASS (sym) == C_EXT)
7194                 S_SET_STORAGE_CLASS (sym, C_THUMBEXTFUNC);
7195               else
7196                 as_bad (_("%s: unexpected function type: %d"),
7197                         S_GET_NAME (sym), S_GET_STORAGE_CLASS (sym));
7198             }
7199           else switch (S_GET_STORAGE_CLASS (sym))
7200             {
7201             case C_EXT:
7202               S_SET_STORAGE_CLASS (sym, C_THUMBEXT);
7203               break;
7204             case C_STAT:
7205               S_SET_STORAGE_CLASS (sym, C_THUMBSTAT);
7206               break;
7207             case C_LABEL:
7208               S_SET_STORAGE_CLASS (sym, C_THUMBLABEL);
7209               break;
7210             default:
7211               /* Do nothing.  */
7212               break;
7213             }
7214         }
7215
7216       if (ARM_IS_INTERWORK (sym))
7217         coffsymbol (symbol_get_bfdsym (sym))->native->u.syment.n_flags = 0xFF;
7218     }
7219 #endif
7220 #ifdef OBJ_ELF
7221   symbolS *sym;
7222   char bind;
7223
7224   for (sym = symbol_rootP; sym != NULL; sym = symbol_next (sym))
7225     {
7226       if (ARM_IS_THUMB (sym))
7227         {
7228           elf_symbol_type *elf_sym;
7229
7230           elf_sym = elf_symbol (symbol_get_bfdsym (sym));
7231           bind = ELF_ST_BIND (elf_sym);
7232
7233           /* If it's a .thumb_func, declare it as so,
7234              otherwise tag label as .code 16.  */
7235           if (THUMB_IS_FUNC (sym))
7236             elf_sym->internal_elf_sym.st_info =
7237               ELF_ST_INFO (bind, STT_ARM_TFUNC);
7238           else
7239             elf_sym->internal_elf_sym.st_info =
7240               ELF_ST_INFO (bind, STT_ARM_16BIT);
7241         }
7242     }
7243 #endif
7244 }
7245
7246 int
7247 arm_data_in_code ()
7248 {
7249   if (thumb_mode && ! strncmp (input_line_pointer + 1, "data:", 5))
7250     {
7251       *input_line_pointer = '/';
7252       input_line_pointer += 5;
7253       *input_line_pointer = 0;
7254       return 1;
7255     }
7256
7257   return 0;
7258 }
7259
7260 char *
7261 arm_canonicalize_symbol_name (name)
7262      char *name;
7263 {
7264   int len;
7265
7266   if (thumb_mode && (len = strlen (name)) > 5
7267       && streq (name + len - 5, "/data"))
7268     *(name + len - 5) = 0;
7269
7270   return name;
7271 }
7272
7273 boolean
7274 arm_validate_fix (fixP)
7275      fixS *fixP;
7276 {
7277   /* If the destination of the branch is a defined symbol which does not have
7278      the THUMB_FUNC attribute, then we must be calling a function which has
7279      the (interfacearm) attribute.  We look for the Thumb entry point to that
7280      function and change the branch to refer to that function instead.  */
7281   if (fixP->fx_r_type == BFD_RELOC_THUMB_PCREL_BRANCH23
7282       && fixP->fx_addsy != NULL
7283       && S_IS_DEFINED (fixP->fx_addsy)
7284       && ! THUMB_IS_FUNC (fixP->fx_addsy))
7285     {
7286       fixP->fx_addsy = find_real_start (fixP->fx_addsy);
7287       return true;
7288     }
7289
7290   return false;
7291 }
7292
7293 #ifdef OBJ_ELF
7294 /* Relocations against Thumb function names must be left unadjusted,
7295    so that the linker can use this information to correctly set the
7296    bottom bit of their addresses.  The MIPS version of this function
7297    also prevents relocations that are mips-16 specific, but I do not
7298    know why it does this.
7299
7300    FIXME:
7301    There is one other problem that ought to be addressed here, but
7302    which currently is not:  Taking the address of a label (rather
7303    than a function) and then later jumping to that address.  Such
7304    addresses also ought to have their bottom bit set (assuming that
7305    they reside in Thumb code), but at the moment they will not.  */
7306
7307 boolean
7308 arm_fix_adjustable (fixP)
7309    fixS *fixP;
7310 {
7311   if (fixP->fx_addsy == NULL)
7312     return 1;
7313
7314   /* Prevent all adjustments to global symbols.  */
7315   if (S_IS_EXTERN (fixP->fx_addsy))
7316     return 0;
7317
7318   if (S_IS_WEAK (fixP->fx_addsy))
7319     return 0;
7320
7321   if (THUMB_IS_FUNC (fixP->fx_addsy)
7322       && fixP->fx_subsy == NULL)
7323     return 0;
7324
7325   /* We need the symbol name for the VTABLE entries.  */
7326   if (   fixP->fx_r_type == BFD_RELOC_VTABLE_INHERIT
7327       || fixP->fx_r_type == BFD_RELOC_VTABLE_ENTRY)
7328     return 0;
7329
7330   return 1;
7331 }
7332
7333 const char *
7334 elf32_arm_target_format ()
7335 {
7336   if (target_big_endian)
7337     {
7338       if (target_oabi)
7339         return "elf32-bigarm-oabi";
7340       else
7341         return "elf32-bigarm";
7342     }
7343   else
7344     {
7345       if (target_oabi)
7346         return "elf32-littlearm-oabi";
7347       else
7348         return "elf32-littlearm";
7349     }
7350 }
7351
7352 void
7353 armelf_frob_symbol (symp, puntp)
7354      symbolS * symp;
7355      int *     puntp;
7356 {
7357   elf_frob_symbol (symp, puntp);
7358 }
7359
7360 int
7361 arm_force_relocation (fixp)
7362      struct fix * fixp;
7363 {
7364   if (   fixp->fx_r_type == BFD_RELOC_VTABLE_INHERIT
7365       || fixp->fx_r_type == BFD_RELOC_VTABLE_ENTRY
7366       || fixp->fx_r_type == BFD_RELOC_ARM_PCREL_BRANCH
7367       || fixp->fx_r_type == BFD_RELOC_ARM_PCREL_BLX
7368       || fixp->fx_r_type == BFD_RELOC_THUMB_PCREL_BLX
7369       || fixp->fx_r_type == BFD_RELOC_THUMB_PCREL_BRANCH23)
7370     return 1;
7371
7372   return 0;
7373 }
7374
7375 static bfd_reloc_code_real_type
7376 arm_parse_reloc ()
7377 {
7378   char         id [16];
7379   char *       ip;
7380   unsigned int i;
7381   static struct
7382   {
7383     char * str;
7384     int    len;
7385     bfd_reloc_code_real_type reloc;
7386   }
7387   reloc_map[] =
7388   {
7389 #define MAP(str,reloc) { str, sizeof (str)-1, reloc }
7390     MAP ("(got)",    BFD_RELOC_ARM_GOT32),
7391     MAP ("(gotoff)", BFD_RELOC_ARM_GOTOFF),
7392     /* ScottB: Jan 30, 1998 - Added support for parsing "var(PLT)"
7393        branch instructions generated by GCC for PLT relocs.  */
7394     MAP ("(plt)",    BFD_RELOC_ARM_PLT32),
7395     { NULL, 0,         BFD_RELOC_UNUSED }
7396 #undef MAP
7397   };
7398
7399   for (i = 0, ip = input_line_pointer;
7400        i < sizeof (id) && (isalnum (*ip) || ispunct (*ip));
7401        i++, ip++)
7402     id[i] = tolower (*ip);
7403
7404   for (i = 0; reloc_map[i].str; i++)
7405     if (strncmp (id, reloc_map[i].str, reloc_map[i].len) == 0)
7406       break;
7407
7408   input_line_pointer += reloc_map[i].len;
7409
7410   return reloc_map[i].reloc;
7411 }
7412
7413 static void
7414 s_arm_elf_cons (nbytes)
7415      int nbytes;
7416 {
7417   expressionS exp;
7418
7419 #ifdef md_flush_pending_output
7420   md_flush_pending_output ();
7421 #endif
7422
7423   if (is_it_end_of_statement ())
7424     {
7425       demand_empty_rest_of_line ();
7426       return;
7427     }
7428
7429 #ifdef md_cons_align
7430   md_cons_align (nbytes);
7431 #endif
7432
7433   do
7434     {
7435       bfd_reloc_code_real_type reloc;
7436
7437       expression (& exp);
7438
7439       if (exp.X_op == O_symbol
7440           && *input_line_pointer == '('
7441           && (reloc = arm_parse_reloc ()) != BFD_RELOC_UNUSED)
7442         {
7443           reloc_howto_type *howto = bfd_reloc_type_lookup (stdoutput, reloc);
7444           int size = bfd_get_reloc_size (howto);
7445
7446           if (size > nbytes)
7447             as_bad ("%s relocations do not fit in %d bytes",
7448                     howto->name, nbytes);
7449           else
7450             {
7451               register char *p = frag_more ((int) nbytes);
7452               int offset = nbytes - size;
7453
7454               fix_new_exp (frag_now, p - frag_now->fr_literal + offset, size,
7455                            &exp, 0, reloc);
7456             }
7457         }
7458       else
7459         emit_expr (&exp, (unsigned int) nbytes);
7460     }
7461   while (*input_line_pointer++ == ',');
7462
7463   /* Put terminator back into stream.  */
7464   input_line_pointer --;
7465   demand_empty_rest_of_line ();
7466 }
7467
7468 #endif /* OBJ_ELF */