gas/config/tc-arm.c

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