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   if (reg == REG_PC)
3593     inst.error = BAD_PC;
3594
3595   end_of_line (str);
3596 }
3597
3598 static void
3599 do_cdp (str, flags)
3600      char * str;
3601      unsigned long flags ATTRIBUTE_UNUSED;
3602 {
3603   /* Co-processor data operation.
3604      Format: CDP{cond} CP#,<expr>,CRd,CRn,CRm{,<expr>}  */
3605   skip_whitespace (str);
3606
3607   if (co_proc_number (&str) == FAIL)
3608     {
3609       if (!inst.error)
3610         inst.error = BAD_ARGS;
3611       return;
3612     }
3613
3614   if (skip_past_comma (&str) == FAIL
3615       || cp_opc_expr (&str, 20,4) == FAIL)
3616     {
3617       if (!inst.error)
3618         inst.error = BAD_ARGS;
3619       return;
3620     }
3621
3622   if (skip_past_comma (&str) == FAIL
3623       || cp_reg_required_here (&str, 12) == FAIL)
3624     {
3625       if (!inst.error)
3626         inst.error = BAD_ARGS;
3627       return;
3628     }
3629
3630   if (skip_past_comma (&str) == FAIL
3631       || cp_reg_required_here (&str, 16) == FAIL)
3632     {
3633       if (!inst.error)
3634         inst.error = BAD_ARGS;
3635       return;
3636     }
3637
3638   if (skip_past_comma (&str) == FAIL
3639       || cp_reg_required_here (&str, 0) == FAIL)
3640     {
3641       if (!inst.error)
3642         inst.error = BAD_ARGS;
3643       return;
3644     }
3645
3646   if (skip_past_comma (&str) == SUCCESS)
3647     {
3648       if (cp_opc_expr (&str, 5, 3) == FAIL)
3649         {
3650           if (!inst.error)
3651             inst.error = BAD_ARGS;
3652           return;
3653         }
3654     }
3655
3656   end_of_line (str);
3657   return;
3658 }
3659
3660 static void
3661 do_lstc (str, flags)
3662      char * str;
3663      unsigned long flags;
3664 {
3665   /* Co-processor register load/store.
3666      Format: <LDC|STC{cond}[L] CP#,CRd,<address>  */
3667
3668   skip_whitespace (str);
3669
3670   if (co_proc_number (&str) == FAIL)
3671     {
3672       if (!inst.error)
3673         inst.error = BAD_ARGS;
3674       return;
3675     }
3676
3677   if (skip_past_comma (&str) == FAIL
3678       || cp_reg_required_here (&str, 12) == FAIL)
3679     {
3680       if (!inst.error)
3681         inst.error = BAD_ARGS;
3682       return;
3683     }
3684
3685   if (skip_past_comma (&str) == FAIL
3686       || cp_address_required_here (&str) == FAIL)
3687     {
3688       if (! inst.error)
3689         inst.error = BAD_ARGS;
3690       return;
3691     }
3692
3693   inst.instruction |= flags;
3694   end_of_line (str);
3695   return;
3696 }
3697
3698 static void
3699 do_co_reg (str, flags)
3700      char * str;
3701      unsigned long flags;
3702 {
3703   /* Co-processor register transfer.
3704      Format: <MCR|MRC>{cond} CP#,<expr1>,Rd,CRn,CRm{,<expr2>}  */
3705
3706   skip_whitespace (str);
3707
3708   if (co_proc_number (&str) == FAIL)
3709     {
3710       if (!inst.error)
3711         inst.error = BAD_ARGS;
3712       return;
3713     }
3714
3715   if (skip_past_comma (&str) == FAIL
3716       || cp_opc_expr (&str, 21, 3) == FAIL)
3717     {
3718       if (!inst.error)
3719         inst.error = BAD_ARGS;
3720       return;
3721     }
3722
3723   if (skip_past_comma (&str) == FAIL
3724       || reg_required_here (&str, 12) == FAIL)
3725     {
3726       if (!inst.error)
3727         inst.error = BAD_ARGS;
3728       return;
3729     }
3730
3731   if (skip_past_comma (&str) == FAIL
3732       || cp_reg_required_here (&str, 16) == FAIL)
3733     {
3734       if (!inst.error)
3735         inst.error = BAD_ARGS;
3736       return;
3737     }
3738
3739   if (skip_past_comma (&str) == FAIL
3740       || cp_reg_required_here (&str, 0) == FAIL)
3741     {
3742       if (!inst.error)
3743         inst.error = BAD_ARGS;
3744       return;
3745     }
3746
3747   if (skip_past_comma (&str) == SUCCESS)
3748     {
3749       if (cp_opc_expr (&str, 5, 3) == FAIL)
3750         {
3751           if (!inst.error)
3752             inst.error = BAD_ARGS;
3753           return;
3754         }
3755     }
3756   if (flags)
3757     {
3758       inst.error = BAD_COND;
3759     }
3760
3761   end_of_line (str);
3762   return;
3763 }
3764
3765 static void
3766 do_fp_ctrl (str, flags)
3767      char * str;
3768      unsigned long flags ATTRIBUTE_UNUSED;
3769 {
3770   /* FP control registers.
3771      Format: <WFS|RFS|WFC|RFC>{cond} Rn  */
3772
3773   skip_whitespace (str);
3774
3775   if (reg_required_here (&str, 12) == FAIL)
3776     {
3777       if (!inst.error)
3778         inst.error = BAD_ARGS;
3779       return;
3780     }
3781
3782   end_of_line (str);
3783   return;
3784 }
3785
3786 static void
3787 do_fp_ldst (str, flags)
3788      char * str;
3789      unsigned long flags ATTRIBUTE_UNUSED;
3790 {
3791   skip_whitespace (str);
3792
3793   switch (inst.suffix)
3794     {
3795     case SUFF_S:
3796       break;
3797     case SUFF_D:
3798       inst.instruction |= CP_T_X;
3799       break;
3800     case SUFF_E:
3801       inst.instruction |= CP_T_Y;
3802       break;
3803     case SUFF_P:
3804       inst.instruction |= CP_T_X | CP_T_Y;
3805       break;
3806     default:
3807       abort ();
3808     }
3809
3810   if (fp_reg_required_here (&str, 12) == FAIL)
3811     {
3812       if (!inst.error)
3813         inst.error = BAD_ARGS;
3814       return;
3815     }
3816
3817   if (skip_past_comma (&str) == FAIL
3818       || cp_address_required_here (&str) == FAIL)
3819     {
3820       if (!inst.error)
3821         inst.error = BAD_ARGS;
3822       return;
3823     }
3824
3825   end_of_line (str);
3826 }
3827
3828 static void
3829 do_fp_ldmstm (str, flags)
3830      char * str;
3831      unsigned long flags;
3832 {
3833   int num_regs;
3834
3835   skip_whitespace (str);
3836
3837   if (fp_reg_required_here (&str, 12) == FAIL)
3838     {
3839       if (! inst.error)
3840         inst.error = BAD_ARGS;
3841       return;
3842     }
3843
3844   /* Get Number of registers to transfer.  */
3845   if (skip_past_comma (&str) == FAIL
3846       || my_get_expression (&inst.reloc.exp, &str))
3847     {
3848       if (! inst.error)
3849         inst.error = _("constant expression expected");
3850       return;
3851     }
3852
3853   if (inst.reloc.exp.X_op != O_constant)
3854     {
3855       inst.error = _("Constant value required for number of registers");
3856       return;
3857     }
3858
3859   num_regs = inst.reloc.exp.X_add_number;
3860
3861   if (num_regs < 1 || num_regs > 4)
3862     {
3863       inst.error = _("number of registers must be in the range [1:4]");
3864       return;
3865     }
3866
3867   switch (num_regs)
3868     {
3869     case 1:
3870       inst.instruction |= CP_T_X;
3871       break;
3872     case 2:
3873       inst.instruction |= CP_T_Y;
3874       break;
3875     case 3:
3876       inst.instruction |= CP_T_Y | CP_T_X;
3877       break;
3878     case 4:
3879       break;
3880     default:
3881       abort ();
3882     }
3883
3884   if (flags)
3885     {
3886       int reg;
3887       int write_back;
3888       int offset;
3889
3890       /* The instruction specified "ea" or "fd", so we can only accept
3891          [Rn]{!}.  The instruction does not really support stacking or
3892          unstacking, so we have to emulate these by setting appropriate
3893          bits and offsets.  */
3894       if (skip_past_comma (&str) == FAIL
3895           || *str != '[')
3896         {
3897           if (! inst.error)
3898             inst.error = BAD_ARGS;
3899           return;
3900         }
3901
3902       str++;
3903       skip_whitespace (str);
3904
3905       if ((reg = reg_required_here (&str, 16)) == FAIL)
3906         return;
3907
3908       skip_whitespace (str);
3909
3910       if (*str != ']')
3911         {
3912           inst.error = BAD_ARGS;
3913           return;
3914         }
3915
3916       str++;
3917       if (*str == '!')
3918         {
3919           write_back = 1;
3920           str++;
3921           if (reg == REG_PC)
3922             {
3923               inst.error =
3924                 _("R15 not allowed as base register with write-back");
3925               return;
3926             }
3927         }
3928       else
3929         write_back = 0;
3930
3931       if (flags & CP_T_Pre)
3932         {
3933           /* Pre-decrement.  */
3934           offset = 3 * num_regs;
3935           if (write_back)
3936             flags |= CP_T_WB;
3937         }
3938       else
3939         {
3940           /* Post-increment.  */
3941           if (write_back)
3942             {
3943               flags |= CP_T_WB;
3944               offset = 3 * num_regs;
3945             }
3946           else
3947             {
3948               /* No write-back, so convert this into a standard pre-increment
3949                  instruction -- aesthetically more pleasing.  */
3950               flags = CP_T_Pre | CP_T_UD;
3951               offset = 0;
3952             }
3953         }
3954
3955       inst.instruction |= flags | offset;
3956     }
3957   else if (skip_past_comma (&str) == FAIL
3958            || cp_address_required_here (&str) == FAIL)
3959     {
3960       if (! inst.error)
3961         inst.error = BAD_ARGS;
3962       return;
3963     }
3964
3965   end_of_line (str);
3966 }
3967
3968 static void
3969 do_fp_dyadic (str, flags)
3970      char * str;
3971      unsigned long flags;
3972 {
3973   skip_whitespace (str);
3974
3975   switch (inst.suffix)
3976     {
3977     case SUFF_S:
3978       break;
3979     case SUFF_D:
3980       inst.instruction |= 0x00000080;
3981       break;
3982     case SUFF_E:
3983       inst.instruction |= 0x00080000;
3984       break;
3985     default:
3986       abort ();
3987     }
3988
3989   if (fp_reg_required_here (&str, 12) == FAIL)
3990     {
3991       if (! inst.error)
3992         inst.error = BAD_ARGS;
3993       return;
3994     }
3995
3996   if (skip_past_comma (&str) == FAIL
3997       || fp_reg_required_here (&str, 16) == FAIL)
3998     {
3999       if (! inst.error)
4000         inst.error = BAD_ARGS;
4001       return;
4002     }
4003
4004   if (skip_past_comma (&str) == FAIL
4005       || fp_op2 (&str) == FAIL)
4006     {
4007       if (! inst.error)
4008         inst.error = BAD_ARGS;
4009       return;
4010     }
4011
4012   inst.instruction |= flags;
4013   end_of_line (str);
4014   return;
4015 }
4016
4017 static void
4018 do_fp_monadic (str, flags)
4019      char * str;
4020      unsigned long flags;
4021 {
4022   skip_whitespace (str);
4023
4024   switch (inst.suffix)
4025     {
4026     case SUFF_S:
4027       break;
4028     case SUFF_D:
4029       inst.instruction |= 0x00000080;
4030       break;
4031     case SUFF_E:
4032       inst.instruction |= 0x00080000;
4033       break;
4034     default:
4035       abort ();
4036     }
4037
4038   if (fp_reg_required_here (&str, 12) == FAIL)
4039     {
4040       if (! inst.error)
4041         inst.error = BAD_ARGS;
4042       return;
4043     }
4044
4045   if (skip_past_comma (&str) == FAIL
4046       || fp_op2 (&str) == FAIL)
4047     {
4048       if (! inst.error)
4049         inst.error = BAD_ARGS;
4050       return;
4051     }
4052
4053   inst.instruction |= flags;
4054   end_of_line (str);
4055   return;
4056 }
4057
4058 static void
4059 do_fp_cmp (str, flags)
4060      char * str;
4061      unsigned long flags;
4062 {
4063   skip_whitespace (str);
4064
4065   if (fp_reg_required_here (&str, 16) == FAIL)
4066     {
4067       if (! inst.error)
4068         inst.error = BAD_ARGS;
4069       return;
4070     }
4071
4072   if (skip_past_comma (&str) == FAIL
4073       || fp_op2 (&str) == FAIL)
4074     {
4075       if (! inst.error)
4076         inst.error = BAD_ARGS;
4077       return;
4078     }
4079
4080   inst.instruction |= flags;
4081   end_of_line (str);
4082   return;
4083 }
4084
4085 static void
4086 do_fp_from_reg (str, flags)
4087      char * str;
4088      unsigned long flags;
4089 {
4090   skip_whitespace (str);
4091
4092   switch (inst.suffix)
4093     {
4094     case SUFF_S:
4095       break;
4096     case SUFF_D:
4097       inst.instruction |= 0x00000080;
4098       break;
4099     case SUFF_E:
4100       inst.instruction |= 0x00080000;
4101       break;
4102     default:
4103       abort ();
4104     }
4105
4106   if (fp_reg_required_here (&str, 16) == FAIL)
4107     {
4108       if (! inst.error)
4109         inst.error = BAD_ARGS;
4110       return;
4111     }
4112
4113   if (skip_past_comma (&str) == FAIL
4114       || reg_required_here (&str, 12) == FAIL)
4115     {
4116       if (! inst.error)
4117         inst.error = BAD_ARGS;
4118       return;
4119     }
4120
4121   inst.instruction |= flags;
4122   end_of_line (str);
4123   return;
4124 }
4125
4126 static void
4127 do_fp_to_reg (str, flags)
4128      char * str;
4129      unsigned long flags;
4130 {
4131   skip_whitespace (str);
4132
4133   if (reg_required_here (&str, 12) == FAIL)
4134     return;
4135
4136   if (skip_past_comma (&str) == FAIL
4137       || fp_reg_required_here (&str, 0) == FAIL)
4138     {
4139       if (! inst.error)
4140         inst.error = BAD_ARGS;
4141       return;
4142     }
4143
4144   inst.instruction |= flags;
4145   end_of_line (str);
4146   return;
4147 }
4148
4149 /* Thumb specific routines.  */
4150
4151 /* Parse and validate that a register is of the right form, this saves
4152    repeated checking of this information in many similar cases.
4153    Unlike the 32-bit case we do not insert the register into the opcode
4154    here, since the position is often unknown until the full instruction
4155    has been parsed.  */
4156
4157 static int
4158 thumb_reg (strp, hi_lo)
4159      char ** strp;
4160      int     hi_lo;
4161 {
4162   int reg;
4163
4164   if ((reg = reg_required_here (strp, -1)) == FAIL)
4165     return FAIL;
4166
4167   switch (hi_lo)
4168     {
4169     case THUMB_REG_LO:
4170       if (reg > 7)
4171         {
4172           inst.error = _("lo register required");
4173           return FAIL;
4174         }
4175       break;
4176
4177     case THUMB_REG_HI:
4178       if (reg < 8)
4179         {
4180           inst.error = _("hi register required");
4181           return FAIL;
4182         }
4183       break;
4184
4185     default:
4186       break;
4187     }
4188
4189   return reg;
4190 }
4191
4192 /* Parse an add or subtract instruction, SUBTRACT is non-zero if the opcode
4193    was SUB.  */
4194
4195 static void
4196 thumb_add_sub (str, subtract)
4197      char * str;
4198      int    subtract;
4199 {
4200   int Rd, Rs, Rn = FAIL;
4201
4202   skip_whitespace (str);
4203
4204   if ((Rd = thumb_reg (&str, THUMB_REG_ANY)) == FAIL
4205       || skip_past_comma (&str) == FAIL)
4206     {
4207       if (! inst.error)
4208         inst.error = BAD_ARGS;
4209       return;
4210     }
4211
4212   if (is_immediate_prefix (*str))
4213     {
4214       Rs = Rd;
4215       str++;
4216       if (my_get_expression (&inst.reloc.exp, &str))
4217         return;
4218     }
4219   else
4220     {
4221       if ((Rs = thumb_reg (&str, THUMB_REG_ANY)) == FAIL)
4222         return;
4223
4224       if (skip_past_comma (&str) == FAIL)
4225         {
4226           /* Two operand format, shuffle the registers
4227              and pretend there are 3.  */
4228           Rn = Rs;
4229           Rs = Rd;
4230         }
4231       else if (is_immediate_prefix (*str))
4232         {
4233           str++;
4234           if (my_get_expression (&inst.reloc.exp, &str))
4235             return;
4236         }
4237       else if ((Rn = thumb_reg (&str, THUMB_REG_ANY)) == FAIL)
4238         return;
4239     }
4240
4241   /* We now have Rd and Rs set to registers, and Rn set to a register or FAIL;
4242      for the latter case, EXPR contains the immediate that was found.  */
4243   if (Rn != FAIL)
4244     {
4245       /* All register format.  */
4246       if (Rd > 7 || Rs > 7 || Rn > 7)
4247         {
4248           if (Rs != Rd)
4249             {
4250               inst.error = _("dest and source1 must be the same register");
4251               return;
4252             }
4253
4254           /* Can't do this for SUB.  */
4255           if (subtract)
4256             {
4257               inst.error = _("subtract valid only on lo regs");
4258               return;
4259             }
4260
4261           inst.instruction = (T_OPCODE_ADD_HI
4262                               | (Rd > 7 ? THUMB_H1 : 0)
4263                               | (Rn > 7 ? THUMB_H2 : 0));
4264           inst.instruction |= (Rd & 7) | ((Rn & 7) << 3);
4265         }
4266       else
4267         {
4268           inst.instruction = subtract ? T_OPCODE_SUB_R3 : T_OPCODE_ADD_R3;
4269           inst.instruction |= Rd | (Rs << 3) | (Rn << 6);
4270         }
4271     }
4272   else
4273     {
4274       /* Immediate expression, now things start to get nasty.  */
4275
4276       /* First deal with HI regs, only very restricted cases allowed:
4277          Adjusting SP, and using PC or SP to get an address.  */
4278       if ((Rd > 7 && (Rd != REG_SP || Rs != REG_SP))
4279           || (Rs > 7 && Rs != REG_SP && Rs != REG_PC))
4280         {
4281           inst.error = _("invalid Hi register with immediate");
4282           return;
4283         }
4284
4285       if (inst.reloc.exp.X_op != O_constant)
4286         {
4287           /* Value isn't known yet, all we can do is store all the fragments
4288              we know about in the instruction and let the reloc hacking
4289              work it all out.  */
4290           inst.instruction = (subtract ? 0x8000 : 0) | (Rd << 4) | Rs;
4291           inst.reloc.type = BFD_RELOC_ARM_THUMB_ADD;
4292         }
4293       else
4294         {
4295           int offset = inst.reloc.exp.X_add_number;
4296
4297           if (subtract)
4298             offset = -offset;
4299
4300           if (offset < 0)
4301             {
4302               offset = -offset;
4303               subtract = 1;
4304
4305               /* Quick check, in case offset is MIN_INT.  */
4306               if (offset < 0)
4307                 {
4308                   inst.error = _("immediate value out of range");
4309                   return;
4310                 }
4311             }
4312           else
4313             subtract = 0;
4314
4315           if (Rd == REG_SP)
4316             {
4317               if (offset & ~0x1fc)
4318                 {
4319                   inst.error = _("invalid immediate value for stack adjust");
4320                   return;
4321                 }
4322               inst.instruction = subtract ? T_OPCODE_SUB_ST : T_OPCODE_ADD_ST;
4323               inst.instruction |= offset >> 2;
4324             }
4325           else if (Rs == REG_PC || Rs == REG_SP)
4326             {
4327               if (subtract
4328                   || (offset & ~0x3fc))
4329                 {
4330                   inst.error = _("invalid immediate for address calculation");
4331                   return;
4332                 }
4333               inst.instruction = (Rs == REG_PC ? T_OPCODE_ADD_PC
4334                                   : T_OPCODE_ADD_SP);
4335               inst.instruction |= (Rd << 8) | (offset >> 2);
4336             }
4337           else if (Rs == Rd)
4338             {
4339               if (offset & ~0xff)
4340                 {
4341                   inst.error = _("immediate value out of range");
4342                   return;
4343                 }
4344               inst.instruction = subtract ? T_OPCODE_SUB_I8 : T_OPCODE_ADD_I8;
4345               inst.instruction |= (Rd << 8) | offset;
4346             }
4347           else
4348             {
4349               if (offset & ~0x7)
4350                 {
4351                   inst.error = _("immediate value out of range");
4352                   return;
4353                 }
4354               inst.instruction = subtract ? T_OPCODE_SUB_I3 : T_OPCODE_ADD_I3;
4355               inst.instruction |= Rd | (Rs << 3) | (offset << 6);
4356             }
4357         }
4358     }
4359
4360   end_of_line (str);
4361 }
4362
4363 static void
4364 thumb_shift (str, shift)
4365      char * str;
4366      int    shift;
4367 {
4368   int Rd, Rs, Rn = FAIL;
4369
4370   skip_whitespace (str);
4371
4372   if ((Rd = thumb_reg (&str, THUMB_REG_LO)) == FAIL
4373       || skip_past_comma (&str) == FAIL)
4374     {
4375       if (! inst.error)
4376         inst.error = BAD_ARGS;
4377       return;
4378     }
4379
4380   if (is_immediate_prefix (*str))
4381     {
4382       /* Two operand immediate format, set Rs to Rd.  */
4383       Rs = Rd;
4384       str ++;
4385       if (my_get_expression (&inst.reloc.exp, &str))
4386         return;
4387     }
4388   else
4389     {
4390       if ((Rs = thumb_reg (&str, THUMB_REG_LO)) == FAIL)
4391         return;
4392
4393       if (skip_past_comma (&str) == FAIL)
4394         {
4395           /* Two operand format, shuffle the registers
4396              and pretend there are 3.  */
4397           Rn = Rs;
4398           Rs = Rd;
4399         }
4400       else if (is_immediate_prefix (*str))
4401         {
4402           str++;
4403           if (my_get_expression (&inst.reloc.exp, &str))
4404             return;
4405         }
4406       else if ((Rn = thumb_reg (&str, THUMB_REG_LO)) == FAIL)
4407         return;
4408     }
4409
4410   /* We now have Rd and Rs set to registers, and Rn set to a register or FAIL;
4411      for the latter case, EXPR contains the immediate that was found.  */
4412
4413   if (Rn != FAIL)
4414     {
4415       if (Rs != Rd)
4416         {
4417           inst.error = _("source1 and dest must be same register");
4418           return;
4419         }
4420
4421       switch (shift)
4422         {
4423         case THUMB_ASR: inst.instruction = T_OPCODE_ASR_R; break;
4424         case THUMB_LSL: inst.instruction = T_OPCODE_LSL_R; break;
4425         case THUMB_LSR: inst.instruction = T_OPCODE_LSR_R; break;
4426         }
4427
4428       inst.instruction |= Rd | (Rn << 3);
4429     }
4430   else
4431     {
4432       switch (shift)
4433         {
4434         case THUMB_ASR: inst.instruction = T_OPCODE_ASR_I; break;
4435         case THUMB_LSL: inst.instruction = T_OPCODE_LSL_I; break;
4436         case THUMB_LSR: inst.instruction = T_OPCODE_LSR_I; break;
4437         }
4438
4439       if (inst.reloc.exp.X_op != O_constant)
4440         {
4441           /* Value isn't known yet, create a dummy reloc and let reloc
4442              hacking fix it up.  */
4443           inst.reloc.type = BFD_RELOC_ARM_THUMB_SHIFT;
4444         }
4445       else
4446         {
4447           unsigned shift_value = inst.reloc.exp.X_add_number;
4448
4449           if (shift_value > 32 || (shift_value == 32 && shift == THUMB_LSL))
4450             {
4451               inst.error = _("Invalid immediate for shift");
4452               return;
4453             }
4454
4455           /* Shifts of zero are handled by converting to LSL.  */
4456           if (shift_value == 0)
4457             inst.instruction = T_OPCODE_LSL_I;
4458
4459           /* Shifts of 32 are encoded as a shift of zero.  */
4460           if (shift_value == 32)
4461             shift_value = 0;
4462
4463           inst.instruction |= shift_value << 6;
4464         }
4465
4466       inst.instruction |= Rd | (Rs << 3);
4467     }
4468
4469   end_of_line (str);
4470 }
4471
4472 static void
4473 thumb_mov_compare (str, move)
4474      char * str;
4475      int    move;
4476 {
4477   int Rd, Rs = FAIL;
4478
4479   skip_whitespace (str);
4480
4481   if ((Rd = thumb_reg (&str, THUMB_REG_ANY)) == FAIL
4482       || skip_past_comma (&str) == FAIL)
4483     {
4484       if (! inst.error)
4485         inst.error = BAD_ARGS;
4486       return;
4487     }
4488
4489   if (is_immediate_prefix (*str))
4490     {
4491       str++;
4492       if (my_get_expression (&inst.reloc.exp, &str))
4493         return;
4494     }
4495   else if ((Rs = thumb_reg (&str, THUMB_REG_ANY)) == FAIL)
4496     return;
4497
4498   if (Rs != FAIL)
4499     {
4500       if (Rs < 8 && Rd < 8)
4501         {
4502           if (move == THUMB_MOVE)
4503             /* A move of two lowregs is encoded as ADD Rd, Rs, #0
4504                since a MOV instruction produces unpredictable results.  */
4505             inst.instruction = T_OPCODE_ADD_I3;
4506           else
4507             inst.instruction = T_OPCODE_CMP_LR;
4508           inst.instruction |= Rd | (Rs << 3);
4509         }
4510       else
4511         {
4512           if (move == THUMB_MOVE)
4513             inst.instruction = T_OPCODE_MOV_HR;
4514           else
4515             inst.instruction = T_OPCODE_CMP_HR;
4516
4517           if (Rd > 7)
4518             inst.instruction |= THUMB_H1;
4519
4520           if (Rs > 7)
4521             inst.instruction |= THUMB_H2;
4522
4523           inst.instruction |= (Rd & 7) | ((Rs & 7) << 3);
4524         }
4525     }
4526   else
4527     {
4528       if (Rd > 7)
4529         {
4530           inst.error = _("only lo regs allowed with immediate");
4531           return;
4532         }
4533
4534       if (move == THUMB_MOVE)
4535         inst.instruction = T_OPCODE_MOV_I8;
4536       else
4537         inst.instruction = T_OPCODE_CMP_I8;
4538
4539       inst.instruction |= Rd << 8;
4540
4541       if (inst.reloc.exp.X_op != O_constant)
4542         inst.reloc.type = BFD_RELOC_ARM_THUMB_IMM;
4543       else
4544         {
4545           unsigned value = inst.reloc.exp.X_add_number;
4546
4547           if (value > 255)
4548             {
4549               inst.error = _("invalid immediate");
4550               return;
4551             }
4552
4553           inst.instruction |= value;
4554         }
4555     }
4556
4557   end_of_line (str);
4558 }
4559
4560 static void
4561 thumb_load_store (str, load_store, size)
4562      char * str;
4563      int    load_store;
4564      int    size;
4565 {
4566   int Rd, Rb, Ro = FAIL;
4567
4568   skip_whitespace (str);
4569
4570   if ((Rd = thumb_reg (&str, THUMB_REG_LO)) == FAIL
4571       || skip_past_comma (&str) == FAIL)
4572     {
4573       if (! inst.error)
4574         inst.error = BAD_ARGS;
4575       return;
4576     }
4577
4578   if (*str == '[')
4579     {
4580       str++;
4581       if ((Rb = thumb_reg (&str, THUMB_REG_ANY)) == FAIL)
4582         return;
4583
4584       if (skip_past_comma (&str) != FAIL)
4585         {
4586           if (is_immediate_prefix (*str))
4587             {
4588               str++;
4589               if (my_get_expression (&inst.reloc.exp, &str))
4590                 return;
4591             }
4592           else if ((Ro = thumb_reg (&str, THUMB_REG_LO)) == FAIL)
4593             return;
4594         }
4595       else
4596         {
4597           inst.reloc.exp.X_op = O_constant;
4598           inst.reloc.exp.X_add_number = 0;
4599         }
4600
4601       if (*str != ']')
4602         {
4603           inst.error = _("expected ']'");
4604           return;
4605         }
4606       str++;
4607     }
4608   else if (*str == '=')
4609     {
4610       /* Parse an "ldr Rd, =expr" instruction; this is another pseudo op.  */
4611       str++;
4612
4613       skip_whitespace (str);
4614
4615       if (my_get_expression (& inst.reloc.exp, & str))
4616         return;
4617
4618       end_of_line (str);
4619
4620       if (   inst.reloc.exp.X_op != O_constant
4621           && inst.reloc.exp.X_op != O_symbol)
4622         {
4623           inst.error = "Constant expression expected";
4624           return;
4625         }
4626
4627       if (inst.reloc.exp.X_op == O_constant
4628           && ((inst.reloc.exp.X_add_number & ~0xFF) == 0))
4629         {
4630           /* This can be done with a mov instruction.  */
4631
4632           inst.instruction  = T_OPCODE_MOV_I8 | (Rd << 8);
4633           inst.instruction |= inst.reloc.exp.X_add_number;
4634           return;
4635         }
4636
4637       /* Insert into literal pool.  */
4638       if (add_to_lit_pool () == FAIL)
4639         {
4640           if (!inst.error)
4641             inst.error = "literal pool insertion failed";
4642           return;
4643         }
4644
4645       inst.reloc.type   = BFD_RELOC_ARM_THUMB_OFFSET;
4646       inst.reloc.pc_rel = 1;
4647       inst.instruction  = T_OPCODE_LDR_PC | (Rd << 8);
4648       /* Adjust ARM pipeline offset to Thumb.  */
4649       inst.reloc.exp.X_add_number += 4;
4650
4651       return;
4652     }
4653   else
4654     {
4655       if (my_get_expression (&inst.reloc.exp, &str))
4656         return;
4657
4658       inst.instruction = T_OPCODE_LDR_PC | (Rd << 8);
4659       inst.reloc.pc_rel = 1;
4660       inst.reloc.exp.X_add_number -= 4; /* Pipeline offset.  */
4661       inst.reloc.type = BFD_RELOC_ARM_THUMB_OFFSET;
4662       end_of_line (str);
4663       return;
4664     }
4665
4666   if (Rb == REG_PC || Rb == REG_SP)
4667     {
4668       if (size != THUMB_WORD)
4669         {
4670           inst.error = _("byte or halfword not valid for base register");
4671           return;
4672         }
4673       else if (Rb == REG_PC && load_store != THUMB_LOAD)
4674         {
4675           inst.error = _("R15 based store not allowed");
4676           return;
4677         }
4678       else if (Ro != FAIL)
4679         {
4680           inst.error = _("Invalid base register for register offset");
4681           return;
4682         }
4683
4684       if (Rb == REG_PC)
4685         inst.instruction = T_OPCODE_LDR_PC;
4686       else if (load_store == THUMB_LOAD)
4687         inst.instruction = T_OPCODE_LDR_SP;
4688       else
4689         inst.instruction = T_OPCODE_STR_SP;
4690
4691       inst.instruction |= Rd << 8;
4692       if (inst.reloc.exp.X_op == O_constant)
4693         {
4694           unsigned offset = inst.reloc.exp.X_add_number;
4695
4696           if (offset & ~0x3fc)
4697             {
4698               inst.error = _("invalid offset");
4699               return;
4700             }
4701
4702           inst.instruction |= offset >> 2;
4703         }
4704       else
4705         inst.reloc.type = BFD_RELOC_ARM_THUMB_OFFSET;
4706     }
4707   else if (Rb > 7)
4708     {
4709       inst.error = _("invalid base register in load/store");
4710       return;
4711     }
4712   else if (Ro == FAIL)
4713     {
4714       /* Immediate offset.  */
4715       if (size == THUMB_WORD)
4716         inst.instruction = (load_store == THUMB_LOAD
4717                             ? T_OPCODE_LDR_IW : T_OPCODE_STR_IW);
4718       else if (size == THUMB_HALFWORD)
4719         inst.instruction = (load_store == THUMB_LOAD
4720                             ? T_OPCODE_LDR_IH : T_OPCODE_STR_IH);
4721       else
4722         inst.instruction = (load_store == THUMB_LOAD
4723                             ? T_OPCODE_LDR_IB : T_OPCODE_STR_IB);
4724
4725       inst.instruction |= Rd | (Rb << 3);
4726
4727       if (inst.reloc.exp.X_op == O_constant)
4728         {
4729           unsigned offset = inst.reloc.exp.X_add_number;
4730
4731           if (offset & ~(0x1f << size))
4732             {
4733               inst.error = _("Invalid offset");
4734               return;
4735             }
4736           inst.instruction |= (offset >> size) << 6;
4737         }
4738       else
4739         inst.reloc.type = BFD_RELOC_ARM_THUMB_OFFSET;
4740     }
4741   else
4742     {
4743       /* Register offset.  */
4744       if (size == THUMB_WORD)
4745         inst.instruction = (load_store == THUMB_LOAD
4746                             ? T_OPCODE_LDR_RW : T_OPCODE_STR_RW);
4747       else if (size == THUMB_HALFWORD)
4748         inst.instruction = (load_store == THUMB_LOAD
4749                             ? T_OPCODE_LDR_RH : T_OPCODE_STR_RH);
4750       else
4751         inst.instruction = (load_store == THUMB_LOAD
4752                             ? T_OPCODE_LDR_RB : T_OPCODE_STR_RB);
4753
4754       inst.instruction |= Rd | (Rb << 3) | (Ro << 6);
4755     }
4756
4757   end_of_line (str);
4758 }
4759
4760 static void
4761 do_t_nop (str)
4762      char * str;
4763 {
4764   /* Do nothing.  */
4765   end_of_line (str);
4766   return;
4767 }
4768
4769 /* Handle the Format 4 instructions that do not have equivalents in other
4770    formats.  That is, ADC, AND, EOR, SBC, ROR, TST, NEG, CMN, ORR, MUL,
4771    BIC and MVN.  */
4772
4773 static void
4774 do_t_arit (str)
4775      char * str;
4776 {
4777   int Rd, Rs, Rn;
4778
4779   skip_whitespace (str);
4780
4781   if ((Rd = thumb_reg (&str, THUMB_REG_LO)) == FAIL
4782       || skip_past_comma (&str) == FAIL
4783       || (Rs = thumb_reg (&str, THUMB_REG_LO)) == FAIL)
4784     {
4785       inst.error = BAD_ARGS;
4786       return;
4787     }
4788
4789   if (skip_past_comma (&str) != FAIL)
4790     {
4791       /* Three operand format not allowed for TST, CMN, NEG and MVN.
4792          (It isn't allowed for CMP either, but that isn't handled by this
4793          function.)  */
4794       if (inst.instruction == T_OPCODE_TST
4795           || inst.instruction == T_OPCODE_CMN
4796           || inst.instruction == T_OPCODE_NEG
4797           || inst.instruction == T_OPCODE_MVN)
4798         {
4799           inst.error = BAD_ARGS;
4800           return;
4801         }
4802
4803       if ((Rn = thumb_reg (&str, THUMB_REG_LO)) == FAIL)
4804         return;
4805
4806       if (Rs != Rd)
4807         {
4808           inst.error = _("dest and source1 one must be the same register");
4809           return;
4810         }
4811       Rs = Rn;
4812     }
4813
4814   if (inst.instruction == T_OPCODE_MUL
4815       && Rs == Rd)
4816     as_tsktsk (_("Rs and Rd must be different in MUL"));
4817
4818   inst.instruction |= Rd | (Rs << 3);
4819   end_of_line (str);
4820 }
4821
4822 static void
4823 do_t_add (str)
4824      char * str;
4825 {
4826   thumb_add_sub (str, 0);
4827 }
4828
4829 static void
4830 do_t_asr (str)
4831      char * str;
4832 {
4833   thumb_shift (str, THUMB_ASR);
4834 }
4835
4836 static void
4837 do_t_branch9 (str)
4838      char * str;
4839 {
4840   if (my_get_expression (&inst.reloc.exp, &str))
4841     return;
4842   inst.reloc.type = BFD_RELOC_THUMB_PCREL_BRANCH9;
4843   inst.reloc.pc_rel = 1;
4844   end_of_line (str);
4845 }
4846
4847 static void
4848 do_t_branch12 (str)
4849      char * str;
4850 {
4851   if (my_get_expression (&inst.reloc.exp, &str))
4852     return;
4853   inst.reloc.type = BFD_RELOC_THUMB_PCREL_BRANCH12;
4854   inst.reloc.pc_rel = 1;
4855   end_of_line (str);
4856 }
4857
4858 /* Find the real, Thumb encoded start of a Thumb function.  */
4859
4860 static symbolS *
4861 find_real_start (symbolP)
4862      symbolS * symbolP;
4863 {
4864   char *       real_start;
4865   const char * name = S_GET_NAME (symbolP);
4866   symbolS *    new_target;
4867
4868   /* This definiton must agree with the one in gcc/config/arm/thumb.c.  */
4869 #define STUB_NAME ".real_start_of"
4870
4871   if (name == NULL)
4872     abort ();
4873
4874   /* Names that start with '.' are local labels, not function entry points.
4875      The compiler may generate BL instructions to these labels because it
4876      needs to perform a branch to a far away location.  */
4877   if (name[0] == '.')
4878     return symbolP;
4879
4880   real_start = malloc (strlen (name) + strlen (STUB_NAME) + 1);
4881   sprintf (real_start, "%s%s", STUB_NAME, name);
4882
4883   new_target = symbol_find (real_start);
4884
4885   if (new_target == NULL)
4886     {
4887       as_warn ("Failed to find real start of function: %s\n", name);
4888       new_target = symbolP;
4889     }
4890
4891   free (real_start);
4892
4893   return new_target;
4894 }
4895
4896 static void
4897 do_t_branch23 (str)
4898      char * str;
4899 {
4900   if (my_get_expression (& inst.reloc.exp, & str))
4901     return;
4902
4903   inst.reloc.type   = BFD_RELOC_THUMB_PCREL_BRANCH23;
4904   inst.reloc.pc_rel = 1;
4905   end_of_line (str);
4906
4907   /* If the destination of the branch is a defined symbol which does not have
4908      the THUMB_FUNC attribute, then we must be calling a function which has
4909      the (interfacearm) attribute.  We look for the Thumb entry point to that
4910      function and change the branch to refer to that function instead.  */
4911   if (   inst.reloc.exp.X_op == O_symbol
4912       && inst.reloc.exp.X_add_symbol != NULL
4913       && S_IS_DEFINED (inst.reloc.exp.X_add_symbol)
4914       && ! THUMB_IS_FUNC (inst.reloc.exp.X_add_symbol))
4915     inst.reloc.exp.X_add_symbol =
4916       find_real_start (inst.reloc.exp.X_add_symbol);
4917 }
4918
4919 static void
4920 do_t_bx (str)
4921      char * str;
4922 {
4923   int reg;
4924
4925   skip_whitespace (str);
4926
4927   if ((reg = thumb_reg (&str, THUMB_REG_ANY)) == FAIL)
4928     return;
4929
4930   /* This sets THUMB_H2 from the top bit of reg.  */
4931   inst.instruction |= reg << 3;
4932
4933   /* ??? FIXME: Should add a hacky reloc here if reg is REG_PC.  The reloc
4934      should cause the alignment to be checked once it is known.  This is
4935      because BX PC only works if the instruction is word aligned.  */
4936
4937   end_of_line (str);
4938 }
4939
4940 static void
4941 do_t_compare (str)
4942      char * str;
4943 {
4944   thumb_mov_compare (str, THUMB_COMPARE);
4945 }
4946
4947 static void
4948 do_t_ldmstm (str)
4949      char * str;
4950 {
4951   int Rb;
4952   long range;
4953
4954   skip_whitespace (str);
4955
4956   if ((Rb = thumb_reg (&str, THUMB_REG_LO)) == FAIL)
4957     return;
4958
4959   if (*str != '!')
4960     as_warn (_("Inserted missing '!': load/store multiple always writes back base register"));
4961   else
4962     str++;
4963
4964   if (skip_past_comma (&str) == FAIL
4965       || (range = reg_list (&str)) == FAIL)
4966     {
4967       if (! inst.error)
4968         inst.error = BAD_ARGS;
4969       return;
4970     }
4971
4972   if (inst.reloc.type != BFD_RELOC_NONE)
4973     {
4974       /* This really doesn't seem worth it.  */
4975       inst.reloc.type = BFD_RELOC_NONE;
4976       inst.error = _("Expression too complex");
4977       return;
4978     }
4979
4980   if (range & ~0xff)
4981     {
4982       inst.error = _("only lo-regs valid in load/store multiple");
4983       return;
4984     }
4985
4986   inst.instruction |= (Rb << 8) | range;
4987   end_of_line (str);
4988 }
4989
4990 static void
4991 do_t_ldr (str)
4992      char * str;
4993 {
4994   thumb_load_store (str, THUMB_LOAD, THUMB_WORD);
4995 }
4996
4997 static void
4998 do_t_ldrb (str)
4999      char * str;
5000 {
5001   thumb_load_store (str, THUMB_LOAD, THUMB_BYTE);
5002 }
5003
5004 static void
5005 do_t_ldrh (str)
5006      char * str;
5007 {
5008   thumb_load_store (str, THUMB_LOAD, THUMB_HALFWORD);
5009 }
5010
5011 static void
5012 do_t_lds (str)
5013      char * str;
5014 {
5015   int Rd, Rb, Ro;
5016
5017   skip_whitespace (str);
5018
5019   if ((Rd = thumb_reg (&str, THUMB_REG_LO)) == FAIL
5020       || skip_past_comma (&str) == FAIL
5021       || *str++ != '['
5022       || (Rb = thumb_reg (&str, THUMB_REG_LO)) == FAIL
5023       || skip_past_comma (&str) == FAIL
5024       || (Ro = thumb_reg (&str, THUMB_REG_LO)) == FAIL
5025       || *str++ != ']')
5026     {
5027       if (! inst.error)
5028         inst.error = _("Syntax: ldrs[b] Rd, [Rb, Ro]");
5029       return;
5030     }
5031
5032   inst.instruction |= Rd | (Rb << 3) | (Ro << 6);
5033   end_of_line (str);
5034 }
5035
5036 static void
5037 do_t_lsl (str)
5038      char * str;
5039 {
5040   thumb_shift (str, THUMB_LSL);
5041 }
5042
5043 static void
5044 do_t_lsr (str)
5045      char * str;
5046 {
5047   thumb_shift (str, THUMB_LSR);
5048 }
5049
5050 static void
5051 do_t_mov (str)
5052      char * str;
5053 {
5054   thumb_mov_compare (str, THUMB_MOVE);
5055 }
5056
5057 static void
5058 do_t_push_pop (str)
5059      char * str;
5060 {
5061   long range;
5062
5063   skip_whitespace (str);
5064
5065   if ((range = reg_list (&str)) == FAIL)
5066     {
5067       if (! inst.error)
5068         inst.error = BAD_ARGS;
5069       return;
5070     }
5071
5072   if (inst.reloc.type != BFD_RELOC_NONE)
5073     {
5074       /* This really doesn't seem worth it.  */
5075       inst.reloc.type = BFD_RELOC_NONE;
5076       inst.error = _("Expression too complex");
5077       return;
5078     }
5079
5080   if (range & ~0xff)
5081     {
5082       if ((inst.instruction == T_OPCODE_PUSH
5083            && (range & ~0xff) == 1 << REG_LR)
5084           || (inst.instruction == T_OPCODE_POP
5085               && (range & ~0xff) == 1 << REG_PC))
5086         {
5087           inst.instruction |= THUMB_PP_PC_LR;
5088           range &= 0xff;
5089         }
5090       else
5091         {
5092           inst.error = _("invalid register list to push/pop instruction");
5093           return;
5094         }
5095     }
5096
5097   inst.instruction |= range;
5098   end_of_line (str);
5099 }
5100
5101 static void
5102 do_t_str (str)
5103      char * str;
5104 {
5105   thumb_load_store (str, THUMB_STORE, THUMB_WORD);
5106 }
5107
5108 static void
5109 do_t_strb (str)
5110      char * str;
5111 {
5112   thumb_load_store (str, THUMB_STORE, THUMB_BYTE);
5113 }
5114
5115 static void
5116 do_t_strh (str)
5117      char * str;
5118 {
5119   thumb_load_store (str, THUMB_STORE, THUMB_HALFWORD);
5120 }
5121
5122 static void
5123 do_t_sub (str)
5124      char * str;
5125 {
5126   thumb_add_sub (str, 1);
5127 }
5128
5129 static void
5130 do_t_swi (str)
5131      char * str;
5132 {
5133   skip_whitespace (str);
5134
5135   if (my_get_expression (&inst.reloc.exp, &str))
5136     return;
5137
5138   inst.reloc.type = BFD_RELOC_ARM_SWI;
5139   end_of_line (str);
5140   return;
5141 }
5142
5143 static void
5144 do_t_adr (str)
5145      char * str;
5146 {
5147   int reg;
5148
5149   /* This is a pseudo-op of the form "adr rd, label" to be converted
5150      into a relative address of the form "add rd, pc, #label-.-4".  */
5151   skip_whitespace (str);
5152
5153   /* Store Rd in temporary location inside instruction.  */
5154   if ((reg = reg_required_here (&str, 4)) == FAIL
5155       || (reg > 7)  /* For Thumb reg must be r0..r7.  */
5156       || skip_past_comma (&str) == FAIL
5157       || my_get_expression (&inst.reloc.exp, &str))
5158     {
5159       if (!inst.error)
5160         inst.error = BAD_ARGS;
5161       return;
5162     }
5163
5164   inst.reloc.type = BFD_RELOC_ARM_THUMB_ADD;
5165   inst.reloc.exp.X_add_number -= 4; /* PC relative adjust.  */
5166   inst.reloc.pc_rel = 1;
5167   inst.instruction |= REG_PC; /* Rd is already placed into the instruction.  */
5168
5169   end_of_line (str);
5170 }
5171
5172 static void
5173 insert_reg (entry)
5174      int entry;
5175 {
5176   int    len  = strlen (reg_table[entry].name) + 2;
5177   char * buf  = (char *) xmalloc (len);
5178   char * buf2 = (char *) xmalloc (len);
5179   int    i    = 0;
5180
5181 #ifdef REGISTER_PREFIX
5182   buf[i++] = REGISTER_PREFIX;
5183 #endif
5184
5185   strcpy (buf + i, reg_table[entry].name);
5186
5187   for (i = 0; buf[i]; i++)
5188     buf2[i] = islower (buf[i]) ? toupper (buf[i]) : buf[i];
5189
5190   buf2[i] = '\0';
5191
5192   hash_insert (arm_reg_hsh, buf,  (PTR) & reg_table[entry]);
5193   hash_insert (arm_reg_hsh, buf2, (PTR) & reg_table[entry]);
5194 }
5195
5196 static void
5197 insert_reg_alias (str, regnum)
5198      char *str;
5199      int regnum;
5200 {
5201   struct reg_entry *new =
5202     (struct reg_entry *) xmalloc (sizeof (struct reg_entry));
5203   char *name = xmalloc (strlen (str) + 1);
5204   strcpy (name, str);
5205
5206   new->name = name;
5207   new->number = regnum;
5208
5209   hash_insert (arm_reg_hsh, name, (PTR) new);
5210 }
5211
5212 static void
5213 set_constant_flonums ()
5214 {
5215   int i;
5216
5217   for (i = 0; i < NUM_FLOAT_VALS; i++)
5218     if (atof_ieee ((char *) fp_const[i], 'x', fp_values[i]) == NULL)
5219       abort ();
5220 }
5221
5222 void
5223 md_begin ()
5224 {
5225   unsigned mach;
5226   unsigned int i;
5227
5228   if (   (arm_ops_hsh = hash_new ()) == NULL
5229       || (arm_tops_hsh = hash_new ()) == NULL
5230       || (arm_cond_hsh = hash_new ()) == NULL
5231       || (arm_shift_hsh = hash_new ()) == NULL
5232       || (arm_reg_hsh = hash_new ()) == NULL
5233       || (arm_psr_hsh = hash_new ()) == NULL)
5234     as_fatal (_("Virtual memory exhausted"));
5235
5236   for (i = 0; i < sizeof (insns) / sizeof (struct asm_opcode); i++)
5237     hash_insert (arm_ops_hsh, insns[i].template, (PTR) (insns + i));
5238   for (i = 0; i < sizeof (tinsns) / sizeof (struct thumb_opcode); i++)
5239     hash_insert (arm_tops_hsh, tinsns[i].template, (PTR) (tinsns + i));
5240   for (i = 0; i < sizeof (conds) / sizeof (struct asm_cond); i++)
5241     hash_insert (arm_cond_hsh, conds[i].template, (PTR) (conds + i));
5242   for (i = 0; i < sizeof (shift) / sizeof (struct asm_shift); i++)
5243     hash_insert (arm_shift_hsh, shift[i].template, (PTR) (shift + i));
5244   for (i = 0; i < sizeof (psrs) / sizeof (struct asm_psr); i++)
5245     hash_insert (arm_psr_hsh, psrs[i].template, (PTR) (psrs + i));
5246
5247   for (i = 0; reg_table[i].name; i++)
5248     insert_reg (i);
5249
5250   set_constant_flonums ();
5251
5252 #if defined OBJ_COFF || defined OBJ_ELF
5253   {
5254     unsigned int flags = 0;
5255
5256     /* Set the flags in the private structure.  */
5257     if (uses_apcs_26)      flags |= F_APCS26;
5258     if (support_interwork) flags |= F_INTERWORK;
5259     if (uses_apcs_float)   flags |= F_APCS_FLOAT;
5260     if (pic_code)          flags |= F_PIC;
5261     if ((cpu_variant & FPU_ALL) == FPU_NONE) flags |= F_SOFT_FLOAT;
5262
5263     bfd_set_private_flags (stdoutput, flags);
5264   }
5265 #endif
5266
5267   /* Record the CPU type as well.  */
5268   switch (cpu_variant & ARM_CPU_MASK)
5269     {
5270     case ARM_2:
5271       mach = bfd_mach_arm_2;
5272       break;
5273
5274     case ARM_3:                 /* Also ARM_250.  */
5275       mach = bfd_mach_arm_2a;
5276       break;
5277
5278     default:
5279     case ARM_6 | ARM_3 | ARM_2: /* Actually no CPU type defined.  */
5280       mach = bfd_mach_arm_4;
5281       break;
5282
5283     case ARM_7:                 /* Also ARM_6.  */
5284       mach = bfd_mach_arm_3;
5285       break;
5286     }
5287
5288   /* Catch special cases.  */
5289   if (cpu_variant != (FPU_DEFAULT | CPU_DEFAULT))
5290     {
5291       if (cpu_variant & (ARM_EXT_V5 & ARM_THUMB))
5292         mach = bfd_mach_arm_5T;
5293       else if (cpu_variant & ARM_EXT_V5)
5294         mach = bfd_mach_arm_5;
5295       else if (cpu_variant & ARM_THUMB)
5296         mach = bfd_mach_arm_4T;
5297       else if ((cpu_variant & ARM_ARCH_V4) == ARM_ARCH_V4)
5298         mach = bfd_mach_arm_4;
5299       else if (cpu_variant & ARM_LONGMUL)
5300         mach = bfd_mach_arm_3M;
5301     }
5302
5303   bfd_set_arch_mach (stdoutput, TARGET_ARCH, mach);
5304 }
5305
5306 /* Turn an integer of n bytes (in val) into a stream of bytes appropriate
5307    for use in the a.out file, and stores them in the array pointed to by buf.
5308    This knows about the endian-ness of the target machine and does
5309    THE RIGHT THING, whatever it is.  Possible values for n are 1 (byte)
5310    2 (short) and 4 (long)  Floating numbers are put out as a series of
5311    LITTLENUMS (shorts, here at least).  */
5312
5313 void
5314 md_number_to_chars (buf, val, n)
5315      char * buf;
5316      valueT val;
5317      int    n;
5318 {
5319   if (target_big_endian)
5320     number_to_chars_bigendian (buf, val, n);
5321   else
5322     number_to_chars_littleendian (buf, val, n);
5323 }
5324
5325 static valueT
5326 md_chars_to_number (buf, n)
5327      char * buf;
5328      int    n;
5329 {
5330   valueT result = 0;
5331   unsigned char * where = (unsigned char *) buf;
5332
5333   if (target_big_endian)
5334     {
5335       while (n--)
5336         {
5337           result <<= 8;
5338           result |= (*where++ & 255);
5339         }
5340     }
5341   else
5342     {
5343       while (n--)
5344         {
5345           result <<= 8;
5346           result |= (where[n] & 255);
5347         }
5348     }
5349
5350   return result;
5351 }
5352
5353 /* Turn a string in input_line_pointer into a floating point constant
5354    of type TYPE, and store the appropriate bytes in *LITP.  The number
5355    of LITTLENUMS emitted is stored in *SIZEP.  An error message is
5356    returned, or NULL on OK.
5357
5358    Note that fp constants aren't represent in the normal way on the ARM.
5359    In big endian mode, things are as expected.  However, in little endian
5360    mode fp constants are big-endian word-wise, and little-endian byte-wise
5361    within the words.  For example, (double) 1.1 in big endian mode is
5362    the byte sequence 3f f1 99 99 99 99 99 9a, and in little endian mode is
5363    the byte sequence 99 99 f1 3f 9a 99 99 99.
5364
5365    ??? The format of 12 byte floats is uncertain according to gcc's arm.h.  */
5366
5367 char *
5368 md_atof (type, litP, sizeP)
5369      char   type;
5370      char * litP;
5371      int *  sizeP;
5372 {
5373   int prec;
5374   LITTLENUM_TYPE words[MAX_LITTLENUMS];
5375   char *t;
5376   int i;
5377
5378   switch (type)
5379     {
5380     case 'f':
5381     case 'F':
5382     case 's':
5383     case 'S':
5384       prec = 2;
5385       break;
5386
5387     case 'd':
5388     case 'D':
5389     case 'r':
5390     case 'R':
5391       prec = 4;
5392       break;
5393
5394     case 'x':
5395     case 'X':
5396       prec = 6;
5397       break;
5398
5399     case 'p':
5400     case 'P':
5401       prec = 6;
5402       break;
5403
5404     default:
5405       *sizeP = 0;
5406       return _("Bad call to MD_ATOF()");
5407     }
5408
5409   t = atof_ieee (input_line_pointer, type, words);
5410   if (t)
5411     input_line_pointer = t;
5412   *sizeP = prec * 2;
5413
5414   if (target_big_endian)
5415     {
5416       for (i = 0; i < prec; i++)
5417         {
5418           md_number_to_chars (litP, (valueT) words[i], 2);
5419           litP += 2;
5420         }
5421     }
5422   else
5423     {
5424       /* For a 4 byte float the order of elements in `words' is 1 0.  For an
5425          8 byte float the order is 1 0 3 2.  */
5426       for (i = 0; i < prec; i += 2)
5427         {
5428           md_number_to_chars (litP, (valueT) words[i + 1], 2);
5429           md_number_to_chars (litP + 2, (valueT) words[i], 2);
5430           litP += 4;
5431         }
5432     }
5433
5434   return 0;
5435 }
5436
5437 /* The knowledge of the PC's pipeline offset is built into the insns
5438    themselves.  */
5439
5440 long
5441 md_pcrel_from (fixP)
5442      fixS * fixP;
5443 {
5444   if (fixP->fx_addsy
5445       && S_GET_SEGMENT (fixP->fx_addsy) == undefined_section
5446       && fixP->fx_subsy == NULL)
5447     return 0;
5448
5449   if (fixP->fx_pcrel && (fixP->fx_r_type == BFD_RELOC_ARM_THUMB_ADD))
5450     {
5451       /* PC relative addressing on the Thumb is slightly odd
5452          as the bottom two bits of the PC are forced to zero
5453          for the calculation.  */
5454       return (fixP->fx_where + fixP->fx_frag->fr_address) & ~3;
5455     }
5456
5457 #ifdef TE_WINCE
5458   /* The pattern was adjusted to accomodate CE's off-by-one fixups,
5459      so we un-adjust here to compensate for the accomodation.  */
5460   return fixP->fx_where + fixP->fx_frag->fr_address + 8;
5461 #else
5462   return fixP->fx_where + fixP->fx_frag->fr_address;
5463 #endif
5464 }
5465
5466 /* Round up a section size to the appropriate boundary.  */
5467
5468 valueT
5469 md_section_align (segment, size)
5470      segT   segment ATTRIBUTE_UNUSED;
5471      valueT size;
5472 {
5473 #ifdef OBJ_ELF
5474   return size;
5475 #else
5476   /* Round all sects to multiple of 4.  */
5477   return (size + 3) & ~3;
5478 #endif
5479 }
5480
5481 /* Under ELF we need to default _GLOBAL_OFFSET_TABLE.
5482    Otherwise we have no need to default values of symbols.  */
5483
5484 symbolS *
5485 md_undefined_symbol (name)
5486      char * name ATTRIBUTE_UNUSED;
5487 {
5488 #ifdef OBJ_ELF
5489   if (name[0] == '_' && name[1] == 'G'
5490       && streq (name, GLOBAL_OFFSET_TABLE_NAME))
5491     {
5492       if (!GOT_symbol)
5493         {
5494           if (symbol_find (name))
5495             as_bad ("GOT already in the symbol table");
5496
5497           GOT_symbol = symbol_new (name, undefined_section,
5498                                    (valueT) 0, & zero_address_frag);
5499         }
5500
5501       return GOT_symbol;
5502     }
5503 #endif
5504
5505   return 0;
5506 }
5507
5508 /* arm_reg_parse () := if it looks like a register, return its token and
5509    advance the pointer.  */
5510
5511 static int
5512 arm_reg_parse (ccp)
5513      register char ** ccp;
5514 {
5515   char * start = * ccp;
5516   char   c;
5517   char * p;
5518   struct reg_entry * reg;
5519
5520 #ifdef REGISTER_PREFIX
5521   if (*start != REGISTER_PREFIX)
5522     return FAIL;
5523   p = start + 1;
5524 #else
5525   p = start;
5526 #ifdef OPTIONAL_REGISTER_PREFIX
5527   if (*p == OPTIONAL_REGISTER_PREFIX)
5528     p++, start++;
5529 #endif
5530 #endif
5531   if (!isalpha (*p) || !is_name_beginner (*p))
5532     return FAIL;
5533
5534   c = *p++;
5535   while (isalpha (c) || isdigit (c) || c == '_')
5536     c = *p++;
5537
5538   *--p = 0;
5539   reg = (struct reg_entry *) hash_find (arm_reg_hsh, start);
5540   *p = c;
5541
5542   if (reg)
5543     {
5544       *ccp = p;
5545       return reg->number;
5546     }
5547
5548   return FAIL;
5549 }
5550
5551 int
5552 md_apply_fix3 (fixP, val, seg)
5553      fixS *   fixP;
5554      valueT * val;
5555      segT     seg;
5556 {
5557   offsetT        value = * val;
5558   offsetT        newval;
5559   unsigned int   newimm;
5560   unsigned long  temp;
5561   int            sign;
5562   char *         buf = fixP->fx_where + fixP->fx_frag->fr_literal;
5563   arm_fix_data * arm_data = (arm_fix_data *) fixP->tc_fix_data;
5564
5565   assert (fixP->fx_r_type < BFD_RELOC_UNUSED);
5566
5567   /* Note whether this will delete the relocation.  */
5568 #if 0
5569   /* Patch from REarnshaw to JDavis (disabled for the moment, since it
5570      doesn't work fully.)  */
5571   if ((fixP->fx_addsy == 0 || symbol_constant_p (fixP->fx_addsy))
5572       && !fixP->fx_pcrel)
5573 #else
5574   if (fixP->fx_addsy == 0 && !fixP->fx_pcrel)
5575 #endif
5576     fixP->fx_done = 1;
5577
5578   /* If this symbol is in a different section then we need to leave it for
5579      the linker to deal with.  Unfortunately, md_pcrel_from can't tell,
5580      so we have to undo it's effects here.  */
5581   if (fixP->fx_pcrel)
5582     {
5583       if (fixP->fx_addsy != NULL
5584           && S_IS_DEFINED (fixP->fx_addsy)
5585           && S_GET_SEGMENT (fixP->fx_addsy) != seg)
5586         {
5587           if (target_oabi
5588               && (fixP->fx_r_type == BFD_RELOC_ARM_PCREL_BRANCH
5589                   || fixP->fx_r_type == BFD_RELOC_ARM_PCREL_BLX
5590                   ))
5591             value = 0;
5592           else
5593             value += md_pcrel_from (fixP);
5594         }
5595     }
5596
5597   /* Remember value for emit_reloc.  */
5598   fixP->fx_addnumber = value;
5599
5600   switch (fixP->fx_r_type)
5601     {
5602     case BFD_RELOC_ARM_IMMEDIATE:
5603       newimm = validate_immediate (value);
5604       temp = md_chars_to_number (buf, INSN_SIZE);
5605
5606       /* If the instruction will fail, see if we can fix things up by
5607          changing the opcode.  */
5608       if (newimm == (unsigned int) FAIL
5609           && (newimm = negate_data_op (&temp, value)) == (unsigned int) FAIL)
5610         {
5611           as_bad_where (fixP->fx_file, fixP->fx_line,
5612                         _("invalid constant (%lx) after fixup"),
5613                         (unsigned long) value);
5614           break;
5615         }
5616
5617       newimm |= (temp & 0xfffff000);
5618       md_number_to_chars (buf, (valueT) newimm, INSN_SIZE);
5619       break;
5620
5621     case BFD_RELOC_ARM_ADRL_IMMEDIATE:
5622       {
5623         unsigned int highpart = 0;
5624         unsigned int newinsn  = 0xe1a00000; /* nop.  */
5625         newimm = validate_immediate (value);
5626         temp = md_chars_to_number (buf, INSN_SIZE);
5627
5628         /* If the instruction will fail, see if we can fix things up by
5629            changing the opcode.  */
5630         if (newimm == (unsigned int) FAIL
5631             && (newimm = negate_data_op (& temp, value)) == (unsigned int) FAIL)
5632           {
5633             /* No ?  OK - try using two ADD instructions to generate
5634                the value.  */
5635             newimm = validate_immediate_twopart (value, & highpart);
5636
5637             /* Yes - then make sure that the second instruction is
5638                also an add.  */
5639             if (newimm != (unsigned int) FAIL)
5640               newinsn = temp;
5641             /* Still No ?  Try using a negated value.  */
5642             else if (validate_immediate_twopart (- value, & highpart) != (unsigned int) FAIL)
5643               temp = newinsn = (temp & OPCODE_MASK) | OPCODE_SUB << DATA_OP_SHIFT;
5644             /* Otherwise - give up.  */
5645             else
5646               {
5647                 as_bad_where (fixP->fx_file, fixP->fx_line,
5648                               _("Unable to compute ADRL instructions for PC offset of 0x%x"),
5649                               value);
5650                 break;
5651               }
5652
5653             /* Replace the first operand in the 2nd instruction (which
5654                is the PC) with the destination register.  We have
5655                already added in the PC in the first instruction and we
5656                do not want to do it again.  */
5657             newinsn &= ~0xf0000;
5658             newinsn |= ((newinsn & 0x0f000) << 4);
5659           }
5660
5661         newimm |= (temp & 0xfffff000);
5662         md_number_to_chars (buf, (valueT) newimm, INSN_SIZE);
5663
5664         highpart |= (newinsn & 0xfffff000);
5665         md_number_to_chars (buf + INSN_SIZE, (valueT) highpart, INSN_SIZE);
5666       }
5667       break;
5668
5669     case BFD_RELOC_ARM_OFFSET_IMM:
5670       sign = value >= 0;
5671
5672       if (value < 0)
5673         value = -value;
5674
5675       if (validate_offset_imm (value, 0) == FAIL)
5676         {
5677           as_bad_where (fixP->fx_file, fixP->fx_line,
5678                         _("bad immediate value for offset (%ld)"),
5679                         (long) value);
5680           break;
5681         }
5682
5683       newval = md_chars_to_number (buf, INSN_SIZE);
5684       newval &= 0xff7ff000;
5685       newval |= value | (sign ? INDEX_UP : 0);
5686       md_number_to_chars (buf, newval, INSN_SIZE);
5687       break;
5688
5689     case BFD_RELOC_ARM_OFFSET_IMM8:
5690     case BFD_RELOC_ARM_HWLITERAL:
5691       sign = value >= 0;
5692
5693       if (value < 0)
5694         value = -value;
5695
5696       if (validate_offset_imm (value, 1) == FAIL)
5697         {
5698           if (fixP->fx_r_type == BFD_RELOC_ARM_HWLITERAL)
5699             as_bad_where (fixP->fx_file, fixP->fx_line,
5700                           _("invalid literal constant: pool needs to be closer"));
5701           else
5702             as_bad (_("bad immediate value for half-word offset (%ld)"),
5703                     (long) value);
5704           break;
5705         }
5706
5707       newval = md_chars_to_number (buf, INSN_SIZE);
5708       newval &= 0xff7ff0f0;
5709       newval |= ((value >> 4) << 8) | (value & 0xf) | (sign ? INDEX_UP : 0);
5710       md_number_to_chars (buf, newval, INSN_SIZE);
5711       break;
5712
5713     case BFD_RELOC_ARM_LITERAL:
5714       sign = value >= 0;
5715
5716       if (value < 0)
5717         value = -value;
5718
5719       if (validate_offset_imm (value, 0) == FAIL)
5720         {
5721           as_bad_where (fixP->fx_file, fixP->fx_line,
5722                         _("invalid literal constant: pool needs to be closer"));
5723           break;
5724         }
5725
5726       newval = md_chars_to_number (buf, INSN_SIZE);
5727       newval &= 0xff7ff000;
5728       newval |= value | (sign ? INDEX_UP : 0);
5729       md_number_to_chars (buf, newval, INSN_SIZE);
5730       break;
5731
5732     case BFD_RELOC_ARM_SHIFT_IMM:
5733       newval = md_chars_to_number (buf, INSN_SIZE);
5734       if (((unsigned long) value) > 32
5735           || (value == 32
5736               && (((newval & 0x60) == 0) || (newval & 0x60) == 0x60)))
5737         {
5738           as_bad_where (fixP->fx_file, fixP->fx_line,
5739                         _("shift expression is too large"));
5740           break;
5741         }
5742
5743       if (value == 0)
5744         /* Shifts of zero must be done as lsl.  */
5745         newval &= ~0x60;
5746       else if (value == 32)
5747         value = 0;
5748       newval &= 0xfffff07f;
5749       newval |= (value & 0x1f) << 7;
5750       md_number_to_chars (buf, newval, INSN_SIZE);
5751       break;
5752
5753     case BFD_RELOC_ARM_SWI:
5754       if (arm_data->thumb_mode)
5755         {
5756           if (((unsigned long) value) > 0xff)
5757             as_bad_where (fixP->fx_file, fixP->fx_line,
5758                           _("Invalid swi expression"));
5759           newval = md_chars_to_number (buf, THUMB_SIZE) & 0xff00;
5760           newval |= value;
5761           md_number_to_chars (buf, newval, THUMB_SIZE);
5762         }
5763       else
5764         {
5765           if (((unsigned long) value) > 0x00ffffff)
5766             as_bad_where (fixP->fx_file, fixP->fx_line,
5767                           _("Invalid swi expression"));
5768           newval = md_chars_to_number (buf, INSN_SIZE) & 0xff000000;
5769           newval |= value;
5770           md_number_to_chars (buf, newval, INSN_SIZE);
5771         }
5772       break;
5773
5774     case BFD_RELOC_ARM_MULTI:
5775       if (((unsigned long) value) > 0xffff)
5776         as_bad_where (fixP->fx_file, fixP->fx_line,
5777                       _("Invalid expression in load/store multiple"));
5778       newval = value | md_chars_to_number (buf, INSN_SIZE);
5779       md_number_to_chars (buf, newval, INSN_SIZE);
5780       break;
5781
5782     case BFD_RELOC_ARM_PCREL_BRANCH:
5783       newval = md_chars_to_number (buf, INSN_SIZE);
5784
5785       /* Sign-extend a 24-bit number.  */
5786 #define SEXT24(x)       ((((x) & 0xffffff) ^ (~ 0x7fffff)) + 0x800000)
5787
5788 #ifdef OBJ_ELF
5789       if (! target_oabi)
5790         value = fixP->fx_offset;
5791 #endif
5792
5793       /* We are going to store value (shifted right by two) in the
5794          instruction, in a 24 bit, signed field.  Thus we need to check
5795          that none of the top 8 bits of the shifted value (top 7 bits of
5796          the unshifted, unsigned value) are set, or that they are all set.  */
5797       if ((value & ~ ((offsetT) 0x1ffffff)) != 0
5798           && ((value & ~ ((offsetT) 0x1ffffff)) != ~ ((offsetT) 0x1ffffff)))
5799         {
5800 #ifdef OBJ_ELF
5801           /* Normally we would be stuck at this point, since we cannot store
5802              the absolute address that is the destination of the branch in the
5803              24 bits of the branch instruction.  If however, we happen to know
5804              that the destination of the branch is in the same section as the
5805              branch instruciton itself, then we can compute the relocation for
5806              ourselves and not have to bother the linker with it.
5807
5808              FIXME: The tests for OBJ_ELF and ! target_oabi are only here
5809              because I have not worked out how to do this for OBJ_COFF or
5810              target_oabi.  */
5811           if (! target_oabi
5812               && fixP->fx_addsy != NULL
5813               && S_IS_DEFINED (fixP->fx_addsy)
5814               && S_GET_SEGMENT (fixP->fx_addsy) == seg)
5815             {
5816               /* Get pc relative value to go into the branch.  */
5817               value = * val;
5818
5819               /* Permit a backward branch provided that enough bits
5820                  are set.  Allow a forwards branch, provided that
5821                  enough bits are clear.  */
5822               if (   (value & ~ ((offsetT) 0x1ffffff)) == ~ ((offsetT) 0x1ffffff)
5823                   || (value & ~ ((offsetT) 0x1ffffff)) == 0)
5824                 fixP->fx_done = 1;
5825             }
5826
5827           if (! fixP->fx_done)
5828 #endif
5829             as_bad_where (fixP->fx_file, fixP->fx_line,
5830                           _("gas can't handle same-section branch dest >= 0x04000000"));
5831         }
5832
5833       value >>= 2;
5834       value += SEXT24 (newval);
5835
5836       if (    (value & ~ ((offsetT) 0xffffff)) != 0
5837           && ((value & ~ ((offsetT) 0xffffff)) != ~ ((offsetT) 0xffffff)))
5838         as_bad_where (fixP->fx_file, fixP->fx_line,
5839                       _("out of range branch"));
5840
5841       newval = (value & 0x00ffffff) | (newval & 0xff000000);
5842       md_number_to_chars (buf, newval, INSN_SIZE);
5843       break;
5844
5845     case BFD_RELOC_ARM_PCREL_BLX:
5846       {
5847         offsetT hbit;
5848         newval = md_chars_to_number (buf, INSN_SIZE);
5849
5850 #ifdef OBJ_ELF
5851         if (! target_oabi)
5852           value = fixP->fx_offset;
5853 #endif
5854         hbit   = (value >> 1) & 1;
5855         value  = (value >> 2) & 0x00ffffff;
5856         value  = (value + (newval & 0x00ffffff)) & 0x00ffffff;
5857         newval = value | (newval & 0xfe000000) | (hbit << 24);
5858         md_number_to_chars (buf, newval, INSN_SIZE);
5859       }
5860       break;
5861
5862     case BFD_RELOC_THUMB_PCREL_BRANCH9: /* Conditional branch.  */
5863       newval = md_chars_to_number (buf, THUMB_SIZE);
5864       {
5865         addressT diff = (newval & 0xff) << 1;
5866         if (diff & 0x100)
5867           diff |= ~0xff;
5868
5869         value += diff;
5870         if ((value & ~0xff) && ((value & ~0xff) != ~0xff))
5871           as_bad_where (fixP->fx_file, fixP->fx_line,
5872                         _("Branch out of range"));
5873         newval = (newval & 0xff00) | ((value & 0x1ff) >> 1);
5874       }
5875       md_number_to_chars (buf, newval, THUMB_SIZE);
5876       break;
5877
5878     case BFD_RELOC_THUMB_PCREL_BRANCH12: /* Unconditional branch.  */
5879       newval = md_chars_to_number (buf, THUMB_SIZE);
5880       {
5881         addressT diff = (newval & 0x7ff) << 1;
5882         if (diff & 0x800)
5883           diff |= ~0x7ff;
5884
5885         value += diff;
5886         if ((value & ~0x7ff) && ((value & ~0x7ff) != ~0x7ff))
5887           as_bad_where (fixP->fx_file, fixP->fx_line,
5888                         _("Branch out of range"));
5889         newval = (newval & 0xf800) | ((value & 0xfff) >> 1);
5890       }
5891       md_number_to_chars (buf, newval, THUMB_SIZE);
5892       break;
5893
5894     case BFD_RELOC_THUMB_PCREL_BLX:
5895     case BFD_RELOC_THUMB_PCREL_BRANCH23:
5896       {
5897         offsetT newval2;
5898         addressT diff;
5899
5900         newval  = md_chars_to_number (buf, THUMB_SIZE);
5901         newval2 = md_chars_to_number (buf + THUMB_SIZE, THUMB_SIZE);
5902         diff = ((newval & 0x7ff) << 12) | ((newval2 & 0x7ff) << 1);
5903         if (diff & 0x400000)
5904           diff |= ~0x3fffff;
5905 #ifdef OBJ_ELF
5906         value = fixP->fx_offset;
5907 #endif
5908         value += diff;
5909         if ((value & ~0x3fffff) && ((value & ~0x3fffff) != ~0x3fffff))
5910           as_bad_where (fixP->fx_file, fixP->fx_line,
5911                         _("Branch with link out of range"));
5912
5913         newval  = (newval  & 0xf800) | ((value & 0x7fffff) >> 12);
5914         newval2 = (newval2 & 0xf800) | ((value & 0xfff) >> 1);
5915         md_number_to_chars (buf, newval, THUMB_SIZE);
5916         md_number_to_chars (buf + THUMB_SIZE, newval2, THUMB_SIZE);
5917       }
5918       break;
5919
5920     case BFD_RELOC_8:
5921       if (fixP->fx_done || fixP->fx_pcrel)
5922         md_number_to_chars (buf, value, 1);
5923 #ifdef OBJ_ELF
5924       else if (!target_oabi)
5925         {
5926           value = fixP->fx_offset;
5927           md_number_to_chars (buf, value, 1);
5928         }
5929 #endif
5930       break;
5931
5932     case BFD_RELOC_16:
5933       if (fixP->fx_done || fixP->fx_pcrel)
5934         md_number_to_chars (buf, value, 2);
5935 #ifdef OBJ_ELF
5936       else if (!target_oabi)
5937         {
5938           value = fixP->fx_offset;
5939           md_number_to_chars (buf, value, 2);
5940         }
5941 #endif
5942       break;
5943
5944 #ifdef OBJ_ELF
5945     case BFD_RELOC_ARM_GOT32:
5946     case BFD_RELOC_ARM_GOTOFF:
5947       md_number_to_chars (buf, 0, 4);
5948       break;
5949 #endif
5950
5951     case BFD_RELOC_RVA:
5952     case BFD_RELOC_32:
5953       if (fixP->fx_done || fixP->fx_pcrel)
5954         md_number_to_chars (buf, value, 4);
5955 #ifdef OBJ_ELF
5956       else if (!target_oabi)
5957         {
5958           value = fixP->fx_offset;
5959           md_number_to_chars (buf, value, 4);
5960         }
5961 #endif
5962       break;
5963
5964 #ifdef OBJ_ELF
5965     case BFD_RELOC_ARM_PLT32:
5966       /* It appears the instruction is fully prepared at this point.  */
5967       break;
5968 #endif
5969
5970     case BFD_RELOC_ARM_GOTPC:
5971       md_number_to_chars (buf, value, 4);
5972       break;
5973
5974     case BFD_RELOC_ARM_CP_OFF_IMM:
5975       sign = value >= 0;
5976       if (value < -1023 || value > 1023 || (value & 3))
5977         as_bad_where (fixP->fx_file, fixP->fx_line,
5978                       _("Illegal value for co-processor offset"));
5979       if (value < 0)
5980         value = -value;
5981       newval = md_chars_to_number (buf, INSN_SIZE) & 0xff7fff00;
5982       newval |= (value >> 2) | (sign ? INDEX_UP : 0);
5983       md_number_to_chars (buf, newval, INSN_SIZE);
5984       break;
5985
5986     case BFD_RELOC_ARM_THUMB_OFFSET:
5987       newval = md_chars_to_number (buf, THUMB_SIZE);
5988       /* Exactly what ranges, and where the offset is inserted depends
5989          on the type of instruction, we can establish this from the
5990          top 4 bits.  */
5991       switch (newval >> 12)
5992         {
5993         case 4: /* PC load.  */
5994           /* Thumb PC loads are somewhat odd, bit 1 of the PC is
5995              forced to zero for these loads, so we will need to round
5996              up the offset if the instruction address is not word
5997              aligned (since the final address produced must be, and
5998              we can only describe word-aligned immediate offsets).  */
5999
6000           if ((fixP->fx_frag->fr_address + fixP->fx_where + value) & 3)
6001             as_bad_where (fixP->fx_file, fixP->fx_line,
6002                           _("Invalid offset, target not word aligned (0x%08X)"),
6003                           (unsigned int) (fixP->fx_frag->fr_address
6004                                           + fixP->fx_where + value));
6005
6006           if ((value + 2) & ~0x3fe)
6007             as_bad_where (fixP->fx_file, fixP->fx_line,
6008                           _("Invalid offset, value too big (0x%08X)"), value);
6009
6010           /* Round up, since pc will be rounded down.  */
6011           newval |= (value + 2) >> 2;
6012           break;
6013
6014         case 9: /* SP load/store.  */
6015           if (value & ~0x3fc)
6016             as_bad_where (fixP->fx_file, fixP->fx_line,
6017                           _("Invalid offset, value too big (0x%08X)"), value);
6018           newval |= value >> 2;
6019           break;
6020
6021         case 6: /* Word load/store.  */
6022           if (value & ~0x7c)
6023             as_bad_where (fixP->fx_file, fixP->fx_line,
6024                           _("Invalid offset, value too big (0x%08X)"), value);
6025           newval |= value << 4; /* 6 - 2.  */
6026           break;
6027
6028         case 7: /* Byte load/store.  */
6029           if (value & ~0x1f)
6030             as_bad_where (fixP->fx_file, fixP->fx_line,
6031                           _("Invalid offset, value too big (0x%08X)"), value);
6032           newval |= value << 6;
6033           break;
6034
6035         case 8: /* Halfword load/store.  */
6036           if (value & ~0x3e)
6037             as_bad_where (fixP->fx_file, fixP->fx_line,
6038                           _("Invalid offset, value too big (0x%08X)"), value);
6039           newval |= value << 5; /* 6 - 1.  */
6040           break;
6041
6042         default:
6043           as_bad_where (fixP->fx_file, fixP->fx_line,
6044                         "Unable to process relocation for thumb opcode: %lx",
6045                         (unsigned long) newval);
6046           break;
6047         }
6048       md_number_to_chars (buf, newval, THUMB_SIZE);
6049       break;
6050
6051     case BFD_RELOC_ARM_THUMB_ADD:
6052       /* This is a complicated relocation, since we use it for all of
6053          the following immediate relocations:
6054
6055             3bit ADD/SUB
6056             8bit ADD/SUB
6057             9bit ADD/SUB SP word-aligned
6058            10bit ADD PC/SP word-aligned
6059
6060          The type of instruction being processed is encoded in the
6061          instruction field:
6062
6063            0x8000  SUB
6064            0x00F0  Rd
6065            0x000F  Rs
6066       */
6067       newval = md_chars_to_number (buf, THUMB_SIZE);
6068       {
6069         int rd = (newval >> 4) & 0xf;
6070         int rs = newval & 0xf;
6071         int subtract = newval & 0x8000;
6072
6073         if (rd == REG_SP)
6074           {
6075             if (value & ~0x1fc)
6076               as_bad_where (fixP->fx_file, fixP->fx_line,
6077                             _("Invalid immediate for stack address calculation"));
6078             newval = subtract ? T_OPCODE_SUB_ST : T_OPCODE_ADD_ST;
6079             newval |= value >> 2;
6080           }
6081         else if (rs == REG_PC || rs == REG_SP)
6082           {
6083             if (subtract ||
6084                 value & ~0x3fc)
6085               as_bad_where (fixP->fx_file, fixP->fx_line,
6086                             _("Invalid immediate for address calculation (value = 0x%08lX)"),
6087                             (unsigned long) value);
6088             newval = (rs == REG_PC ? T_OPCODE_ADD_PC : T_OPCODE_ADD_SP);
6089             newval |= rd << 8;
6090             newval |= value >> 2;
6091           }
6092         else if (rs == rd)
6093           {
6094             if (value & ~0xff)
6095               as_bad_where (fixP->fx_file, fixP->fx_line,
6096                             _("Invalid 8bit immediate"));
6097             newval = subtract ? T_OPCODE_SUB_I8 : T_OPCODE_ADD_I8;
6098             newval |= (rd << 8) | value;
6099           }
6100         else
6101           {
6102             if (value & ~0x7)
6103               as_bad_where (fixP->fx_file, fixP->fx_line,
6104                             _("Invalid 3bit immediate"));
6105             newval = subtract ? T_OPCODE_SUB_I3 : T_OPCODE_ADD_I3;
6106             newval |= rd | (rs << 3) | (value << 6);
6107           }
6108       }
6109       md_number_to_chars (buf, newval, THUMB_SIZE);
6110       break;
6111
6112     case BFD_RELOC_ARM_THUMB_IMM:
6113       newval = md_chars_to_number (buf, THUMB_SIZE);
6114       switch (newval >> 11)
6115         {
6116         case 0x04: /* 8bit immediate MOV.  */
6117         case 0x05: /* 8bit immediate CMP.  */
6118           if (value < 0 || value > 255)
6119             as_bad_where (fixP->fx_file, fixP->fx_line,
6120                           _("Invalid immediate: %ld is too large"),
6121                           (long) value);
6122           newval |= value;
6123           break;
6124
6125         default:
6126           abort ();
6127         }
6128       md_number_to_chars (buf, newval, THUMB_SIZE);
6129       break;
6130
6131     case BFD_RELOC_ARM_THUMB_SHIFT:
6132       /* 5bit shift value (0..31).  */
6133       if (value < 0 || value > 31)
6134         as_bad_where (fixP->fx_file, fixP->fx_line,
6135                       _("Illegal Thumb shift value: %ld"), (long) value);
6136       newval = md_chars_to_number (buf, THUMB_SIZE) & 0xf03f;
6137       newval |= value << 6;
6138       md_number_to_chars (buf, newval, THUMB_SIZE);
6139       break;
6140
6141     case BFD_RELOC_VTABLE_INHERIT:
6142     case BFD_RELOC_VTABLE_ENTRY:
6143       fixP->fx_done = 0;
6144       return 1;
6145
6146     case BFD_RELOC_NONE:
6147     default:
6148       as_bad_where (fixP->fx_file, fixP->fx_line,
6149                     _("Bad relocation fixup type (%d)"), fixP->fx_r_type);
6150     }
6151
6152   return 1;
6153 }
6154
6155 /* Translate internal representation of relocation info to BFD target
6156    format.  */
6157
6158 arelent *
6159 tc_gen_reloc (section, fixp)
6160      asection * section ATTRIBUTE_UNUSED;
6161      fixS * fixp;
6162 {
6163   arelent * reloc;
6164   bfd_reloc_code_real_type code;
6165
6166   reloc = (arelent *) xmalloc (sizeof (arelent));
6167
6168   reloc->sym_ptr_ptr = (asymbol **) xmalloc (sizeof (asymbol *));
6169   *reloc->sym_ptr_ptr = symbol_get_bfdsym (fixp->fx_addsy);
6170   reloc->address = fixp->fx_frag->fr_address + fixp->fx_where;
6171
6172   /* @@ Why fx_addnumber sometimes and fx_offset other times?  */
6173 #ifndef OBJ_ELF
6174   if (fixp->fx_pcrel == 0)
6175     reloc->addend = fixp->fx_offset;
6176   else
6177     reloc->addend = fixp->fx_offset = reloc->address;
6178 #else  /* OBJ_ELF */
6179   reloc->addend = fixp->fx_offset;
6180 #endif
6181
6182   switch (fixp->fx_r_type)
6183     {
6184     case BFD_RELOC_8:
6185       if (fixp->fx_pcrel)
6186         {
6187           code = BFD_RELOC_8_PCREL;
6188           break;
6189         }
6190
6191     case BFD_RELOC_16:
6192       if (fixp->fx_pcrel)
6193         {
6194           code = BFD_RELOC_16_PCREL;
6195           break;
6196         }
6197
6198     case BFD_RELOC_32:
6199       if (fixp->fx_pcrel)
6200         {
6201           code = BFD_RELOC_32_PCREL;
6202           break;
6203         }
6204
6205     case BFD_RELOC_ARM_PCREL_BRANCH:
6206     case BFD_RELOC_ARM_PCREL_BLX:
6207     case BFD_RELOC_RVA:
6208     case BFD_RELOC_THUMB_PCREL_BRANCH9:
6209     case BFD_RELOC_THUMB_PCREL_BRANCH12:
6210     case BFD_RELOC_THUMB_PCREL_BRANCH23:
6211     case BFD_RELOC_THUMB_PCREL_BLX:
6212     case BFD_RELOC_VTABLE_ENTRY:
6213     case BFD_RELOC_VTABLE_INHERIT:
6214       code = fixp->fx_r_type;
6215       break;
6216
6217     case BFD_RELOC_ARM_LITERAL:
6218     case BFD_RELOC_ARM_HWLITERAL:
6219       /* If this is called then the a literal has been referenced across
6220          a section boundary - possibly due to an implicit dump.  */
6221       as_bad_where (fixp->fx_file, fixp->fx_line,
6222                     _("Literal referenced across section boundary (Implicit dump?)"));
6223       return NULL;
6224
6225 #ifdef OBJ_ELF
6226     case BFD_RELOC_ARM_GOT32:
6227     case BFD_RELOC_ARM_GOTOFF:
6228     case BFD_RELOC_ARM_PLT32:
6229       code = fixp->fx_r_type;
6230       break;
6231 #endif
6232
6233     case BFD_RELOC_ARM_IMMEDIATE:
6234       as_bad_where (fixp->fx_file, fixp->fx_line,
6235                     _("Internal_relocation (type %d) not fixed up (IMMEDIATE)"),
6236                     fixp->fx_r_type);
6237       return NULL;
6238
6239     case BFD_RELOC_ARM_ADRL_IMMEDIATE:
6240       as_bad_where (fixp->fx_file, fixp->fx_line,
6241                     _("ADRL used for a symbol not defined in the same file"),
6242                     fixp->fx_r_type);
6243       return NULL;
6244
6245     case BFD_RELOC_ARM_OFFSET_IMM:
6246       as_bad_where (fixp->fx_file, fixp->fx_line,
6247                     _("Internal_relocation (type %d) not fixed up (OFFSET_IMM)"),
6248                     fixp->fx_r_type);
6249       return NULL;
6250
6251     default:
6252       {
6253         char * type;
6254
6255         switch (fixp->fx_r_type)
6256           {
6257           case BFD_RELOC_ARM_IMMEDIATE:    type = "IMMEDIATE";    break;
6258           case BFD_RELOC_ARM_OFFSET_IMM:   type = "OFFSET_IMM";   break;
6259           case BFD_RELOC_ARM_OFFSET_IMM8:  type = "OFFSET_IMM8";  break;
6260           case BFD_RELOC_ARM_SHIFT_IMM:    type = "SHIFT_IMM";    break;
6261           case BFD_RELOC_ARM_SWI:          type = "SWI";          break;
6262           case BFD_RELOC_ARM_MULTI:        type = "MULTI";        break;
6263           case BFD_RELOC_ARM_CP_OFF_IMM:   type = "CP_OFF_IMM";   break;
6264           case BFD_RELOC_ARM_THUMB_ADD:    type = "THUMB_ADD";    break;
6265           case BFD_RELOC_ARM_THUMB_SHIFT:  type = "THUMB_SHIFT";  break;
6266           case BFD_RELOC_ARM_THUMB_IMM:    type = "THUMB_IMM";    break;
6267           case BFD_RELOC_ARM_THUMB_OFFSET: type = "THUMB_OFFSET"; break;
6268           default:                         type = _("<unknown>"); break;
6269           }
6270         as_bad_where (fixp->fx_file, fixp->fx_line,
6271                       _("Can not represent %s relocation in this object file format (%d)"),
6272                       type, fixp->fx_pcrel);
6273         return NULL;
6274       }
6275     }
6276
6277 #ifdef OBJ_ELF
6278   if (code == BFD_RELOC_32_PCREL
6279       && GOT_symbol
6280       && fixp->fx_addsy == GOT_symbol)
6281     {
6282       code = BFD_RELOC_ARM_GOTPC;
6283       reloc->addend = fixp->fx_offset = reloc->address;
6284     }
6285 #endif
6286
6287   reloc->howto = bfd_reloc_type_lookup (stdoutput, code);
6288
6289   if (reloc->howto == NULL)
6290     {
6291       as_bad_where (fixp->fx_file, fixp->fx_line,
6292                     _("Can not represent %s relocation in this object file format"),
6293                     bfd_get_reloc_code_name (code));
6294       return NULL;
6295     }
6296
6297   /* HACK: Since arm ELF uses Rel instead of Rela, encode the
6298      vtable entry to be used in the relocation's section offset.  */
6299   if (fixp->fx_r_type == BFD_RELOC_VTABLE_ENTRY)
6300     reloc->address = fixp->fx_offset;
6301
6302   return reloc;
6303 }
6304
6305 int
6306 md_estimate_size_before_relax (fragP, segtype)
6307      fragS * fragP ATTRIBUTE_UNUSED;
6308      segT    segtype ATTRIBUTE_UNUSED;
6309 {
6310   as_fatal (_("md_estimate_size_before_relax\n"));
6311   return 1;
6312 }
6313
6314 static void
6315 output_inst PARAMS ((void))
6316 {
6317   char * to = NULL;
6318
6319   if (inst.error)
6320     {
6321       as_bad (inst.error);
6322       return;
6323     }
6324
6325   to = frag_more (inst.size);
6326
6327   if (thumb_mode && (inst.size > THUMB_SIZE))
6328     {
6329       assert (inst.size == (2 * THUMB_SIZE));
6330       md_number_to_chars (to, inst.instruction >> 16, THUMB_SIZE);
6331       md_number_to_chars (to + THUMB_SIZE, inst.instruction, THUMB_SIZE);
6332     }
6333   else if (inst.size > INSN_SIZE)
6334     {
6335       assert (inst.size == (2 * INSN_SIZE));
6336       md_number_to_chars (to, inst.instruction, INSN_SIZE);
6337       md_number_to_chars (to + INSN_SIZE, inst.instruction, INSN_SIZE);
6338     }
6339   else
6340     md_number_to_chars (to, inst.instruction, inst.size);
6341
6342   if (inst.reloc.type != BFD_RELOC_NONE)
6343     fix_new_arm (frag_now, to - frag_now->fr_literal,
6344                  inst.size, & inst.reloc.exp, inst.reloc.pc_rel,
6345                  inst.reloc.type);
6346
6347   return;
6348 }
6349
6350 void
6351 md_assemble (str)
6352      char * str;
6353 {
6354   char   c;
6355   char * p;
6356   char * q;
6357   char * start;
6358
6359   /* Align the instruction.
6360      This may not be the right thing to do but ...  */
6361 #if 0
6362   arm_align (2, 0);
6363 #endif
6364   listing_prev_line (); /* Defined in listing.h.  */
6365
6366   /* Align the previous label if needed.  */
6367   if (last_label_seen != NULL)
6368     {
6369       symbol_set_frag (last_label_seen, frag_now);
6370       S_SET_VALUE (last_label_seen, (valueT) frag_now_fix ());
6371       S_SET_SEGMENT (last_label_seen, now_seg);
6372     }
6373
6374   memset (&inst, '\0', sizeof (inst));
6375   inst.reloc.type = BFD_RELOC_NONE;
6376
6377   skip_whitespace (str);
6378
6379   /* Scan up to the end of the op-code, which must end in white space or
6380      end of string.  */
6381   for (start = p = str; *p != '\0'; p++)
6382     if (*p == ' ')
6383       break;
6384
6385   if (p == str)
6386     {
6387       as_bad (_("No operator -- statement `%s'\n"), str);
6388       return;
6389     }
6390
6391   if (thumb_mode)
6392     {
6393       CONST struct thumb_opcode * opcode;
6394
6395       c = *p;
6396       *p = '\0';
6397       opcode = (CONST struct thumb_opcode *) hash_find (arm_tops_hsh, str);
6398       *p = c;
6399
6400       if (opcode)
6401         {
6402           /* Check that this instruction is supported for this CPU.  */
6403           if (thumb_mode == 1 && (opcode->variants & cpu_variant) == 0)
6404             {
6405               as_bad (_("selected processor does not support this opcode"));
6406               return;
6407             }
6408
6409           inst.instruction = opcode->value;
6410           inst.size = opcode->size;
6411           (*opcode->parms) (p);
6412           output_inst ();
6413           return;
6414         }
6415     }
6416   else
6417     {
6418       CONST struct asm_opcode * opcode;
6419       unsigned long cond_code;
6420
6421       inst.size = INSN_SIZE;
6422       /* P now points to the end of the opcode, probably white space, but we
6423          have to break the opcode up in case it contains condionals and flags;
6424          keep trying with progressively smaller basic instructions until one
6425          matches, or we run out of opcode.  */
6426       q = (p - str > LONGEST_INST) ? str + LONGEST_INST : p;
6427
6428       for (; q != str; q--)
6429         {
6430           c = *q;
6431           *q = '\0';
6432
6433           opcode = (CONST struct asm_opcode *) hash_find (arm_ops_hsh, str);
6434           *q = c;
6435
6436           if (opcode && opcode->template)
6437             {
6438               unsigned long flag_bits = 0;
6439               char * r;
6440
6441               /* Check that this instruction is supported for this CPU.  */
6442               if ((opcode->variants & cpu_variant) == 0)
6443                 goto try_shorter;
6444
6445               inst.instruction = opcode->value;
6446               if (q == p)               /* Just a simple opcode.  */
6447                 {
6448                   if (opcode->comp_suffix)
6449                     {
6450                       if (*opcode->comp_suffix != '\0')
6451                         as_bad (_("Opcode `%s' must have suffix from list: <%s>"),
6452                                 str, opcode->comp_suffix);
6453                       else
6454                         /* Not a conditional instruction.  */
6455                         (*opcode->parms) (q, 0);
6456                     }
6457                   else
6458                     {
6459                       /* A conditional instruction with default condition.  */
6460                       inst.instruction |= COND_ALWAYS;
6461                       (*opcode->parms) (q, 0);
6462                     }
6463                   output_inst ();
6464                   return;
6465                 }
6466
6467               /* Not just a simple opcode.  Check if extra is a
6468                  conditional.  */
6469               r = q;
6470               if (p - r >= 2)
6471                 {
6472                   CONST struct asm_cond *cond;
6473                   char d = *(r + 2);
6474
6475                   *(r + 2) = '\0';
6476                   cond = (CONST struct asm_cond *) hash_find (arm_cond_hsh, r);
6477                   *(r + 2) = d;
6478                   if (cond)
6479                     {
6480                       if (cond->value == 0xf0000000)
6481                         as_tsktsk (
6482 _("Warning: Use of the 'nv' conditional is deprecated\n"));
6483
6484                       cond_code = cond->value;
6485                       r += 2;
6486                     }
6487                   else
6488                     cond_code = COND_ALWAYS;
6489                 }
6490               else
6491                 cond_code = COND_ALWAYS;
6492
6493               /* Apply the conditional, or complain it's not allowed.  */
6494               if (opcode->comp_suffix && *opcode->comp_suffix == '\0')
6495                 {
6496                   /* Instruction isn't conditional.  */
6497                   if (cond_code != COND_ALWAYS)
6498                     {
6499                       as_bad (_("Opcode `%s' is unconditional\n"), str);
6500                       return;
6501                     }
6502                 }
6503               else
6504                 /* Instruction is conditional: set the condition into it.  */
6505                 inst.instruction |= cond_code;
6506
6507               /* If there is a compulsory suffix, it should come here
6508                  before any optional flags.  */
6509               if (opcode->comp_suffix && *opcode->comp_suffix != '\0')
6510                 {
6511                   CONST char *s = opcode->comp_suffix;
6512
6513                   while (*s)
6514                     {
6515                       inst.suffix++;
6516                       if (*r == *s)
6517                         break;
6518                       s++;
6519                     }
6520
6521                   if (*s == '\0')
6522                     {
6523                       as_bad (_("Opcode `%s' must have suffix from <%s>\n"),
6524                               str, opcode->comp_suffix);
6525                       return;
6526                     }
6527
6528                   r++;
6529                 }
6530
6531               /* The remainder, if any should now be flags for the instruction;
6532                  Scan these checking each one found with the opcode.  */
6533               if (r != p)
6534                 {
6535                   char d;
6536                   CONST struct asm_flg *flag = opcode->flags;
6537
6538                   if (flag)
6539                     {
6540                       int flagno;
6541
6542                       d = *p;
6543                       *p = '\0';
6544
6545                       for (flagno = 0; flag[flagno].template; flagno++)
6546                         {
6547                           if (streq (r, flag[flagno].template))
6548                             {
6549                               flag_bits |= flag[flagno].set_bits;
6550                               break;
6551                             }
6552                         }
6553
6554                       *p = d;
6555                       if (! flag[flagno].template)
6556                         goto try_shorter;
6557                     }
6558                   else
6559                     goto try_shorter;
6560                 }
6561
6562               (*opcode->parms) (p, flag_bits);
6563               output_inst ();
6564               return;
6565             }
6566
6567         try_shorter:
6568           ;
6569         }
6570     }
6571
6572   /* It wasn't an instruction, but it might be a register alias of the form
6573      alias .req reg.  */
6574   q = p;
6575   skip_whitespace (q);
6576
6577   c = *p;
6578   *p = '\0';
6579
6580   if (*q && !strncmp (q, ".req ", 4))
6581     {
6582       int    reg;
6583       char * copy_of_str = str;
6584       char * r;
6585
6586       q += 4;
6587       skip_whitespace (q);
6588
6589       for (r = q; *r != '\0'; r++)
6590         if (*r == ' ')
6591           break;
6592
6593       if (r != q)
6594         {
6595           int regnum;
6596           char d = *r;
6597
6598           *r = '\0';
6599           regnum = arm_reg_parse (& q);
6600           *r = d;
6601
6602           reg = arm_reg_parse (& str);
6603
6604           if (reg == FAIL)
6605             {
6606               if (regnum != FAIL)
6607                 insert_reg_alias (str, regnum);
6608               else
6609                 as_warn (_("register '%s' does not exist\n"), q);
6610             }
6611           else if (regnum != FAIL)
6612             {
6613               if (reg != regnum)
6614                 as_warn (_("ignoring redefinition of register alias '%s'"),
6615                          copy_of_str);
6616
6617               /* Do not warn about redefinitions to the same alias.  */
6618             }
6619           else
6620             as_warn (_("ignoring redefinition of register alias '%s' to non-existant register '%s'"),
6621                      copy_of_str, q);
6622         }
6623       else
6624         as_warn (_("ignoring incomplete .req pseuso op"));
6625
6626       *p = c;
6627       return;
6628     }
6629
6630   *p = c;
6631   as_bad (_("bad instruction `%s'"), start);
6632 }
6633
6634 /* md_parse_option
6635       Invocation line includes a switch not recognized by the base assembler.
6636       See if it's a processor-specific option.  These are:
6637       Cpu variants, the arm part is optional:
6638               -m[arm]1                Currently not supported.
6639               -m[arm]2, -m[arm]250    Arm 2 and Arm 250 processor
6640               -m[arm]3                Arm 3 processor
6641               -m[arm]6[xx],           Arm 6 processors
6642               -m[arm]7[xx][t][[d]m]   Arm 7 processors
6643               -m[arm]8[10]            Arm 8 processors
6644               -m[arm]9[20][tdmi]      Arm 9 processors
6645               -mstrongarm[110[0]]     StrongARM processors
6646               -m[arm]v[2345[t]]       Arm architectures
6647               -mall                   All (except the ARM1)
6648       FP variants:
6649               -mfpa10, -mfpa11        FPA10 and 11 co-processor instructions
6650               -mfpe-old               (No float load/store multiples)
6651               -mno-fpu                Disable all floating point instructions
6652       Run-time endian selection:
6653               -EB                     big endian cpu
6654               -EL                     little endian cpu
6655       ARM Procedure Calling Standard:
6656               -mapcs-32               32 bit APCS
6657               -mapcs-26               26 bit APCS
6658               -mapcs-float            Pass floats in float regs
6659               -mapcs-reentrant        Position independent code
6660               -mthumb-interwork       Code supports Arm/Thumb interworking
6661               -moabi                  Old ELF ABI  */
6662
6663 CONST char * md_shortopts = "m:k";
6664
6665 struct option md_longopts[] =
6666 {
6667 #ifdef ARM_BI_ENDIAN
6668 #define OPTION_EB (OPTION_MD_BASE + 0)
6669   {"EB", no_argument, NULL, OPTION_EB},
6670 #define OPTION_EL (OPTION_MD_BASE + 1)
6671   {"EL", no_argument, NULL, OPTION_EL},
6672 #ifdef OBJ_ELF
6673 #define OPTION_OABI (OPTION_MD_BASE +2)
6674   {"oabi", no_argument, NULL, OPTION_OABI},
6675 #endif
6676 #endif
6677   {NULL, no_argument, NULL, 0}
6678 };
6679
6680 size_t md_longopts_size = sizeof (md_longopts);
6681
6682 int
6683 md_parse_option (c, arg)
6684      int    c;
6685      char * arg;
6686 {
6687   char * str = arg;
6688
6689   switch (c)
6690     {
6691 #ifdef ARM_BI_ENDIAN
6692     case OPTION_EB:
6693       target_big_endian = 1;
6694       break;
6695     case OPTION_EL:
6696       target_big_endian = 0;
6697       break;
6698 #endif
6699
6700     case 'm':
6701       switch (*str)
6702         {
6703         case 'f':
6704           if (streq (str, "fpa10"))
6705             cpu_variant = (cpu_variant & ~FPU_ALL) | FPU_FPA10;
6706           else if (streq (str, "fpa11"))
6707             cpu_variant = (cpu_variant & ~FPU_ALL) | FPU_FPA11;
6708           else if (streq (str, "fpe-old"))
6709             cpu_variant = (cpu_variant & ~FPU_ALL) | FPU_CORE;
6710           else
6711             goto bad;
6712           break;
6713
6714         case 'n':
6715           if (streq (str, "no-fpu"))
6716             cpu_variant &= ~FPU_ALL;
6717           break;
6718
6719 #ifdef OBJ_ELF
6720         case 'o':
6721           if (streq (str, "oabi"))
6722             target_oabi = true;
6723           break;
6724 #endif
6725
6726         case 't':
6727           /* Limit assembler to generating only Thumb instructions:  */
6728           if (streq (str, "thumb"))
6729             {
6730               cpu_variant = (cpu_variant & ~ARM_ANY) | ARM_THUMB;
6731               cpu_variant = (cpu_variant & ~FPU_ALL) | FPU_NONE;
6732               thumb_mode = 1;
6733             }
6734           else if (streq (str, "thumb-interwork"))
6735             {
6736               if ((cpu_variant & ARM_THUMB) == 0)
6737                 cpu_variant = (cpu_variant & ~ARM_ANY) | ARM_ARCH_V4T;
6738 #if defined OBJ_COFF || defined OBJ_ELF
6739               support_interwork = true;
6740 #endif
6741             }
6742           else
6743             goto bad;
6744           break;
6745
6746         default:
6747           if (streq (str, "all"))
6748             {
6749               cpu_variant = ARM_ALL | FPU_ALL;
6750               return 1;
6751             }
6752 #if defined OBJ_COFF || defined OBJ_ELF
6753           if (! strncmp (str, "apcs-", 5))
6754             {
6755               /* GCC passes on all command line options starting "-mapcs-..."
6756                  to us, so we must parse them here.  */
6757
6758               str += 5;
6759
6760               if (streq (str, "32"))
6761                 {
6762                   uses_apcs_26 = false;
6763                   return 1;
6764                 }
6765               else if (streq (str, "26"))
6766                 {
6767                   uses_apcs_26 = true;
6768                   return 1;
6769                 }
6770               else if (streq (str, "frame"))
6771                 {
6772                   /* Stack frames are being generated - does not affect
6773                      linkage of code.  */
6774                   return 1;
6775                 }
6776               else if (streq (str, "stack-check"))
6777                 {
6778                   /* Stack checking is being performed - does not affect
6779                      linkage, but does require that the functions
6780                      __rt_stkovf_split_small and __rt_stkovf_split_big be
6781                      present in the final link.  */
6782
6783                   return 1;
6784                 }
6785               else if (streq (str, "float"))
6786                 {
6787                   /* Floating point arguments are being passed in the floating
6788                      point registers.  This does affect linking, since this
6789                      version of the APCS is incompatible with the version that
6790                      passes floating points in the integer registers.  */
6791
6792                   uses_apcs_float = true;
6793                   return 1;
6794                 }
6795               else if (streq (str, "reentrant"))
6796                 {
6797                   /* Reentrant code has been generated.  This does affect
6798                      linking, since there is no point in linking reentrant/
6799                      position independent code with absolute position code.  */
6800                   pic_code = true;
6801                   return 1;
6802                 }
6803
6804               as_bad (_("Unrecognised APCS switch -m%s"), arg);
6805               return 0;
6806             }
6807 #endif
6808           /* Strip off optional "arm".  */
6809           if (! strncmp (str, "arm", 3))
6810             str += 3;
6811
6812           switch (*str)
6813             {
6814             case '1':
6815               if (streq (str, "1"))
6816                 cpu_variant = (cpu_variant & ~ARM_ANY) | ARM_1;
6817               else
6818                 goto bad;
6819               break;
6820
6821             case '2':
6822               if (streq (str, "2"))
6823                 cpu_variant = (cpu_variant & ~ARM_ANY) | ARM_2;
6824               else if (streq (str, "250"))
6825                 cpu_variant = (cpu_variant & ~ARM_ANY) | ARM_250;
6826               else
6827                 goto bad;
6828               break;
6829
6830             case '3':
6831               if (streq (str, "3"))
6832                 cpu_variant = (cpu_variant & ~ARM_ANY) | ARM_3;
6833               else
6834                 goto bad;
6835               break;
6836
6837             case '6':
6838               switch (strtol (str, NULL, 10))
6839                 {
6840                 case 6:
6841                 case 60:
6842                 case 600:
6843                 case 610:
6844                 case 620:
6845                   cpu_variant = (cpu_variant & ~ARM_ANY) | ARM_6;
6846                   break;
6847                 default:
6848                   goto bad;
6849                 }
6850               break;
6851
6852             case '7':
6853               /* Eat the processor name.  */
6854               switch (strtol (str, & str, 10))
6855                 {
6856                 case 7:
6857                 case 70:
6858                 case 700:
6859                 case 710:
6860                 case 720:
6861                 case 7100:
6862                 case 7500:
6863                   break;
6864                 default:
6865                   goto bad;
6866                 }
6867               cpu_variant = (cpu_variant & ~ARM_ANY) | ARM_7;
6868               for (; *str; str++)
6869                 {
6870                   switch (*str)
6871                     {
6872                     case 't':
6873                       cpu_variant |= (ARM_THUMB | ARM_ARCH_V4);
6874                       break;
6875
6876                     case 'm':
6877                       cpu_variant |= ARM_LONGMUL;
6878                       break;
6879
6880                     case 'f': /* fe => fp enabled cpu.  */
6881                       if (str[1] == 'e')
6882                         ++ str;
6883                       else
6884                         goto bad;
6885
6886                     case 'c': /* Left over from 710c processor name.  */
6887                     case 'd': /* Debug.  */
6888                     case 'i': /* Embedded ICE.  */
6889                       /* Included for completeness in ARM processor naming.  */
6890                       break;
6891
6892                     default:
6893                       goto bad;
6894                     }
6895                 }
6896               break;
6897
6898             case '8':
6899               if (streq (str, "8") || streq (str, "810"))
6900                 cpu_variant = (cpu_variant & ~ARM_ANY)
6901                   | ARM_8 | ARM_ARCH_V4 | ARM_LONGMUL;
6902               else
6903                 goto bad;
6904               break;
6905
6906             case '9':
6907               if (streq (str, "9"))
6908                 cpu_variant = (cpu_variant & ~ARM_ANY)
6909                   | ARM_9 | ARM_ARCH_V4 | ARM_LONGMUL | ARM_THUMB;
6910               else if (streq (str, "920"))
6911                 cpu_variant = (cpu_variant & ~ARM_ANY)
6912                   | ARM_9 | ARM_ARCH_V4 | ARM_LONGMUL;
6913               else if (streq (str, "920t"))
6914                 cpu_variant = (cpu_variant & ~ARM_ANY)
6915                   | ARM_9 | ARM_ARCH_V4 | ARM_LONGMUL | ARM_THUMB;
6916               else if (streq (str, "9tdmi"))
6917                 cpu_variant = (cpu_variant & ~ARM_ANY)
6918                   | ARM_9 | ARM_ARCH_V4 | ARM_LONGMUL | ARM_THUMB;
6919               else
6920                 goto bad;
6921               break;
6922
6923             case 's':
6924               if (streq (str, "strongarm")
6925                   || streq (str, "strongarm110")
6926                   || streq (str, "strongarm1100"))
6927                 cpu_variant = (cpu_variant & ~ARM_ANY)
6928                   | ARM_8 | ARM_ARCH_V4 | ARM_LONGMUL;
6929               else
6930                 goto bad;
6931               break;
6932
6933             case 'v':
6934               /* Select variant based on architecture rather than
6935                  processor.  */
6936               switch (*++str)
6937                 {
6938                 case '2':
6939                   switch (*++str)
6940                     {
6941                     case 'a':
6942                       cpu_variant = (cpu_variant & ~ARM_ANY) | ARM_3;
6943                       break;
6944                     case 0:
6945                       cpu_variant = (cpu_variant & ~ARM_ANY) | ARM_2;
6946                       break;
6947                     default:
6948                       as_bad (_("Invalid architecture variant -m%s"), arg);
6949                       break;
6950                     }
6951                   break;
6952
6953                 case '3':
6954                   cpu_variant = (cpu_variant & ~ARM_ANY) | ARM_7;
6955
6956                   switch (*++str)
6957                     {
6958                     case 'm': cpu_variant |= ARM_LONGMUL; break;
6959                     case 0:   break;
6960                     default:
6961                       as_bad (_("Invalid architecture variant -m%s"), arg);
6962                       break;
6963                     }
6964                   break;
6965
6966                 case '4':
6967                   cpu_variant = (cpu_variant & ~ARM_ANY) | ARM_ARCH_V4;
6968
6969                   switch (*++str)
6970                     {
6971                     case 't': cpu_variant |= ARM_THUMB; break;
6972                     case 0:   break;
6973                     default:
6974                       as_bad (_("Invalid architecture variant -m%s"), arg);
6975                       break;
6976                     }
6977                   break;
6978
6979                 case '5':
6980                   cpu_variant = (cpu_variant & ~ARM_ANY) | ARM_ARCH_V5;
6981                   switch (*++str)
6982                     {
6983                     case 't': cpu_variant |= ARM_THUMB; break;
6984                     case 0:   break;
6985                     default:
6986                       as_bad (_("Invalid architecture variant -m%s"), arg);
6987                       break;
6988                     }
6989                   break;
6990
6991                 default:
6992                   as_bad (_("Invalid architecture variant -m%s"), arg);
6993                   break;
6994                 }
6995               break;
6996
6997             default:
6998             bad:
6999               as_bad (_("Invalid processor variant -m%s"), arg);
7000               return 0;
7001             }
7002         }
7003       break;
7004
7005 #if defined OBJ_ELF || defined OBJ_COFF
7006     case 'k':
7007       pic_code = 1;
7008       break;
7009 #endif
7010
7011     default:
7012       return 0;
7013     }
7014
7015   return 1;
7016 }
7017
7018 void
7019 md_show_usage (fp)
7020      FILE * fp;
7021 {
7022   fprintf (fp, _("\
7023  ARM Specific Assembler Options:\n\
7024   -m[arm][<processor name>] select processor variant\n\
7025   -m[arm]v[2|2a|3|3m|4|4t|5[t][e]] select architecture variant\n\
7026   -mthumb                   only allow Thumb instructions\n\
7027   -mthumb-interwork         mark the assembled code as supporting interworking\n\
7028   -mall                     allow any instruction\n\
7029   -mfpa10, -mfpa11          select floating point architecture\n\
7030   -mfpe-old                 don't allow floating-point multiple instructions\n\
7031   -mno-fpu                  don't allow any floating-point instructions.\n\
7032   -k                        generate PIC code.\n"));
7033 #if defined OBJ_COFF || defined OBJ_ELF
7034   fprintf (fp, _("\
7035   -mapcs-32, -mapcs-26      specify which ARM Procedure Calling Standard to use\n\
7036   -mapcs-float              floating point args are passed in FP regs\n\
7037   -mapcs-reentrant          the code is position independent/reentrant\n"));
7038 #endif
7039 #ifdef OBJ_ELF
7040   fprintf (fp, _("\
7041   -moabi                    support the old ELF ABI\n"));
7042 #endif
7043 #ifdef ARM_BI_ENDIAN
7044   fprintf (fp, _("\
7045   -EB                       assemble code for a big endian cpu\n\
7046   -EL                       assemble code for a little endian cpu\n"));
7047 #endif
7048 }
7049
7050 /* We need to be able to fix up arbitrary expressions in some statements.
7051    This is so that we can handle symbols that are an arbitrary distance from
7052    the pc.  The most common cases are of the form ((+/-sym -/+ . - 8) & mask),
7053    which returns part of an address in a form which will be valid for
7054    a data instruction.  We do this by pushing the expression into a symbol
7055    in the expr_section, and creating a fix for that.  */
7056
7057 static void
7058 fix_new_arm (frag, where, size, exp, pc_rel, reloc)
7059      fragS *       frag;
7060      int           where;
7061      short int     size;
7062      expressionS * exp;
7063      int           pc_rel;
7064      int           reloc;
7065 {
7066   fixS *           new_fix;
7067   arm_fix_data *   arm_data;
7068
7069   switch (exp->X_op)
7070     {
7071     case O_constant:
7072     case O_symbol:
7073     case O_add:
7074     case O_subtract:
7075       new_fix = fix_new_exp (frag, where, size, exp, pc_rel, reloc);
7076       break;
7077
7078     default:
7079       new_fix = fix_new (frag, where, size, make_expr_symbol (exp), 0,
7080                          pc_rel, reloc);
7081       break;
7082     }
7083
7084   /* Mark whether the fix is to a THUMB instruction, or an ARM
7085      instruction.  */
7086   arm_data = (arm_fix_data *) obstack_alloc (& notes, sizeof (arm_fix_data));
7087   new_fix->tc_fix_data = (PTR) arm_data;
7088   arm_data->thumb_mode = thumb_mode;
7089
7090   return;
7091 }
7092
7093 /* This fix_new is called by cons via TC_CONS_FIX_NEW.  */
7094
7095 void
7096 cons_fix_new_arm (frag, where, size, exp)
7097      fragS *       frag;
7098      int           where;
7099      int           size;
7100      expressionS * exp;
7101 {
7102   bfd_reloc_code_real_type type;
7103   int pcrel = 0;
7104
7105   /* Pick a reloc.
7106      FIXME: @@ Should look at CPU word size.  */
7107   switch (size)
7108     {
7109     case 1:
7110       type = BFD_RELOC_8;
7111       break;
7112     case 2:
7113       type = BFD_RELOC_16;
7114       break;
7115     case 4:
7116     default:
7117       type = BFD_RELOC_32;
7118       break;
7119     case 8:
7120       type = BFD_RELOC_64;
7121       break;
7122     }
7123
7124   fix_new_exp (frag, where, (int) size, exp, pcrel, type);
7125 }
7126
7127 /* A good place to do this, although this was probably not intended
7128    for this kind of use.  We need to dump the literal pool before
7129    references are made to a null symbol pointer.  */
7130
7131 void
7132 arm_cleanup ()
7133 {
7134   if (current_poolP == NULL)
7135     return;
7136
7137   /* Put it at the end of text section.  */
7138   subseg_set (text_section, 0);
7139   s_ltorg (0);
7140   listing_prev_line ();
7141 }
7142
7143 void
7144 arm_start_line_hook ()
7145 {
7146   last_label_seen = NULL;
7147 }
7148
7149 void
7150 arm_frob_label (sym)
7151      symbolS * sym;
7152 {
7153   last_label_seen = sym;
7154
7155   ARM_SET_THUMB (sym, thumb_mode);
7156
7157 #if defined OBJ_COFF || defined OBJ_ELF
7158   ARM_SET_INTERWORK (sym, support_interwork);
7159 #endif
7160
7161   if (label_is_thumb_function_name)
7162     {
7163       /* When the address of a Thumb function is taken the bottom
7164          bit of that address should be set.  This will allow
7165          interworking between Arm and Thumb functions to work
7166          correctly.  */
7167
7168       THUMB_SET_FUNC (sym, 1);
7169
7170       label_is_thumb_function_name = false;
7171     }
7172 }
7173
7174 /* Adjust the symbol table.  This marks Thumb symbols as distinct from
7175    ARM ones.  */
7176
7177 void
7178 arm_adjust_symtab ()
7179 {
7180 #ifdef OBJ_COFF
7181   symbolS * sym;
7182
7183   for (sym = symbol_rootP; sym != NULL; sym = symbol_next (sym))
7184     {
7185       if (ARM_IS_THUMB (sym))
7186         {
7187           if (THUMB_IS_FUNC (sym))
7188             {
7189               /* Mark the symbol as a Thumb function.  */
7190               if (   S_GET_STORAGE_CLASS (sym) == C_STAT
7191                   || S_GET_STORAGE_CLASS (sym) == C_LABEL)  /* This can happen!  */
7192                 S_SET_STORAGE_CLASS (sym, C_THUMBSTATFUNC);
7193
7194               else if (S_GET_STORAGE_CLASS (sym) == C_EXT)
7195                 S_SET_STORAGE_CLASS (sym, C_THUMBEXTFUNC);
7196               else
7197                 as_bad (_("%s: unexpected function type: %d"),
7198                         S_GET_NAME (sym), S_GET_STORAGE_CLASS (sym));
7199             }
7200           else switch (S_GET_STORAGE_CLASS (sym))
7201             {
7202             case C_EXT:
7203               S_SET_STORAGE_CLASS (sym, C_THUMBEXT);
7204               break;
7205             case C_STAT:
7206               S_SET_STORAGE_CLASS (sym, C_THUMBSTAT);
7207               break;
7208             case C_LABEL:
7209               S_SET_STORAGE_CLASS (sym, C_THUMBLABEL);
7210               break;
7211             default:
7212               /* Do nothing.  */
7213               break;
7214             }
7215         }
7216
7217       if (ARM_IS_INTERWORK (sym))
7218         coffsymbol (symbol_get_bfdsym (sym))->native->u.syment.n_flags = 0xFF;
7219     }
7220 #endif
7221 #ifdef OBJ_ELF
7222   symbolS *sym;
7223   char bind;
7224
7225   for (sym = symbol_rootP; sym != NULL; sym = symbol_next (sym))
7226     {
7227       if (ARM_IS_THUMB (sym))
7228         {
7229           elf_symbol_type *elf_sym;
7230
7231           elf_sym = elf_symbol (symbol_get_bfdsym (sym));
7232           bind = ELF_ST_BIND (elf_sym);
7233
7234           /* If it's a .thumb_func, declare it as so,
7235              otherwise tag label as .code 16.  */
7236           if (THUMB_IS_FUNC (sym))
7237             elf_sym->internal_elf_sym.st_info =
7238               ELF_ST_INFO (bind, STT_ARM_TFUNC);
7239           else
7240             elf_sym->internal_elf_sym.st_info =
7241               ELF_ST_INFO (bind, STT_ARM_16BIT);
7242         }
7243     }
7244 #endif
7245 }
7246
7247 int
7248 arm_data_in_code ()
7249 {
7250   if (thumb_mode && ! strncmp (input_line_pointer + 1, "data:", 5))
7251     {
7252       *input_line_pointer = '/';
7253       input_line_pointer += 5;
7254       *input_line_pointer = 0;
7255       return 1;
7256     }
7257
7258   return 0;
7259 }
7260
7261 char *
7262 arm_canonicalize_symbol_name (name)
7263      char *name;
7264 {
7265   int len;
7266
7267   if (thumb_mode && (len = strlen (name)) > 5
7268       && streq (name + len - 5, "/data"))
7269     *(name + len - 5) = 0;
7270
7271   return name;
7272 }
7273
7274 boolean
7275 arm_validate_fix (fixP)
7276      fixS *fixP;
7277 {
7278   /* If the destination of the branch is a defined symbol which does not have
7279      the THUMB_FUNC attribute, then we must be calling a function which has
7280      the (interfacearm) attribute.  We look for the Thumb entry point to that
7281      function and change the branch to refer to that function instead.  */
7282   if (fixP->fx_r_type == BFD_RELOC_THUMB_PCREL_BRANCH23
7283       && fixP->fx_addsy != NULL
7284       && S_IS_DEFINED (fixP->fx_addsy)
7285       && ! THUMB_IS_FUNC (fixP->fx_addsy))
7286     {
7287       fixP->fx_addsy = find_real_start (fixP->fx_addsy);
7288       return true;
7289     }
7290
7291   return false;
7292 }
7293
7294 #ifdef OBJ_ELF
7295 /* Relocations against Thumb function names must be left unadjusted,
7296    so that the linker can use this information to correctly set the
7297    bottom bit of their addresses.  The MIPS version of this function
7298    also prevents relocations that are mips-16 specific, but I do not
7299    know why it does this.
7300
7301    FIXME:
7302    There is one other problem that ought to be addressed here, but
7303    which currently is not:  Taking the address of a label (rather
7304    than a function) and then later jumping to that address.  Such
7305    addresses also ought to have their bottom bit set (assuming that
7306    they reside in Thumb code), but at the moment they will not.  */
7307
7308 boolean
7309 arm_fix_adjustable (fixP)
7310    fixS *fixP;
7311 {
7312   if (fixP->fx_addsy == NULL)
7313     return 1;
7314
7315   /* Prevent all adjustments to global symbols.  */
7316   if (S_IS_EXTERN (fixP->fx_addsy))
7317     return 0;
7318
7319   if (S_IS_WEAK (fixP->fx_addsy))
7320     return 0;
7321
7322   if (THUMB_IS_FUNC (fixP->fx_addsy)
7323       && fixP->fx_subsy == NULL)
7324     return 0;
7325
7326   /* We need the symbol name for the VTABLE entries.  */
7327   if (   fixP->fx_r_type == BFD_RELOC_VTABLE_INHERIT
7328       || fixP->fx_r_type == BFD_RELOC_VTABLE_ENTRY)
7329     return 0;
7330
7331   return 1;
7332 }
7333
7334 const char *
7335 elf32_arm_target_format ()
7336 {
7337   if (target_big_endian)
7338     {
7339       if (target_oabi)
7340         return "elf32-bigarm-oabi";
7341       else
7342         return "elf32-bigarm";
7343     }
7344   else
7345     {
7346       if (target_oabi)
7347         return "elf32-littlearm-oabi";
7348       else
7349         return "elf32-littlearm";
7350     }
7351 }
7352
7353 void
7354 armelf_frob_symbol (symp, puntp)
7355      symbolS * symp;
7356      int *     puntp;
7357 {
7358   elf_frob_symbol (symp, puntp);
7359 }
7360
7361 int
7362 arm_force_relocation (fixp)
7363      struct fix * fixp;
7364 {
7365   if (   fixp->fx_r_type == BFD_RELOC_VTABLE_INHERIT
7366       || fixp->fx_r_type == BFD_RELOC_VTABLE_ENTRY
7367       || fixp->fx_r_type == BFD_RELOC_ARM_PCREL_BRANCH
7368       || fixp->fx_r_type == BFD_RELOC_ARM_PCREL_BLX
7369       || fixp->fx_r_type == BFD_RELOC_THUMB_PCREL_BLX
7370       || fixp->fx_r_type == BFD_RELOC_THUMB_PCREL_BRANCH23)
7371     return 1;
7372
7373   return 0;
7374 }
7375
7376 static bfd_reloc_code_real_type
7377 arm_parse_reloc ()
7378 {
7379   char         id [16];
7380   char *       ip;
7381   unsigned int i;
7382   static struct
7383   {
7384     char * str;
7385     int    len;
7386     bfd_reloc_code_real_type reloc;
7387   }
7388   reloc_map[] =
7389   {
7390 #define MAP(str,reloc) { str, sizeof (str)-1, reloc }
7391     MAP ("(got)",    BFD_RELOC_ARM_GOT32),
7392     MAP ("(gotoff)", BFD_RELOC_ARM_GOTOFF),
7393     /* ScottB: Jan 30, 1998 - Added support for parsing "var(PLT)"
7394        branch instructions generated by GCC for PLT relocs.  */
7395     MAP ("(plt)",    BFD_RELOC_ARM_PLT32),
7396     { NULL, 0,         BFD_RELOC_UNUSED }
7397 #undef MAP
7398   };
7399
7400   for (i = 0, ip = input_line_pointer;
7401        i < sizeof (id) && (isalnum (*ip) || ispunct (*ip));
7402        i++, ip++)
7403     id[i] = tolower (*ip);
7404
7405   for (i = 0; reloc_map[i].str; i++)
7406     if (strncmp (id, reloc_map[i].str, reloc_map[i].len) == 0)
7407       break;
7408
7409   input_line_pointer += reloc_map[i].len;
7410
7411   return reloc_map[i].reloc;
7412 }
7413
7414 static void
7415 s_arm_elf_cons (nbytes)
7416      int nbytes;
7417 {
7418   expressionS exp;
7419
7420 #ifdef md_flush_pending_output
7421   md_flush_pending_output ();
7422 #endif
7423
7424   if (is_it_end_of_statement ())
7425     {
7426       demand_empty_rest_of_line ();
7427       return;
7428     }
7429
7430 #ifdef md_cons_align
7431   md_cons_align (nbytes);
7432 #endif
7433
7434   do
7435     {
7436       bfd_reloc_code_real_type reloc;
7437
7438       expression (& exp);
7439
7440       if (exp.X_op == O_symbol
7441           && *input_line_pointer == '('
7442           && (reloc = arm_parse_reloc ()) != BFD_RELOC_UNUSED)
7443         {
7444           reloc_howto_type *howto = bfd_reloc_type_lookup (stdoutput, reloc);
7445           int size = bfd_get_reloc_size (howto);
7446
7447           if (size > nbytes)
7448             as_bad ("%s relocations do not fit in %d bytes",
7449                     howto->name, nbytes);
7450           else
7451             {
7452               register char *p = frag_more ((int) nbytes);
7453               int offset = nbytes - size;
7454
7455               fix_new_exp (frag_now, p - frag_now->fr_literal + offset, size,
7456                            &exp, 0, reloc);
7457             }
7458         }
7459       else
7460         emit_expr (&exp, (unsigned int) nbytes);
7461     }
7462   while (*input_line_pointer++ == ',');
7463
7464   /* Put terminator back into stream.  */
7465   input_line_pointer --;
7466   demand_empty_rest_of_line ();
7467 }
7468
7469 #endif /* OBJ_ELF */