gas/config/tc-msp430.c

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