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