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