gas/config/tc-msp430.c

   1 /* tc-msp430.c -- Assembler code for the Texas Instruments MSP430
   2
   3   Copyright (C) 2002-2017 Free Software Foundation, Inc.
   4   Contributed by Dmitry Diky <diwil@mail.ru>
   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 3, 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
  20   the Free Software Foundation, 51 Franklin Street - Fifth Floor,
  21   Boston, MA 02110-1301, USA.  */
  22
  23 #include "as.h"
  24 #include <limits.h>
  25 #include "subsegs.h"
  26 #include "opcode/msp430.h"
  27 #include "safe-ctype.h"
  28 #include "dwarf2dbg.h"
  29 #include "elf/msp430.h"
  30 #include "libiberty.h"
  31
  32 /* We will disable polymorphs by default because it is dangerous.
  33    The potential problem here is the following: assume we got the
  34    following code:
  35
  36         jump .l1
  37         nop
  38         jump  subroutine        ; external symbol
  39       .l1:
  40         nop
  41         ret
  42
  43    In case of assembly time relaxation we'll get:
  44         0: jmp .l1 <.text +0x08> (reloc deleted)
  45         2: nop
  46         4: br subroutine
  47     .l1:
  48         8: nop
  49         10: ret
  50
  51    If the 'subroutine' is within +-1024 bytes range then linker
  52    will produce:
  53         0: jmp .text +0x08
  54         2: nop
  55         4: jmp subroutine
  56         .l1:
  57         6: nop
  58         8: ret  ; 'jmp .text +0x08' will land here. WRONG!!!
  59
  60    The workaround is the following:
  61    1. Declare global var enable_polymorphs which set to 1 via option -mp.
  62    2. Declare global var enable_relax   which set to 1 via option -mQ.
  63
  64    If polymorphs are enabled, and relax isn't, treat all jumps as long jumps,
  65    do not delete any relocs and leave them for linker.
  66
  67    If relax is enabled, relax at assembly time and kill relocs as necessary.  */
  68
  69 int msp430_enable_relax;
  70 int msp430_enable_polys;
  71
  72 /* GCC uses the some condition codes which we'll
  73    implement as new polymorph instructions.
  74
  75    COND EXPL       SHORT JUMP   LONG JUMP
  76    ===============================================
  77    eq   ==         jeq          jne +4; br lab
  78    ne   !=         jne          jeq +4; br lab
  79
  80    ltn honours no-overflow flag
  81    ltn  <          jn           jn +2;  jmp +4; br lab
  82
  83    lt   <          jl           jge +4; br lab
  84    ltu  <          jlo          lhs +4; br lab
  85    le   <= see below
  86    leu  <= see below
  87
  88    gt   >  see below
  89    gtu  >  see below
  90    ge   >=         jge          jl +4; br lab
  91    geu  >=         jhs          jlo +4; br lab
  92    ===============================================
  93
  94    Therefore, new opcodes are (BranchEQ -> beq; and so on...)
  95    beq,bne,blt,bltn,bltu,bge,bgeu
  96    'u' means unsigned compares
  97
  98    Also, we add 'jump' instruction:
  99    jump UNCOND  -> jmp          br lab
 100
 101    They will have fmt == 4, and insn_opnumb == number of instruction.  */
 102
 103 struct rcodes_s
 104 {
 105   const char * name;
 106   int    index; /* Corresponding insn_opnumb.  */
 107   int    sop;   /* Opcode if jump length is short.  */
 108   long   lpos;  /* Label position.  */
 109   long   lop0;  /* Opcode 1 _word_ (16 bits).  */
 110   long   lop1;  /* Opcode second word.  */
 111   long   lop2;  /* Opcode third word.  */
 112 };
 113
 114 #define MSP430_RLC(n,i,sop,o1) \
 115   {#n, i, sop, 2, (o1 + 2), 0x4010, 0}
 116
 117 static struct rcodes_s msp430_rcodes[] =
 118 {
 119   MSP430_RLC (beq,  0, 0x2400, 0x2000),
 120   MSP430_RLC (bne,  1, 0x2000, 0x2400),
 121   MSP430_RLC (blt,  2, 0x3800, 0x3400),
 122   MSP430_RLC (bltu, 3, 0x2800, 0x2c00),
 123   MSP430_RLC (bge,  4, 0x3400, 0x3800),
 124   MSP430_RLC (bgeu, 5, 0x2c00, 0x2800),
 125   {"bltn",          6, 0x3000, 3, 0x3000 + 1, 0x3c00 + 2,0x4010},
 126   {"jump",          7, 0x3c00, 1, 0x4010, 0, 0},
 127   {0,0,0,0,0,0,0}
 128 };
 129
 130 #undef  MSP430_RLC
 131 #define MSP430_RLC(n,i,sop,o1) \
 132   {#n, i, sop, 2, (o1 + 2), 0x0030, 0}
 133
 134 static struct rcodes_s msp430x_rcodes[] =
 135 {
 136   MSP430_RLC (beq,  0, 0x2400,    0x2000),
 137   MSP430_RLC (bne,  1, 0x2000,    0x2400),
 138   MSP430_RLC (blt,  2, 0x3800,    0x3400),
 139   MSP430_RLC (bltu, 3, 0x2800,    0x2c00),
 140   MSP430_RLC (bge,  4, 0x3400,    0x3800),
 141   MSP430_RLC (bgeu, 5, 0x2c00,    0x2800),
 142   {"bltn",          6, 0x3000, 3, 0x0030 + 1, 0x3c00 + 2, 0x3000},
 143   {"jump",          7, 0x3c00, 1, 0x0030,     0,          0},
 144   {0,0,0,0,0,0,0}
 145 };
 146 #undef MSP430_RLC
 147
 148 /* More difficult than above and they have format 5.
 149
 150    COND EXPL    SHORT                   LONG
 151    =================================================================
 152    gt   >       jeq +2; jge label       jeq +6; jl  +4; br label
 153    gtu  >       jeq +2; jhs label       jeq +6; jlo +4; br label
 154    leu  <=      jeq label; jlo label    jeq +2; jhs +4; br label
 155    le   <=      jeq label; jl  label    jeq +2; jge +4; br label
 156    =================================================================  */
 157
 158 struct hcodes_s
 159 {
 160   const char * name;
 161   int    index;         /* Corresponding insn_opnumb.  */
 162   int    tlab;          /* Number of labels in short mode.  */
 163   int    op0;           /* Opcode for first word of short jump.  */
 164   int    op1;           /* Opcode for second word of short jump.  */
 165   int    lop0;          /* Opcodes for long jump mode.  */
 166   int    lop1;
 167   int    lop2;
 168 };
 169
 170 static struct hcodes_s msp430_hcodes[] =
 171 {
 172   {"bgt",  0, 1, 0x2401, 0x3400, 0x2403, 0x3802, 0x4010 },
 173   {"bgtu", 1, 1, 0x2401, 0x2c00, 0x2403, 0x2802, 0x4010 },
 174   {"bleu", 2, 2, 0x2400, 0x2800, 0x2401, 0x2c02, 0x4010 },
 175   {"ble",  3, 2, 0x2400, 0x3800, 0x2401, 0x3402, 0x4010 },
 176   {0,0,0,0,0,0,0,0}
 177 };
 178
 179 static struct hcodes_s msp430x_hcodes[] =
 180 {
 181   {"bgt",  0, 1, 0x2401, 0x3400, 0x2403, 0x3802, 0x0030 },
 182   {"bgtu", 1, 1, 0x2401, 0x2c00, 0x2403, 0x2802, 0x0030 },
 183   {"bleu", 2, 2, 0x2400, 0x2800, 0x2401, 0x2c02, 0x0030 },
 184   {"ble",  3, 2, 0x2400, 0x3800, 0x2401, 0x3402, 0x0030 },
 185   {0,0,0,0,0,0,0,0}
 186 };
 187
 188 const char comment_chars[] = ";";
 189 const char line_comment_chars[] = "#";
 190 const char line_separator_chars[] = "{";
 191 const char EXP_CHARS[] = "eE";
 192 const char FLT_CHARS[] = "dD";
 193
 194 /* Handle  long expressions.  */
 195 extern LITTLENUM_TYPE generic_bignum[];
 196
 197 static struct hash_control *msp430_hash;
 198
 199 /* Relaxations.  */
 200 #define STATE_UNCOND_BRANCH     1       /* jump */
 201 #define STATE_NOOV_BRANCH       3       /* bltn */
 202 #define STATE_SIMPLE_BRANCH     2       /* bne, beq, etc... */
 203 #define STATE_EMUL_BRANCH       4
 204
 205 #define CNRL    2
 206 #define CUBL    4
 207 #define CNOL    8
 208 #define CSBL    6
 209 #define CEBL    4
 210
 211 /* Length.  */
 212 #define STATE_BITS10    1       /* wild guess. short jump */
 213 #define STATE_WORD      2       /* 2 bytes pc rel. addr. more */
 214 #define STATE_UNDEF     3       /* cannot handle this yet. convert to word mode */
 215
 216 #define ENCODE_RELAX(what,length) (((what) << 2) + (length))
 217 #define RELAX_STATE(s)            ((s) & 3)
 218 #define RELAX_LEN(s)              ((s) >> 2)
 219 #define RELAX_NEXT(a,b)           ENCODE_RELAX (a, b + 1)
 220
 221 relax_typeS md_relax_table[] =
 222 {
 223   /* Unused.  */
 224   {1, 1, 0, 0},
 225   {1, 1, 0, 0},
 226   {1, 1, 0, 0},
 227   {1, 1, 0, 0},
 228
 229   /* Unconditional jump.  */
 230   {1, 1, 8, 5},
 231   {1024, -1024, CNRL, RELAX_NEXT (STATE_UNCOND_BRANCH, STATE_BITS10)},  /* state 10 bits displ */
 232   {0, 0, CUBL, RELAX_NEXT (STATE_UNCOND_BRANCH, STATE_WORD)},           /* state word */
 233   {1, 1, CUBL, 0},                                                      /* state undef */
 234
 235   /* Simple branches.  */
 236   {0, 0, 8, 9},
 237   {1024, -1024, CNRL, RELAX_NEXT (STATE_SIMPLE_BRANCH, STATE_BITS10)},  /* state 10 bits displ */
 238   {0, 0, CSBL, RELAX_NEXT (STATE_SIMPLE_BRANCH, STATE_WORD)},           /* state word */
 239   {1, 1, CSBL, 0},
 240
 241   /* blt no overflow branch.  */
 242   {1, 1, 8, 13},
 243   {1024, -1024, CNRL, RELAX_NEXT (STATE_NOOV_BRANCH, STATE_BITS10)},    /* state 10 bits displ */
 244   {0, 0, CNOL, RELAX_NEXT (STATE_NOOV_BRANCH, STATE_WORD)},             /* state word */
 245   {1, 1, CNOL, 0},
 246
 247   /* Emulated branches.  */
 248   {1, 1, 8, 17},
 249   {1020, -1020, CEBL, RELAX_NEXT (STATE_EMUL_BRANCH, STATE_BITS10)},    /* state 10 bits displ */
 250   {0, 0, CNOL, RELAX_NEXT (STATE_EMUL_BRANCH, STATE_WORD)},             /* state word */
 251   {1, 1, CNOL, 0}
 252 };
 253
 254
 255 #define MAX_OP_LEN      4096
 256
 257 typedef enum msp_isa
 258 {
 259   MSP_ISA_430,
 260   MSP_ISA_430X,
 261   MSP_ISA_430Xv2
 262 } msp_isa;
 263
 264 static enum msp_isa selected_isa = MSP_ISA_430Xv2;
 265
 266 static inline bfd_boolean
 267 target_is_430x (void)
 268 {
 269   return selected_isa >= MSP_ISA_430X;
 270 }
 271
 272 static inline bfd_boolean
 273 target_is_430xv2 (void)
 274 {
 275   return selected_isa == MSP_ISA_430Xv2;
 276 }
 277
 278 /* Generate an absolute 16-bit relocation.
 279    For the 430X we generate a relocation without linker range checking
 280     if the value is being used in an extended (ie 20-bit) instruction,
 281     otherwise if have a shifted expression we use a HI reloc.
 282    For the 430 we generate a relocation without assembler range checking
 283     if we are handling an immediate value or a byte-width instruction.  */
 284
 285 #undef  CHECK_RELOC_MSP430
 286 #define CHECK_RELOC_MSP430(OP)                          \
 287   (target_is_430x ()                                    \
 288   ? (extended_op                                        \
 289      ? BFD_RELOC_16                                     \
 290      : ((OP).vshift == 1)                               \
 291      ? BFD_RELOC_MSP430_ABS_HI16                        \
 292      : BFD_RELOC_MSP430X_ABS16)                         \
 293    : ((imm_op || byte_op)                               \
 294       ? BFD_RELOC_MSP430_16_BYTE : BFD_RELOC_MSP430_16))
 295
 296 /* Generate a 16-bit pc-relative relocation.
 297    For the 430X we generate a relocation without linker range checking.
 298    For the 430 we generate a relocation without assembler range checking
 299    if we are handling an immediate value or a byte-width instruction.  */
 300 #undef  CHECK_RELOC_MSP430_PCREL
 301 #define CHECK_RELOC_MSP430_PCREL                             \
 302   (target_is_430x ()                                         \
 303    ? BFD_RELOC_MSP430X_PCR16                                 \
 304    : (imm_op || byte_op)                                     \
 305    ? BFD_RELOC_MSP430_16_PCREL_BYTE : BFD_RELOC_MSP430_16_PCREL)
 306
 307 /* Profiling capability:
 308    It is a performance hit to use gcc's profiling approach for this tiny target.
 309    Even more -- jtag hardware facility does not perform any profiling functions.
 310    However we've got gdb's built-in simulator where we can do anything.
 311    Therefore my suggestion is:
 312
 313    We define new section ".profiler" which holds all profiling information.
 314    We define new pseudo operation .profiler which will instruct assembler to
 315    add new profile entry to the object file. Profile should take place at the
 316    present address.
 317
 318    Pseudo-op format:
 319
 320       .profiler flags,function_to_profile [, cycle_corrector, extra]
 321
 322    where 'flags' is a combination of the following chars:
 323             s - function Start
 324             x - function eXit
 325             i - function is in Init section
 326             f - function is in Fini section
 327             l - Library call
 328             c - libC standard call
 329             d - stack value Demand (saved at run-time in simulator)
 330             I - Interrupt service routine
 331             P - Prologue start
 332             p - Prologue end
 333             E - Epilogue start
 334             e - Epilogue end
 335             j - long Jump/ sjlj unwind
 336             a - an Arbitrary code fragment
 337             t - exTra parameter saved (constant value like frame size)
 338           '""' optional: "sil" == sil
 339
 340       function_to_profile - function's address
 341       cycle_corrector     - a value which should be added to the cycle
 342                               counter, zero if omitted
 343       extra - some extra parameter, zero if omitted.
 344
 345       For example:
 346       ------------------------------
 347         .global fxx
 348         .type fxx,@function
 349       fxx:
 350       .LFrameOffset_fxx=0x08
 351       .profiler "scdP", fxx     ; function entry.
 352                                 ; we also demand stack value to be displayed
 353         push r11
 354         push r10
 355         push r9
 356         push r8
 357       .profiler "cdp",fxx,0, .LFrameOffset_fxx  ; check stack value at this point
 358                                                 ; (this is a prologue end)
 359                                                 ; note, that spare var filled with the frame size
 360         mov r15,r8
 361         ....
 362       .profiler cdE,fxx         ; check stack
 363         pop r8
 364         pop r9
 365         pop r10
 366         pop r11
 367       .profiler xcde,fxx,3      ; exit adds 3 to the cycle counter
 368       ret                       ; cause 'ret' insn takes 3 cycles
 369       -------------------------------
 370
 371       This profiling approach does not produce any overhead and
 372       absolutely harmless.
 373       So, even profiled code can be uploaded to the MCU.  */
 374 #define MSP430_PROFILER_FLAG_ENTRY      1       /* s */
 375 #define MSP430_PROFILER_FLAG_EXIT       2       /* x */
 376 #define MSP430_PROFILER_FLAG_INITSECT   4       /* i */
 377 #define MSP430_PROFILER_FLAG_FINISECT   8       /* f */
 378 #define MSP430_PROFILER_FLAG_LIBCALL    0x10    /* l */
 379 #define MSP430_PROFILER_FLAG_STDCALL    0x20    /* c */
 380 #define MSP430_PROFILER_FLAG_STACKDMD   0x40    /* d */
 381 #define MSP430_PROFILER_FLAG_ISR        0x80    /* I */
 382 #define MSP430_PROFILER_FLAG_PROLSTART  0x100   /* P */
 383 #define MSP430_PROFILER_FLAG_PROLEND    0x200   /* p */
 384 #define MSP430_PROFILER_FLAG_EPISTART   0x400   /* E */
 385 #define MSP430_PROFILER_FLAG_EPIEND     0x800   /* e */
 386 #define MSP430_PROFILER_FLAG_JUMP       0x1000  /* j */
 387 #define MSP430_PROFILER_FLAG_FRAGMENT   0x2000  /* a */
 388 #define MSP430_PROFILER_FLAG_EXTRA      0x4000  /* t */
 389 #define MSP430_PROFILER_FLAG_notyet     0x8000  /* ? */
 390
 391 static int
 392 pow2value (int y)
 393 {
 394   int n = 0;
 395   unsigned int x;
 396
 397   x = y;
 398
 399   if (!x)
 400     return 1;
 401
 402   for (; x; x = x >> 1)
 403     if (x & 1)
 404       n++;
 405
 406   return n == 1;
 407 }
 408
 409 /* Parse ordinary expression.  */
 410
 411 static char *
 412 parse_exp (char * s, expressionS * op)
 413 {
 414   input_line_pointer = s;
 415   expression (op);
 416   if (op->X_op == O_absent)
 417     as_bad (_("missing operand"));
 418   return input_line_pointer;
 419 }
 420
 421
 422 /* Delete spaces from s: X ( r 1  2)  => X(r12).  */
 423
 424 static void
 425 del_spaces (char * s)
 426 {
 427   while (*s)
 428     {
 429       if (ISSPACE (*s))
 430         {
 431           char *m = s + 1;
 432
 433           while (ISSPACE (*m) && *m)
 434             m++;
 435           memmove (s, m, strlen (m) + 1);
 436         }
 437       else
 438         s++;
 439     }
 440 }
 441
 442 static inline char *
 443 skip_space (char * s)
 444 {
 445   while (ISSPACE (*s))
 446     ++s;
 447   return s;
 448 }
 449
 450 /* Extract one word from FROM and copy it to TO. Delimiters are ",;\n"  */
 451
 452 static char *
 453 extract_operand (char * from, char * to, int limit)
 454 {
 455   int size = 0;
 456
 457   /* Drop leading whitespace.  */
 458   from = skip_space (from);
 459
 460   while (size < limit && *from)
 461     {
 462       *(to + size) = *from;
 463       if (*from == ',' || *from == ';' || *from == '\n')
 464         break;
 465       from++;
 466       size++;
 467     }
 468
 469   *(to + size) = 0;
 470   del_spaces (to);
 471
 472   from++;
 473
 474   return from;
 475 }
 476
 477 static void
 478 msp430_profiler (int dummy ATTRIBUTE_UNUSED)
 479 {
 480   char   buffer[1024];
 481   char   f[32];
 482   char * str = buffer;
 483   char * flags = f;
 484   int    p_flags = 0;
 485   char * halt;
 486   int    ops = 0;
 487   int    left;
 488   char * s;
 489   segT   seg;
 490   int    subseg;
 491   char * end = 0;
 492   expressionS exp;
 493   expressionS exp1;
 494
 495   s = input_line_pointer;
 496   end = input_line_pointer;
 497
 498   while (*end && *end != '\n')
 499     end++;
 500
 501   while (*s && *s != '\n')
 502     {
 503       if (*s == ',')
 504         ops++;
 505       s++;
 506     }
 507
 508   left = 3 - ops;
 509
 510   if (ops < 1)
 511     {
 512       as_bad (_(".profiler pseudo requires at least two operands."));
 513       input_line_pointer = end;
 514       return;
 515     }
 516
 517   input_line_pointer = extract_operand (input_line_pointer, flags, 32);
 518
 519   while (*flags)
 520     {
 521       switch (*flags)
 522         {
 523         case '"':
 524           break;
 525         case 'a':
 526           p_flags |= MSP430_PROFILER_FLAG_FRAGMENT;
 527           break;
 528         case 'j':
 529           p_flags |= MSP430_PROFILER_FLAG_JUMP;
 530           break;
 531         case 'P':
 532           p_flags |= MSP430_PROFILER_FLAG_PROLSTART;
 533           break;
 534         case 'p':
 535           p_flags |= MSP430_PROFILER_FLAG_PROLEND;
 536           break;
 537         case 'E':
 538           p_flags |= MSP430_PROFILER_FLAG_EPISTART;
 539           break;
 540         case 'e':
 541           p_flags |= MSP430_PROFILER_FLAG_EPIEND;
 542           break;
 543         case 's':
 544           p_flags |= MSP430_PROFILER_FLAG_ENTRY;
 545           break;
 546         case 'x':
 547           p_flags |= MSP430_PROFILER_FLAG_EXIT;
 548           break;
 549         case 'i':
 550           p_flags |= MSP430_PROFILER_FLAG_INITSECT;
 551           break;
 552         case 'f':
 553           p_flags |= MSP430_PROFILER_FLAG_FINISECT;
 554           break;
 555         case 'l':
 556           p_flags |= MSP430_PROFILER_FLAG_LIBCALL;
 557           break;
 558         case 'c':
 559           p_flags |= MSP430_PROFILER_FLAG_STDCALL;
 560           break;
 561         case 'd':
 562           p_flags |= MSP430_PROFILER_FLAG_STACKDMD;
 563           break;
 564         case 'I':
 565           p_flags |= MSP430_PROFILER_FLAG_ISR;
 566           break;
 567         case 't':
 568           p_flags |= MSP430_PROFILER_FLAG_EXTRA;
 569           break;
 570         default:
 571           as_warn (_("unknown profiling flag - ignored."));
 572           break;
 573         }
 574       flags++;
 575     }
 576
 577   if (p_flags
 578       && (   ! pow2value (p_flags & (  MSP430_PROFILER_FLAG_ENTRY
 579                                      | MSP430_PROFILER_FLAG_EXIT))
 580           || ! pow2value (p_flags & (  MSP430_PROFILER_FLAG_PROLSTART
 581                                      | MSP430_PROFILER_FLAG_PROLEND
 582                                      | MSP430_PROFILER_FLAG_EPISTART
 583                                      | MSP430_PROFILER_FLAG_EPIEND))
 584           || ! pow2value (p_flags & (  MSP430_PROFILER_FLAG_INITSECT
 585                                      | MSP430_PROFILER_FLAG_FINISECT))))
 586     {
 587       as_bad (_("ambiguous flags combination - '.profiler' directive ignored."));
 588       input_line_pointer = end;
 589       return;
 590     }
 591
 592   /* Generate temp symbol which denotes current location.  */
 593   if (now_seg == absolute_section)      /* Paranoia ?  */
 594     {
 595       exp1.X_op = O_constant;
 596       exp1.X_add_number = abs_section_offset;
 597       as_warn (_("profiling in absolute section?"));
 598     }
 599   else
 600     {
 601       exp1.X_op = O_symbol;
 602       exp1.X_add_symbol = symbol_temp_new_now ();
 603       exp1.X_add_number = 0;
 604     }
 605
 606   /* Generate a symbol which holds flags value.  */
 607   exp.X_op = O_constant;
 608   exp.X_add_number = p_flags;
 609
 610   /* Save current section.  */
 611   seg = now_seg;
 612   subseg = now_subseg;
 613
 614   /* Now go to .profiler section.  */
 615   obj_elf_change_section (".profiler", SHT_PROGBITS, 0, 0, 0, 0, 0, 0);
 616
 617   /* Save flags.  */
 618   emit_expr (& exp, 2);
 619
 620   /* Save label value.  */
 621   emit_expr (& exp1, 2);
 622
 623   while (ops--)
 624     {
 625       /* Now get profiling info.  */
 626       halt = extract_operand (input_line_pointer, str, 1024);
 627       /* Process like ".word xxx" directive.  */
 628       parse_exp (str, & exp);
 629       emit_expr (& exp, 2);
 630       input_line_pointer = halt;
 631     }
 632
 633   /* Fill the rest with zeros.  */
 634   exp.X_op = O_constant;
 635   exp.X_add_number = 0;
 636   while (left--)
 637     emit_expr (& exp, 2);
 638
 639   /* Return to current section.  */
 640   subseg_set (seg, subseg);
 641 }
 642
 643 static char *
 644 extract_word (char * from, char * to, int limit)
 645 {
 646   char *op_end;
 647   int size = 0;
 648
 649   /* Drop leading whitespace.  */
 650   from = skip_space (from);
 651   *to = 0;
 652
 653   /* Find the op code end.  */
 654   for (op_end = from; *op_end != 0 && is_part_of_name (*op_end);)
 655     {
 656       to[size++] = *op_end++;
 657       if (size + 1 >= limit)
 658         break;
 659     }
 660
 661   to[size] = 0;
 662   return op_end;
 663 }
 664
 665 #define OPTION_MMCU 'm'
 666 #define OPTION_RELAX 'Q'
 667 #define OPTION_POLYMORPHS 'P'
 668 #define OPTION_LARGE 'l'
 669 static bfd_boolean large_model = FALSE;
 670 #define OPTION_NO_INTR_NOPS 'N'
 671 #define OPTION_INTR_NOPS 'n'
 672 static bfd_boolean gen_interrupt_nops = FALSE;
 673 #define OPTION_WARN_INTR_NOPS 'y'
 674 #define OPTION_NO_WARN_INTR_NOPS 'Y'
 675 static bfd_boolean warn_interrupt_nops = TRUE;
 676 #define OPTION_MCPU 'c'
 677 #define OPTION_MOVE_DATA 'd'
 678 static bfd_boolean move_data = FALSE;
 679
 680 enum
 681 {
 682   OPTION_SILICON_ERRATA = OPTION_MD_BASE,
 683   OPTION_SILICON_ERRATA_WARN,
 684 };
 685
 686 static unsigned int silicon_errata_fix = 0;
 687 static unsigned int silicon_errata_warn = 0;
 688 #define SILICON_ERRATA_CPU4             (1 << 0)
 689 #define SILICON_ERRATA_CPU8             (1 << 1)
 690 #define SILICON_ERRATA_CPU11            (1 << 2)
 691 #define SILICON_ERRATA_CPU12            (1 << 3)
 692 #define SILICON_ERRATA_CPU13            (1 << 4)
 693 #define SILICON_ERRATA_CPU19            (1 << 5)
 694
 695 static void
 696 msp430_set_arch (int option)
 697 {
 698   char str[32]; /* 32 for good measure.  */
 699
 700   input_line_pointer = extract_word (input_line_pointer, str, 32);
 701
 702   md_parse_option (option, str);
 703   bfd_set_arch_mach (stdoutput, TARGET_ARCH,
 704                      target_is_430x () ? bfd_mach_msp430x : bfd_mach_msp11);
 705 }
 706
 707 /* This is a copy of the same data structure found in gcc/config/msp430/msp430.c
 708    Keep these two structures in sync.
 709    The data in this structure has been extracted from version 1.194 of the
 710    devices.csv file released by TI in September 2016.  */
 711
 712 struct msp430_mcu_data
 713 {
 714   const char * name;
 715   unsigned int revision; /* 0=> MSP430, 1=>MSP430X, 2=> MSP430Xv2.  */
 716   unsigned int hwmpy;    /* 0=>none, 1=>16-bit, 2=>16-bit w/sign extend, 4=>32-bit, 8=> 32-bit (5xx).  */
 717 }
 718 msp430_mcu_data [] =
 719 {
 720   { "cc430f5123",2,8 },
 721   { "cc430f5125",2,8 },
 722   { "cc430f5133",2,8 },
 723   { "cc430f5135",2,8 },
 724   { "cc430f5137",2,8 },
 725   { "cc430f5143",2,8 },
 726   { "cc430f5145",2,8 },
 727   { "cc430f5147",2,8 },
 728   { "cc430f6125",2,8 },
 729   { "cc430f6126",2,8 },
 730   { "cc430f6127",2,8 },
 731   { "cc430f6135",2,8 },
 732   { "cc430f6137",2,8 },
 733   { "cc430f6143",2,8 },
 734   { "cc430f6145",2,8 },
 735   { "cc430f6147",2,8 },
 736   { "msp430afe221",0,2 },
 737   { "msp430afe222",0,2 },
 738   { "msp430afe223",0,2 },
 739   { "msp430afe231",0,2 },
 740   { "msp430afe232",0,2 },
 741   { "msp430afe233",0,2 },
 742   { "msp430afe251",0,2 },
 743   { "msp430afe252",0,2 },
 744   { "msp430afe253",0,2 },
 745   { "msp430bt5190",2,8 },
 746   { "msp430c091",0,0 },
 747   { "msp430c092",0,0 },
 748   { "msp430c111",0,0 },
 749   { "msp430c1111",0,0 },
 750   { "msp430c112",0,0 },
 751   { "msp430c1121",0,0 },
 752   { "msp430c1331",0,0 },
 753   { "msp430c1351",0,0 },
 754   { "msp430c311s",0,0 },
 755   { "msp430c312",0,0 },
 756   { "msp430c313",0,0 },
 757   { "msp430c314",0,0 },
 758   { "msp430c315",0,0 },
 759   { "msp430c323",0,0 },
 760   { "msp430c325",0,0 },
 761   { "msp430c336",0,1 },
 762   { "msp430c337",0,1 },
 763   { "msp430c412",0,0 },
 764   { "msp430c413",0,0 },
 765   { "msp430cg4616",1,1 },
 766   { "msp430cg4617",1,1 },
 767   { "msp430cg4618",1,1 },
 768   { "msp430cg4619",1,1 },
 769   { "msp430e112",0,0 },
 770   { "msp430e313",0,0 },
 771   { "msp430e315",0,0 },
 772   { "msp430e325",0,0 },
 773   { "msp430e337",0,1 },
 774   { "msp430f110",0,0 },
 775   { "msp430f1101",0,0 },
 776   { "msp430f1101a",0,0 },
 777   { "msp430f1111",0,0 },
 778   { "msp430f1111a",0,0 },
 779   { "msp430f112",0,0 },
 780   { "msp430f1121",0,0 },
 781   { "msp430f1121a",0,0 },
 782   { "msp430f1122",0,0 },
 783   { "msp430f1132",0,0 },
 784   { "msp430f122",0,0 },
 785   { "msp430f1222",0,0 },
 786   { "msp430f123",0,0 },
 787   { "msp430f1232",0,0 },
 788   { "msp430f133",0,0 },
 789   { "msp430f135",0,0 },
 790   { "msp430f147",0,1 },
 791   { "msp430f1471",0,1 },
 792   { "msp430f148",0,1 },
 793   { "msp430f1481",0,1 },
 794   { "msp430f149",0,1 },
 795   { "msp430f1491",0,1 },
 796   { "msp430f155",0,0 },
 797   { "msp430f156",0,0 },
 798   { "msp430f157",0,0 },
 799   { "msp430f1610",0,1 },
 800   { "msp430f1611",0,1 },
 801   { "msp430f1612",0,1 },
 802   { "msp430f167",0,1 },
 803   { "msp430f168",0,1 },
 804   { "msp430f169",0,1 },
 805   { "msp430f2001",0,0 },
 806   { "msp430f2002",0,0 },
 807   { "msp430f2003",0,0 },
 808   { "msp430f2011",0,0 },
 809   { "msp430f2012",0,0 },
 810   { "msp430f2013",0,0 },
 811   { "msp430f2101",0,0 },
 812   { "msp430f2111",0,0 },
 813   { "msp430f2112",0,0 },
 814   { "msp430f2121",0,0 },
 815   { "msp430f2122",0,0 },
 816   { "msp430f2131",0,0 },
 817   { "msp430f2132",0,0 },
 818   { "msp430f2232",0,0 },
 819   { "msp430f2234",0,0 },
 820   { "msp430f2252",0,0 },
 821   { "msp430f2254",0,0 },
 822   { "msp430f2272",0,0 },
 823   { "msp430f2274",0,0 },
 824   { "msp430f233",0,2 },
 825   { "msp430f2330",0,2 },
 826   { "msp430f235",0,2 },
 827   { "msp430f2350",0,2 },
 828   { "msp430f2370",0,2 },
 829   { "msp430f2410",0,2 },
 830   { "msp430f2416",1,2 },
 831   { "msp430f2417",1,2 },
 832   { "msp430f2418",1,2 },
 833   { "msp430f2419",1,2 },
 834   { "msp430f247",0,2 },
 835   { "msp430f2471",0,2 },
 836   { "msp430f248",0,2 },
 837   { "msp430f2481",0,2 },
 838   { "msp430f249",0,2 },
 839   { "msp430f2491",0,2 },
 840   { "msp430f2616",1,2 },
 841   { "msp430f2617",1,2 },
 842   { "msp430f2618",1,2 },
 843   { "msp430f2619",1,2 },
 844   { "msp430f412",0,0 },
 845   { "msp430f413",0,0 },
 846   { "msp430f4132",0,0 },
 847   { "msp430f415",0,0 },
 848   { "msp430f4152",0,0 },
 849   { "msp430f417",0,0 },
 850   { "msp430f423",0,1 },
 851   { "msp430f423a",0,1 },
 852   { "msp430f425",0,1 },
 853   { "msp430f4250",0,0 },
 854   { "msp430f425a",0,1 },
 855   { "msp430f4260",0,0 },
 856   { "msp430f427",0,1 },
 857   { "msp430f4270",0,0 },
 858   { "msp430f427a",0,1 },
 859   { "msp430f435",0,0 },
 860   { "msp430f4351",0,0 },
 861   { "msp430f436",0,0 },
 862   { "msp430f4361",0,0 },
 863   { "msp430f437",0,0 },
 864   { "msp430f4371",0,0 },
 865   { "msp430f438",0,0 },
 866   { "msp430f439",0,0 },
 867   { "msp430f447",0,1 },
 868   { "msp430f448",0,1 },
 869   { "msp430f4481",0,1 },
 870   { "msp430f449",0,1 },
 871   { "msp430f4491",0,1 },
 872   { "msp430f4616",1,1 },
 873   { "msp430f46161",1,1 },
 874   { "msp430f4617",1,1 },
 875   { "msp430f46171",1,1 },
 876   { "msp430f4618",1,1 },
 877   { "msp430f46181",1,1 },
 878   { "msp430f4619",1,1 },
 879   { "msp430f46191",1,1 },
 880   { "msp430f47126",1,4 },
 881   { "msp430f47127",1,4 },
 882   { "msp430f47163",1,4 },
 883   { "msp430f47166",1,4 },
 884   { "msp430f47167",1,4 },
 885   { "msp430f47173",1,4 },
 886   { "msp430f47176",1,4 },
 887   { "msp430f47177",1,4 },
 888   { "msp430f47183",1,4 },
 889   { "msp430f47186",1,4 },
 890   { "msp430f47187",1,4 },
 891   { "msp430f47193",1,4 },
 892   { "msp430f47196",1,4 },
 893   { "msp430f47197",1,4 },
 894   { "msp430f477",0,0 },
 895   { "msp430f478",0,0 },
 896   { "msp430f4783",0,4 },
 897   { "msp430f4784",0,4 },
 898   { "msp430f479",0,0 },
 899   { "msp430f4793",0,4 },
 900   { "msp430f4794",0,4 },
 901   { "msp430f5131",2,8 },
 902   { "msp430f5132",2,8 },
 903   { "msp430f5151",2,8 },
 904   { "msp430f5152",2,8 },
 905   { "msp430f5171",2,8 },
 906   { "msp430f5172",2,8 },
 907   { "msp430f5212",2,8 },
 908   { "msp430f5213",2,8 },
 909   { "msp430f5214",2,8 },
 910   { "msp430f5217",2,8 },
 911   { "msp430f5218",2,8 },
 912   { "msp430f5219",2,8 },
 913   { "msp430f5222",2,8 },
 914   { "msp430f5223",2,8 },
 915   { "msp430f5224",2,8 },
 916   { "msp430f5227",2,8 },
 917   { "msp430f5228",2,8 },
 918   { "msp430f5229",2,8 },
 919   { "msp430f5232",2,8 },
 920   { "msp430f5234",2,8 },
 921   { "msp430f5237",2,8 },
 922   { "msp430f5239",2,8 },
 923   { "msp430f5242",2,8 },
 924   { "msp430f5244",2,8 },
 925   { "msp430f5247",2,8 },
 926   { "msp430f5249",2,8 },
 927   { "msp430f5252",2,8 },
 928   { "msp430f5253",2,8 },
 929   { "msp430f5254",2,8 },
 930   { "msp430f5255",2,8 },
 931   { "msp430f5256",2,8 },
 932   { "msp430f5257",2,8 },
 933   { "msp430f5258",2,8 },
 934   { "msp430f5259",2,8 },
 935   { "msp430f5304",2,8 },
 936   { "msp430f5308",2,8 },
 937   { "msp430f5309",2,8 },
 938   { "msp430f5310",2,8 },
 939   { "msp430f5324",2,8 },
 940   { "msp430f5325",2,8 },
 941   { "msp430f5326",2,8 },
 942   { "msp430f5327",2,8 },
 943   { "msp430f5328",2,8 },
 944   { "msp430f5329",2,8 },
 945   { "msp430f5333",2,8 },
 946   { "msp430f5335",2,8 },
 947   { "msp430f5336",2,8 },
 948   { "msp430f5338",2,8 },
 949   { "msp430f5340",2,8 },
 950   { "msp430f5341",2,8 },
 951   { "msp430f5342",2,8 },
 952   { "msp430f5358",2,8 },
 953   { "msp430f5359",2,8 },
 954   { "msp430f5418",2,8 },
 955   { "msp430f5418a",2,8 },
 956   { "msp430f5419",2,8 },
 957   { "msp430f5419a",2,8 },
 958   { "msp430f5435",2,8 },
 959   { "msp430f5435a",2,8 },
 960   { "msp430f5436",2,8 },
 961   { "msp430f5436a",2,8 },
 962   { "msp430f5437",2,8 },
 963   { "msp430f5437a",2,8 },
 964   { "msp430f5438",2,8 },
 965   { "msp430f5438a",2,8 },
 966   { "msp430f5500",2,8 },
 967   { "msp430f5501",2,8 },
 968   { "msp430f5502",2,8 },
 969   { "msp430f5503",2,8 },
 970   { "msp430f5504",2,8 },
 971   { "msp430f5505",2,8 },
 972   { "msp430f5506",2,8 },
 973   { "msp430f5507",2,8 },
 974   { "msp430f5508",2,8 },
 975   { "msp430f5509",2,8 },
 976   { "msp430f5510",2,8 },
 977   { "msp430f5513",2,8 },
 978   { "msp430f5514",2,8 },
 979   { "msp430f5515",2,8 },
 980   { "msp430f5517",2,8 },
 981   { "msp430f5519",2,8 },
 982   { "msp430f5521",2,8 },
 983   { "msp430f5522",2,8 },
 984   { "msp430f5524",2,8 },
 985   { "msp430f5525",2,8 },
 986   { "msp430f5526",2,8 },
 987   { "msp430f5527",2,8 },
 988   { "msp430f5528",2,8 },
 989   { "msp430f5529",2,8 },
 990   { "msp430f5630",2,8 },
 991   { "msp430f5631",2,8 },
 992   { "msp430f5632",2,8 },
 993   { "msp430f5633",2,8 },
 994   { "msp430f5634",2,8 },
 995   { "msp430f5635",2,8 },
 996   { "msp430f5636",2,8 },
 997   { "msp430f5637",2,8 },
 998   { "msp430f5638",2,8 },
 999   { "msp430f5658",2,8 },
1000   { "msp430f5659",2,8 },
1001   { "msp430f5xx_6xxgeneric",2,8 },
1002   { "msp430f6433",2,8 },
1003   { "msp430f6435",2,8 },
1004   { "msp430f6436",2,8 },
1005   { "msp430f6438",2,8 },
1006   { "msp430f6458",2,8 },
1007   { "msp430f6459",2,8 },
1008   { "msp430f6630",2,8 },
1009   { "msp430f6631",2,8 },
1010   { "msp430f6632",2,8 },
1011   { "msp430f6633",2,8 },
1012   { "msp430f6634",2,8 },
1013   { "msp430f6635",2,8 },
1014   { "msp430f6636",2,8 },
1015   { "msp430f6637",2,8 },
1016   { "msp430f6638",2,8 },
1017   { "msp430f6658",2,8 },
1018   { "msp430f6659",2,8 },
1019   { "msp430f6720",2,8 },
1020   { "msp430f6720a",2,8 },
1021   { "msp430f6721",2,8 },
1022   { "msp430f6721a",2,8 },
1023   { "msp430f6723",2,8 },
1024   { "msp430f6723a",2,8 },
1025   { "msp430f6724",2,8 },
1026   { "msp430f6724a",2,8 },
1027   { "msp430f6725",2,8 },
1028   { "msp430f6725a",2,8 },
1029   { "msp430f6726",2,8 },
1030   { "msp430f6726a",2,8 },
1031   { "msp430f6730",2,8 },
1032   { "msp430f6730a",2,8 },
1033   { "msp430f6731",2,8 },
1034   { "msp430f6731a",2,8 },
1035   { "msp430f6733",2,8 },
1036   { "msp430f6733a",2,8 },
1037   { "msp430f6734",2,8 },
1038   { "msp430f6734a",2,8 },
1039   { "msp430f6735",2,8 },
1040   { "msp430f6735a",2,8 },
1041   { "msp430f6736",2,8 },
1042   { "msp430f6736a",2,8 },
1043   { "msp430f6745",2,8 },
1044   { "msp430f67451",2,8 },
1045   { "msp430f67451a",2,8 },
1046   { "msp430f6745a",2,8 },
1047   { "msp430f6746",2,8 },
1048   { "msp430f67461",2,8 },
1049   { "msp430f67461a",2,8 },
1050   { "msp430f6746a",2,8 },
1051   { "msp430f6747",2,8 },
1052   { "msp430f67471",2,8 },
1053   { "msp430f67471a",2,8 },
1054   { "msp430f6747a",2,8 },
1055   { "msp430f6748",2,8 },
1056   { "msp430f67481",2,8 },
1057   { "msp430f67481a",2,8 },
1058   { "msp430f6748a",2,8 },
1059   { "msp430f6749",2,8 },
1060   { "msp430f67491",2,8 },
1061   { "msp430f67491a",2,8 },
1062   { "msp430f6749a",2,8 },
1063   { "msp430f67621",2,8 },
1064   { "msp430f67621a",2,8 },
1065   { "msp430f67641",2,8 },
1066   { "msp430f67641a",2,8 },
1067   { "msp430f6765",2,8 },
1068   { "msp430f67651",2,8 },
1069   { "msp430f67651a",2,8 },
1070   { "msp430f6765a",2,8 },
1071   { "msp430f6766",2,8 },
1072   { "msp430f67661",2,8 },
1073   { "msp430f67661a",2,8 },
1074   { "msp430f6766a",2,8 },
1075   { "msp430f6767",2,8 },
1076   { "msp430f67671",2,8 },
1077   { "msp430f67671a",2,8 },
1078   { "msp430f6767a",2,8 },
1079   { "msp430f6768",2,8 },
1080   { "msp430f67681",2,8 },
1081   { "msp430f67681a",2,8 },
1082   { "msp430f6768a",2,8 },
1083   { "msp430f6769",2,8 },
1084   { "msp430f67691",2,8 },
1085   { "msp430f67691a",2,8 },
1086   { "msp430f6769a",2,8 },
1087   { "msp430f6775",2,8 },
1088   { "msp430f67751",2,8 },
1089   { "msp430f67751a",2,8 },
1090   { "msp430f6775a",2,8 },
1091   { "msp430f6776",2,8 },
1092   { "msp430f67761",2,8 },
1093   { "msp430f67761a",2,8 },
1094   { "msp430f6776a",2,8 },
1095   { "msp430f6777",2,8 },
1096   { "msp430f67771",2,8 },
1097   { "msp430f67771a",2,8 },
1098   { "msp430f6777a",2,8 },
1099   { "msp430f6778",2,8 },
1100   { "msp430f67781",2,8 },
1101   { "msp430f67781a",2,8 },
1102   { "msp430f6778a",2,8 },
1103   { "msp430f6779",2,8 },
1104   { "msp430f67791",2,8 },
1105   { "msp430f67791a",2,8 },
1106   { "msp430f6779a",2,8 },
1107   { "msp430fe423",0,0 },
1108   { "msp430fe4232",0,0 },
1109   { "msp430fe423a",0,0 },
1110   { "msp430fe4242",0,0 },
1111   { "msp430fe425",0,0 },
1112   { "msp430fe4252",0,0 },
1113   { "msp430fe425a",0,0 },
1114   { "msp430fe427",0,0 },
1115   { "msp430fe4272",0,0 },
1116   { "msp430fe427a",0,0 },
1117   { "msp430fg4250",0,0 },
1118   { "msp430fg4260",0,0 },
1119   { "msp430fg4270",0,0 },
1120   { "msp430fg437",0,0 },
1121   { "msp430fg438",0,0 },
1122   { "msp430fg439",0,0 },
1123   { "msp430fg4616",1,1 },
1124   { "msp430fg4617",1,1 },
1125   { "msp430fg4618",1,1 },
1126   { "msp430fg4619",1,1 },
1127   { "msp430fg477",0,0 },
1128   { "msp430fg478",0,0 },
1129   { "msp430fg479",0,0 },
1130   { "msp430fg6425",2,8 },
1131   { "msp430fg6426",2,8 },
1132   { "msp430fg6625",2,8 },
1133   { "msp430fg6626",2,8 },
1134   { "msp430fr2032",2,0 },
1135   { "msp430fr2033",2,0 },
1136   { "msp430fr2110",2,0 },
1137   { "msp430fr2111",2,0 },
1138   { "msp430fr2310",2,0 },
1139   { "msp430fr2311",2,0 },
1140   { "msp430fr2433",2,8 },
1141   { "msp430fr2532",2,8 },
1142   { "msp430fr2533",2,8 },
1143   { "msp430fr2632",2,8 },
1144   { "msp430fr2633",2,8 },
1145   { "msp430fr2xx_4xxgeneric",2,8 },
1146   { "msp430fr4131",2,0 },
1147   { "msp430fr4132",2,0 },
1148   { "msp430fr4133",2,0 },
1149   { "msp430fr5720",2,8 },
1150   { "msp430fr5721",2,8 },
1151   { "msp430fr5722",2,8 },
1152   { "msp430fr5723",2,8 },
1153   { "msp430fr5724",2,8 },
1154   { "msp430fr5725",2,8 },
1155   { "msp430fr5726",2,8 },
1156   { "msp430fr5727",2,8 },
1157   { "msp430fr5728",2,8 },
1158   { "msp430fr5729",2,8 },
1159   { "msp430fr5730",2,8 },
1160   { "msp430fr5731",2,8 },
1161   { "msp430fr5732",2,8 },
1162   { "msp430fr5733",2,8 },
1163   { "msp430fr5734",2,8 },
1164   { "msp430fr5735",2,8 },
1165   { "msp430fr5736",2,8 },
1166   { "msp430fr5737",2,8 },
1167   { "msp430fr5738",2,8 },
1168   { "msp430fr5739",2,8 },
1169   { "msp430fr57xxgeneric",2,8 },
1170   { "msp430fr5847",2,8 },
1171   { "msp430fr58471",2,8 },
1172   { "msp430fr5848",2,8 },
1173   { "msp430fr5849",2,8 },
1174   { "msp430fr5857",2,8 },
1175   { "msp430fr5858",2,8 },
1176   { "msp430fr5859",2,8 },
1177   { "msp430fr5867",2,8 },
1178   { "msp430fr58671",2,8 },
1179   { "msp430fr5868",2,8 },
1180   { "msp430fr5869",2,8 },
1181   { "msp430fr5870",2,8 },
1182   { "msp430fr5872",2,8 },
1183   { "msp430fr58721",2,8 },
1184   { "msp430fr5887",2,8 },
1185   { "msp430fr5888",2,8 },
1186   { "msp430fr5889",2,8 },
1187   { "msp430fr58891",2,8 },
1188   { "msp430fr5922",2,8 },
1189   { "msp430fr59221",2,8 },
1190   { "msp430fr5947",2,8 },
1191   { "msp430fr59471",2,8 },
1192   { "msp430fr5948",2,8 },
1193   { "msp430fr5949",2,8 },
1194   { "msp430fr5957",2,8 },
1195   { "msp430fr5958",2,8 },
1196   { "msp430fr5959",2,8 },
1197   { "msp430fr5962",2,8 },
1198   { "msp430fr5964",2,8 },
1199   { "msp430fr5967",2,8 },
1200   { "msp430fr5968",2,8 },
1201   { "msp430fr5969",2,8 },
1202   { "msp430fr59691",2,8 },
1203   { "msp430fr5970",2,8 },
1204   { "msp430fr5972",2,8 },
1205   { "msp430fr59721",2,8 },
1206   { "msp430fr5986",2,8 },
1207   { "msp430fr5987",2,8 },
1208   { "msp430fr5988",2,8 },
1209   { "msp430fr5989",2,8 },
1210   { "msp430fr59891",2,8 },
1211   { "msp430fr5992",2,8 },
1212   { "msp430fr5994",2,8 },
1213   { "msp430fr59941",2,8 },
1214   { "msp430fr5xx_6xxgeneric",2,8 },
1215   { "msp430fr6820",2,8 },
1216   { "msp430fr6822",2,8 },
1217   { "msp430fr68221",2,8 },
1218   { "msp430fr6870",2,8 },
1219   { "msp430fr6872",2,8 },
1220   { "msp430fr68721",2,8 },
1221   { "msp430fr6877",2,8 },
1222   { "msp430fr6879",2,8 },
1223   { "msp430fr68791",2,8 },
1224   { "msp430fr6887",2,8 },
1225   { "msp430fr6888",2,8 },
1226   { "msp430fr6889",2,8 },
1227   { "msp430fr68891",2,8 },
1228   { "msp430fr6920",2,8 },
1229   { "msp430fr6922",2,8 },
1230   { "msp430fr69221",2,8 },
1231   { "msp430fr6927",2,8 },
1232   { "msp430fr69271",2,8 },
1233   { "msp430fr6928",2,8 },
1234   { "msp430fr6970",2,8 },
1235   { "msp430fr6972",2,8 },
1236   { "msp430fr69721",2,8 },
1237   { "msp430fr6977",2,8 },
1238   { "msp430fr6979",2,8 },
1239   { "msp430fr69791",2,8 },
1240   { "msp430fr6987",2,8 },
1241   { "msp430fr6988",2,8 },
1242   { "msp430fr6989",2,8 },
1243   { "msp430fr69891",2,8 },
1244   { "msp430fw423",0,0 },
1245   { "msp430fw425",0,0 },
1246   { "msp430fw427",0,0 },
1247   { "msp430fw428",0,0 },
1248   { "msp430fw429",0,0 },
1249   { "msp430g2001",0,0 },
1250   { "msp430g2101",0,0 },
1251   { "msp430g2102",0,0 },
1252   { "msp430g2111",0,0 },
1253   { "msp430g2112",0,0 },
1254   { "msp430g2113",0,0 },
1255   { "msp430g2121",0,0 },
1256   { "msp430g2131",0,0 },
1257   { "msp430g2132",0,0 },
1258   { "msp430g2152",0,0 },
1259   { "msp430g2153",0,0 },
1260   { "msp430g2201",0,0 },
1261   { "msp430g2202",0,0 },
1262   { "msp430g2203",0,0 },
1263   { "msp430g2210",0,0 },
1264   { "msp430g2211",0,0 },
1265   { "msp430g2212",0,0 },
1266   { "msp430g2213",0,0 },
1267   { "msp430g2221",0,0 },
1268   { "msp430g2230",0,0 },
1269   { "msp430g2231",0,0 },
1270   { "msp430g2232",0,0 },
1271   { "msp430g2233",0,0 },
1272   { "msp430g2252",0,0 },
1273   { "msp430g2253",0,0 },
1274   { "msp430g2302",0,0 },
1275   { "msp430g2303",0,0 },
1276   { "msp430g2312",0,0 },
1277   { "msp430g2313",0,0 },
1278   { "msp430g2332",0,0 },
1279   { "msp430g2333",0,0 },
1280   { "msp430g2352",0,0 },
1281   { "msp430g2353",0,0 },
1282   { "msp430g2402",0,0 },
1283   { "msp430g2403",0,0 },
1284   { "msp430g2412",0,0 },
1285   { "msp430g2413",0,0 },
1286   { "msp430g2432",0,0 },
1287   { "msp430g2433",0,0 },
1288   { "msp430g2444",0,0 },
1289   { "msp430g2452",0,0 },
1290   { "msp430g2453",0,0 },
1291   { "msp430g2513",0,0 },
1292   { "msp430g2533",0,0 },
1293   { "msp430g2544",0,0 },
1294   { "msp430g2553",0,0 },
1295   { "msp430g2744",0,0 },
1296   { "msp430g2755",0,0 },
1297   { "msp430g2855",0,0 },
1298   { "msp430g2955",0,0 },
1299   { "msp430i2020",0,2 },
1300   { "msp430i2021",0,2 },
1301   { "msp430i2030",0,2 },
1302   { "msp430i2031",0,2 },
1303   { "msp430i2040",0,2 },
1304   { "msp430i2041",0,2 },
1305   { "msp430i2xxgeneric",0,2 },
1306   { "msp430l092",0,0 },
1307   { "msp430p112",0,0 },
1308   { "msp430p313",0,0 },
1309   { "msp430p315",0,0 },
1310   { "msp430p315s",0,0 },
1311   { "msp430p325",0,0 },
1312   { "msp430p337",0,1 },
1313   { "msp430sl5438a",2,8 },
1314   { "msp430tch5e",0,0 },
1315   { "msp430xgeneric",2,8 },
1316   { "rf430f5144",2,8 },
1317   { "rf430f5155",2,8 },
1318   { "rf430f5175",2,8 },
1319   { "rf430frl152h",0,0 },
1320   { "rf430frl152h_rom",0,0 },
1321   { "rf430frl153h",0,0 },
1322   { "rf430frl153h_rom",0,0 },
1323   { "rf430frl154h",0,0 },
1324   { "rf430frl154h_rom",0,0 }
1325 };
1326
1327 int
1328 md_parse_option (int c, const char * arg)
1329 {
1330   switch (c)
1331     {
1332     case OPTION_SILICON_ERRATA:
1333     case OPTION_SILICON_ERRATA_WARN:
1334       {
1335         signed int i;
1336         const struct
1337         {
1338           const char *       name;
1339           unsigned int length;
1340           unsigned int bitfield;
1341         } erratas[] =
1342         {
1343           { STRING_COMMA_LEN ("cpu4"), SILICON_ERRATA_CPU4 },
1344           { STRING_COMMA_LEN ("cpu8"), SILICON_ERRATA_CPU8 },
1345           { STRING_COMMA_LEN ("cpu11"), SILICON_ERRATA_CPU11 },
1346           { STRING_COMMA_LEN ("cpu12"), SILICON_ERRATA_CPU12 },
1347           { STRING_COMMA_LEN ("cpu13"), SILICON_ERRATA_CPU13 },
1348           { STRING_COMMA_LEN ("cpu19"), SILICON_ERRATA_CPU19 },
1349         };
1350
1351         do
1352           {
1353             for (i = ARRAY_SIZE (erratas); i--;)
1354               if (strncasecmp (arg, erratas[i].name, erratas[i].length) == 0)
1355                 {
1356                   if (c == OPTION_SILICON_ERRATA)
1357                     silicon_errata_fix |= erratas[i].bitfield;
1358                   else
1359                     silicon_errata_warn |= erratas[i].bitfield;
1360                   arg += erratas[i].length;
1361                   break;
1362                 }
1363             if (i < 0)
1364               {
1365                 as_warn (_("Unrecognised CPU errata name starting here: %s"), arg);
1366                 break;
1367               }
1368             if (*arg == 0)
1369               break;
1370             if (*arg != ',')
1371               as_warn (_("Expecting comma after CPU errata name, not: %s"), arg);
1372             else
1373               arg ++;
1374           }
1375         while (*arg != 0);
1376       }
1377       return 1;
1378
1379     case OPTION_MMCU:
1380       if (arg == NULL)
1381         as_fatal (_("MCU option requires a name\n"));
1382
1383       if (strcasecmp ("msp430", arg) == 0)
1384         selected_isa = MSP_ISA_430;
1385       else if (strcasecmp ("msp430xv2", arg) == 0)
1386         selected_isa = MSP_ISA_430Xv2;
1387       else if (strcasecmp ("msp430x", arg) == 0)
1388         selected_isa = MSP_ISA_430X;
1389       else
1390         {
1391           int i;
1392
1393           for (i = ARRAY_SIZE (msp430_mcu_data); i--;)
1394             if (strcasecmp (msp430_mcu_data[i].name, arg) == 0)
1395               {
1396                 switch (msp430_mcu_data[i].revision)
1397                   {
1398                   case 0: selected_isa = MSP_ISA_430; break;
1399                   case 1: selected_isa = MSP_ISA_430X; break;
1400                   case 2: selected_isa = MSP_ISA_430Xv2; break;
1401                   }
1402                 break;
1403             }
1404         }
1405       /* It is not an error if we do not match the MCU name.  */
1406       return 1;
1407
1408     case OPTION_MCPU:
1409       if (strcmp (arg, "430") == 0
1410           || strcasecmp (arg, "msp430") == 0)
1411         selected_isa = MSP_ISA_430;
1412       else if (strcasecmp (arg, "430x") == 0
1413                || strcasecmp (arg, "msp430x") == 0)
1414         selected_isa = MSP_ISA_430X;
1415       else if (strcasecmp (arg, "430xv2") == 0
1416                || strcasecmp (arg, "msp430xv2") == 0)
1417         selected_isa = MSP_ISA_430Xv2;
1418       else
1419         as_fatal (_("unrecognised argument to -mcpu option '%s'"), arg);
1420       return 1;
1421
1422     case OPTION_RELAX:
1423       msp430_enable_relax = 1;
1424       return 1;
1425
1426     case OPTION_POLYMORPHS:
1427       msp430_enable_polys = 1;
1428       return 1;
1429
1430     case OPTION_LARGE:
1431       large_model = TRUE;
1432       return 1;
1433
1434     case OPTION_NO_INTR_NOPS:
1435       gen_interrupt_nops = FALSE;
1436       return 1;
1437     case OPTION_INTR_NOPS:
1438       gen_interrupt_nops = TRUE;
1439       return 1;
1440
1441     case OPTION_WARN_INTR_NOPS:
1442       warn_interrupt_nops = TRUE;
1443       return 1;
1444     case OPTION_NO_WARN_INTR_NOPS:
1445       warn_interrupt_nops = FALSE;
1446       return 1;
1447
1448     case OPTION_MOVE_DATA:
1449       move_data = TRUE;
1450       return 1;
1451     }
1452
1453   return 0;
1454 }
1455
1456 /* The intention here is to have the mere presence of these sections
1457    cause the object to have a reference to a well-known symbol.  This
1458    reference pulls in the bits of the runtime (crt0) that initialize
1459    these sections.  Thus, for example, the startup code to call
1460    memset() to initialize .bss will only be linked in when there is a
1461    non-empty .bss section.  Otherwise, the call would exist but have a
1462    zero length parameter, which is a waste of memory and cycles.
1463
1464    The code which initializes these sections should have a global
1465    label for these symbols, and should be marked with KEEP() in the
1466    linker script.  */
1467
1468 static void
1469 msp430_make_init_symbols (const char * name)
1470 {
1471   if (strncmp (name, ".bss", 4) == 0
1472       || strncmp (name, ".gnu.linkonce.b.", 16) == 0)
1473     (void) symbol_find_or_make ("__crt0_init_bss");
1474
1475   if (strncmp (name, ".data", 5) == 0
1476       || strncmp (name, ".gnu.linkonce.d.", 16) == 0)
1477     (void) symbol_find_or_make ("__crt0_movedata");
1478
1479   /* Note - data assigned to the .either.data section may end up being
1480      placed in the .upper.data section if the .lower.data section is
1481      full.  Hence the need to define the crt0 symbol.  */
1482   if (strncmp (name, ".either.data", 12) == 0
1483       || strncmp (name, ".upper.data", 11) == 0)
1484     (void) symbol_find_or_make ("__crt0_move_highdata");
1485
1486   /* See note about .either.data above.  */
1487   if (strncmp (name, ".upper.bss", 10) == 0
1488       || strncmp (name, ".either.bss", 11) == 0)
1489     (void) symbol_find_or_make ("__crt0_init_highbss");
1490 }
1491
1492 static void
1493 msp430_section (int arg)
1494 {
1495   char * saved_ilp = input_line_pointer;
1496   const char * name = obj_elf_section_name ();
1497
1498   msp430_make_init_symbols (name);
1499
1500   input_line_pointer = saved_ilp;
1501   obj_elf_section (arg);
1502 }
1503
1504 void
1505 msp430_frob_section (asection *sec)
1506 {
1507   const char *name = sec->name;
1508
1509   if (sec->size == 0)
1510     return;
1511
1512   msp430_make_init_symbols (name);
1513 }
1514
1515 static void
1516 msp430_lcomm (int ignore ATTRIBUTE_UNUSED)
1517 {
1518   symbolS *symbolP = s_comm_internal (0, s_lcomm_internal);
1519
1520   if (symbolP)
1521     symbol_get_bfdsym (symbolP)->flags |= BSF_OBJECT;
1522   (void) symbol_find_or_make ("__crt0_init_bss");
1523 }
1524
1525 static void
1526 msp430_comm (int needs_align)
1527 {
1528   s_comm_internal (needs_align, elf_common_parse);
1529   (void) symbol_find_or_make ("__crt0_init_bss");
1530 }
1531
1532 static void
1533 msp430_refsym (int arg ATTRIBUTE_UNUSED)
1534 {
1535   char sym_name[1024];
1536   input_line_pointer = extract_word (input_line_pointer, sym_name, 1024);
1537
1538   (void) symbol_find_or_make (sym_name);
1539 }
1540
1541 const pseudo_typeS md_pseudo_table[] =
1542 {
1543   {"arch", msp430_set_arch, OPTION_MMCU},
1544   {"cpu", msp430_set_arch, OPTION_MCPU},
1545   {"profiler", msp430_profiler, 0},
1546   {"section", msp430_section, 0},
1547   {"section.s", msp430_section, 0},
1548   {"sect", msp430_section, 0},
1549   {"sect.s", msp430_section, 0},
1550   {"pushsection", msp430_section, 1},
1551   {"refsym", msp430_refsym, 0},
1552   {"comm", msp430_comm, 0},
1553   {"lcomm", msp430_lcomm, 0},
1554   {NULL, NULL, 0}
1555 };
1556
1557 const char *md_shortopts = "mm:,mP,mQ,ml,mN,mn,my,mY";
1558
1559 struct option md_longopts[] =
1560 {
1561   {"msilicon-errata", required_argument, NULL, OPTION_SILICON_ERRATA},
1562   {"msilicon-errata-warn", required_argument, NULL, OPTION_SILICON_ERRATA_WARN},
1563   {"mmcu", required_argument, NULL, OPTION_MMCU},
1564   {"mcpu", required_argument, NULL, OPTION_MCPU},
1565   {"mP", no_argument, NULL, OPTION_POLYMORPHS},
1566   {"mQ", no_argument, NULL, OPTION_RELAX},
1567   {"ml", no_argument, NULL, OPTION_LARGE},
1568   {"mN", no_argument, NULL, OPTION_NO_INTR_NOPS},
1569   {"mn", no_argument, NULL, OPTION_INTR_NOPS},
1570   {"mY", no_argument, NULL, OPTION_NO_WARN_INTR_NOPS},
1571   {"my", no_argument, NULL, OPTION_WARN_INTR_NOPS},
1572   {"md", no_argument, NULL, OPTION_MOVE_DATA},
1573   {NULL, no_argument, NULL, 0}
1574 };
1575
1576 size_t md_longopts_size = sizeof (md_longopts);
1577
1578 void
1579 md_show_usage (FILE * stream)
1580 {
1581   fprintf (stream,
1582            _("MSP430 options:\n"
1583              "  -mmcu=<msp430-name>     - select microcontroller type\n"
1584              "  -mcpu={430|430x|430xv2} - select microcontroller architecture\n"));
1585   fprintf (stream,
1586            _("  -msilicon-errata=<name>[,<name>...] - enable fixups for silicon errata\n"
1587              "  -msilicon-errata-warn=<name>[,<name>...] - warn when a fixup might be needed\n"
1588              "   supported errata names: cpu4, cpu8, cpu11, cpu12, cpu13, cpu19\n"));
1589   fprintf (stream,
1590            _("  -mQ - enable relaxation at assembly time. DANGEROUS!\n"
1591              "  -mP - enable polymorph instructions\n"));
1592   fprintf (stream,
1593            _("  -ml - enable large code model\n"));
1594   fprintf (stream,
1595            _("  -mN - do not insert NOPs after changing interrupts (default)\n"));
1596   fprintf (stream,
1597            _("  -mn - insert a NOP after changing interrupts\n"));
1598   fprintf (stream,
1599            _("  -mY - do not warn about missing NOPs after changing interrupts\n"));
1600   fprintf (stream,
1601            _("  -my - warn about missing NOPs after changing interrupts (default)\n"));
1602   fprintf (stream,
1603            _("  -md - Force copying of data from ROM to RAM at startup\n"));
1604 }
1605
1606 symbolS *
1607 md_undefined_symbol (char * name ATTRIBUTE_UNUSED)
1608 {
1609   return NULL;
1610 }
1611
1612 static char *
1613 extract_cmd (char * from, char * to, int limit)
1614 {
1615   int size = 0;
1616
1617   while (*from && ! ISSPACE (*from) && *from != '.' && limit > size)
1618     {
1619       *(to + size) = *from;
1620       from++;
1621       size++;
1622     }
1623
1624   *(to + size) = 0;
1625
1626   return from;
1627 }
1628
1629 const char *
1630 md_atof (int type, char * litP, int * sizeP)
1631 {
1632   return ieee_md_atof (type, litP, sizeP, FALSE);
1633 }
1634
1635 void
1636 md_begin (void)
1637 {
1638   struct msp430_opcode_s * opcode;
1639   msp430_hash = hash_new ();
1640
1641   for (opcode = msp430_opcodes; opcode->name; opcode++)
1642     hash_insert (msp430_hash, opcode->name, (char *) opcode);
1643
1644   bfd_set_arch_mach (stdoutput, TARGET_ARCH,
1645                      target_is_430x () ? bfd_mach_msp430x : bfd_mach_msp11);
1646
1647   /*  Set linkrelax here to avoid fixups in most sections.  */
1648   linkrelax = 1;
1649 }
1650
1651 /* Returns the register number equivalent to the string T.
1652    Returns -1 if there is no such register.
1653    Skips a leading 'r' or 'R' character if there is one.
1654    Handles the register aliases PC and SP.  */
1655
1656 static signed int
1657 check_reg (char * t)
1658 {
1659   signed int val;
1660
1661   if (t == NULL)
1662     return -1;
1663
1664   if (*t == 'r' || *t == 'R')
1665     ++t;
1666
1667   if (strncasecmp (t, "pc", 2) == 0)
1668     return 0;
1669
1670   if (strncasecmp (t, "sp", 2) == 0)
1671     return 1;
1672
1673   if (strncasecmp (t, "sr", 2) == 0)
1674     return 2;
1675
1676   if (*t == '0')
1677     return 0;
1678
1679   val = atoi (t);
1680
1681   if (val < 1 || val > 15)
1682     return -1;
1683
1684   return val;
1685 }
1686
1687 static int
1688 msp430_srcoperand (struct msp430_operand_s * op,
1689                    char * l,
1690                    int bin,
1691                    bfd_boolean * imm_op,
1692                    bfd_boolean allow_20bit_values,
1693                    bfd_boolean constants_allowed)
1694 {
1695   char *__tl = l;
1696
1697   /* Check if an immediate #VALUE.  The hash sign should be only at the beginning!  */
1698   if (*l == '#')
1699     {
1700       char *h = l;
1701       int vshift = -1;
1702       int rval = 0;
1703
1704       /* Check if there is:
1705          llo(x) - least significant 16 bits, x &= 0xffff
1706          lhi(x) - x = (x >> 16) & 0xffff,
1707          hlo(x) - x = (x >> 32) & 0xffff,
1708          hhi(x) - x = (x >> 48) & 0xffff
1709          The value _MUST_ be constant expression: #hlo(1231231231).  */
1710
1711       *imm_op = TRUE;
1712
1713       if (strncasecmp (h, "#llo(", 5) == 0)
1714         {
1715           vshift = 0;
1716           rval = 3;
1717         }
1718       else if (strncasecmp (h, "#lhi(", 5) == 0)
1719         {
1720           vshift = 1;
1721           rval = 3;
1722         }
1723       else if (strncasecmp (h, "#hlo(", 5) == 0)
1724         {
1725           vshift = 2;
1726           rval = 3;
1727         }
1728       else if (strncasecmp (h, "#hhi(", 5) == 0)
1729         {
1730           vshift = 3;
1731           rval = 3;
1732         }
1733       else if (strncasecmp (h, "#lo(", 4) == 0)
1734         {
1735           vshift = 0;
1736           rval = 2;
1737         }
1738       else if (strncasecmp (h, "#hi(", 4) == 0)
1739         {
1740           vshift = 1;
1741           rval = 2;
1742         }
1743
1744       op->reg = 0;              /* Reg PC.  */
1745       op->am = 3;
1746       op->ol = 1;               /* Immediate will follow an instruction.  */
1747       __tl = h + 1 + rval;
1748       op->mode = OP_EXP;
1749       op->vshift = vshift;
1750
1751       parse_exp (__tl, &(op->exp));
1752       if (op->exp.X_op == O_constant)
1753         {
1754           int x = op->exp.X_add_number;
1755
1756           if (vshift == 0)
1757             {
1758               x = x & 0xffff;
1759               op->exp.X_add_number = x;
1760             }
1761           else if (vshift == 1)
1762             {
1763               x = (x >> 16) & 0xffff;
1764               op->exp.X_add_number = x;
1765               op->vshift = 0;
1766             }
1767           else if (vshift > 1)
1768             {
1769               if (x < 0)
1770                 op->exp.X_add_number = -1;
1771               else
1772                 op->exp.X_add_number = 0;       /* Nothing left.  */
1773               x = op->exp.X_add_number;
1774               op->vshift = 0;
1775             }
1776
1777           if (allow_20bit_values)
1778             {
1779               if (op->exp.X_add_number > 0xfffff || op->exp.X_add_number < -524288)
1780                 {
1781                   as_bad (_("value 0x%x out of extended range."), x);
1782                   return 1;
1783                 }
1784             }
1785           else if (op->exp.X_add_number > 65535 || op->exp.X_add_number < -32768)
1786             {
1787               as_bad (_("value %d out of range. Use #lo() or #hi()"), x);
1788               return 1;
1789             }
1790
1791           /* Now check constants.  */
1792           /* Substitute register mode with a constant generator if applicable.  */
1793
1794           if (!allow_20bit_values)
1795             x = (short) x;      /* Extend sign.  */
1796
1797           if (! constants_allowed)
1798             ;
1799           else if (x == 0)
1800             {
1801               op->reg = 3;
1802               op->am = 0;
1803               op->ol = 0;
1804               op->mode = OP_REG;
1805             }
1806           else if (x == 1)
1807             {
1808               op->reg = 3;
1809               op->am = 1;
1810               op->ol = 0;
1811               op->mode = OP_REG;
1812             }
1813           else if (x == 2)
1814             {
1815               op->reg = 3;
1816               op->am = 2;
1817               op->ol = 0;
1818               op->mode = OP_REG;
1819             }
1820           else if (x == -1)
1821             {
1822               op->reg = 3;
1823               op->am = 3;
1824               op->ol = 0;
1825               op->mode = OP_REG;
1826             }
1827           else if (x == 4)
1828             {
1829               if (bin == 0x1200 && ! target_is_430x ())
1830                 {
1831                   /* CPU4: The shorter form of PUSH #4 is not supported on MSP430.  */
1832                   if (silicon_errata_warn & SILICON_ERRATA_CPU4)
1833                     as_warn (_("cpu4: not converting PUSH #4 to shorter form"));
1834                   /* No need to check silicon_errata_fixes - this fix is always implemented.  */
1835                 }
1836               else
1837                 {
1838                   op->reg = 2;
1839                   op->am = 2;
1840                   op->ol = 0;
1841                   op->mode = OP_REG;
1842                 }
1843             }
1844           else if (x == 8)
1845             {
1846               if (bin == 0x1200 && ! target_is_430x ())
1847                 {
1848                   /* CPU4: The shorter form of PUSH #8 is not supported on MSP430.  */
1849                   if (silicon_errata_warn & SILICON_ERRATA_CPU4)
1850                     as_warn (_("cpu4: not converting PUSH #8 to shorter form"));
1851                 }
1852               else
1853                 {
1854                   op->reg = 2;
1855                   op->am = 3;
1856                   op->ol = 0;
1857                   op->mode = OP_REG;
1858                 }
1859             }
1860         }
1861       else if (op->exp.X_op == O_symbol)
1862         {
1863           if (vshift > 1)
1864             as_bad (_("error: unsupported #foo() directive used on symbol"));
1865           op->mode = OP_EXP;
1866         }
1867       else if (op->exp.X_op == O_big)
1868         {
1869           short x;
1870
1871           if (vshift != -1)
1872             {
1873               op->exp.X_op = O_constant;
1874               op->exp.X_add_number = 0xffff & generic_bignum[vshift];
1875               x = op->exp.X_add_number;
1876               op->vshift = 0;
1877             }
1878           else
1879             {
1880               as_bad (_
1881                       ("unknown expression in operand %s.  Use #llo(), #lhi(), #hlo() or #hhi()"),
1882                       l);
1883               return 1;
1884             }
1885
1886           if (x == 0)
1887             {
1888               op->reg = 3;
1889               op->am = 0;
1890               op->ol = 0;
1891               op->mode = OP_REG;
1892             }
1893           else if (x == 1)
1894             {
1895               op->reg = 3;
1896               op->am = 1;
1897               op->ol = 0;
1898               op->mode = OP_REG;
1899             }
1900           else if (x == 2)
1901             {
1902               op->reg = 3;
1903               op->am = 2;
1904               op->ol = 0;
1905               op->mode = OP_REG;
1906             }
1907           else if (x == -1)
1908             {
1909               op->reg = 3;
1910               op->am = 3;
1911               op->ol = 0;
1912               op->mode = OP_REG;
1913             }
1914           else if (x == 4)
1915             {
1916               op->reg = 2;
1917               op->am = 2;
1918               op->ol = 0;
1919               op->mode = OP_REG;
1920             }
1921           else if (x == 8)
1922             {
1923               op->reg = 2;
1924               op->am = 3;
1925               op->ol = 0;
1926               op->mode = OP_REG;
1927             }
1928         }
1929       /* Redundant (yet) check.  */
1930       else if (op->exp.X_op == O_register)
1931         as_bad
1932           (_("Registers cannot be used within immediate expression [%s]"), l);
1933       else
1934         as_bad (_("unknown operand %s"), l);
1935
1936       return 0;
1937     }
1938
1939   /* Check if absolute &VALUE (assume that we can construct something like ((a&b)<<7 + 25).  */
1940   if (*l == '&')
1941     {
1942       char *h = l;
1943
1944       op->reg = 2;              /* reg 2 in absolute addr mode.  */
1945       op->am = 1;               /* mode As == 01 bin.  */
1946       op->ol = 1;               /* Immediate value followed by instruction.  */
1947       __tl = h + 1;
1948       parse_exp (__tl, &(op->exp));
1949       op->mode = OP_EXP;
1950       op->vshift = 0;
1951       if (op->exp.X_op == O_constant)
1952         {
1953           int x = op->exp.X_add_number;
1954
1955           if (allow_20bit_values)
1956             {
1957               if (x > 0xfffff || x < -(0x7ffff))
1958                 {
1959                   as_bad (_("value 0x%x out of extended range."), x);
1960                   return 1;
1961                 }
1962             }
1963           else if (x > 65535 || x < -32768)
1964             {
1965               as_bad (_("value out of range: 0x%x"), x);
1966               return 1;
1967             }
1968         }
1969       else if (op->exp.X_op == O_symbol)
1970         ;
1971       else
1972         {
1973           /* Redundant (yet) check.  */
1974           if (op->exp.X_op == O_register)
1975             as_bad
1976               (_("Registers cannot be used within absolute expression [%s]"), l);
1977           else
1978             as_bad (_("unknown expression in operand %s"), l);
1979           return 1;
1980         }
1981       return 0;
1982     }
1983
1984   /* Check if indirect register mode @Rn / postincrement @Rn+.  */
1985   if (*l == '@')
1986     {
1987       char *t = l;
1988       char *m = strchr (l, '+');
1989
1990       if (t != l)
1991         {
1992           as_bad (_("unknown addressing mode %s"), l);
1993           return 1;
1994         }
1995
1996       t++;
1997
1998       if ((op->reg = check_reg (t)) == -1)
1999         {
2000           as_bad (_("Bad register name %s"), t);
2001           return 1;
2002         }
2003
2004       op->mode = OP_REG;
2005       op->am = m ? 3 : 2;
2006       op->ol = 0;
2007
2008       /* PC cannot be used in indirect addressing.  */
2009       if (target_is_430xv2 () && op->reg == 0)
2010         {
2011           as_bad (_("cannot use indirect addressing with the PC"));
2012           return 1;
2013         }
2014
2015       return 0;
2016     }
2017
2018   /* Check if register indexed X(Rn).  */
2019   do
2020     {
2021       char *h = strrchr (l, '(');
2022       char *m = strrchr (l, ')');
2023       char *t;
2024
2025       *imm_op = TRUE;
2026
2027       if (!h)
2028         break;
2029       if (!m)
2030         {
2031           as_bad (_("')' required"));
2032           return 1;
2033         }
2034
2035       t = h;
2036       op->am = 1;
2037       op->ol = 1;
2038
2039       /* Extract a register.  */
2040       if ((op->reg = check_reg (t + 1)) == -1)
2041         {
2042           as_bad (_
2043                   ("unknown operator %s. Did you mean X(Rn) or #[hl][hl][oi](CONST) ?"),
2044                   l);
2045           return 1;
2046         }
2047
2048       if (op->reg == 2)
2049         {
2050           as_bad (_("r2 should not be used in indexed addressing mode"));
2051           return 1;
2052         }
2053
2054       /* Extract constant.  */
2055       __tl = l;
2056       *h = 0;
2057       op->mode = OP_EXP;
2058       op->vshift = 0;
2059       parse_exp (__tl, &(op->exp));
2060       if (op->exp.X_op == O_constant)
2061         {
2062           int x = op->exp.X_add_number;
2063
2064           if (allow_20bit_values)
2065             {
2066               if (x > 0xfffff || x < - (0x7ffff))
2067                 {
2068                   as_bad (_("value 0x%x out of extended range."), x);
2069                   return 1;
2070                 }
2071             }
2072           else if (x > 65535 || x < -32768)
2073             {
2074               as_bad (_("value out of range: 0x%x"), x);
2075               return 1;
2076             }
2077
2078           if (x == 0)
2079             {
2080               op->mode = OP_REG;
2081               op->am = 2;
2082               op->ol = 0;
2083               return 0;
2084             }
2085
2086           if (op->reg == 1 && (x & 1))
2087             {
2088               if (silicon_errata_fix & SILICON_ERRATA_CPU8)
2089                 as_bad (_("CPU8: Stack pointer accessed with an odd offset"));
2090               else if (silicon_errata_warn & SILICON_ERRATA_CPU8)
2091                 as_warn (_("CPU8: Stack pointer accessed with an odd offset"));
2092             }
2093         }
2094       else if (op->exp.X_op == O_symbol)
2095         ;
2096       else
2097         {
2098           /* Redundant (yet) check.  */
2099           if (op->exp.X_op == O_register)
2100             as_bad
2101               (_("Registers cannot be used as a prefix of indexed expression [%s]"), l);
2102           else
2103             as_bad (_("unknown expression in operand %s"), l);
2104           return 1;
2105         }
2106
2107       return 0;
2108     }
2109   while (0);
2110
2111   /* Possibly register mode 'mov r1,r2'.  */
2112   if ((op->reg = check_reg (l)) != -1)
2113     {
2114       op->mode = OP_REG;
2115       op->am = 0;
2116       op->ol = 0;
2117       return 0;
2118     }
2119
2120   /* Symbolic mode 'mov a, b' == 'mov x(pc), y(pc)'.  */
2121   do
2122     {
2123       op->mode = OP_EXP;
2124       op->reg = 0;              /* PC relative... be careful.  */
2125       /* An expression starting with a minus sign is a constant, not an address.  */
2126       op->am = (*l == '-' ? 3 : 1);
2127       op->ol = 1;
2128       op->vshift = 0;
2129       __tl = l;
2130       parse_exp (__tl, &(op->exp));
2131       return 0;
2132     }
2133   while (0);
2134
2135   /* Unreachable.  */
2136   as_bad (_("unknown addressing mode for operand %s"), l);
2137   return 1;
2138 }
2139
2140
2141 static int
2142 msp430_dstoperand (struct msp430_operand_s * op,
2143                    char * l,
2144                    int bin,
2145                    bfd_boolean allow_20bit_values,
2146                    bfd_boolean constants_allowed)
2147 {
2148   int dummy;
2149   int ret = msp430_srcoperand (op, l, bin, & dummy,
2150                                allow_20bit_values,
2151                                constants_allowed);
2152
2153   if (ret)
2154     return ret;
2155
2156   if (op->am == 2)
2157     {
2158       char *__tl = (char *) "0";
2159
2160       op->mode = OP_EXP;
2161       op->am = 1;
2162       op->ol = 1;
2163       op->vshift = 0;
2164       parse_exp (__tl, &(op->exp));
2165
2166       if (op->exp.X_op != O_constant || op->exp.X_add_number != 0)
2167         {
2168           as_bad (_("Internal bug. Try to use 0(r%d) instead of @r%d"),
2169                   op->reg, op->reg);
2170           return 1;
2171         }
2172       return 0;
2173     }
2174
2175   if (op->am > 1)
2176     {
2177       as_bad (_
2178               ("this addressing mode is not applicable for destination operand"));
2179       return 1;
2180     }
2181   return 0;
2182 }
2183
2184 /* Attempt to encode a MOVA instruction with the given operands.
2185    Returns the length of the encoded instruction if successful
2186    or 0 upon failure.  If the encoding fails, an error message
2187    will be returned if a pointer is provided.  */
2188
2189 static int
2190 try_encode_mova (bfd_boolean imm_op,
2191                  int bin,
2192                  struct msp430_operand_s * op1,
2193                  struct msp430_operand_s * op2,
2194                  const char ** error_message_return)
2195 {
2196   short ZEROS = 0;
2197   char *frag;
2198   int where;
2199
2200   /* Only a restricted subset of the normal MSP430 addressing modes
2201      are supported here, so check for the ones that are allowed.  */
2202   if (imm_op)
2203     {
2204       if (op1->mode == OP_EXP)
2205         {
2206           if (op2->mode != OP_REG)
2207             {
2208               if (error_message_return != NULL)
2209                 * error_message_return = _("expected register as second argument of %s");
2210               return 0;
2211             }
2212
2213           if (op1->am == 3)
2214             {
2215               /* MOVA #imm20, Rdst.  */
2216               bin |= 0x80 | op2->reg;
2217               frag = frag_more (4);
2218               where = frag - frag_now->fr_literal;
2219               if (op1->exp.X_op == O_constant)
2220                 {
2221                   bin |= ((op1->exp.X_add_number >> 16) & 0xf) << 8;
2222                   bfd_putl16 ((bfd_vma) bin, frag);
2223                   bfd_putl16 (op1->exp.X_add_number & 0xffff, frag + 2);
2224                 }
2225               else
2226                 {
2227                   bfd_putl16 ((bfd_vma) bin, frag);
2228                   fix_new_exp (frag_now, where, 4, &(op1->exp), FALSE,
2229                                BFD_RELOC_MSP430X_ABS20_ADR_SRC);
2230                   bfd_putl16 ((bfd_vma) ZEROS, frag + 2);
2231                 }
2232
2233               return 4;
2234             }
2235           else if (op1->am == 1)
2236             {
2237               /* MOVA z16(Rsrc), Rdst.  */
2238               bin |= 0x30 | (op1->reg << 8) | op2->reg;
2239               frag = frag_more (4);
2240               where = frag - frag_now->fr_literal;
2241               bfd_putl16 ((bfd_vma) bin, frag);
2242               if (op1->exp.X_op == O_constant)
2243                 {
2244                   if (op1->exp.X_add_number > 0xffff
2245                       || op1->exp.X_add_number < -(0x7fff))
2246                     {
2247                       if (error_message_return != NULL)
2248                         * error_message_return = _("index value too big for %s");
2249                       return 0;
2250                     }
2251                   bfd_putl16 (op1->exp.X_add_number & 0xffff, frag + 2);
2252                 }
2253               else
2254                 {
2255                   bfd_putl16 ((bfd_vma) ZEROS, frag + 2);
2256                   fix_new_exp (frag_now, where + 2, 2, &(op1->exp), FALSE,
2257                                op1->reg == 0 ?
2258                                BFD_RELOC_MSP430X_PCR16 :
2259                                BFD_RELOC_MSP430X_ABS16);
2260                 }
2261               return 4;
2262             }
2263
2264           if (error_message_return != NULL)
2265             * error_message_return = _("unexpected addressing mode for %s");
2266           return 0;
2267         }
2268       else if (op1->am == 0)
2269         {
2270           /* MOVA Rsrc, ... */
2271           if (op2->mode == OP_REG)
2272             {
2273               bin |= 0xc0 | (op1->reg << 8) | op2->reg;
2274               frag = frag_more (2);
2275               where = frag - frag_now->fr_literal;
2276               bfd_putl16 ((bfd_vma) bin, frag);
2277               return 2;
2278             }
2279           else if (op2->am == 1)
2280             {
2281               if (op2->reg == 2)
2282                 {
2283                   /* MOVA Rsrc, &abs20.  */
2284                   bin |= 0x60 | (op1->reg << 8);
2285                   frag = frag_more (4);
2286                   where = frag - frag_now->fr_literal;
2287                   if (op2->exp.X_op == O_constant)
2288                     {
2289                       bin |= (op2->exp.X_add_number >> 16) & 0xf;
2290                       bfd_putl16 ((bfd_vma) bin, frag);
2291                       bfd_putl16 (op2->exp.X_add_number & 0xffff, frag + 2);
2292                     }
2293                   else
2294                     {
2295                       bfd_putl16 ((bfd_vma) bin, frag);
2296                       bfd_putl16 ((bfd_vma) ZEROS, frag + 2);
2297                       fix_new_exp (frag_now, where, 4, &(op2->exp), FALSE,
2298                                    BFD_RELOC_MSP430X_ABS20_ADR_DST);
2299                     }
2300                   return 4;
2301                 }
2302
2303               /* MOVA Rsrc, z16(Rdst).  */
2304               bin |= 0x70 | (op1->reg << 8) | op2->reg;
2305               frag = frag_more (4);
2306               where = frag - frag_now->fr_literal;
2307               bfd_putl16 ((bfd_vma) bin, frag);
2308               if (op2->exp.X_op == O_constant)
2309                 {
2310                   if (op2->exp.X_add_number > 0xffff
2311                       || op2->exp.X_add_number < -(0x7fff))
2312                     {
2313                       if (error_message_return != NULL)
2314                         * error_message_return = _("index value too big for %s");
2315                       return 0;
2316                     }
2317                   bfd_putl16 (op2->exp.X_add_number & 0xffff, frag + 2);
2318                 }
2319               else
2320                 {
2321                   bfd_putl16 ((bfd_vma) ZEROS, frag + 2);
2322                   fix_new_exp (frag_now, where + 2, 2, &(op2->exp), FALSE,
2323                                op2->reg == 0 ?
2324                                BFD_RELOC_MSP430X_PCR16 :
2325                                BFD_RELOC_MSP430X_ABS16);
2326                 }
2327               return 4;
2328             }
2329
2330           if (error_message_return != NULL)
2331             * error_message_return = _("unexpected addressing mode for %s");
2332           return 0;
2333         }
2334     }
2335
2336   /* imm_op == FALSE.  */
2337
2338   if (op1->reg == 2 && op1->am == 1 && op1->mode == OP_EXP)
2339     {
2340       /* MOVA &abs20, Rdst.  */
2341       if (op2->mode != OP_REG)
2342         {
2343           if (error_message_return != NULL)
2344             * error_message_return = _("expected register as second argument of %s");
2345           return 0;
2346         }
2347
2348       if (op2->reg == 2 || op2->reg == 3)
2349         {
2350           if (error_message_return != NULL)
2351             * error_message_return = _("constant generator destination register found in %s");
2352           return 0;
2353         }
2354
2355       bin |= 0x20 | op2->reg;
2356       frag = frag_more (4);
2357       where = frag - frag_now->fr_literal;
2358       if (op1->exp.X_op == O_constant)
2359         {
2360           bin |= ((op1->exp.X_add_number >> 16) & 0xf) << 8;
2361           bfd_putl16 ((bfd_vma) bin, frag);
2362           bfd_putl16 (op1->exp.X_add_number & 0xffff, frag + 2);
2363         }
2364       else
2365         {
2366           bfd_putl16 ((bfd_vma) bin, frag);
2367           bfd_putl16 ((bfd_vma) ZEROS, frag + 2);
2368           fix_new_exp (frag_now, where, 4, &(op1->exp), FALSE,
2369                        BFD_RELOC_MSP430X_ABS20_ADR_SRC);
2370         }
2371       return 4;
2372     }
2373   else if (op1->mode == OP_REG)
2374     {
2375       if (op1->am == 3)
2376         {
2377           /* MOVA @Rsrc+, Rdst.  */
2378           if (op2->mode != OP_REG)
2379             {
2380               if (error_message_return != NULL)
2381                 * error_message_return = _("expected register as second argument of %s");
2382               return 0;
2383             }
2384
2385           if (op2->reg == 2 || op2->reg == 3)
2386             {
2387               if (error_message_return != NULL)
2388                 * error_message_return = _("constant generator destination register found in %s");
2389               return 0;
2390             }
2391
2392           if (op1->reg == 2 || op1->reg == 3)
2393             {
2394               if (error_message_return != NULL)
2395                 * error_message_return = _("constant generator source register found in %s");
2396               return 0;
2397             }
2398
2399           bin |= 0x10 | (op1->reg << 8) | op2->reg;
2400           frag = frag_more (2);
2401           where = frag - frag_now->fr_literal;
2402           bfd_putl16 ((bfd_vma) bin, frag);
2403           return 2;
2404         }
2405       else if (op1->am == 2)
2406         {
2407           /* MOVA @Rsrc,Rdst */
2408           if (op2->mode != OP_REG)
2409             {
2410               if (error_message_return != NULL)
2411                 * error_message_return = _("expected register as second argument of %s");
2412               return 0;
2413             }
2414
2415           if (op2->reg == 2 || op2->reg == 3)
2416             {
2417               if (error_message_return != NULL)
2418                 * error_message_return = _("constant generator destination register found in %s");
2419               return 0;
2420             }
2421
2422           if (op1->reg == 2 || op1->reg == 3)
2423             {
2424               if (error_message_return != NULL)
2425                 * error_message_return = _("constant generator source register found in %s");
2426               return 0;
2427             }
2428
2429           bin |= (op1->reg << 8) | op2->reg;
2430           frag = frag_more (2);
2431           where = frag - frag_now->fr_literal;
2432           bfd_putl16 ((bfd_vma) bin, frag);
2433           return 2;
2434         }
2435     }
2436
2437   if (error_message_return != NULL)
2438     * error_message_return = _("unexpected addressing mode for %s");
2439
2440   return 0;
2441 }
2442
2443 #define NOP_CHECK_INTERRUPT  (1 << 0)
2444 #define NOP_CHECK_CPU12      (1 << 1)
2445 #define NOP_CHECK_CPU19      (1 << 2)
2446
2447 static signed int check_for_nop = 0;
2448
2449 #define is_opcode(NAME) (strcmp (opcode->name, NAME) == 0)
2450
2451 /* Parse instruction operands.
2452    Return binary opcode.  */
2453
2454 static unsigned int
2455 msp430_operands (struct msp430_opcode_s * opcode, char * line)
2456 {
2457   int bin = opcode->bin_opcode; /* Opcode mask.  */
2458   int insn_length = 0;
2459   char l1[MAX_OP_LEN], l2[MAX_OP_LEN];
2460   char *frag;
2461   int where;
2462   struct msp430_operand_s op1, op2;
2463   int res = 0;
2464   static short ZEROS = 0;
2465   bfd_boolean byte_op, imm_op;
2466   int op_length = 0;
2467   int fmt;
2468   int extended = 0x1800;
2469   bfd_boolean extended_op = FALSE;
2470   bfd_boolean addr_op;
2471   const char * error_message;
2472   static signed int repeat_count = 0;
2473   static bfd_boolean prev_insn_is_nop = FALSE;
2474   bfd_boolean fix_emitted;
2475
2476   /* Opcode is the one from opcodes table
2477      line contains something like
2478      [.w] @r2+, 5(R1)
2479      or
2480      .b @r2+, 5(R1).  */
2481
2482   byte_op = FALSE;
2483   addr_op = FALSE;
2484   if (*line == '.')
2485     {
2486       bfd_boolean check = FALSE;
2487       ++ line;
2488
2489       switch (TOLOWER (* line))
2490         {
2491         case 'b':
2492           /* Byte operation.  */
2493           bin |= BYTE_OPERATION;
2494           byte_op = TRUE;
2495           check = TRUE;
2496           break;
2497
2498         case 'a':
2499           /* "Address" ops work on 20-bit values.  */
2500           addr_op = TRUE;
2501           bin |= BYTE_OPERATION;
2502           check = TRUE;
2503           break;
2504
2505         case 'w':
2506           /* Word operation - this is the default.  */
2507           check = TRUE;
2508           break;
2509
2510         case 0:
2511         case ' ':
2512         case '\n':
2513         case '\r':
2514           as_warn (_("no size modifier after period, .w assumed"));
2515           break;
2516
2517         default:
2518           as_bad (_("unrecognised instruction size modifier .%c"),
2519                    * line);
2520           return 0;
2521         }
2522
2523       if (check)
2524         {
2525           ++ line;
2526
2527         }
2528     }
2529
2530   if (*line && ! ISSPACE (*line))
2531     {
2532       as_bad (_("junk found after instruction: %s.%s"),
2533               opcode->name, line);
2534       return 0;
2535     }
2536
2537   /* Catch the case where the programmer has used a ".a" size modifier on an
2538      instruction that does not support it.  Look for an alternative extended
2539      instruction that has the same name without the period.  Eg: "add.a"
2540      becomes "adda".  Although this not an officially supported way of
2541      specifying instruction aliases other MSP430 assemblers allow it.  So we
2542      support it for compatibility purposes.  */
2543   if (addr_op && opcode->fmt >= 0)
2544     {
2545       const char * old_name = opcode->name;
2546       char real_name[32];
2547
2548       sprintf (real_name, "%sa", old_name);
2549       opcode = hash_find (msp430_hash, real_name);
2550       if (opcode == NULL)
2551         {
2552           as_bad (_("instruction %s.a does not exist"), old_name);
2553           return 0;
2554         }
2555 #if 0 /* Enable for debugging.  */
2556       as_warn ("treating %s.a as %s", old_name, real_name);
2557 #endif
2558       addr_op = FALSE;
2559       bin = opcode->bin_opcode;
2560     }
2561
2562   if (opcode->fmt != -1
2563       && opcode->insn_opnumb
2564       && (!*line || *line == '\n'))
2565     {
2566       as_bad (_("instruction %s requires %d operand(s)"),
2567               opcode->name, opcode->insn_opnumb);
2568       return 0;
2569     }
2570
2571   memset (l1, 0, sizeof (l1));
2572   memset (l2, 0, sizeof (l2));
2573   memset (&op1, 0, sizeof (op1));
2574   memset (&op2, 0, sizeof (op2));
2575
2576   imm_op = FALSE;
2577
2578   if ((fmt = opcode->fmt) < 0)
2579     {
2580       if (! target_is_430x ())
2581         {
2582           as_bad (_("instruction %s requires MSP430X mcu"),
2583                   opcode->name);
2584           return 0;
2585         }
2586
2587       fmt = (-fmt) - 1;
2588       extended_op = TRUE;
2589     }
2590
2591   if (repeat_count)
2592     {
2593       /* If requested set the extended instruction repeat count.  */
2594       if (extended_op)
2595         {
2596           if (repeat_count > 0)
2597             extended |= (repeat_count - 1);
2598           else
2599             extended |= (1 << 7) | (- repeat_count);
2600         }
2601       else
2602         as_bad (_("unable to repeat %s insn"), opcode->name);
2603
2604       repeat_count = 0;
2605     }
2606
2607   if (check_for_nop)
2608     {
2609       if (! is_opcode ("nop"))
2610         {
2611           bfd_boolean doit = FALSE;
2612
2613           do
2614             {
2615               switch (check_for_nop & - check_for_nop)
2616                 {
2617                 case NOP_CHECK_INTERRUPT:
2618                   if (warn_interrupt_nops)
2619                     {
2620                       if (gen_interrupt_nops)
2621                         as_warn (_("NOP inserted between two instructions that change interrupt state"));
2622                       else
2623                         as_warn (_("a NOP might be needed here because of successive changes in interrupt state"));
2624                     }
2625
2626                   if (gen_interrupt_nops)
2627                     /* Emit a NOP between interrupt enable/disable.
2628                        See 1.3.4.1 of the MSP430x5xx User Guide.  */
2629                     doit = TRUE;
2630                   break;
2631
2632                 case NOP_CHECK_CPU12:
2633                   if (silicon_errata_warn & SILICON_ERRATA_CPU12)
2634                     as_warn (_("CPU12: CMP/BIT with PC destinstion ignores next instruction"));
2635
2636                   if (silicon_errata_fix & SILICON_ERRATA_CPU12)
2637                     doit = TRUE;
2638                   break;
2639
2640                 case NOP_CHECK_CPU19:
2641                   if (silicon_errata_warn & SILICON_ERRATA_CPU19)
2642                     as_warn (_("CPU19: Instruction setting CPUOFF must be followed by a NOP"));
2643
2644                   if (silicon_errata_fix & SILICON_ERRATA_CPU19)
2645                     doit = TRUE;
2646                   break;
2647
2648                 default:
2649                   as_bad (_("internal error: unknown nop check state"));
2650                   break;
2651                 }
2652               check_for_nop &= ~ (check_for_nop & - check_for_nop);
2653             }
2654           while (check_for_nop);
2655
2656           if (doit)
2657             {
2658               frag = frag_more (2);
2659               bfd_putl16 ((bfd_vma) 0x4303 /* NOP */, frag);
2660               dwarf2_emit_insn (2);
2661             }
2662         }
2663
2664       check_for_nop = 0;
2665     }
2666
2667   switch (fmt)
2668     {
2669     case 0:                     /* Emulated.  */
2670       switch (opcode->insn_opnumb)
2671         {
2672         case 0:
2673           if (is_opcode ("eint"))
2674             {
2675               if (! prev_insn_is_nop)
2676                 {
2677                   if (gen_interrupt_nops)
2678                     {
2679                       frag = frag_more (2);
2680                       bfd_putl16 ((bfd_vma) 0x4303 /* NOP */, frag);
2681                       dwarf2_emit_insn (2);
2682
2683                       if (warn_interrupt_nops)
2684                         as_warn (_("inserting a NOP before EINT"));
2685                     }
2686                   else if (warn_interrupt_nops)
2687                     as_warn (_("a NOP might be needed before the EINT"));
2688                 }
2689             }
2690           else if (is_opcode ("dint"))
2691             check_for_nop |= NOP_CHECK_INTERRUPT;
2692
2693           /* Set/clear bits instructions.  */
2694           if (extended_op)
2695             {
2696               if (!addr_op)
2697                 extended |= BYTE_OPERATION;
2698
2699               /* Emit the extension word.  */
2700               insn_length += 2;
2701               frag = frag_more (2);
2702               bfd_putl16 (extended, frag);
2703             }
2704
2705           insn_length += 2;
2706           frag = frag_more (2);
2707           bfd_putl16 ((bfd_vma) bin, frag);
2708           dwarf2_emit_insn (insn_length);
2709           break;
2710
2711         case 1:
2712           /* Something which works with destination operand.  */
2713           line = extract_operand (line, l1, sizeof (l1));
2714           res = msp430_dstoperand (&op1, l1, opcode->bin_opcode, extended_op, TRUE);
2715           if (res)
2716             break;
2717
2718           bin |= (op1.reg | (op1.am << 7));
2719
2720           /* If the PC is the destination...  */
2721           if (op1.am == 0 && op1.reg == 0
2722               /* ... and the opcode alters the SR.  */
2723               && !(is_opcode ("bic") || is_opcode ("bis") || is_opcode ("mov")
2724                    || is_opcode ("bicx") || is_opcode ("bisx") || is_opcode ("movx")))
2725             {
2726               if (silicon_errata_fix & SILICON_ERRATA_CPU11)
2727                 as_bad (_("CPU11: PC is destinstion of SR altering instruction"));
2728               else if (silicon_errata_warn & SILICON_ERRATA_CPU11)
2729                 as_warn (_("CPU11: PC is destinstion of SR altering instruction"));
2730             }
2731
2732           /* If the status register is the destination...  */
2733           if (op1.am == 0 && op1.reg == 2
2734               /* ... and the opcode alters the SR.  */
2735               && (is_opcode ("adc") || is_opcode ("dec") || is_opcode ("decd")
2736                   || is_opcode ("inc") || is_opcode ("incd") || is_opcode ("inv")
2737                   || is_opcode ("sbc") || is_opcode ("sxt")
2738                   || is_opcode ("adcx") || is_opcode ("decx") || is_opcode ("decdx")
2739                   || is_opcode ("incx") || is_opcode ("incdx") || is_opcode ("invx")
2740                   || is_opcode ("sbcx")
2741                   ))
2742             {
2743               if (silicon_errata_fix & SILICON_ERRATA_CPU13)
2744                 as_bad (_("CPU13: SR is destinstion of SR altering instruction"));
2745               else if (silicon_errata_warn & SILICON_ERRATA_CPU13)
2746                 as_warn (_("CPU13: SR is destinstion of SR altering instruction"));
2747             }
2748
2749           if (is_opcode ("clr") && bin == 0x4302 /* CLR R2*/)
2750             check_for_nop |= NOP_CHECK_INTERRUPT;
2751
2752           /* Compute the entire instruction length, in bytes.  */
2753           op_length = (extended_op ? 2 : 0) + 2 + (op1.ol * 2);
2754           insn_length += op_length;
2755           frag = frag_more (op_length);
2756           where = frag - frag_now->fr_literal;
2757
2758           if (extended_op)
2759             {
2760               if (!addr_op)
2761                 extended |= BYTE_OPERATION;
2762
2763               if (op1.ol != 0 && ((extended & 0xf) != 0))
2764                 {
2765                   as_bad (_("repeat instruction used with non-register mode instruction"));
2766                   extended &= ~ 0xf;
2767                 }
2768
2769               if (op1.mode == OP_EXP)
2770                 {
2771                   if (op1.exp.X_op == O_constant)
2772                     extended |= ((op1.exp.X_add_number >> 16) & 0xf) << 7;
2773
2774                   else if (op1.reg || op1.am == 3)      /* Not PC relative.  */
2775                     fix_new_exp (frag_now, where, 6, &(op1.exp), FALSE,
2776                                  BFD_RELOC_MSP430X_ABS20_EXT_SRC);
2777                   else
2778                     fix_new_exp (frag_now, where, 6, &(op1.exp), FALSE,
2779                                  BFD_RELOC_MSP430X_PCR20_EXT_SRC);
2780                 }
2781
2782               /* Emit the extension word.  */
2783               bfd_putl16 (extended, frag);
2784               frag += 2;
2785               where += 2;
2786             }
2787
2788           bfd_putl16 ((bfd_vma) bin, frag);
2789           frag += 2;
2790           where += 2;
2791
2792           if (op1.mode == OP_EXP)
2793             {
2794               if (op1.exp.X_op == O_constant)
2795                 {
2796                   bfd_putl16 (op1.exp.X_add_number & 0xffff, frag);
2797                 }
2798               else
2799                 {
2800                   bfd_putl16 ((bfd_vma) ZEROS, frag);
2801
2802                   if (!extended_op)
2803                     {
2804                       if (op1.reg)
2805                         fix_new_exp (frag_now, where, 2,
2806                                      &(op1.exp), FALSE, CHECK_RELOC_MSP430 (op1));
2807                       else
2808                         fix_new_exp (frag_now, where, 2,
2809                                      &(op1.exp), TRUE, CHECK_RELOC_MSP430_PCREL);
2810                     }
2811                 }
2812             }
2813
2814           dwarf2_emit_insn (insn_length);
2815           break;
2816
2817         case 2:
2818           /* Shift instruction.  */
2819           line = extract_operand (line, l1, sizeof (l1));
2820           strncpy (l2, l1, sizeof (l2));
2821           l2[sizeof (l2) - 1] = '\0';
2822           res = msp430_srcoperand (&op1, l1, opcode->bin_opcode, &imm_op, extended_op, TRUE);
2823           res += msp430_dstoperand (&op2, l2, opcode->bin_opcode, extended_op, TRUE);
2824
2825           if (res)
2826             break;      /* An error occurred.  All warnings were done before.  */
2827
2828           insn_length = (extended_op ? 2 : 0) + 2 + (op1.ol * 2) + (op2.ol * 2);
2829           frag = frag_more (insn_length);
2830           where = frag - frag_now->fr_literal;
2831
2832           if (target_is_430xv2 ()
2833               && op1.mode == OP_REG
2834               && op1.reg == 0
2835               && (is_opcode ("rlax")
2836                   || is_opcode ("rlcx")
2837                   || is_opcode ("rla")
2838                   || is_opcode ("rlc")))
2839             {
2840               as_bad (_("%s: attempt to rotate the PC register"), opcode->name);
2841               break;
2842             }
2843
2844           /* If the status register is the destination...  */
2845           if (op1.am == 0 && op1.reg == 2
2846               /* ... and the opcode alters the SR.  */
2847               && (is_opcode ("rla") || is_opcode ("rlc")
2848                   || is_opcode ("rlax") || is_opcode ("rlcx")
2849                   ))
2850             {
2851               if (silicon_errata_fix & SILICON_ERRATA_CPU13)
2852                 as_bad (_("CPU13: SR is destinstion of SR altering instruction"));
2853               else if (silicon_errata_warn & SILICON_ERRATA_CPU13)
2854                 as_warn (_("CPU13: SR is destinstion of SR altering instruction"));
2855             }
2856
2857           if (extended_op)
2858             {
2859               if (!addr_op)
2860                 extended |= BYTE_OPERATION;
2861
2862               if ((op1.ol != 0 || op2.ol != 0) && ((extended & 0xf) != 0))
2863                 {
2864                   as_bad (_("repeat instruction used with non-register mode instruction"));
2865                   extended &= ~ 0xf;
2866                 }
2867
2868               if (op1.mode == OP_EXP)
2869                 {
2870                   if (op1.exp.X_op == O_constant)
2871                     extended |= ((op1.exp.X_add_number >> 16) & 0xf) << 7;
2872
2873                   else if (op1.reg || op1.am == 3)      /* Not PC relative.  */
2874                     fix_new_exp (frag_now, where, 6, &(op1.exp), FALSE,
2875                                  BFD_RELOC_MSP430X_ABS20_EXT_SRC);
2876                   else
2877                     fix_new_exp (frag_now, where, 6, &(op1.exp), FALSE,
2878                                  BFD_RELOC_MSP430X_PCR20_EXT_SRC);
2879                 }
2880
2881               if (op2.mode == OP_EXP)
2882                 {
2883                   if (op2.exp.X_op == O_constant)
2884                     extended |= (op2.exp.X_add_number >> 16) & 0xf;
2885
2886                   else if (op1.mode == OP_EXP)
2887                     fix_new_exp (frag_now, where, 8, &(op2.exp), FALSE,
2888                                  op2.reg ? BFD_RELOC_MSP430X_ABS20_EXT_ODST
2889                                  : BFD_RELOC_MSP430X_PCR20_EXT_ODST);
2890                   else
2891                     fix_new_exp (frag_now, where, 6, &(op2.exp), FALSE,
2892                                  op2.reg ? BFD_RELOC_MSP430X_ABS20_EXT_DST
2893                                  : BFD_RELOC_MSP430X_PCR20_EXT_DST);
2894                 }
2895
2896               /* Emit the extension word.  */
2897               bfd_putl16 (extended, frag);
2898               frag += 2;
2899               where += 2;
2900             }
2901
2902           bin |= (op2.reg | (op1.reg << 8) | (op1.am << 4) | (op2.am << 7));
2903           bfd_putl16 ((bfd_vma) bin, frag);
2904           frag += 2;
2905           where += 2;
2906
2907           if (op1.mode == OP_EXP)
2908             {
2909               if (op1.exp.X_op == O_constant)
2910                 {
2911                   bfd_putl16 (op1.exp.X_add_number & 0xffff, frag);
2912                 }
2913               else
2914                 {
2915                   bfd_putl16 ((bfd_vma) ZEROS, frag);
2916
2917                   if (!extended_op)
2918                     {
2919                       if (op1.reg || op1.am == 3)       /* Not PC relative.  */
2920                         fix_new_exp (frag_now, where, 2,
2921                                      &(op1.exp), FALSE, CHECK_RELOC_MSP430 (op1));
2922                       else
2923                         fix_new_exp (frag_now, where, 2,
2924                                      &(op1.exp), TRUE, CHECK_RELOC_MSP430_PCREL);
2925                     }
2926                 }
2927               frag += 2;
2928               where += 2;
2929             }
2930
2931           if (op2.mode == OP_EXP)
2932             {
2933               if (op2.exp.X_op == O_constant)
2934                 {
2935                   bfd_putl16 (op2.exp.X_add_number & 0xffff, frag);
2936                 }
2937               else
2938                 {
2939                   bfd_putl16 ((bfd_vma) ZEROS, frag);
2940
2941                   if (!extended_op)
2942                     {
2943                       if (op2.reg)      /* Not PC relative.  */
2944                         fix_new_exp (frag_now, where, 2,
2945                                      &(op2.exp), FALSE, CHECK_RELOC_MSP430 (op2));
2946                       else
2947                         fix_new_exp (frag_now, where, 2,
2948                                      &(op2.exp), TRUE, CHECK_RELOC_MSP430_PCREL);
2949                     }
2950                 }
2951             }
2952
2953           dwarf2_emit_insn (insn_length);
2954           break;
2955
2956         case 3:
2957           /* Branch instruction => mov dst, r0.  */
2958           if (extended_op)
2959             {
2960               as_bad ("Internal error: state 0/3 not coded for extended instructions");
2961               break;
2962             }
2963
2964           line = extract_operand (line, l1, sizeof (l1));
2965           res = msp430_srcoperand (&op1, l1, opcode->bin_opcode, &imm_op, extended_op, FALSE);
2966           if (res)
2967             break;
2968
2969           byte_op = FALSE;
2970           imm_op = FALSE;
2971           bin |= ((op1.reg << 8) | (op1.am << 4));
2972           op_length = 2 + 2 * op1.ol;
2973           frag = frag_more (op_length);
2974           where = frag - frag_now->fr_literal;
2975           bfd_putl16 ((bfd_vma) bin, frag);
2976
2977           if (op1.mode == OP_EXP)
2978             {
2979               if (op1.exp.X_op == O_constant)
2980                 {
2981                   bfd_putl16 (op1.exp.X_add_number & 0xffff, frag + 2);
2982                 }
2983               else
2984                 {
2985                   where += 2;
2986
2987                   bfd_putl16 ((bfd_vma) ZEROS, frag + 2);
2988
2989                   if (op1.reg || op1.am == 3)
2990                     fix_new_exp (frag_now, where, 2,
2991                                  &(op1.exp), FALSE, CHECK_RELOC_MSP430 (op1));
2992                   else
2993                     fix_new_exp (frag_now, where, 2,
2994                                  &(op1.exp), TRUE, CHECK_RELOC_MSP430_PCREL);
2995                 }
2996             }
2997
2998           dwarf2_emit_insn (insn_length + op_length);
2999           break;
3000
3001         case 4:
3002           /* CALLA instructions.  */
3003           fix_emitted = FALSE;
3004
3005           line = extract_operand (line, l1, sizeof (l1));
3006           imm_op = FALSE;
3007
3008           res = msp430_srcoperand (&op1, l1, opcode->bin_opcode, &imm_op,
3009                                    extended_op, FALSE);
3010           if (res)
3011             break;
3012
3013           byte_op = FALSE;
3014
3015           op_length = 2 + 2 * op1.ol;
3016           frag = frag_more (op_length);
3017           where = frag - frag_now->fr_literal;
3018
3019           if (imm_op)
3020             {
3021               if (op1.am == 3)
3022                 {
3023                   bin |= 0xb0;
3024
3025                   fix_new_exp (frag_now, where, 4, &(op1.exp), FALSE,
3026                                BFD_RELOC_MSP430X_ABS20_ADR_DST);
3027                   fix_emitted = TRUE;
3028                 }
3029               else if (op1.am == 1)
3030                 {
3031                   if (op1.reg == 0)
3032                     {
3033                       bin |=  0x90;
3034
3035                       fix_new_exp (frag_now, where, 4, &(op1.exp), FALSE,
3036                                    BFD_RELOC_MSP430X_PCR20_CALL);
3037                       fix_emitted = TRUE;
3038                     }
3039                   else
3040                     bin |=  0x50 | op1.reg;
3041                 }
3042               else if (op1.am == 0)
3043                 bin |= 0x40 | op1.reg;
3044             }
3045           else if (op1.am == 1)
3046             {
3047               bin |= 0x80;
3048
3049               fix_new_exp (frag_now, where, 4, &(op1.exp), FALSE,
3050                            BFD_RELOC_MSP430X_ABS20_ADR_DST);
3051               fix_emitted = TRUE;
3052             }
3053           else if (op1.am == 2)
3054             bin |= 0x60 | op1.reg;
3055           else if (op1.am == 3)
3056             bin |= 0x70 | op1.reg;
3057
3058           bfd_putl16 ((bfd_vma) bin, frag);
3059
3060           if (op1.mode == OP_EXP)
3061             {
3062               if (op1.ol != 1)
3063                 {
3064                   as_bad ("Internal error: unexpected CALLA instruction length: %d\n", op1.ol);
3065                   break;
3066                 }
3067
3068               bfd_putl16 ((bfd_vma) ZEROS, frag + 2);
3069
3070               if (! fix_emitted)
3071                 fix_new_exp (frag_now, where + 2, 2,
3072                              &(op1.exp), FALSE, BFD_RELOC_16);
3073             }
3074
3075           dwarf2_emit_insn (insn_length + op_length);
3076           break;
3077
3078         case 5:
3079           {
3080             int n;
3081             int reg;
3082
3083             /* [POP|PUSH]M[.A] #N, Rd */
3084             line = extract_operand (line, l1, sizeof (l1));
3085             line = extract_operand (line, l2, sizeof (l2));
3086
3087             if (*l1 != '#')
3088               {
3089                 as_bad (_("expected #n as first argument of %s"), opcode->name);
3090                 break;
3091               }
3092             parse_exp (l1 + 1, &(op1.exp));
3093             if (op1.exp.X_op != O_constant)
3094               {
3095                 as_bad (_("expected constant expression as first argument of %s"),
3096                         opcode->name);
3097                 break;
3098               }
3099
3100             if ((reg = check_reg (l2)) == -1)
3101               {
3102                 as_bad (_("expected register as second argument of %s"),
3103                         opcode->name);
3104                 break;
3105               }
3106
3107             op_length = 2;
3108             frag = frag_more (op_length);
3109             where = frag - frag_now->fr_literal;
3110             bin = opcode->bin_opcode;
3111             if (! addr_op)
3112               bin |= 0x100;
3113             n = op1.exp.X_add_number;
3114             bin |= (n - 1) << 4;
3115             if (is_opcode ("pushm"))
3116               bin |= reg;
3117             else
3118               {
3119                 if (reg - n + 1 < 0)
3120                   {
3121                     as_bad (_("Too many registers popped"));
3122                     break;
3123                   }
3124
3125                 /* CPU21 errata: cannot use POPM to restore the SR register.  */
3126                 if (target_is_430xv2 ()
3127                     && (reg - n + 1 < 3)
3128                     && reg >= 2
3129                     && is_opcode ("popm"))
3130                   {
3131                     as_bad (_("Cannot use POPM to restore the SR register"));
3132                     break;
3133                   }
3134
3135                 bin |= (reg - n + 1);
3136               }
3137
3138             bfd_putl16 ((bfd_vma) bin, frag);
3139             dwarf2_emit_insn (op_length);
3140             break;
3141           }
3142
3143         case 6:
3144           {
3145             int n;
3146             int reg;
3147
3148             /* Bit rotation instructions. RRCM, RRAM, RRUM, RLAM.  */
3149             if (extended & 0xff)
3150               {
3151                 as_bad (_("repeat count cannot be used with %s"), opcode->name);
3152                 break;
3153               }
3154
3155             line = extract_operand (line, l1, sizeof (l1));
3156             line = extract_operand (line, l2, sizeof (l2));
3157
3158             if (*l1 != '#')
3159               {
3160                 as_bad (_("expected #n as first argument of %s"), opcode->name);
3161                 break;
3162               }
3163             parse_exp (l1 + 1, &(op1.exp));
3164             if (op1.exp.X_op != O_constant)
3165               {
3166                 as_bad (_("expected constant expression as first argument of %s"),
3167                         opcode->name);
3168                 break;
3169               }
3170             n = op1.exp.X_add_number;
3171             if (n > 4 || n < 1)
3172               {
3173                 as_bad (_("expected first argument of %s to be in the range 1-4"),
3174                         opcode->name);
3175                 break;
3176               }
3177
3178             if ((reg = check_reg (l2)) == -1)
3179               {
3180                 as_bad (_("expected register as second argument of %s"),
3181                         opcode->name);
3182                 break;
3183               }
3184
3185             if (target_is_430xv2 () && reg == 0)
3186               {
3187                 as_bad (_("%s: attempt to rotate the PC register"), opcode->name);
3188                 break;
3189               }
3190
3191             op_length = 2;
3192             frag = frag_more (op_length);
3193             where = frag - frag_now->fr_literal;
3194
3195             bin = opcode->bin_opcode;
3196             if (! addr_op)
3197               bin |= 0x10;
3198             bin |= (n - 1) << 10;
3199             bin |= reg;
3200
3201             bfd_putl16 ((bfd_vma) bin, frag);
3202             dwarf2_emit_insn (op_length);
3203             break;
3204           }
3205
3206         case 8:
3207           {
3208             bfd_boolean need_reloc = FALSE;
3209             int n;
3210             int reg;
3211
3212             /* ADDA, CMPA and SUBA address instructions.  */
3213             if (extended & 0xff)
3214               {
3215                 as_bad (_("repeat count cannot be used with %s"), opcode->name);
3216                 break;
3217               }
3218
3219             line = extract_operand (line, l1, sizeof (l1));
3220             line = extract_operand (line, l2, sizeof (l2));
3221
3222             bin = opcode->bin_opcode;
3223
3224             if (*l1 == '#')
3225               {
3226                 parse_exp (l1 + 1, &(op1.exp));
3227
3228                 if (op1.exp.X_op == O_constant)
3229                   {
3230                     n = op1.exp.X_add_number;
3231                     if (n > 0xfffff || n < - (0x7ffff))
3232                       {
3233                         as_bad (_("expected value of first argument of %s to fit into 20-bits"),
3234                                 opcode->name);
3235                         break;
3236                       }
3237
3238                     bin |= ((n >> 16) & 0xf) << 8;
3239                   }
3240                 else
3241                   {
3242                     n = 0;
3243                     need_reloc = TRUE;
3244                   }
3245
3246                 op_length = 4;
3247               }
3248             else
3249               {
3250                 if ((n = check_reg (l1)) == -1)
3251                   {
3252                     as_bad (_("expected register name or constant as first argument of %s"),
3253                             opcode->name);
3254                     break;
3255                   }
3256
3257                 bin |= (n << 8) | (1 << 6);
3258                 op_length = 2;
3259               }
3260
3261             if ((reg = check_reg (l2)) == -1)
3262               {
3263                 as_bad (_("expected register as second argument of %s"),
3264                         opcode->name);
3265                 break;
3266               }
3267
3268             frag = frag_more (op_length);
3269             where = frag - frag_now->fr_literal;
3270             bin |= reg;
3271             if (need_reloc)
3272               fix_new_exp (frag_now, where, 4, &(op1.exp), FALSE,
3273                            BFD_RELOC_MSP430X_ABS20_ADR_SRC);
3274
3275             bfd_putl16 ((bfd_vma) bin, frag);
3276             if (op_length == 4)
3277               bfd_putl16 ((bfd_vma) (n & 0xffff), frag + 2);
3278             dwarf2_emit_insn (op_length);
3279             break;
3280           }
3281
3282         case 9: /* MOVA, BRA, RETA.  */
3283           imm_op = FALSE;
3284           bin = opcode->bin_opcode;
3285
3286           if (is_opcode ("reta"))
3287             {
3288               /* The RETA instruction does not take any arguments.
3289                  The implicit first argument is @SP+.
3290                  The implicit second argument is PC.  */
3291               op1.mode = OP_REG;
3292               op1.am = 3;
3293               op1.reg = 1;
3294
3295               op2.mode = OP_REG;
3296               op2.reg = 0;
3297             }
3298           else
3299             {
3300               line = extract_operand (line, l1, sizeof (l1));
3301               res = msp430_srcoperand (&op1, l1, opcode->bin_opcode,
3302                                        &imm_op, extended_op, FALSE);
3303
3304               if (is_opcode ("bra"))
3305                 {
3306                   /* This is the BRA synthetic instruction.
3307                      The second argument is always PC.  */
3308                   op2.mode = OP_REG;
3309                   op2.reg = 0;
3310                 }
3311               else
3312                 {
3313                   line = extract_operand (line, l2, sizeof (l2));
3314                   res += msp430_dstoperand (&op2, l2, opcode->bin_opcode,
3315                                             extended_op, TRUE);
3316                 }
3317
3318               if (res)
3319                 break;  /* Error occurred.  All warnings were done before.  */
3320             }
3321
3322           /* Only a restricted subset of the normal MSP430 addressing modes
3323              are supported here, so check for the ones that are allowed.  */
3324           if ((op_length = try_encode_mova (imm_op, bin, & op1, & op2,
3325                                             & error_message)) == 0)
3326             {
3327               as_bad (error_message, opcode->name);
3328               break;
3329             }
3330           dwarf2_emit_insn (op_length);
3331           break;
3332
3333         case 10: /* RPT */
3334           line = extract_operand (line, l1, sizeof l1);
3335           /* The RPT instruction only accepted immediates and registers.  */
3336           if (*l1 == '#')
3337             {
3338               parse_exp (l1 + 1, &(op1.exp));
3339               if (op1.exp.X_op != O_constant)
3340                 {
3341                   as_bad (_("expected constant value as argument to RPT"));
3342                   break;
3343                 }
3344               if (op1.exp.X_add_number < 1
3345                   || op1.exp.X_add_number > (1 << 4))
3346                 {
3347                   as_bad (_("expected constant in the range 2..16"));
3348                   break;
3349                 }
3350
3351               /* We silently accept and ignore a repeat count of 1.  */
3352               if (op1.exp.X_add_number > 1)
3353                 repeat_count = op1.exp.X_add_number;
3354             }
3355           else
3356             {
3357               int reg;
3358
3359               if ((reg = check_reg (l1)) != -1)
3360                 {
3361                   if (reg == 0)
3362                     as_warn (_("PC used as an argument to RPT"));
3363                   else
3364                     repeat_count = - reg;
3365                 }
3366               else
3367                 {
3368                   as_bad (_("expected constant or register name as argument to RPT insn"));
3369                   break;
3370                 }
3371             }
3372           break;
3373
3374         default:
3375           as_bad (_("Illegal emulated instruction"));
3376           break;
3377         }
3378       break;
3379
3380     case 1:                     /* Format 1, double operand.  */
3381       line = extract_operand (line, l1, sizeof (l1));
3382       line = extract_operand (line, l2, sizeof (l2));
3383       res = msp430_srcoperand (&op1, l1, opcode->bin_opcode, &imm_op, extended_op, TRUE);
3384       res += msp430_dstoperand (&op2, l2, opcode->bin_opcode, extended_op, TRUE);
3385
3386       if (res)
3387         break;                  /* Error occurred.  All warnings were done before.  */
3388
3389       if (extended_op
3390           && is_opcode ("movx")
3391           && addr_op
3392           && msp430_enable_relax)
3393         {
3394           /* This is the MOVX.A instruction.  See if we can convert
3395              it into the MOVA instruction instead.  This saves 2 bytes.  */
3396           if ((op_length = try_encode_mova (imm_op, 0x0000, & op1, & op2,
3397                                             NULL)) != 0)
3398             {
3399               dwarf2_emit_insn (op_length);
3400               break;
3401             }
3402         }
3403
3404       bin |= (op2.reg | (op1.reg << 8) | (op1.am << 4) | (op2.am << 7));
3405
3406       /* If the PC is the destination...  */
3407       if (op2.am == 0 && op2.reg == 0
3408           /* ... and the opcode alters the SR.  */
3409           && !(is_opcode ("bic") || is_opcode ("bis") || is_opcode ("mov")
3410                || is_opcode ("bicx") || is_opcode ("bisx") || is_opcode ("movx")))
3411         {
3412           if (silicon_errata_fix & SILICON_ERRATA_CPU11)
3413             as_bad (_("CPU11: PC is destinstion of SR altering instruction"));
3414           else if (silicon_errata_warn & SILICON_ERRATA_CPU11)
3415             as_warn (_("CPU11: PC is destinstion of SR altering instruction"));
3416         }
3417
3418       /* If the status register is the destination...  */
3419       if (op2.am == 0 && op2.reg == 2
3420           /* ... and the opcode alters the SR.  */
3421           && (is_opcode ("add") || is_opcode ("addc") || is_opcode ("and")
3422               || is_opcode ("dadd") || is_opcode ("sub") || is_opcode ("subc")
3423               || is_opcode ("xor")
3424               || is_opcode ("addx") || is_opcode ("addcx") || is_opcode ("andx")
3425               || is_opcode ("daddx") || is_opcode ("subx") || is_opcode ("subcx")
3426               || is_opcode ("xorx")
3427               ))
3428         {
3429           if (silicon_errata_fix & SILICON_ERRATA_CPU13)
3430             as_bad (_("CPU13: SR is destinstion of SR altering instruction"));
3431           else if (silicon_errata_warn & SILICON_ERRATA_CPU13)
3432             as_warn (_("CPU13: SR is destinstion of SR altering instruction"));
3433         }
3434
3435       if (   (is_opcode ("bic") && bin == 0xc232)
3436           || (is_opcode ("bis") && bin == 0xd232)
3437           || (is_opcode ("mov") && op2.mode == OP_REG && op2.reg == 2))
3438         {
3439           /* Avoid false checks when a constant value is being put into the SR.  */
3440           if (op1.mode == OP_EXP
3441               && op1.exp.X_op == O_constant
3442               && (op1.exp.X_add_number & 0x8) != 0x8)
3443             ;
3444           else
3445             check_for_nop |= NOP_CHECK_INTERRUPT;
3446         }
3447
3448       if (((is_opcode ("bis") && bin == 0xd032)
3449            || (is_opcode ("mov") && bin == 0x4032)
3450            || (is_opcode ("xor") && bin == 0xe032))
3451           && op1.mode == OP_EXP
3452           && op1.exp.X_op == O_constant
3453           && (op1.exp.X_add_number & 0x10) == 0x10)
3454         check_for_nop |= NOP_CHECK_CPU19;
3455
3456       /* Compute the entire length of the instruction in bytes.  */
3457       op_length = (extended_op ? 2 : 0) /* The extension word.  */
3458         + 2                     /* The opcode */
3459         + (2 * op1.ol)          /* The first operand. */
3460         + (2 * op2.ol);         /* The second operand.  */
3461
3462       insn_length += op_length;
3463       frag = frag_more (op_length);
3464       where = frag - frag_now->fr_literal;
3465
3466       if (extended_op)
3467         {
3468           if (!addr_op)
3469             extended |= BYTE_OPERATION;
3470
3471           if ((op1.ol != 0 || op2.ol != 0) && ((extended & 0xf) != 0))
3472             {
3473               as_bad (_("repeat instruction used with non-register mode instruction"));
3474               extended &= ~ 0xf;
3475             }
3476
3477           /* If necessary, emit a reloc to update the extension word.  */
3478           if (op1.mode == OP_EXP)
3479             {
3480               if (op1.exp.X_op == O_constant)
3481                 extended |= ((op1.exp.X_add_number >> 16) & 0xf) << 7;
3482
3483               else  if (op1.reg || op1.am == 3) /* Not PC relative.  */
3484                 fix_new_exp (frag_now, where, 6, &(op1.exp), FALSE,
3485                              BFD_RELOC_MSP430X_ABS20_EXT_SRC);
3486               else
3487                 fix_new_exp (frag_now, where, 6, &(op1.exp), FALSE,
3488                              BFD_RELOC_MSP430X_PCR20_EXT_SRC);
3489             }
3490
3491           if (op2.mode == OP_EXP)
3492             {
3493               if (op2.exp.X_op == O_constant)
3494                 extended |= (op2.exp.X_add_number >> 16) & 0xf;
3495
3496               else if (op1.mode == OP_EXP)
3497                 fix_new_exp (frag_now, where, 8, &(op2.exp), FALSE,
3498                              op2.reg ? BFD_RELOC_MSP430X_ABS20_EXT_ODST
3499                              : BFD_RELOC_MSP430X_PCR20_EXT_ODST);
3500
3501               else
3502                 fix_new_exp (frag_now, where, 6, &(op2.exp), FALSE,
3503                              op2.reg ? BFD_RELOC_MSP430X_ABS20_EXT_DST
3504                              : BFD_RELOC_MSP430X_PCR20_EXT_DST);
3505             }
3506
3507           /* Emit the extension word.  */
3508           bfd_putl16 (extended, frag);
3509           where += 2;
3510           frag += 2;
3511         }
3512
3513       bfd_putl16 ((bfd_vma) bin, frag);
3514       where += 2;
3515       frag += 2;
3516
3517       if (op1.mode == OP_EXP)
3518         {
3519           if (op1.exp.X_op == O_constant)
3520             {
3521               bfd_putl16 (op1.exp.X_add_number & 0xffff, frag);
3522             }
3523           else
3524             {
3525               bfd_putl16 ((bfd_vma) ZEROS, frag);
3526
3527               if (!extended_op)
3528                 {
3529                   if (op1.reg || op1.am == 3)   /* Not PC relative.  */
3530                     fix_new_exp (frag_now, where, 2,
3531                                  &(op1.exp), FALSE, CHECK_RELOC_MSP430 (op1));
3532                   else
3533                     fix_new_exp (frag_now, where, 2,
3534                                  &(op1.exp), TRUE, CHECK_RELOC_MSP430_PCREL);
3535                 }
3536             }
3537
3538           where += 2;
3539           frag += 2;
3540         }
3541
3542       if (op2.mode == OP_EXP)
3543         {
3544           if (op2.exp.X_op == O_constant)
3545             {
3546               bfd_putl16 (op2.exp.X_add_number & 0xffff, frag);
3547             }
3548           else
3549             {
3550               bfd_putl16 ((bfd_vma) ZEROS, frag);
3551
3552               if (!extended_op)
3553                 {
3554                   if (op2.reg)          /* Not PC relative.  */
3555                     fix_new_exp (frag_now, where, 2,
3556                                  &(op2.exp), FALSE, CHECK_RELOC_MSP430 (op2));
3557                   else
3558                     fix_new_exp (frag_now, where, 2,
3559                                  &(op2.exp), TRUE, CHECK_RELOC_MSP430_PCREL);
3560                 }
3561             }
3562         }
3563
3564       dwarf2_emit_insn (insn_length);
3565
3566       /* If the PC is the destination...  */
3567       if (op2.am == 0 && op2.reg == 0
3568           /* ... but the opcode does not alter the destination.  */
3569           && (is_opcode ("cmp") || is_opcode ("bit") || is_opcode ("cmpx")))
3570         check_for_nop |= NOP_CHECK_CPU12;
3571       break;
3572
3573     case 2:                     /* Single-operand mostly instr.  */
3574       if (opcode->insn_opnumb == 0)
3575         {
3576           /* reti instruction.  */
3577           insn_length += 2;
3578           frag = frag_more (2);
3579           bfd_putl16 ((bfd_vma) bin, frag);
3580           dwarf2_emit_insn (insn_length);
3581           break;
3582         }
3583
3584       line = extract_operand (line, l1, sizeof (l1));
3585       res = msp430_srcoperand (&op1, l1, opcode->bin_opcode,
3586                                &imm_op, extended_op, TRUE);
3587       if (res)
3588         break;          /* Error in operand.  */
3589
3590       if (target_is_430xv2 ()
3591           && op1.mode == OP_REG
3592           && op1.reg == 0
3593           && (is_opcode ("rrax")
3594               || is_opcode ("rrcx")
3595               || is_opcode ("rra")
3596               || is_opcode ("rrc")))
3597         {
3598           as_bad (_("%s: attempt to rotate the PC register"), opcode->name);
3599           break;
3600         }
3601
3602       /* If the status register is the destination...  */
3603       if (op1.am == 0 && op1.reg == 2
3604           /* ... and the opcode alters the SR.  */
3605           && (is_opcode ("rra") || is_opcode ("rrc") || is_opcode ("sxt")))
3606         {
3607           if (silicon_errata_fix & SILICON_ERRATA_CPU13)
3608             as_bad (_("CPU13: SR is destinstion of SR altering instruction"));
3609           else if (silicon_errata_warn & SILICON_ERRATA_CPU13)
3610             as_warn (_("CPU13: SR is destinstion of SR altering instruction"));
3611         }
3612
3613       insn_length = (extended_op ? 2 : 0) + 2 + (op1.ol * 2);
3614       frag = frag_more (insn_length);
3615       where = frag - frag_now->fr_literal;
3616
3617       if (extended_op)
3618         {
3619           if (is_opcode ("swpbx") || is_opcode ("sxtx"))
3620             {
3621               /* These two instructions use a special
3622                  encoding of the A/L and B/W bits.  */
3623               bin &= ~ BYTE_OPERATION;
3624
3625               if (byte_op)
3626                 {
3627                   as_bad (_("%s instruction does not accept a .b suffix"),
3628                           opcode->name);
3629                   break;
3630                 }
3631               else if (! addr_op)
3632                 extended |= BYTE_OPERATION;
3633             }
3634           else if (! addr_op)
3635             extended |= BYTE_OPERATION;
3636
3637           if (is_opcode ("rrux"))
3638             extended |= IGNORE_CARRY_BIT;
3639
3640           if (op1.ol != 0 && ((extended & 0xf) != 0))
3641             {
3642               as_bad (_("repeat instruction used with non-register mode instruction"));
3643               extended &= ~ 0xf;
3644             }
3645
3646           if (op1.mode == OP_EXP)
3647             {
3648               if (op1.exp.X_op == O_constant)
3649                 extended |= ((op1.exp.X_add_number >> 16) & 0xf) << 7;
3650
3651               else if (op1.reg || op1.am == 3)  /* Not PC relative.  */
3652                 fix_new_exp (frag_now, where, 6, &(op1.exp), FALSE,
3653                              BFD_RELOC_MSP430X_ABS20_EXT_SRC);
3654               else
3655                 fix_new_exp (frag_now, where, 6, &(op1.exp), FALSE,
3656                              BFD_RELOC_MSP430X_PCR20_EXT_SRC);
3657             }
3658
3659           /* Emit the extension word.  */
3660           bfd_putl16 (extended, frag);
3661           frag += 2;
3662           where += 2;
3663         }
3664
3665       bin |= op1.reg | (op1.am << 4);
3666       bfd_putl16 ((bfd_vma) bin, frag);
3667       frag += 2;
3668       where += 2;
3669
3670       if (op1.mode == OP_EXP)
3671         {
3672           if (op1.exp.X_op == O_constant)
3673             {
3674               bfd_putl16 (op1.exp.X_add_number & 0xffff, frag);
3675             }
3676           else
3677             {
3678               bfd_putl16 ((bfd_vma) ZEROS, frag);
3679
3680               if (!extended_op)
3681                 {
3682                   if (op1.reg || op1.am == 3)   /* Not PC relative.  */
3683                     fix_new_exp (frag_now, where, 2,
3684                                  &(op1.exp), FALSE, CHECK_RELOC_MSP430 (op1));
3685                   else
3686                     fix_new_exp (frag_now, where, 2,
3687                                  &(op1.exp), TRUE, CHECK_RELOC_MSP430_PCREL);
3688                 }
3689             }
3690         }
3691
3692       dwarf2_emit_insn (insn_length);
3693       break;
3694
3695     case 3:                     /* Conditional jumps instructions.  */
3696       line = extract_operand (line, l1, sizeof (l1));
3697       /* l1 is a label.  */
3698       if (l1[0])
3699         {
3700           char *m = l1;
3701           expressionS exp;
3702
3703           if (*m == '$')
3704             m++;
3705
3706           parse_exp (m, &exp);
3707
3708           /* In order to handle something like:
3709
3710              and #0x8000, r5
3711              tst r5
3712              jz   4     ;       skip next 4 bytes
3713              inv r5
3714              inc r5
3715              nop        ;       will jump here if r5 positive or zero
3716
3717              jCOND      -n      ;assumes jump n bytes backward:
3718
3719              mov r5,r6
3720              jmp -2
3721
3722              is equal to:
3723              lab:
3724              mov r5,r6
3725              jmp lab
3726
3727              jCOND      $n      ; jump from PC in either direction.  */
3728
3729           if (exp.X_op == O_constant)
3730             {
3731               int x = exp.X_add_number;
3732
3733               if (x & 1)
3734                 {
3735                   as_warn (_("Even number required. Rounded to %d"), x + 1);
3736                   x++;
3737                 }
3738
3739               if ((*l1 == '$' && x > 0) || x < 0)
3740                 x -= 2;
3741
3742               x >>= 1;
3743
3744               if (x > 512 || x < -511)
3745                 {
3746                   as_bad (_("Wrong displacement %d"), x << 1);
3747                   break;
3748                 }
3749
3750               insn_length += 2;
3751               frag = frag_more (2);     /* Instr size is 1 word.  */
3752
3753               bin |= x & 0x3ff;
3754               bfd_putl16 ((bfd_vma) bin, frag);
3755             }
3756           else if (exp.X_op == O_symbol && *l1 != '$')
3757             {
3758               insn_length += 2;
3759               frag = frag_more (2);     /* Instr size is 1 word.  */
3760               where = frag - frag_now->fr_literal;
3761               fix_new_exp (frag_now, where, 2,
3762                            &exp, TRUE, BFD_RELOC_MSP430_10_PCREL);
3763
3764               bfd_putl16 ((bfd_vma) bin, frag);
3765             }
3766           else if (*l1 == '$')
3767             {
3768               as_bad (_("instruction requires label sans '$'"));
3769             }
3770           else
3771             as_bad (_
3772                     ("instruction requires label or value in range -511:512"));
3773           dwarf2_emit_insn (insn_length);
3774           break;
3775         }
3776       else
3777         {
3778           as_bad (_("instruction requires label"));
3779           break;
3780         }
3781       break;
3782
3783     case 4:     /* Extended jumps.  */
3784       if (!msp430_enable_polys)
3785         {
3786           as_bad (_("polymorphs are not enabled. Use -mP option to enable."));
3787           break;
3788         }
3789
3790       line = extract_operand (line, l1, sizeof (l1));
3791       if (l1[0])
3792         {
3793           char *m = l1;
3794           expressionS exp;
3795
3796           /* Ignore absolute addressing. make it PC relative anyway.  */
3797           if (*m == '#' || *m == '$')
3798             m++;
3799
3800           parse_exp (m, & exp);
3801           if (exp.X_op == O_symbol)
3802             {
3803               /* Relaxation required.  */
3804               struct rcodes_s rc = msp430_rcodes[opcode->insn_opnumb];
3805
3806               if (target_is_430x ())
3807                 rc = msp430x_rcodes[opcode->insn_opnumb];
3808
3809               /* The parameter to dwarf2_emit_insn is actually the offset to
3810                  the start of the insn from the fix piece of instruction that
3811                  was emitted.  Since next fragments may have variable size we
3812                  tie debug info to the beginning of the instruction.  */
3813               insn_length += 8;
3814               frag = frag_more (8);
3815               dwarf2_emit_insn (0);
3816               bfd_putl16 ((bfd_vma) rc.sop, frag);
3817               frag = frag_variant (rs_machine_dependent, 8, 2,
3818                                     /* Wild guess.  */
3819                                    ENCODE_RELAX (rc.lpos, STATE_BITS10),
3820                                    exp.X_add_symbol,
3821                                    0,   /* Offset is zero if jump dist less than 1K.  */
3822                                    (char *) frag);
3823               break;
3824             }
3825         }
3826
3827       as_bad (_("instruction requires label"));
3828       break;
3829
3830     case 5:     /* Emulated extended branches.  */
3831       if (!msp430_enable_polys)
3832         {
3833           as_bad (_("polymorphs are not enabled. Use -mP option to enable."));
3834           break;
3835         }
3836       line = extract_operand (line, l1, sizeof (l1));
3837       if (l1[0])
3838         {
3839           char * m = l1;
3840           expressionS exp;
3841
3842           /* Ignore absolute addressing. make it PC relative anyway.  */
3843           if (*m == '#' || *m == '$')
3844             m++;
3845
3846           parse_exp (m, & exp);
3847           if (exp.X_op == O_symbol)
3848             {
3849               /* Relaxation required.  */
3850               struct hcodes_s hc = msp430_hcodes[opcode->insn_opnumb];
3851
3852               if (target_is_430x ())
3853                 hc = msp430x_hcodes[opcode->insn_opnumb];
3854
3855               insn_length += 8;
3856               frag = frag_more (8);
3857               dwarf2_emit_insn (0);
3858               bfd_putl16 ((bfd_vma) hc.op0, frag);
3859               bfd_putl16 ((bfd_vma) hc.op1, frag+2);
3860
3861               frag = frag_variant (rs_machine_dependent, 8, 2,
3862                                    ENCODE_RELAX (STATE_EMUL_BRANCH, STATE_BITS10), /* Wild guess.  */
3863                                    exp.X_add_symbol,
3864                                    0,   /* Offset is zero if jump dist less than 1K.  */
3865                                    (char *) frag);
3866               break;
3867             }
3868         }
3869
3870       as_bad (_("instruction requires label"));
3871       break;
3872
3873     default:
3874       as_bad (_("Illegal instruction or not implemented opcode."));
3875     }
3876
3877   if (is_opcode ("nop"))
3878     prev_insn_is_nop = TRUE;
3879   else
3880     prev_insn_is_nop = FALSE;
3881
3882   input_line_pointer = line;
3883   return 0;
3884 }
3885
3886 void
3887 md_assemble (char * str)
3888 {
3889   struct msp430_opcode_s * opcode;
3890   char cmd[32];
3891   unsigned int i = 0;
3892
3893   str = skip_space (str);       /* Skip leading spaces.  */
3894   str = extract_cmd (str, cmd, sizeof (cmd) - 1);
3895
3896   while (cmd[i])
3897     {
3898       char a = TOLOWER (cmd[i]);
3899       cmd[i] = a;
3900       i++;
3901     }
3902
3903   if (!cmd[0])
3904     {
3905       as_bad (_("can't find opcode"));
3906       return;
3907     }
3908
3909   opcode = (struct msp430_opcode_s *) hash_find (msp430_hash, cmd);
3910
3911   if (opcode == NULL)
3912     {
3913       as_bad (_("unknown opcode `%s'"), cmd);
3914       return;
3915     }
3916
3917   {
3918     char *__t = input_line_pointer;
3919
3920     msp430_operands (opcode, str);
3921     input_line_pointer = __t;
3922   }
3923 }
3924
3925 /* GAS will call this function for each section at the end of the assembly,
3926    to permit the CPU backend to adjust the alignment of a section.  */
3927
3928 valueT
3929 md_section_align (asection * seg, valueT addr)
3930 {
3931   int align = bfd_get_section_alignment (stdoutput, seg);
3932
3933   return ((addr + (1 << align) - 1) & -(1 << align));
3934 }
3935
3936 /* If you define this macro, it should return the offset between the
3937    address of a PC relative fixup and the position from which the PC
3938    relative adjustment should be made.  On many processors, the base
3939    of a PC relative instruction is the next instruction, so this
3940    macro would return the length of an instruction.  */
3941
3942 long
3943 md_pcrel_from_section (fixS * fixp, segT sec)
3944 {
3945   if (fixp->fx_addsy != (symbolS *) NULL
3946       && (!S_IS_DEFINED (fixp->fx_addsy)
3947           || (S_GET_SEGMENT (fixp->fx_addsy) != sec)))
3948     return 0;
3949
3950   return fixp->fx_frag->fr_address + fixp->fx_where;
3951 }
3952
3953 /* Addition to the standard TC_FORCE_RELOCATION_LOCAL.
3954    Now it handles the situation when relocations
3955    have to be passed to linker.  */
3956 int
3957 msp430_force_relocation_local (fixS *fixp)
3958 {
3959   if (fixp->fx_r_type == BFD_RELOC_MSP430_10_PCREL)
3960     return 1;
3961   if (fixp->fx_pcrel)
3962     return 1;
3963   if (msp430_enable_polys
3964         && !msp430_enable_relax)
3965     return 1;
3966
3967   return 0;
3968 }
3969
3970
3971 /* GAS will call this for each fixup.  It should store the correct
3972    value in the object file.  */
3973 void
3974 md_apply_fix (fixS * fixp, valueT * valuep, segT seg)
3975 {
3976   unsigned char * where;
3977   unsigned long insn;
3978   long value;
3979
3980   if (fixp->fx_addsy == (symbolS *) NULL)
3981     {
3982       value = *valuep;
3983       fixp->fx_done = 1;
3984     }
3985   else if (fixp->fx_pcrel)
3986     {
3987       segT s = S_GET_SEGMENT (fixp->fx_addsy);
3988
3989       if (fixp->fx_addsy && (s == seg || s == absolute_section))
3990         {
3991           /* FIXME: We can appear here only in case if we perform a pc
3992              relative jump to the label which is i) global, ii) locally
3993              defined or this is a jump to an absolute symbol.
3994              If this is an absolute symbol -- everything is OK.
3995              If this is a global label, we've got a symbol value defined
3996              twice:
3997                1. S_GET_VALUE (fixp->fx_addsy) will contain a symbol offset
3998                   from this section start
3999                2. *valuep will contain the real offset from jump insn to the
4000                   label
4001              So, the result of S_GET_VALUE (fixp->fx_addsy) + (* valuep);
4002              will be incorrect. Therefore remove s_get_value.  */
4003           value = /* S_GET_VALUE (fixp->fx_addsy) + */ * valuep;
4004           fixp->fx_done = 1;
4005         }
4006       else
4007         value = *valuep;
4008     }
4009   else
4010     {
4011       value = fixp->fx_offset;
4012
4013       if (fixp->fx_subsy != (symbolS *) NULL)
4014         {
4015           if (S_GET_SEGMENT (fixp->fx_subsy) == absolute_section)
4016             {
4017               value -= S_GET_VALUE (fixp->fx_subsy);
4018               fixp->fx_done = 1;
4019             }
4020         }
4021     }
4022
4023   fixp->fx_no_overflow = 1;
4024
4025   /* If polymorphs are enabled and relax disabled.
4026      do not kill any relocs and pass them to linker.  */
4027   if (msp430_enable_polys
4028       && !msp430_enable_relax)
4029     {
4030       if (!fixp->fx_addsy
4031           || S_GET_SEGMENT (fixp->fx_addsy) == absolute_section)
4032         fixp->fx_done = 1;      /* It is ok to kill 'abs' reloc.  */
4033       else
4034         fixp->fx_done = 0;
4035     }
4036
4037   if (fixp->fx_done)
4038     {
4039       /* Fetch the instruction, insert the fully resolved operand
4040          value, and stuff the instruction back again.  */
4041       where = (unsigned char *) fixp->fx_frag->fr_literal + fixp->fx_where;
4042
4043       insn = bfd_getl16 (where);
4044
4045       switch (fixp->fx_r_type)
4046         {
4047         case BFD_RELOC_MSP430_10_PCREL:
4048           if (value & 1)
4049             as_bad_where (fixp->fx_file, fixp->fx_line,
4050                           _("odd address operand: %ld"), value);
4051
4052           /* Jumps are in words.  */
4053           value >>= 1;
4054           --value;              /* Correct PC.  */
4055
4056           if (value < -512 || value > 511)
4057             as_bad_where (fixp->fx_file, fixp->fx_line,
4058                           _("operand out of range: %ld"), value);
4059
4060           value &= 0x3ff;       /* get rid of extended sign */
4061           bfd_putl16 ((bfd_vma) (value | insn), where);
4062           break;
4063
4064         case BFD_RELOC_MSP430X_PCR16:
4065         case BFD_RELOC_MSP430_RL_PCREL:
4066         case BFD_RELOC_MSP430_16_PCREL:
4067           if (value & 1)
4068             as_bad_where (fixp->fx_file, fixp->fx_line,
4069                           _("odd address operand: %ld"), value);
4070           /* Fall through.  */
4071
4072         case BFD_RELOC_MSP430_16_PCREL_BYTE:
4073           /* Nothing to be corrected here.  */
4074           if (value < -32768 || value > 65536)
4075             as_bad_where (fixp->fx_file, fixp->fx_line,
4076                           _("operand out of range: %ld"), value);
4077           /* Fall through.  */
4078
4079         case BFD_RELOC_MSP430X_ABS16:
4080         case BFD_RELOC_MSP430_16:
4081         case BFD_RELOC_16:
4082         case BFD_RELOC_MSP430_16_BYTE:
4083           value &= 0xffff;      /* Get rid of extended sign.  */
4084           bfd_putl16 ((bfd_vma) value, where);
4085           break;
4086
4087         case BFD_RELOC_MSP430_ABS_HI16:
4088           value >>= 16;
4089           value &= 0xffff;      /* Get rid of extended sign.  */
4090           bfd_putl16 ((bfd_vma) value, where);
4091           break;
4092
4093         case BFD_RELOC_32:
4094           bfd_putl16 ((bfd_vma) value, where);
4095           break;
4096
4097         case BFD_RELOC_MSP430_ABS8:
4098         case BFD_RELOC_8:
4099           bfd_put_8 (NULL, (bfd_vma) value, where);
4100           break;
4101
4102         case BFD_RELOC_MSP430X_ABS20_EXT_SRC:
4103         case BFD_RELOC_MSP430X_PCR20_EXT_SRC:
4104           bfd_putl16 ((bfd_vma) (value & 0xffff), where + 4);
4105           value >>= 16;
4106           bfd_putl16 ((bfd_vma) (((value & 0xf) << 7) | insn), where);
4107           break;
4108
4109         case BFD_RELOC_MSP430X_ABS20_ADR_SRC:
4110           bfd_putl16 ((bfd_vma) (value & 0xffff), where + 2);
4111           value >>= 16;
4112           bfd_putl16 ((bfd_vma) (((value & 0xf) << 8) | insn), where);
4113           break;
4114
4115         case BFD_RELOC_MSP430X_ABS20_EXT_ODST:
4116           bfd_putl16 ((bfd_vma) (value & 0xffff), where + 6);
4117           value >>= 16;
4118           bfd_putl16 ((bfd_vma) ((value & 0xf) | insn), where);
4119           break;
4120
4121         case BFD_RELOC_MSP430X_PCR20_CALL:
4122           bfd_putl16 ((bfd_vma) (value & 0xffff), where + 2);
4123           value >>= 16;
4124           bfd_putl16 ((bfd_vma) ((value & 0xf) | insn), where);
4125           break;
4126
4127         case BFD_RELOC_MSP430X_ABS20_EXT_DST:
4128         case BFD_RELOC_MSP430X_PCR20_EXT_DST:
4129           bfd_putl16 ((bfd_vma) (value & 0xffff), where + 4);
4130           value >>= 16;
4131           bfd_putl16 ((bfd_vma) ((value & 0xf) | insn), where);
4132           break;
4133
4134         case BFD_RELOC_MSP430X_PCR20_EXT_ODST:
4135           bfd_putl16 ((bfd_vma) (value & 0xffff), where + 6);
4136           value >>= 16;
4137           bfd_putl16 ((bfd_vma) ((value & 0xf) | insn), where);
4138           break;
4139
4140         case BFD_RELOC_MSP430X_ABS20_ADR_DST:
4141           bfd_putl16 ((bfd_vma) (value & 0xffff), where + 2);
4142           value >>= 16;
4143           bfd_putl16 ((bfd_vma) ((value & 0xf) | insn), where);
4144           break;
4145
4146         default:
4147           as_fatal (_("line %d: unknown relocation type: 0x%x"),
4148                     fixp->fx_line, fixp->fx_r_type);
4149           break;
4150         }
4151     }
4152   else
4153     {
4154       fixp->fx_addnumber = value;
4155     }
4156 }
4157
4158 static bfd_boolean
4159 S_IS_GAS_LOCAL (symbolS * s)
4160 {
4161   const char * name;
4162   unsigned int len;
4163
4164   if (s == NULL)
4165     return FALSE;
4166   name = S_GET_NAME (s);
4167   len = strlen (name) - 1;
4168
4169   return name[len] == 1 || name[len] == 2;
4170 }
4171
4172 /* GAS will call this to generate a reloc, passing the resulting reloc
4173    to `bfd_install_relocation'.  This currently works poorly, as
4174    `bfd_install_relocation' often does the wrong thing, and instances of
4175    `tc_gen_reloc' have been written to work around the problems, which
4176    in turns makes it difficult to fix `bfd_install_relocation'.  */
4177
4178 /* If while processing a fixup, a reloc really needs to be created
4179    then it is done here.  */
4180
4181 arelent **
4182 tc_gen_reloc (asection * seg ATTRIBUTE_UNUSED, fixS * fixp)
4183 {
4184   static arelent * no_relocs = NULL;
4185   static arelent * relocs[MAX_RELOC_EXPANSION + 1];
4186   arelent *reloc;
4187
4188   reloc = XNEW (arelent);
4189   reloc->address = fixp->fx_frag->fr_address + fixp->fx_where;
4190   reloc->howto = bfd_reloc_type_lookup (stdoutput, fixp->fx_r_type);
4191
4192   if (reloc->howto == (reloc_howto_type *) NULL)
4193     {
4194       as_bad_where (fixp->fx_file, fixp->fx_line,
4195                     _("reloc %d not supported by object file format"),
4196                     (int) fixp->fx_r_type);
4197       free (reloc);
4198       return & no_relocs;
4199     }
4200
4201   relocs[0] = reloc;
4202   relocs[1] = NULL;
4203
4204   if (fixp->fx_subsy
4205       && S_GET_SEGMENT (fixp->fx_subsy) == absolute_section)
4206     {
4207       fixp->fx_offset -= S_GET_VALUE (fixp->fx_subsy);
4208       fixp->fx_subsy = NULL;
4209     }
4210
4211   if (fixp->fx_addsy && fixp->fx_subsy)
4212     {
4213       asection *asec, *ssec;
4214
4215       asec = S_GET_SEGMENT (fixp->fx_addsy);
4216       ssec = S_GET_SEGMENT (fixp->fx_subsy);
4217
4218       /* If we have a difference between two different, non-absolute symbols
4219          we must generate two relocs (one for each symbol) and allow the
4220          linker to resolve them - relaxation may change the distances between
4221          symbols, even local symbols defined in the same section.
4222
4223          Unfortunately we cannot do this with assembler generated local labels
4224          because there can be multiple incarnations of the same label, with
4225          exactly the same name, in any given section and the linker will have
4226          no way to identify the correct one.  Instead we just have to hope
4227          that no relaxation will occur between the local label and the other
4228          symbol in the expression.
4229
4230          Similarly we have to compute differences between symbols in the .eh_frame
4231          section as the linker is not smart enough to apply relocations there
4232          before attempting to process it.  */
4233       if ((ssec != absolute_section || asec != absolute_section)
4234           && (fixp->fx_addsy != fixp->fx_subsy)
4235           && strcmp (ssec->name, ".eh_frame") != 0
4236           && ! S_IS_GAS_LOCAL (fixp->fx_addsy)
4237           && ! S_IS_GAS_LOCAL (fixp->fx_subsy))
4238         {
4239           arelent * reloc2 = XNEW (arelent);
4240
4241           relocs[0] = reloc2;
4242           relocs[1] = reloc;
4243
4244           reloc2->address = reloc->address;
4245           reloc2->howto = bfd_reloc_type_lookup (stdoutput,
4246                                                  BFD_RELOC_MSP430_SYM_DIFF);
4247           reloc2->addend = - S_GET_VALUE (fixp->fx_subsy);
4248
4249           if (ssec == absolute_section)
4250             reloc2->sym_ptr_ptr = bfd_abs_section_ptr->symbol_ptr_ptr;
4251           else
4252             {
4253               reloc2->sym_ptr_ptr = XNEW (asymbol *);
4254               *reloc2->sym_ptr_ptr = symbol_get_bfdsym (fixp->fx_subsy);
4255             }
4256
4257           reloc->addend = fixp->fx_offset;
4258           if (asec == absolute_section)
4259             {
4260               reloc->addend += S_GET_VALUE (fixp->fx_addsy);
4261               reloc->sym_ptr_ptr = bfd_abs_section_ptr->symbol_ptr_ptr;
4262             }
4263           else
4264             {
4265               reloc->sym_ptr_ptr = XNEW (asymbol *);
4266               *reloc->sym_ptr_ptr = symbol_get_bfdsym (fixp->fx_addsy);
4267             }
4268
4269           fixp->fx_pcrel = 0;
4270           fixp->fx_done = 1;
4271           return relocs;
4272         }
4273       else
4274         {
4275           char *fixpos = fixp->fx_where + fixp->fx_frag->fr_literal;
4276
4277           reloc->addend = (S_GET_VALUE (fixp->fx_addsy)
4278                            - S_GET_VALUE (fixp->fx_subsy) + fixp->fx_offset);
4279
4280           switch (fixp->fx_r_type)
4281             {
4282             case BFD_RELOC_8:
4283               md_number_to_chars (fixpos, reloc->addend, 1);
4284               break;
4285
4286             case BFD_RELOC_16:
4287               md_number_to_chars (fixpos, reloc->addend, 2);
4288               break;
4289
4290             case BFD_RELOC_24:
4291               md_number_to_chars (fixpos, reloc->addend, 3);
4292               break;
4293
4294             case BFD_RELOC_32:
4295               md_number_to_chars (fixpos, reloc->addend, 4);
4296               break;
4297
4298             default:
4299               reloc->sym_ptr_ptr
4300                 = (asymbol **) bfd_abs_section_ptr->symbol_ptr_ptr;
4301               return relocs;
4302             }
4303
4304           free (reloc);
4305           return & no_relocs;
4306         }
4307     }
4308   else
4309     {
4310 #if 0
4311       if (fixp->fx_r_type == BFD_RELOC_MSP430X_ABS16
4312           && S_GET_SEGMENT (fixp->fx_addsy) == absolute_section)
4313         {
4314           bfd_vma amount = S_GET_VALUE (fixp->fx_addsy);
4315           char *fixpos = fixp->fx_where + fixp->fx_frag->fr_literal;
4316
4317           md_number_to_chars (fixpos, amount, 2);
4318           free (reloc);
4319           return & no_relocs;
4320         }
4321 #endif
4322       reloc->sym_ptr_ptr = XNEW (asymbol *);
4323       *reloc->sym_ptr_ptr = symbol_get_bfdsym (fixp->fx_addsy);
4324       reloc->addend = fixp->fx_offset;
4325
4326       if (fixp->fx_r_type == BFD_RELOC_VTABLE_INHERIT
4327           || fixp->fx_r_type == BFD_RELOC_VTABLE_ENTRY)
4328         reloc->address = fixp->fx_offset;
4329     }
4330
4331   return relocs;
4332 }
4333
4334 int
4335 md_estimate_size_before_relax (fragS * fragP ATTRIBUTE_UNUSED,
4336                                asection * segment_type ATTRIBUTE_UNUSED)
4337 {
4338   if (fragP->fr_symbol && S_GET_SEGMENT (fragP->fr_symbol) == segment_type)
4339     {
4340       /* This is a jump -> pcrel mode. Nothing to do much here.
4341          Return value == 2.  */
4342       fragP->fr_subtype =
4343           ENCODE_RELAX (RELAX_LEN (fragP->fr_subtype), STATE_BITS10);
4344     }
4345   else if (fragP->fr_symbol)
4346     {
4347       /* It's got a segment, but it's not ours.   Even if fr_symbol is in
4348          an absolute segment, we don't know a displacement until we link
4349          object files. So it will always be long. This also applies to
4350          labels in a subsegment of current. Liker may relax it to short
4351          jump later. Return value == 8.  */
4352       fragP->fr_subtype =
4353           ENCODE_RELAX (RELAX_LEN (fragP->fr_subtype), STATE_WORD);
4354     }
4355   else
4356     {
4357       /* We know the abs value. may be it is a jump to fixed address.
4358          Impossible in our case, cause all constants already handled. */
4359       fragP->fr_subtype =
4360           ENCODE_RELAX (RELAX_LEN (fragP->fr_subtype), STATE_UNDEF);
4361     }
4362
4363   return md_relax_table[fragP->fr_subtype].rlx_length;
4364 }
4365
4366 void
4367 md_convert_frag (bfd * abfd ATTRIBUTE_UNUSED,
4368                  asection * sec ATTRIBUTE_UNUSED,
4369                  fragS * fragP)
4370 {
4371   char * where = 0;
4372   int rela = -1;
4373   int i;
4374   struct rcodes_s * cc = NULL;
4375   struct hcodes_s * hc = NULL;
4376
4377   switch (fragP->fr_subtype)
4378     {
4379     case ENCODE_RELAX (STATE_UNCOND_BRANCH, STATE_BITS10):
4380     case ENCODE_RELAX (STATE_SIMPLE_BRANCH, STATE_BITS10):
4381     case ENCODE_RELAX (STATE_NOOV_BRANCH, STATE_BITS10):
4382       /* We do not have to convert anything here.
4383          Just apply a fix.  */
4384       rela = BFD_RELOC_MSP430_10_PCREL;
4385       break;
4386
4387     case ENCODE_RELAX (STATE_UNCOND_BRANCH, STATE_WORD):
4388     case ENCODE_RELAX (STATE_UNCOND_BRANCH, STATE_UNDEF):
4389       /* Convert uncond branch jmp lab -> br lab.  */
4390       if (target_is_430x ())
4391         cc = msp430x_rcodes + 7;
4392       else
4393         cc = msp430_rcodes + 7;
4394       where = fragP->fr_literal + fragP->fr_fix;
4395       bfd_putl16 (cc->lop0, where);
4396       rela = BFD_RELOC_MSP430_RL_PCREL;
4397       fragP->fr_fix += 2;
4398       break;
4399
4400     case ENCODE_RELAX (STATE_SIMPLE_BRANCH, STATE_WORD):
4401     case ENCODE_RELAX (STATE_SIMPLE_BRANCH, STATE_UNDEF):
4402       {
4403         /* Other simple branches.  */
4404         int insn = bfd_getl16 (fragP->fr_opcode);
4405
4406         insn &= 0xffff;
4407         /* Find actual instruction.  */
4408         if (target_is_430x ())
4409           {
4410             for (i = 0; i < 7 && !cc; i++)
4411               if (msp430x_rcodes[i].sop == insn)
4412                 cc = msp430x_rcodes + i;
4413           }
4414         else
4415           {
4416             for (i = 0; i < 7 && !cc; i++)
4417               if (msp430_rcodes[i].sop == insn)
4418                 cc = & msp430_rcodes[i];
4419           }
4420
4421         if (!cc || !cc->name)
4422           as_fatal (_("internal inconsistency problem in %s: insn %04lx"),
4423                     __FUNCTION__, (long) insn);
4424         where = fragP->fr_literal + fragP->fr_fix;
4425         bfd_putl16 (cc->lop0, where);
4426         bfd_putl16 (cc->lop1, where + 2);
4427         rela = BFD_RELOC_MSP430_RL_PCREL;
4428         fragP->fr_fix += 4;
4429       }
4430       break;
4431
4432     case ENCODE_RELAX (STATE_NOOV_BRANCH, STATE_WORD):
4433     case ENCODE_RELAX (STATE_NOOV_BRANCH, STATE_UNDEF):
4434       if (target_is_430x ())
4435         cc = msp430x_rcodes + 6;
4436       else
4437         cc = msp430_rcodes + 6;
4438       where = fragP->fr_literal + fragP->fr_fix;
4439       bfd_putl16 (cc->lop0, where);
4440       bfd_putl16 (cc->lop1, where + 2);
4441       bfd_putl16 (cc->lop2, where + 4);
4442       rela = BFD_RELOC_MSP430_RL_PCREL;
4443       fragP->fr_fix += 6;
4444       break;
4445
4446     case ENCODE_RELAX (STATE_EMUL_BRANCH, STATE_BITS10):
4447       {
4448         int insn = bfd_getl16 (fragP->fr_opcode + 2);
4449
4450         insn &= 0xffff;
4451         if (target_is_430x ())
4452           {
4453             for (i = 0; i < 4 && !hc; i++)
4454               if (msp430x_hcodes[i].op1 == insn)
4455                 hc = msp430x_hcodes + i;
4456           }
4457         else
4458           {
4459             for (i = 0; i < 4 && !hc; i++)
4460               if (msp430_hcodes[i].op1 == insn)
4461                 hc = &msp430_hcodes[i];
4462           }
4463         if (!hc || !hc->name)
4464           as_fatal (_("internal inconsistency problem in %s: ext. insn %04lx"),
4465               __FUNCTION__, (long) insn);
4466         rela = BFD_RELOC_MSP430_10_PCREL;
4467         /* Apply a fix for a first label if necessary.
4468            another fix will be applied to the next word of insn anyway.  */
4469         if (hc->tlab == 2)
4470           fix_new (fragP, fragP->fr_fix, 2, fragP->fr_symbol,
4471                    fragP->fr_offset, TRUE, rela);
4472         fragP->fr_fix += 2;
4473       }
4474
4475       break;
4476
4477     case ENCODE_RELAX (STATE_EMUL_BRANCH, STATE_WORD):
4478     case ENCODE_RELAX (STATE_EMUL_BRANCH, STATE_UNDEF):
4479       {
4480         int insn = bfd_getl16 (fragP->fr_opcode + 2);
4481
4482         insn &= 0xffff;
4483         if (target_is_430x ())
4484           {
4485             for (i = 0; i < 4 && !hc; i++)
4486               if (msp430x_hcodes[i].op1 == insn)
4487                 hc = msp430x_hcodes + i;
4488           }
4489         else
4490           {
4491             for (i = 0; i < 4 && !hc; i++)
4492               if (msp430_hcodes[i].op1 == insn)
4493                 hc = & msp430_hcodes[i];
4494           }
4495         if (!hc || !hc->name)
4496           as_fatal (_("internal inconsistency problem in %s: ext. insn %04lx"),
4497               __FUNCTION__, (long) insn);
4498         rela = BFD_RELOC_MSP430_RL_PCREL;
4499         where = fragP->fr_literal + fragP->fr_fix;
4500         bfd_putl16 (hc->lop0, where);
4501         bfd_putl16 (hc->lop1, where + 2);
4502         bfd_putl16 (hc->lop2, where + 4);
4503         fragP->fr_fix += 6;
4504       }
4505       break;
4506
4507     default:
4508       as_fatal (_("internal inconsistency problem in %s: %lx"),
4509                 __FUNCTION__, (long) fragP->fr_subtype);
4510       break;
4511     }
4512
4513   /* Now apply fix.  */
4514   fix_new (fragP, fragP->fr_fix, 2, fragP->fr_symbol,
4515            fragP->fr_offset, TRUE, rela);
4516   /* Just fixed 2 bytes.  */
4517   fragP->fr_fix += 2;
4518 }
4519
4520 /* Relax fragment. Mostly stolen from hc11 and mcore
4521    which arches I think I know.  */
4522
4523 long
4524 msp430_relax_frag (segT seg ATTRIBUTE_UNUSED, fragS * fragP,
4525                    long stretch ATTRIBUTE_UNUSED)
4526 {
4527   long growth;
4528   offsetT aim = 0;
4529   symbolS *symbolP;
4530   const relax_typeS *this_type;
4531   const relax_typeS *start_type;
4532   relax_substateT next_state;
4533   relax_substateT this_state;
4534   const relax_typeS *table = md_relax_table;
4535
4536   /* Nothing to be done if the frag has already max size.  */
4537   if (RELAX_STATE (fragP->fr_subtype) == STATE_UNDEF
4538       || RELAX_STATE (fragP->fr_subtype) == STATE_WORD)
4539     return 0;
4540
4541   if (RELAX_STATE (fragP->fr_subtype) == STATE_BITS10)
4542     {
4543       symbolP = fragP->fr_symbol;
4544       if (symbol_resolved_p (symbolP))
4545         as_fatal (_("internal inconsistency problem in %s: resolved symbol"),
4546                   __FUNCTION__);
4547       /* We know the offset. calculate a distance.  */
4548       aim = S_GET_VALUE (symbolP) - fragP->fr_address - fragP->fr_fix;
4549     }
4550
4551   if (!msp430_enable_relax)
4552     {
4553       /* Relaxation is not enabled. So, make all jump as long ones
4554          by setting 'aim' to quite high value.  */
4555       aim = 0x7fff;
4556     }
4557
4558   this_state = fragP->fr_subtype;
4559   start_type = this_type = table + this_state;
4560
4561   if (aim < 0)
4562     {
4563       /* Look backwards.  */
4564       for (next_state = this_type->rlx_more; next_state;)
4565         if (aim >= this_type->rlx_backward || !this_type->rlx_backward)
4566           next_state = 0;
4567         else
4568           {
4569             /* Grow to next state.  */
4570             this_state = next_state;
4571             this_type = table + this_state;
4572             next_state = this_type->rlx_more;
4573           }
4574     }
4575   else
4576     {
4577       /* Look forwards.  */
4578       for (next_state = this_type->rlx_more; next_state;)
4579         if (aim <= this_type->rlx_forward || !this_type->rlx_forward)
4580           next_state = 0;
4581         else
4582           {
4583             /* Grow to next state.  */
4584             this_state = next_state;
4585             this_type = table + this_state;
4586             next_state = this_type->rlx_more;
4587           }
4588     }
4589
4590   growth = this_type->rlx_length - start_type->rlx_length;
4591   if (growth != 0)
4592     fragP->fr_subtype = this_state;
4593   return growth;
4594 }
4595
4596 /* Return FALSE if the fixup in fixp should be left alone and not
4597    adjusted.   We return FALSE here so that linker relaxation will
4598    work.  */
4599
4600 bfd_boolean
4601 msp430_fix_adjustable (struct fix *fixp ATTRIBUTE_UNUSED)
4602 {
4603   /* If the symbol is in a non-code section then it should be OK.  */
4604   if (fixp->fx_addsy
4605       && ((S_GET_SEGMENT (fixp->fx_addsy)->flags & SEC_CODE) == 0))
4606     return TRUE;
4607
4608   return FALSE;
4609 }
4610
4611 /* Set the contents of the .MSP430.attributes section.  */
4612
4613 void
4614 msp430_md_end (void)
4615 {
4616   if (check_for_nop)
4617     as_warn ("assembly finished without a possibly needed NOP instruction");
4618
4619   bfd_elf_add_proc_attr_int (stdoutput, OFBA_MSPABI_Tag_ISA,
4620                              target_is_430x () ? 2 : 1);
4621
4622   bfd_elf_add_proc_attr_int (stdoutput, OFBA_MSPABI_Tag_Code_Model,
4623                              large_model ? 2 : 1);
4624
4625   bfd_elf_add_proc_attr_int (stdoutput, OFBA_MSPABI_Tag_Data_Model,
4626                              large_model ? 2 : 1);
4627 }
4628
4629 /* Returns FALSE if there is a msp430 specific reason why the
4630    subtraction of two same-section symbols cannot be computed by
4631    the assembler.  */
4632
4633 bfd_boolean
4634 msp430_allow_local_subtract (expressionS * left,
4635                              expressionS * right,
4636                              segT section)
4637 {
4638   /* If the symbols are not in a code section then they are OK.  */
4639   if ((section->flags & SEC_CODE) == 0)
4640     return TRUE;
4641
4642   if (S_IS_GAS_LOCAL (left->X_add_symbol) || S_IS_GAS_LOCAL (right->X_add_symbol))
4643     return TRUE;
4644
4645   if (left->X_add_symbol == right->X_add_symbol)
4646     return TRUE;
4647
4648   /* We have to assume that there may be instructions between the
4649      two symbols and that relaxation may increase the distance between
4650      them.  */
4651   return FALSE;
4652 }