gas/config/tc-arm.c

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