source: trunk/binutils/gas/config/tc-avr.c@ 2446

Last change on this file since 2446 was 610, checked in by bird, 22 years ago

This commit was generated by cvs2svn to compensate for changes in r609,
which included commits to RCS files with non-trunk default branches.
  • Property cvs2svn:cvs-rev set to 1.1.1.2
  • Property svn:eol-style set to native
  • Property svn:executable set to *
File size: 31.1 KB
Line 
1/* tc-avr.c -- Assembler code for the ATMEL AVR
2
3 Copyright 1999, 2000, 2001, 2002 Free Software Foundation, Inc.
4 Contributed by Denis Chertykov <denisc@overta.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 2, 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, 59 Temple Place - Suite 330,
21 Boston, MA 02111-1307, USA. */
22
23#include <stdio.h>
24#include "as.h"
25#include "safe-ctype.h"
26#include "subsegs.h"
27
28struct avr_opcodes_s
29{
30 char *name;
31 char *constraints;
32 int insn_size; /* In words. */
33 int isa;
34 unsigned int bin_opcode;
35};
36
37#define AVR_INSN(NAME, CONSTR, OPCODE, SIZE, ISA, BIN) \
38{#NAME, CONSTR, SIZE, ISA, BIN},
39
40struct avr_opcodes_s avr_opcodes[] =
41{
42 #include "opcode/avr.h"
43 {NULL, NULL, 0, 0, 0}
44};
45
46const char comment_chars[] = ";";
47const char line_comment_chars[] = "#";
48const char line_separator_chars[] = "$";
49
50const char *md_shortopts = "m:";
51struct mcu_type_s
52{
53 char *name;
54 int isa;
55 int mach;
56};
57
58/* XXX - devices that don't seem to exist (renamed, replaced with larger
59 ones, or planned but never produced), left here for compatibility.
60 TODO: hide them in show_mcu_list output? */
61
62static struct mcu_type_s mcu_types[] =
63{
64 {"avr1", AVR_ISA_TINY1, bfd_mach_avr1},
65 {"avr2", AVR_ISA_2xxx, bfd_mach_avr2},
66 {"avr3", AVR_ISA_M103, bfd_mach_avr3},
67 {"avr4", AVR_ISA_M8, bfd_mach_avr4},
68 {"avr5", AVR_ISA_ALL, bfd_mach_avr5},
69 {"at90s1200", AVR_ISA_1200, bfd_mach_avr1},
70 {"attiny10", AVR_ISA_TINY1, bfd_mach_avr1}, /* XXX -> tn11 */
71 {"attiny11", AVR_ISA_TINY1, bfd_mach_avr1},
72 {"attiny12", AVR_ISA_TINY1, bfd_mach_avr1},
73 {"attiny15", AVR_ISA_TINY1, bfd_mach_avr1},
74 {"attiny28", AVR_ISA_TINY1, bfd_mach_avr1},
75 {"at90s2313", AVR_ISA_2xxx, bfd_mach_avr2},
76 {"at90s2323", AVR_ISA_2xxx, bfd_mach_avr2},
77 {"at90s2333", AVR_ISA_2xxx, bfd_mach_avr2}, /* XXX -> 4433 */
78 {"at90s2343", AVR_ISA_2xxx, bfd_mach_avr2},
79 {"attiny22", AVR_ISA_2xxx, bfd_mach_avr2}, /* XXX -> 2343 */
80 {"attiny26", AVR_ISA_2xxx, bfd_mach_avr2},
81 {"at90s4433", AVR_ISA_2xxx, bfd_mach_avr2},
82 {"at90s4414", AVR_ISA_2xxx, bfd_mach_avr2}, /* XXX -> 8515 */
83 {"at90s4434", AVR_ISA_2xxx, bfd_mach_avr2}, /* XXX -> 8535 */
84 {"at90s8515", AVR_ISA_2xxx, bfd_mach_avr2},
85 {"at90s8535", AVR_ISA_2xxx, bfd_mach_avr2},
86 {"at90c8534", AVR_ISA_2xxx, bfd_mach_avr2},
87 {"at86rf401", AVR_ISA_2xxx, bfd_mach_avr2},
88 {"atmega603", AVR_ISA_M603, bfd_mach_avr3}, /* XXX -> m103 */
89 {"atmega103", AVR_ISA_M103, bfd_mach_avr3},
90 {"at43usb320",AVR_ISA_M103, bfd_mach_avr3},
91 {"at43usb355",AVR_ISA_M603, bfd_mach_avr3},
92 {"at76c711", AVR_ISA_M603, bfd_mach_avr3},
93 {"atmega8", AVR_ISA_M8, bfd_mach_avr4},
94 {"atmega83", AVR_ISA_M8, bfd_mach_avr4}, /* XXX -> m8535 */
95 {"atmega85", AVR_ISA_M8, bfd_mach_avr4}, /* XXX -> m8 */
96 {"atmega8515",AVR_ISA_M8, bfd_mach_avr4},
97 {"atmega8535",AVR_ISA_M8, bfd_mach_avr4},
98 {"atmega16", AVR_ISA_M323, bfd_mach_avr5},
99 {"atmega161", AVR_ISA_M161, bfd_mach_avr5},
100 {"atmega162", AVR_ISA_M323, bfd_mach_avr5},
101 {"atmega163", AVR_ISA_M161, bfd_mach_avr5},
102 {"atmega169", AVR_ISA_M323, bfd_mach_avr5},
103 {"atmega32", AVR_ISA_M323, bfd_mach_avr5},
104 {"atmega323", AVR_ISA_M323, bfd_mach_avr5},
105 {"atmega64", AVR_ISA_M323, bfd_mach_avr5},
106 {"atmega128", AVR_ISA_M128, bfd_mach_avr5},
107 {"at94k", AVR_ISA_94K, bfd_mach_avr5},
108 {NULL, 0, 0}
109};
110
111/* Current MCU type. */
112static struct mcu_type_s default_mcu = {"avr2", AVR_ISA_2xxx,bfd_mach_avr2};
113static struct mcu_type_s *avr_mcu = &default_mcu;
114
115/* AVR target-specific switches. */
116struct avr_opt_s
117{
118 int all_opcodes; /* -mall-opcodes: accept all known AVR opcodes */
119 int no_skip_bug; /* -mno-skip-bug: no warnings for skipping 2-word insns */
120 int no_wrap; /* -mno-wrap: reject rjmp/rcall with 8K wrap-around */
121};
122
123static struct avr_opt_s avr_opt = { 0, 0, 0 };
124
125const char EXP_CHARS[] = "eE";
126const char FLT_CHARS[] = "dD";
127static void avr_set_arch (int dummy);
128
129/* The target specific pseudo-ops which we support. */
130const pseudo_typeS md_pseudo_table[] =
131{
132 {"arch", avr_set_arch, 0},
133 { NULL, NULL, 0}
134};
135
136#define LDI_IMMEDIATE(x) (((x) & 0xf) | (((x) << 4) & 0xf00))
137
138static void show_mcu_list PARAMS ((FILE *));
139static char *skip_space PARAMS ((char *));
140static char *extract_word PARAMS ((char *, char *, int));
141static unsigned int avr_operand PARAMS ((struct avr_opcodes_s *,
142 int, char *, char **));
143static unsigned int avr_operands PARAMS ((struct avr_opcodes_s *, char **));
144static unsigned int avr_get_constant PARAMS ((char *, int));
145static char *parse_exp PARAMS ((char *, expressionS *));
146static bfd_reloc_code_real_type avr_ldi_expression PARAMS ((expressionS *));
147
148#define EXP_MOD_NAME(i) exp_mod[i].name
149#define EXP_MOD_RELOC(i) exp_mod[i].reloc
150#define EXP_MOD_NEG_RELOC(i) exp_mod[i].neg_reloc
151#define HAVE_PM_P(i) exp_mod[i].have_pm
152
153struct exp_mod_s
154{
155 char *name;
156 bfd_reloc_code_real_type reloc;
157 bfd_reloc_code_real_type neg_reloc;
158 int have_pm;
159};
160
161static struct exp_mod_s exp_mod[] =
162{
163 {"hh8", BFD_RELOC_AVR_HH8_LDI, BFD_RELOC_AVR_HH8_LDI_NEG, 1},
164 {"pm_hh8", BFD_RELOC_AVR_HH8_LDI_PM, BFD_RELOC_AVR_HH8_LDI_PM_NEG, 0},
165 {"hi8", BFD_RELOC_AVR_HI8_LDI, BFD_RELOC_AVR_HI8_LDI_NEG, 1},
166 {"pm_hi8", BFD_RELOC_AVR_HI8_LDI_PM, BFD_RELOC_AVR_HI8_LDI_PM_NEG, 0},
167 {"lo8", BFD_RELOC_AVR_LO8_LDI, BFD_RELOC_AVR_LO8_LDI_NEG, 1},
168 {"pm_lo8", BFD_RELOC_AVR_LO8_LDI_PM, BFD_RELOC_AVR_LO8_LDI_PM_NEG, 0},
169 {"hlo8", -BFD_RELOC_AVR_LO8_LDI, -BFD_RELOC_AVR_LO8_LDI_NEG, 0},
170 {"hhi8", -BFD_RELOC_AVR_HI8_LDI, -BFD_RELOC_AVR_HI8_LDI_NEG, 0},
171};
172
173/* Opcode hash table. */
174static struct hash_control *avr_hash;
175
176/* Reloc modifiers hash control (hh8,hi8,lo8,pm_xx). */
177static struct hash_control *avr_mod_hash;
178
179#define OPTION_MMCU 'm'
180#define OPTION_ALL_OPCODES (OPTION_MD_BASE + 1)
181#define OPTION_NO_SKIP_BUG (OPTION_MD_BASE + 2)
182#define OPTION_NO_WRAP (OPTION_MD_BASE + 3)
183
184struct option md_longopts[] =
185{
186 { "mmcu", required_argument, NULL, OPTION_MMCU },
187 { "mall-opcodes", no_argument, NULL, OPTION_ALL_OPCODES },
188 { "mno-skip-bug", no_argument, NULL, OPTION_NO_SKIP_BUG },
189 { "mno-wrap", no_argument, NULL, OPTION_NO_WRAP },
190 { NULL, no_argument, NULL, 0 }
191};
192
193size_t md_longopts_size = sizeof (md_longopts);
194
195/* Display nicely formatted list of known MCU names. */
196
197static void
198show_mcu_list (stream)
199 FILE *stream;
200{
201 int i, x;
202
203 fprintf (stream, _("Known MCU names:"));
204 x = 1000;
205
206 for (i = 0; mcu_types[i].name; i++)
207 {
208 int len = strlen (mcu_types[i].name);
209
210 x += len + 1;
211
212 if (x < 75)
213 fprintf (stream, " %s", mcu_types[i].name);
214 else
215 {
216 fprintf (stream, "\n %s", mcu_types[i].name);
217 x = len + 2;
218 }
219 }
220
221 fprintf (stream, "\n");
222}
223
224static inline char *
225skip_space (s)
226 char *s;
227{
228 while (*s == ' ' || *s == '\t')
229 ++s;
230 return s;
231}
232
233/* Extract one word from FROM and copy it to TO. */
234
235static char *
236extract_word (char *from, char *to, int limit)
237{
238 char *op_start;
239 char *op_end;
240 int size = 0;
241
242 /* Drop leading whitespace. */
243 from = skip_space (from);
244 *to = 0;
245
246 /* Find the op code end. */
247 for (op_start = op_end = from; *op_end != 0 && is_part_of_name (*op_end);)
248 {
249 to[size++] = *op_end++;
250 if (size + 1 >= limit)
251 break;
252 }
253
254 to[size] = 0;
255 return op_end;
256}
257
258int
259md_estimate_size_before_relax (fragp, seg)
260 fragS *fragp ATTRIBUTE_UNUSED;
261 asection *seg ATTRIBUTE_UNUSED;
262{
263 abort ();
264 return 0;
265}
266
267void
268md_show_usage (stream)
269 FILE *stream;
270{
271 fprintf (stream,
272 _("AVR options:\n"
273 " -mmcu=[avr-name] select microcontroller variant\n"
274 " [avr-name] can be:\n"
275 " avr1 - AT90S1200, ATtiny1x, ATtiny28\n"
276 " avr2 - AT90S2xxx, AT90S4xxx, AT90S8xxx, ATtiny22\n"
277 " avr3 - ATmega103, ATmega603\n"
278 " avr4 - ATmega83, ATmega85\n"
279 " avr5 - ATmega161, ATmega163, ATmega32, AT94K\n"
280 " or immediate microcontroller name.\n"));
281 fprintf (stream,
282 _(" -mall-opcodes accept all AVR opcodes, even if not supported by MCU\n"
283 " -mno-skip-bug disable warnings for skipping two-word instructions\n"
284 " (default for avr4, avr5)\n"
285 " -mno-wrap reject rjmp/rcall instructions with 8K wrap-around\n"
286 " (default for avr3, avr5)\n"));
287 show_mcu_list (stream);
288}
289
290static void
291avr_set_arch (dummy)
292 int dummy ATTRIBUTE_UNUSED;
293{
294 char *str;
295
296 str = (char *) alloca (20);
297 input_line_pointer = extract_word (input_line_pointer, str, 20);
298 md_parse_option (OPTION_MMCU, str);
299 bfd_set_arch_mach (stdoutput, TARGET_ARCH, avr_mcu->mach);
300}
301
302int
303md_parse_option (c, arg)
304 int c;
305 char *arg;
306{
307 switch (c)
308 {
309 case OPTION_MMCU:
310 {
311 int i;
312 char *s = alloca (strlen (arg) + 1);
313
314 {
315 char *t = s;
316 char *arg1 = arg;
317
318 do
319 *t = TOLOWER (*arg1++);
320 while (*t++);
321 }
322
323 for (i = 0; mcu_types[i].name; ++i)
324 if (strcmp (mcu_types[i].name, s) == 0)
325 break;
326
327 if (!mcu_types[i].name)
328 {
329 show_mcu_list (stderr);
330 as_fatal (_("unknown MCU: %s\n"), arg);
331 }
332
333 /* It is OK to redefine mcu type within the same avr[1-5] bfd machine
334 type - this for allows passing -mmcu=... via gcc ASM_SPEC as well
335 as .arch ... in the asm output at the same time. */
336 if (avr_mcu == &default_mcu || avr_mcu->mach == mcu_types[i].mach)
337 avr_mcu = &mcu_types[i];
338 else
339 as_fatal (_("redefinition of mcu type `%s' to `%s'"),
340 avr_mcu->name, mcu_types[i].name);
341 return 1;
342 }
343 case OPTION_ALL_OPCODES:
344 avr_opt.all_opcodes = 1;
345 return 1;
346 case OPTION_NO_SKIP_BUG:
347 avr_opt.no_skip_bug = 1;
348 return 1;
349 case OPTION_NO_WRAP:
350 avr_opt.no_wrap = 1;
351 return 1;
352 }
353
354 return 0;
355}
356
357symbolS *
358md_undefined_symbol (name)
359 char *name ATTRIBUTE_UNUSED;
360{
361 return 0;
362}
363
364/* Turn a string in input_line_pointer into a floating point constant
365 of type TYPE, and store the appropriate bytes in *LITP. The number
366 of LITTLENUMS emitted is stored in *SIZEP. An error message is
367 returned, or NULL on OK. */
368
369char *
370md_atof (type, litP, sizeP)
371 int type;
372 char *litP;
373 int *sizeP;
374{
375 int prec;
376 LITTLENUM_TYPE words[4];
377 LITTLENUM_TYPE *wordP;
378 char *t;
379
380 switch (type)
381 {
382 case 'f':
383 prec = 2;
384 break;
385 case 'd':
386 prec = 4;
387 break;
388 default:
389 *sizeP = 0;
390 return _("bad call to md_atof");
391 }
392
393 t = atof_ieee (input_line_pointer, type, words);
394 if (t)
395 input_line_pointer = t;
396
397 *sizeP = prec * sizeof (LITTLENUM_TYPE);
398
399 /* This loop outputs the LITTLENUMs in REVERSE order. */
400 for (wordP = words + prec - 1; prec--;)
401 {
402 md_number_to_chars (litP, (valueT) (*wordP--), sizeof (LITTLENUM_TYPE));
403 litP += sizeof (LITTLENUM_TYPE);
404 }
405
406 return NULL;
407}
408
409void
410md_convert_frag (abfd, sec, fragP)
411 bfd *abfd ATTRIBUTE_UNUSED;
412 asection *sec ATTRIBUTE_UNUSED;
413 fragS *fragP ATTRIBUTE_UNUSED;
414{
415 abort ();
416}
417
418void
419md_begin ()
420{
421 unsigned int i;
422 struct avr_opcodes_s *opcode;
423 avr_hash = hash_new ();
424
425 /* Insert unique names into hash table. This hash table then provides a
426 quick index to the first opcode with a particular name in the opcode
427 table. */
428 for (opcode = avr_opcodes; opcode->name; opcode++)
429 hash_insert (avr_hash, opcode->name, (char *) opcode);
430
431 avr_mod_hash = hash_new ();
432
433 for (i = 0; i < sizeof (exp_mod) / sizeof (exp_mod[0]); ++i)
434 hash_insert (avr_mod_hash, EXP_MOD_NAME (i), (void *) (i + 10));
435
436 bfd_set_arch_mach (stdoutput, TARGET_ARCH, avr_mcu->mach);
437}
438
439/* Resolve STR as a constant expression and return the result.
440 If result greater than MAX then error. */
441
442static unsigned int
443avr_get_constant (str, max)
444 char *str;
445 int max;
446{
447 expressionS ex;
448 str = skip_space (str);
449 input_line_pointer = str;
450 expression (&ex);
451
452 if (ex.X_op != O_constant)
453 as_bad (_("constant value required"));
454
455 if (ex.X_add_number > max || ex.X_add_number < 0)
456 as_bad (_("number must be less than %d"), max + 1);
457
458 return ex.X_add_number;
459}
460
461/* Parse instruction operands.
462 Return binary opcode. */
463
464static unsigned int
465avr_operands (opcode, line)
466 struct avr_opcodes_s *opcode;
467 char **line;
468{
469 char *op = opcode->constraints;
470 unsigned int bin = opcode->bin_opcode;
471 char *frag = frag_more (opcode->insn_size * 2);
472 char *str = *line;
473 int where = frag - frag_now->fr_literal;
474 static unsigned int prev = 0; /* Previous opcode. */
475
476 /* Opcode have operands. */
477 if (*op)
478 {
479 unsigned int reg1 = 0;
480 unsigned int reg2 = 0;
481 int reg1_present = 0;
482 int reg2_present = 0;
483
484 /* Parse first operand. */
485 if (REGISTER_P (*op))
486 reg1_present = 1;
487 reg1 = avr_operand (opcode, where, op, &str);
488 ++op;
489
490 /* Parse second operand. */
491 if (*op)
492 {
493 if (*op == ',')
494 ++op;
495
496 if (*op == '=')
497 {
498 reg2 = reg1;
499 reg2_present = 1;
500 }
501 else
502 {
503 if (REGISTER_P (*op))
504 reg2_present = 1;
505
506 str = skip_space (str);
507 if (*str++ != ',')
508 as_bad (_("`,' required"));
509 str = skip_space (str);
510
511 reg2 = avr_operand (opcode, where, op, &str);
512
513 }
514
515 if (reg1_present && reg2_present)
516 reg2 = (reg2 & 0xf) | ((reg2 << 5) & 0x200);
517 else if (reg2_present)
518 reg2 <<= 4;
519 }
520 if (reg1_present)
521 reg1 <<= 4;
522 bin |= reg1 | reg2;
523 }
524
525 /* Detect undefined combinations (like ld r31,Z+). */
526 if (!avr_opt.all_opcodes && AVR_UNDEF_P (bin))
527 as_warn (_("undefined combination of operands"));
528
529 if (opcode->insn_size == 2)
530 {
531 /* Warn if the previous opcode was cpse/sbic/sbis/sbrc/sbrs
532 (AVR core bug, fixed in the newer devices). */
533
534 if (!(avr_opt.no_skip_bug || (avr_mcu->isa & AVR_ISA_MUL))
535 && AVR_SKIP_P (prev))
536 as_warn (_("skipping two-word instruction"));
537
538 bfd_putl32 ((bfd_vma) bin, frag);
539 }
540 else
541 bfd_putl16 ((bfd_vma) bin, frag);
542
543 prev = bin;
544 *line = str;
545 return bin;
546}
547
548/* Parse one instruction operand.
549 Return operand bitmask. Also fixups can be generated. */
550
551static unsigned int
552avr_operand (opcode, where, op, line)
553 struct avr_opcodes_s *opcode;
554 int where;
555 char *op;
556 char **line;
557{
558 expressionS op_expr;
559 unsigned int op_mask = 0;
560 char *str = skip_space (*line);
561
562 switch (*op)
563 {
564 /* Any register operand. */
565 case 'w':
566 case 'd':
567 case 'r':
568 case 'a':
569 case 'v':
570 if (*str == 'r' || *str == 'R')
571 {
572 char r_name[20];
573
574 str = extract_word (str, r_name, sizeof (r_name));
575 op_mask = 0xff;
576 if (ISDIGIT (r_name[1]))
577 {
578 if (r_name[2] == '\0')
579 op_mask = r_name[1] - '0';
580 else if (r_name[1] != '0'
581 && ISDIGIT (r_name[2])
582 && r_name[3] == '\0')
583 op_mask = (r_name[1] - '0') * 10 + r_name[2] - '0';
584 }
585 }
586 else
587 {
588 op_mask = avr_get_constant (str, 31);
589 str = input_line_pointer;
590 }
591
592 if (op_mask <= 31)
593 {
594 switch (*op)
595 {
596 case 'a':
597 if (op_mask < 16 || op_mask > 23)
598 as_bad (_("register r16-r23 required"));
599 op_mask -= 16;
600 break;
601
602 case 'd':
603 if (op_mask < 16)
604 as_bad (_("register number above 15 required"));
605 op_mask -= 16;
606 break;
607
608 case 'v':
609 if (op_mask & 1)
610 as_bad (_("even register number required"));
611 op_mask >>= 1;
612 break;
613
614 case 'w':
615 if ((op_mask & 1) || op_mask < 24)
616 as_bad (_("register r24, r26, r28 or r30 required"));
617 op_mask = (op_mask - 24) >> 1;
618 break;
619 }
620 break;
621 }
622 as_bad (_("register name or number from 0 to 31 required"));
623 break;
624
625 case 'e':
626 {
627 char c;
628
629 if (*str == '-')
630 {
631 str = skip_space (str + 1);
632 op_mask = 0x1002;
633 }
634 c = TOLOWER (*str);
635 if (c == 'x')
636 op_mask |= 0x100c;
637 else if (c == 'y')
638 op_mask |= 0x8;
639 else if (c != 'z')
640 as_bad (_("pointer register (X, Y or Z) required"));
641
642 str = skip_space (str + 1);
643 if (*str == '+')
644 {
645 ++str;
646 if (op_mask & 2)
647 as_bad (_("cannot both predecrement and postincrement"));
648 op_mask |= 0x1001;
649 }
650
651 /* avr1 can do "ld r,Z" and "st Z,r" but no other pointer
652 registers, no predecrement, no postincrement. */
653 if (!avr_opt.all_opcodes && (op_mask & 0x100F)
654 && !(avr_mcu->isa & AVR_ISA_SRAM))
655 as_bad (_("addressing mode not supported"));
656 }
657 break;
658
659 case 'z':
660 if (*str == '-')
661 as_bad (_("can't predecrement"));
662
663 if (! (*str == 'z' || *str == 'Z'))
664 as_bad (_("pointer register Z required"));
665
666 str = skip_space (str + 1);
667
668 if (*str == '+')
669 {
670 ++str;
671 op_mask |= 1;
672 }
673 break;
674
675 case 'b':
676 {
677 char c = TOLOWER (*str++);
678
679 if (c == 'y')
680 op_mask |= 0x8;
681 else if (c != 'z')
682 as_bad (_("pointer register (Y or Z) required"));
683 str = skip_space (str);
684 if (*str++ == '+')
685 {
686 unsigned int x;
687 x = avr_get_constant (str, 63);
688 str = input_line_pointer;
689 op_mask |= (x & 7) | ((x & (3 << 3)) << 7) | ((x & (1 << 5)) << 8);
690 }
691 }
692 break;
693
694 case 'h':
695 str = parse_exp (str, &op_expr);
696 fix_new_exp (frag_now, where, opcode->insn_size * 2,
697 &op_expr, FALSE, BFD_RELOC_AVR_CALL);
698 break;
699
700 case 'L':
701 str = parse_exp (str, &op_expr);
702 fix_new_exp (frag_now, where, opcode->insn_size * 2,
703 &op_expr, TRUE, BFD_RELOC_AVR_13_PCREL);
704 break;
705
706 case 'l':
707 str = parse_exp (str, &op_expr);
708 fix_new_exp (frag_now, where, opcode->insn_size * 2,
709 &op_expr, TRUE, BFD_RELOC_AVR_7_PCREL);
710 break;
711
712 case 'i':
713 str = parse_exp (str, &op_expr);
714 fix_new_exp (frag_now, where + 2, opcode->insn_size * 2,
715 &op_expr, FALSE, BFD_RELOC_16);
716 break;
717
718 case 'M':
719 {
720 bfd_reloc_code_real_type r_type;
721
722 input_line_pointer = str;
723 r_type = avr_ldi_expression (&op_expr);
724 str = input_line_pointer;
725 fix_new_exp (frag_now, where, 3,
726 &op_expr, FALSE, r_type);
727 }
728 break;
729
730 case 'n':
731 {
732 unsigned int x;
733
734 x = ~avr_get_constant (str, 255);
735 str = input_line_pointer;
736 op_mask |= (x & 0xf) | ((x << 4) & 0xf00);
737 }
738 break;
739
740 case 'K':
741 {
742 unsigned int x;
743
744 x = avr_get_constant (str, 63);
745 str = input_line_pointer;
746 op_mask |= (x & 0xf) | ((x & 0x30) << 2);
747 }
748 break;
749
750 case 'S':
751 case 's':
752 {
753 unsigned int x;
754
755 x = avr_get_constant (str, 7);
756 str = input_line_pointer;
757 if (*op == 'S')
758 x <<= 4;
759 op_mask |= x;
760 }
761 break;
762
763 case 'P':
764 {
765 unsigned int x;
766
767 x = avr_get_constant (str, 63);
768 str = input_line_pointer;
769 op_mask |= (x & 0xf) | ((x & 0x30) << 5);
770 }
771 break;
772
773 case 'p':
774 {
775 unsigned int x;
776
777 x = avr_get_constant (str, 31);
778 str = input_line_pointer;
779 op_mask |= x << 3;
780 }
781 break;
782
783 case '?':
784 break;
785
786 default:
787 as_bad (_("unknown constraint `%c'"), *op);
788 }
789
790 *line = str;
791 return op_mask;
792}
793
794/* GAS will call this function for each section at the end of the assembly,
795 to permit the CPU backend to adjust the alignment of a section. */
796
797valueT
798md_section_align (seg, addr)
799 asection *seg;
800 valueT addr;
801{
802 int align = bfd_get_section_alignment (stdoutput, seg);
803 return ((addr + (1 << align) - 1) & (-1 << align));
804}
805
806/* If you define this macro, it should return the offset between the
807 address of a PC relative fixup and the position from which the PC
808 relative adjustment should be made. On many processors, the base
809 of a PC relative instruction is the next instruction, so this
810 macro would return the length of an instruction. */
811
812long
813md_pcrel_from_section (fixp, sec)
814 fixS *fixp;
815 segT sec;
816{
817 if (fixp->fx_addsy != (symbolS *) NULL
818 && (!S_IS_DEFINED (fixp->fx_addsy)
819 || (S_GET_SEGMENT (fixp->fx_addsy) != sec)))
820 return 0;
821
822 return fixp->fx_frag->fr_address + fixp->fx_where;
823}
824
825/* GAS will call this for each fixup. It should store the correct
826 value in the object file. */
827
828void
829md_apply_fix3 (fixP, valP, seg)
830 fixS *fixP;
831 valueT * valP;
832 segT seg;
833{
834 unsigned char *where;
835 unsigned long insn;
836 long value = *valP;
837
838 if (fixP->fx_addsy == (symbolS *) NULL)
839 fixP->fx_done = 1;
840
841 else if (fixP->fx_pcrel)
842 {
843 segT s = S_GET_SEGMENT (fixP->fx_addsy);
844
845 if (s == seg || s == absolute_section)
846 {
847 value += S_GET_VALUE (fixP->fx_addsy);
848 fixP->fx_done = 1;
849 }
850 }
851
852 /* We don't actually support subtracting a symbol. */
853 if (fixP->fx_subsy != (symbolS *) NULL)
854 as_bad_where (fixP->fx_file, fixP->fx_line, _("expression too complex"));
855
856 switch (fixP->fx_r_type)
857 {
858 default:
859 fixP->fx_no_overflow = 1;
860 break;
861 case BFD_RELOC_AVR_7_PCREL:
862 case BFD_RELOC_AVR_13_PCREL:
863 case BFD_RELOC_32:
864 case BFD_RELOC_16:
865 case BFD_RELOC_AVR_CALL:
866 break;
867 }
868
869 if (fixP->fx_done)
870 {
871 /* Fetch the instruction, insert the fully resolved operand
872 value, and stuff the instruction back again. */
873 where = fixP->fx_frag->fr_literal + fixP->fx_where;
874 insn = bfd_getl16 (where);
875
876 switch (fixP->fx_r_type)
877 {
878 case BFD_RELOC_AVR_7_PCREL:
879 if (value & 1)
880 as_bad_where (fixP->fx_file, fixP->fx_line,
881 _("odd address operand: %ld"), value);
882
883 /* Instruction addresses are always right-shifted by 1. */
884 value >>= 1;
885 --value; /* Correct PC. */
886
887 if (value < -64 || value > 63)
888 as_bad_where (fixP->fx_file, fixP->fx_line,
889 _("operand out of range: %ld"), value);
890 value = (value << 3) & 0x3f8;
891 bfd_putl16 ((bfd_vma) (value | insn), where);
892 break;
893
894 case BFD_RELOC_AVR_13_PCREL:
895 if (value & 1)
896 as_bad_where (fixP->fx_file, fixP->fx_line,
897 _("odd address operand: %ld"), value);
898
899 /* Instruction addresses are always right-shifted by 1. */
900 value >>= 1;
901 --value; /* Correct PC. */
902
903 if (value < -2048 || value > 2047)
904 {
905 /* No wrap for devices with >8K of program memory. */
906 if ((avr_mcu->isa & AVR_ISA_MEGA) || avr_opt.no_wrap)
907 as_bad_where (fixP->fx_file, fixP->fx_line,
908 _("operand out of range: %ld"), value);
909 }
910
911 value &= 0xfff;
912 bfd_putl16 ((bfd_vma) (value | insn), where);
913 break;
914
915 case BFD_RELOC_32:
916 bfd_putl16 ((bfd_vma) value, where);
917 break;
918
919 case BFD_RELOC_16:
920 bfd_putl16 ((bfd_vma) value, where);
921 break;
922
923 case BFD_RELOC_AVR_16_PM:
924 bfd_putl16 ((bfd_vma) (value >> 1), where);
925 break;
926
927 case BFD_RELOC_AVR_LO8_LDI:
928 bfd_putl16 ((bfd_vma) insn | LDI_IMMEDIATE (value), where);
929 break;
930
931 case -BFD_RELOC_AVR_LO8_LDI:
932 bfd_putl16 ((bfd_vma) insn | LDI_IMMEDIATE (value >> 16), where);
933 break;
934
935 case BFD_RELOC_AVR_HI8_LDI:
936 bfd_putl16 ((bfd_vma) insn | LDI_IMMEDIATE (value >> 8), where);
937 break;
938
939 case -BFD_RELOC_AVR_HI8_LDI:
940 bfd_putl16 ((bfd_vma) insn | LDI_IMMEDIATE (value >> 24), where);
941 break;
942
943 case BFD_RELOC_AVR_HH8_LDI:
944 bfd_putl16 ((bfd_vma) insn | LDI_IMMEDIATE (value >> 16), where);
945 break;
946
947 case BFD_RELOC_AVR_LO8_LDI_NEG:
948 bfd_putl16 ((bfd_vma) insn | LDI_IMMEDIATE (-value), where);
949 break;
950
951 case -BFD_RELOC_AVR_LO8_LDI_NEG:
952 bfd_putl16 ((bfd_vma) insn | LDI_IMMEDIATE (-value >> 16), where);
953 break;
954
955 case BFD_RELOC_AVR_HI8_LDI_NEG:
956 bfd_putl16 ((bfd_vma) insn | LDI_IMMEDIATE (-value >> 8), where);
957 break;
958
959 case -BFD_RELOC_AVR_HI8_LDI_NEG:
960 bfd_putl16 ((bfd_vma) insn | LDI_IMMEDIATE (-value >> 24), where);
961 break;
962
963 case BFD_RELOC_AVR_HH8_LDI_NEG:
964 bfd_putl16 ((bfd_vma) insn | LDI_IMMEDIATE (-value >> 16), where);
965 break;
966
967 case BFD_RELOC_AVR_LO8_LDI_PM:
968 bfd_putl16 ((bfd_vma) insn | LDI_IMMEDIATE (value >> 1), where);
969 break;
970
971 case BFD_RELOC_AVR_HI8_LDI_PM:
972 bfd_putl16 ((bfd_vma) insn | LDI_IMMEDIATE (value >> 9), where);
973 break;
974
975 case BFD_RELOC_AVR_HH8_LDI_PM:
976 bfd_putl16 ((bfd_vma) insn | LDI_IMMEDIATE (value >> 17), where);
977 break;
978
979 case BFD_RELOC_AVR_LO8_LDI_PM_NEG:
980 bfd_putl16 ((bfd_vma) insn | LDI_IMMEDIATE (-value >> 1), where);
981 break;
982
983 case BFD_RELOC_AVR_HI8_LDI_PM_NEG:
984 bfd_putl16 ((bfd_vma) insn | LDI_IMMEDIATE (-value >> 9), where);
985 break;
986
987 case BFD_RELOC_AVR_HH8_LDI_PM_NEG:
988 bfd_putl16 ((bfd_vma) insn | LDI_IMMEDIATE (-value >> 17), where);
989 break;
990
991 case BFD_RELOC_AVR_CALL:
992 {
993 unsigned long x;
994
995 x = bfd_getl16 (where);
996 if (value & 1)
997 as_bad_where (fixP->fx_file, fixP->fx_line,
998 _("odd address operand: %ld"), value);
999 value >>= 1;
1000 x |= ((value & 0x10000) | ((value << 3) & 0x1f00000)) >> 16;
1001 bfd_putl16 ((bfd_vma) x, where);
1002 bfd_putl16 ((bfd_vma) (value & 0xffff), where + 2);
1003 }
1004 break;
1005
1006 default:
1007 as_fatal (_("line %d: unknown relocation type: 0x%x"),
1008 fixP->fx_line, fixP->fx_r_type);
1009 break;
1010 }
1011 }
1012 else
1013 {
1014 switch (fixP->fx_r_type)
1015 {
1016 case -BFD_RELOC_AVR_HI8_LDI_NEG:
1017 case -BFD_RELOC_AVR_HI8_LDI:
1018 case -BFD_RELOC_AVR_LO8_LDI_NEG:
1019 case -BFD_RELOC_AVR_LO8_LDI:
1020 as_bad_where (fixP->fx_file, fixP->fx_line,
1021 _("only constant expression allowed"));
1022 fixP->fx_done = 1;
1023 break;
1024 default:
1025 break;
1026 }
1027 }
1028}
1029
1030/* A `BFD_ASSEMBLER' GAS will call this to generate a reloc. GAS
1031 will pass the resulting reloc to `bfd_install_relocation'. This
1032 currently works poorly, as `bfd_install_relocation' often does the
1033 wrong thing, and instances of `tc_gen_reloc' have been written to
1034 work around the problems, which in turns makes it difficult to fix
1035 `bfd_install_relocation'. */
1036
1037/* If while processing a fixup, a reloc really needs to be created
1038 then it is done here. */
1039
1040arelent *
1041tc_gen_reloc (seg, fixp)
1042 asection *seg ATTRIBUTE_UNUSED;
1043 fixS *fixp;
1044{
1045 arelent *reloc;
1046
1047 reloc = (arelent *) xmalloc (sizeof (arelent));
1048
1049 reloc->sym_ptr_ptr = (asymbol **) xmalloc (sizeof (asymbol *));
1050 *reloc->sym_ptr_ptr = symbol_get_bfdsym (fixp->fx_addsy);
1051
1052 reloc->address = fixp->fx_frag->fr_address + fixp->fx_where;
1053 reloc->howto = bfd_reloc_type_lookup (stdoutput, fixp->fx_r_type);
1054 if (reloc->howto == (reloc_howto_type *) NULL)
1055 {
1056 as_bad_where (fixp->fx_file, fixp->fx_line,
1057 _("reloc %d not supported by object file format"),
1058 (int) fixp->fx_r_type);
1059 return NULL;
1060 }
1061
1062 if (fixp->fx_r_type == BFD_RELOC_VTABLE_INHERIT
1063 || fixp->fx_r_type == BFD_RELOC_VTABLE_ENTRY)
1064 reloc->address = fixp->fx_offset;
1065
1066 reloc->addend = fixp->fx_offset;
1067
1068 return reloc;
1069}
1070
1071void
1072md_assemble (str)
1073 char *str;
1074{
1075 struct avr_opcodes_s *opcode;
1076 char op[11];
1077
1078 str = skip_space (extract_word (str, op, sizeof (op)));
1079
1080 if (!op[0])
1081 as_bad (_("can't find opcode "));
1082
1083 opcode = (struct avr_opcodes_s *) hash_find (avr_hash, op);
1084
1085 if (opcode == NULL)
1086 {
1087 as_bad (_("unknown opcode `%s'"), op);
1088 return;
1089 }
1090
1091 /* Special case for opcodes with optional operands (lpm, elpm) -
1092 version with operands exists in avr_opcodes[] in the next entry. */
1093
1094 if (*str && *opcode->constraints == '?')
1095 ++opcode;
1096
1097 if (!avr_opt.all_opcodes && (opcode->isa & avr_mcu->isa) != opcode->isa)
1098 as_bad (_("illegal opcode %s for mcu %s"), opcode->name, avr_mcu->name);
1099
1100 /* We used to set input_line_pointer to the result of get_operands,
1101 but that is wrong. Our caller assumes we don't change it. */
1102 {
1103 char *t = input_line_pointer;
1104 avr_operands (opcode, &str);
1105 if (*skip_space (str))
1106 as_bad (_("garbage at end of line"));
1107 input_line_pointer = t;
1108 }
1109}
1110
1111/* Parse ordinary expression. */
1112
1113static char *
1114parse_exp (s, op)
1115 char *s;
1116 expressionS *op;
1117{
1118 input_line_pointer = s;
1119 expression (op);
1120 if (op->X_op == O_absent)
1121 as_bad (_("missing operand"));
1122 return input_line_pointer;
1123}
1124
1125/* Parse special expressions (needed for LDI command):
1126 xx8 (address)
1127 xx8 (-address)
1128 pm_xx8 (address)
1129 pm_xx8 (-address)
1130 where xx is: hh, hi, lo. */
1131
1132static bfd_reloc_code_real_type
1133avr_ldi_expression (exp)
1134 expressionS *exp;
1135{
1136 char *str = input_line_pointer;
1137 char *tmp;
1138 char op[8];
1139 int mod;
1140 tmp = str;
1141
1142 str = extract_word (str, op, sizeof (op));
1143
1144 if (op[0])
1145 {
1146 mod = (int) hash_find (avr_mod_hash, op);
1147
1148 if (mod)
1149 {
1150 int closes = 0;
1151
1152 mod -= 10;
1153 str = skip_space (str);
1154
1155 if (*str == '(')
1156 {
1157 int neg_p = 0;
1158
1159 ++str;
1160
1161 if (strncmp ("pm(", str, 3) == 0
1162 || strncmp ("-(pm(", str, 5) == 0)
1163 {
1164 if (HAVE_PM_P (mod))
1165 {
1166 ++mod;
1167 ++closes;
1168 }
1169 else
1170 as_bad (_("illegal expression"));
1171
1172 if (*str == '-')
1173 {
1174 neg_p = 1;
1175 ++closes;
1176 str += 5;
1177 }
1178 else
1179 str += 3;
1180 }
1181
1182 if (*str == '-' && *(str + 1) == '(')
1183 {
1184 neg_p ^= 1;
1185 ++closes;
1186 str += 2;
1187 }
1188
1189 input_line_pointer = str;
1190 expression (exp);
1191
1192 do
1193 {
1194 if (*input_line_pointer != ')')
1195 {
1196 as_bad (_("`)' required"));
1197 break;
1198 }
1199 input_line_pointer++;
1200 }
1201 while (closes--);
1202
1203 return neg_p ? EXP_MOD_NEG_RELOC (mod) : EXP_MOD_RELOC (mod);
1204 }
1205 }
1206 }
1207
1208 input_line_pointer = tmp;
1209 expression (exp);
1210
1211 /* Warn about expressions that fail to use lo8 (). */
1212 if (exp->X_op == O_constant)
1213 {
1214 int x = exp->X_add_number;
1215 if (x < -255 || x > 255)
1216 as_warn (_("constant out of 8-bit range: %d"), x);
1217 }
1218 else
1219 as_warn (_("expression possibly out of 8-bit range"));
1220
1221 return BFD_RELOC_AVR_LO8_LDI;
1222}
1223
1224/* Flag to pass `pm' mode between `avr_parse_cons_expression' and
1225 `avr_cons_fix_new'. */
1226static int exp_mod_pm = 0;
1227
1228/* Parse special CONS expression: pm (expression)
1229 which is used for addressing to a program memory.
1230 Relocation: BFD_RELOC_AVR_16_PM. */
1231
1232void
1233avr_parse_cons_expression (exp, nbytes)
1234 expressionS *exp;
1235 int nbytes;
1236{
1237 char *tmp;
1238
1239 exp_mod_pm = 0;
1240
1241 tmp = input_line_pointer = skip_space (input_line_pointer);
1242
1243 if (nbytes == 2)
1244 {
1245 char *pm_name = "pm";
1246 int len = strlen (pm_name);
1247
1248 if (strncasecmp (input_line_pointer, pm_name, len) == 0)
1249 {
1250 input_line_pointer = skip_space (input_line_pointer + len);
1251
1252 if (*input_line_pointer == '(')
1253 {
1254 input_line_pointer = skip_space (input_line_pointer + 1);
1255 exp_mod_pm = 1;
1256 expression (exp);
1257
1258 if (*input_line_pointer == ')')
1259 ++input_line_pointer;
1260 else
1261 {
1262 as_bad (_("`)' required"));
1263 exp_mod_pm = 0;
1264 }
1265
1266 return;
1267 }
1268
1269 input_line_pointer = tmp;
1270 }
1271 }
1272
1273 expression (exp);
1274}
1275
1276void
1277avr_cons_fix_new (frag, where, nbytes, exp)
1278 fragS *frag;
1279 int where;
1280 int nbytes;
1281 expressionS *exp;
1282{
1283 if (exp_mod_pm == 0)
1284 {
1285 if (nbytes == 2)
1286 fix_new_exp (frag, where, nbytes, exp, FALSE, BFD_RELOC_16);
1287 else if (nbytes == 4)
1288 fix_new_exp (frag, where, nbytes, exp, FALSE, BFD_RELOC_32);
1289 else
1290 as_bad (_("illegal %srelocation size: %d"), "", nbytes);
1291 }
1292 else
1293 {
1294 if (nbytes == 2)
1295 fix_new_exp (frag, where, nbytes, exp, FALSE, BFD_RELOC_AVR_16_PM);
1296 else
1297 as_bad (_("illegal %srelocation size: %d"), "`pm' ", nbytes);
1298 exp_mod_pm = 0;
1299 }
1300}
Note: See TracBrowser for help on using the repository browser.