gas/config/tc-msp430.c

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