gas/config/tc-avr.c

   1 /* tc-avr.c -- Assembler code for the ATMEL AVR
   2
   3    Copyright 1999, 2000, 2001, 2002, 2004, 2005, 2006, 2007, 2008
   4    Free Software Foundation, Inc.
   5    Contributed by Denis Chertykov <denisc@overta.ru>
   6
   7    This file is part of GAS, the GNU Assembler.
   8
   9    GAS is free software; you can redistribute it and/or modify
  10    it under the terms of the GNU General Public License as published by
  11    the Free Software Foundation; either version 3, or (at your option)
  12    any later version.
  13
  14    GAS is distributed in the hope that it will be useful,
  15    but WITHOUT ANY WARRANTY; without even the implied warranty of
  16    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17    GNU General Public License for more details.
  18
  19    You should have received a copy of the GNU General Public License
  20    along with GAS; see the file COPYING.  If not, write to
  21    the Free Software Foundation, 51 Franklin Street - Fifth Floor,
  22    Boston, MA 02110-1301, USA.  */
  23
  24 #include "as.h"
  25 #include "safe-ctype.h"
  26 #include "subsegs.h"
  27
  28 struct 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
  40 struct avr_opcodes_s avr_opcodes[] =
  41 {
  42   #include "opcode/avr.h"
  43   {NULL, NULL, 0, 0, 0}
  44 };
  45
  46 const char comment_chars[] = ";";
  47 const char line_comment_chars[] = "#";
  48 const char line_separator_chars[] = "$";
  49
  50 const char *md_shortopts = "m:";
  51 struct 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
  61 static struct mcu_type_s mcu_types[] =
  62 {
  63   {"avr1",       AVR_ISA_AVR1,    bfd_mach_avr1},
  64 /* TODO: insruction set for avr2 architecture should be AVR_ISA_AVR2,
  65  but set to AVR_ISA_AVR25 for some following version
  66  of GCC (from 4.3) for backward compatibility.  */
  67   {"avr2",       AVR_ISA_AVR25,   bfd_mach_avr2},
  68   {"avr25",      AVR_ISA_AVR25,   bfd_mach_avr25},
  69 /* TODO: insruction set for avr3 architecture should be AVR_ISA_AVR3,
  70  but set to AVR_ISA_AVR3_ALL for some following version
  71  of GCC (from 4.3) for backward compatibility.  */
  72   {"avr3",       AVR_ISA_AVR3_ALL, bfd_mach_avr3},
  73   {"avr31",      AVR_ISA_AVR31,   bfd_mach_avr31},
  74   {"avr35",      AVR_ISA_AVR35,   bfd_mach_avr35},
  75   {"avr4",       AVR_ISA_AVR4,    bfd_mach_avr4},
  76 /* TODO: insruction set for avr5 architecture should be AVR_ISA_AVR5,
  77  but set to AVR_ISA_AVR51 for some following version
  78  of GCC (from 4.3) for backward compatibility.  */
  79   {"avr5",       AVR_ISA_AVR51,   bfd_mach_avr5},
  80   {"avr51",      AVR_ISA_AVR51,   bfd_mach_avr51},
  81   {"avr6",       AVR_ISA_AVR6,    bfd_mach_avr6},
  82   {"at90s1200",  AVR_ISA_1200,    bfd_mach_avr1},
  83   {"attiny11",   AVR_ISA_AVR1,    bfd_mach_avr1},
  84   {"attiny12",   AVR_ISA_AVR1,    bfd_mach_avr1},
  85   {"attiny15",   AVR_ISA_AVR1,    bfd_mach_avr1},
  86   {"attiny28",   AVR_ISA_AVR1,    bfd_mach_avr1},
  87   {"at90s2313",  AVR_ISA_AVR2,    bfd_mach_avr2},
  88   {"at90s2323",  AVR_ISA_AVR2,    bfd_mach_avr2},
  89   {"at90s2333",  AVR_ISA_AVR2,    bfd_mach_avr2}, /* XXX -> 4433 */
  90   {"at90s2343",  AVR_ISA_AVR2,    bfd_mach_avr2},
  91   {"attiny22",   AVR_ISA_AVR2,    bfd_mach_avr2}, /* XXX -> 2343 */
  92   {"attiny26",   AVR_ISA_2xxe,    bfd_mach_avr2},
  93   {"at90s4414",  AVR_ISA_AVR2,    bfd_mach_avr2}, /* XXX -> 8515 */
  94   {"at90s4433",  AVR_ISA_AVR2,    bfd_mach_avr2},
  95   {"at90s4434",  AVR_ISA_AVR2,    bfd_mach_avr2}, /* XXX -> 8535 */
  96   {"at90s8515",  AVR_ISA_AVR2,    bfd_mach_avr2},
  97   {"at90c8534",  AVR_ISA_AVR2,    bfd_mach_avr2},
  98   {"at90s8535",  AVR_ISA_AVR2,    bfd_mach_avr2},
  99   {"attiny13",   AVR_ISA_AVR25,   bfd_mach_avr25},
 100   {"attiny13a",  AVR_ISA_AVR25,   bfd_mach_avr25},
 101   {"attiny2313", AVR_ISA_AVR25,   bfd_mach_avr25},
 102   {"attiny24",   AVR_ISA_AVR25,   bfd_mach_avr25},
 103   {"attiny44",   AVR_ISA_AVR25,   bfd_mach_avr25},
 104   {"attiny84",   AVR_ISA_AVR25,   bfd_mach_avr25},
 105   {"attiny25",   AVR_ISA_AVR25,   bfd_mach_avr25},
 106   {"attiny45",   AVR_ISA_AVR25,   bfd_mach_avr25},
 107   {"attiny85",   AVR_ISA_AVR25,   bfd_mach_avr25},
 108   {"attiny261",  AVR_ISA_AVR25,   bfd_mach_avr25},
 109   {"attiny461",  AVR_ISA_AVR25,   bfd_mach_avr25},
 110   {"attiny861",  AVR_ISA_AVR25,   bfd_mach_avr25},
 111   {"attiny87",   AVR_ISA_AVR25,   bfd_mach_avr25},
 112   {"attiny43u",  AVR_ISA_AVR25,   bfd_mach_avr25},
 113   {"attiny48",   AVR_ISA_AVR25,   bfd_mach_avr25},
 114   {"attiny88",   AVR_ISA_AVR25,   bfd_mach_avr25},
 115   {"at86rf401",  AVR_ISA_RF401,   bfd_mach_avr25},
 116   {"ata6289",    AVR_ISA_AVR25,   bfd_mach_avr25},
 117   {"at43usb355", AVR_ISA_AVR3,    bfd_mach_avr3},
 118   {"at76c711",   AVR_ISA_AVR3,    bfd_mach_avr3},
 119   {"atmega103",  AVR_ISA_AVR31,   bfd_mach_avr31},
 120   {"at43usb320", AVR_ISA_AVR31,   bfd_mach_avr31},
 121   {"attiny167",  AVR_ISA_AVR35,   bfd_mach_avr35},
 122   {"attiny327",  AVR_ISA_AVR35,   bfd_mach_avr35},
 123   {"at90usb82",  AVR_ISA_AVR35,   bfd_mach_avr35},
 124   {"at90usb162", AVR_ISA_AVR35,   bfd_mach_avr35},
 125   {"atmega8u2",  AVR_ISA_AVR35,   bfd_mach_avr35},
 126   {"atmega16u2", AVR_ISA_AVR35,   bfd_mach_avr35},
 127   {"atmega32u2", AVR_ISA_AVR35,   bfd_mach_avr35},
 128   {"atmega8",    AVR_ISA_M8,      bfd_mach_avr4},
 129   {"atmega48",   AVR_ISA_AVR4,    bfd_mach_avr4},
 130   {"atmega48p",  AVR_ISA_AVR4,    bfd_mach_avr4},
 131   {"atmega88",   AVR_ISA_AVR4,    bfd_mach_avr4},
 132   {"atmega88p",  AVR_ISA_AVR4,    bfd_mach_avr4},
 133   {"atmega8515", AVR_ISA_M8,      bfd_mach_avr4},
 134   {"atmega8535", AVR_ISA_M8,      bfd_mach_avr4},
 135   {"atmega8hva", AVR_ISA_AVR4,    bfd_mach_avr4},
 136   {"atmega4hvd", AVR_ISA_AVR4,    bfd_mach_avr4},
 137   {"atmega8hvd", AVR_ISA_AVR4,    bfd_mach_avr4},
 138   {"atmega8c1",  AVR_ISA_AVR4,    bfd_mach_avr4},
 139   {"atmega8m1",  AVR_ISA_AVR4,    bfd_mach_avr4},
 140   {"at90pwm1",   AVR_ISA_AVR4,    bfd_mach_avr4},
 141   {"at90pwm2",   AVR_ISA_AVR4,    bfd_mach_avr4},
 142   {"at90pwm2b",  AVR_ISA_AVR4,    bfd_mach_avr4},
 143   {"at90pwm3",   AVR_ISA_AVR4,    bfd_mach_avr4},
 144   {"at90pwm3b",  AVR_ISA_AVR4,    bfd_mach_avr4},
 145   {"at90pwm81",  AVR_ISA_AVR4,    bfd_mach_avr4},
 146   {"atmega16",   AVR_ISA_AVR5,    bfd_mach_avr5},
 147   {"atmega161",  AVR_ISA_M161,    bfd_mach_avr5},
 148   {"atmega162",  AVR_ISA_AVR5,    bfd_mach_avr5},
 149   {"atmega163",  AVR_ISA_M161,    bfd_mach_avr5},
 150   {"atmega164p", AVR_ISA_AVR5,    bfd_mach_avr5},
 151   {"atmega165",  AVR_ISA_AVR5,    bfd_mach_avr5},
 152   {"atmega165p", AVR_ISA_AVR5,    bfd_mach_avr5},
 153   {"atmega168",  AVR_ISA_AVR5,    bfd_mach_avr5},
 154   {"atmega168p", AVR_ISA_AVR5,    bfd_mach_avr5},
 155   {"atmega169",  AVR_ISA_AVR5,    bfd_mach_avr5},
 156   {"atmega169p", AVR_ISA_AVR5,    bfd_mach_avr5},
 157   {"atmega16c1", AVR_ISA_AVR5,    bfd_mach_avr5},
 158   {"atmega32",   AVR_ISA_AVR5,    bfd_mach_avr5},
 159   {"atmega323",  AVR_ISA_AVR5,    bfd_mach_avr5},
 160   {"atmega324p", AVR_ISA_AVR5,    bfd_mach_avr5},
 161   {"atmega325",  AVR_ISA_AVR5,    bfd_mach_avr5},
 162   {"atmega325p", AVR_ISA_AVR5,    bfd_mach_avr5},
 163   {"atmega3250", AVR_ISA_AVR5,    bfd_mach_avr5},
 164   {"atmega3250p",AVR_ISA_AVR5,    bfd_mach_avr5},
 165   {"atmega328p", AVR_ISA_AVR5,    bfd_mach_avr5},
 166   {"atmega329",  AVR_ISA_AVR5,    bfd_mach_avr5},
 167   {"atmega329p", AVR_ISA_AVR5,    bfd_mach_avr5},
 168   {"atmega3290", AVR_ISA_AVR5,    bfd_mach_avr5},
 169   {"atmega3290p",AVR_ISA_AVR5,    bfd_mach_avr5},
 170   {"atmega406",  AVR_ISA_AVR5,    bfd_mach_avr5},
 171   {"atmega64",   AVR_ISA_AVR5,    bfd_mach_avr5},
 172   {"atmega640",  AVR_ISA_AVR5,    bfd_mach_avr5},
 173   {"atmega644",  AVR_ISA_AVR5,    bfd_mach_avr5},
 174   {"atmega644p", AVR_ISA_AVR5,    bfd_mach_avr5},
 175   {"atmega645",  AVR_ISA_AVR5,    bfd_mach_avr5},
 176   {"atmega649",  AVR_ISA_AVR5,    bfd_mach_avr5},
 177   {"atmega6450", AVR_ISA_AVR5,    bfd_mach_avr5},
 178   {"atmega6490", AVR_ISA_AVR5,    bfd_mach_avr5},
 179   {"atmega16hva",AVR_ISA_AVR5,    bfd_mach_avr5},
 180   {"atmega16hvb",AVR_ISA_AVR5,    bfd_mach_avr5},
 181   {"atmega32hvb",AVR_ISA_AVR5,    bfd_mach_avr5},
 182   {"at90can32" , AVR_ISA_AVR5,    bfd_mach_avr5},
 183   {"at90can64" , AVR_ISA_AVR5,    bfd_mach_avr5},
 184   {"at90pwm216", AVR_ISA_AVR5,    bfd_mach_avr5},
 185   {"at90pwm316", AVR_ISA_AVR5,    bfd_mach_avr5},
 186   {"atmega32c1", AVR_ISA_AVR5,    bfd_mach_avr5},
 187   {"atmega64c1", AVR_ISA_AVR5,    bfd_mach_avr5},
 188   {"atmega16m1", AVR_ISA_AVR5,    bfd_mach_avr5},
 189   {"atmega32m1", AVR_ISA_AVR5,    bfd_mach_avr5},
 190   {"atmega64m1", AVR_ISA_AVR5,    bfd_mach_avr5},
 191   {"atmega16u4", AVR_ISA_AVR5,    bfd_mach_avr5},
 192   {"atmega32u4", AVR_ISA_AVR5,    bfd_mach_avr5},
 193   {"atmega32u6", AVR_ISA_AVR5,    bfd_mach_avr5},
 194   {"at90usb646", AVR_ISA_AVR5,    bfd_mach_avr5},
 195   {"at90usb647", AVR_ISA_AVR5,    bfd_mach_avr5},
 196   {"at90scr100", AVR_ISA_AVR5,    bfd_mach_avr5},
 197   {"at94k",      AVR_ISA_94K,     bfd_mach_avr5},
 198   {"atmega128",  AVR_ISA_AVR51,   bfd_mach_avr51},
 199   {"atmega1280", AVR_ISA_AVR51,   bfd_mach_avr51},
 200   {"atmega1281", AVR_ISA_AVR51,   bfd_mach_avr51},
 201   {"atmega1284p",AVR_ISA_AVR51,   bfd_mach_avr51},
 202   {"atmega128rfa1",AVR_ISA_AVR51, bfd_mach_avr51},
 203   {"at90can128", AVR_ISA_AVR51,   bfd_mach_avr51},
 204   {"at90usb1286",AVR_ISA_AVR51,   bfd_mach_avr51},
 205   {"at90usb1287",AVR_ISA_AVR51,   bfd_mach_avr51},
 206   {"m3000f",     AVR_ISA_AVR51,   bfd_mach_avr51},
 207   {"m3000s",     AVR_ISA_AVR51,   bfd_mach_avr51},
 208   {"m3001b",     AVR_ISA_AVR51,   bfd_mach_avr51},
 209   {"atmega2560", AVR_ISA_AVR6,    bfd_mach_avr6},
 210   {"atmega2561", AVR_ISA_AVR6,    bfd_mach_avr6},
 211   {NULL, 0, 0}
 212 };
 213
 214 /* Current MCU type.  */
 215 static struct mcu_type_s   default_mcu = {"avr2", AVR_ISA_AVR2, bfd_mach_avr2};
 216 static struct mcu_type_s * avr_mcu = & default_mcu;
 217
 218 /* AVR target-specific switches.  */
 219 struct avr_opt_s
 220 {
 221   int all_opcodes;  /* -mall-opcodes: accept all known AVR opcodes.  */
 222   int no_skip_bug;  /* -mno-skip-bug: no warnings for skipping 2-word insns.  */
 223   int no_wrap;      /* -mno-wrap: reject rjmp/rcall with 8K wrap-around.  */
 224 };
 225
 226 static struct avr_opt_s avr_opt = { 0, 0, 0 };
 227
 228 const char EXP_CHARS[] = "eE";
 229 const char FLT_CHARS[] = "dD";
 230
 231 static void avr_set_arch (int);
 232
 233 /* The target specific pseudo-ops which we support.  */
 234 const pseudo_typeS md_pseudo_table[] =
 235 {
 236   {"arch", avr_set_arch,        0},
 237   { NULL,       NULL,           0}
 238 };
 239
 240 #define LDI_IMMEDIATE(x) (((x) & 0xf) | (((x) << 4) & 0xf00))
 241
 242 #define EXP_MOD_NAME(i)       exp_mod[i].name
 243 #define EXP_MOD_RELOC(i)      exp_mod[i].reloc
 244 #define EXP_MOD_NEG_RELOC(i)  exp_mod[i].neg_reloc
 245 #define HAVE_PM_P(i)          exp_mod[i].have_pm
 246
 247 struct exp_mod_s
 248 {
 249   char *                    name;
 250   bfd_reloc_code_real_type  reloc;
 251   bfd_reloc_code_real_type  neg_reloc;
 252   int                       have_pm;
 253 };
 254
 255 static struct exp_mod_s exp_mod[] =
 256 {
 257   {"hh8",    BFD_RELOC_AVR_HH8_LDI,    BFD_RELOC_AVR_HH8_LDI_NEG,    1},
 258   {"pm_hh8", BFD_RELOC_AVR_HH8_LDI_PM, BFD_RELOC_AVR_HH8_LDI_PM_NEG, 0},
 259   {"hi8",    BFD_RELOC_AVR_HI8_LDI,    BFD_RELOC_AVR_HI8_LDI_NEG,    1},
 260   {"pm_hi8", BFD_RELOC_AVR_HI8_LDI_PM, BFD_RELOC_AVR_HI8_LDI_PM_NEG, 0},
 261   {"lo8",    BFD_RELOC_AVR_LO8_LDI,    BFD_RELOC_AVR_LO8_LDI_NEG,    1},
 262   {"pm_lo8", BFD_RELOC_AVR_LO8_LDI_PM, BFD_RELOC_AVR_LO8_LDI_PM_NEG, 0},
 263   {"hlo8",   BFD_RELOC_AVR_HH8_LDI,    BFD_RELOC_AVR_HH8_LDI_NEG,    0},
 264   {"hhi8",   BFD_RELOC_AVR_MS8_LDI,    BFD_RELOC_AVR_MS8_LDI_NEG,    0},
 265 };
 266
 267 /* A union used to store indicies into the exp_mod[] array
 268    in a hash table which expects void * data types.  */
 269 typedef union
 270 {
 271   void * ptr;
 272   int    index;
 273 } mod_index;
 274
 275 /* Opcode hash table.  */
 276 static struct hash_control *avr_hash;
 277
 278 /* Reloc modifiers hash control (hh8,hi8,lo8,pm_xx).  */
 279 static struct hash_control *avr_mod_hash;
 280
 281 #define OPTION_MMCU 'm'
 282 enum options
 283 {
 284   OPTION_ALL_OPCODES = OPTION_MD_BASE + 1,
 285   OPTION_NO_SKIP_BUG,
 286   OPTION_NO_WRAP
 287 };
 288
 289 struct option md_longopts[] =
 290 {
 291   { "mmcu",   required_argument, NULL, OPTION_MMCU        },
 292   { "mall-opcodes", no_argument, NULL, OPTION_ALL_OPCODES },
 293   { "mno-skip-bug", no_argument, NULL, OPTION_NO_SKIP_BUG },
 294   { "mno-wrap",     no_argument, NULL, OPTION_NO_WRAP     },
 295   { NULL, no_argument, NULL, 0 }
 296 };
 297
 298 size_t md_longopts_size = sizeof (md_longopts);
 299
 300 /* Display nicely formatted list of known MCU names.  */
 301
 302 static void
 303 show_mcu_list (FILE *stream)
 304 {
 305   int i, x;
 306
 307   fprintf (stream, _("Known MCU names:"));
 308   x = 1000;
 309
 310   for (i = 0; mcu_types[i].name; i++)
 311     {
 312       int len = strlen (mcu_types[i].name);
 313
 314       x += len + 1;
 315
 316       if (x < 75)
 317         fprintf (stream, " %s", mcu_types[i].name);
 318       else
 319         {
 320           fprintf (stream, "\n  %s", mcu_types[i].name);
 321           x = len + 2;
 322         }
 323     }
 324
 325   fprintf (stream, "\n");
 326 }
 327
 328 static inline char *
 329 skip_space (char *s)
 330 {
 331   while (*s == ' ' || *s == '\t')
 332     ++s;
 333   return s;
 334 }
 335
 336 /* Extract one word from FROM and copy it to TO.  */
 337
 338 static char *
 339 extract_word (char *from, char *to, int limit)
 340 {
 341   char *op_start;
 342   char *op_end;
 343   int size = 0;
 344
 345   /* Drop leading whitespace.  */
 346   from = skip_space (from);
 347   *to = 0;
 348
 349   /* Find the op code end.  */
 350   for (op_start = op_end = from; *op_end != 0 && is_part_of_name (*op_end);)
 351     {
 352       to[size++] = *op_end++;
 353       if (size + 1 >= limit)
 354         break;
 355     }
 356
 357   to[size] = 0;
 358   return op_end;
 359 }
 360
 361 int
 362 md_estimate_size_before_relax (fragS *fragp ATTRIBUTE_UNUSED,
 363                                asection *seg ATTRIBUTE_UNUSED)
 364 {
 365   abort ();
 366   return 0;
 367 }
 368
 369 void
 370 md_show_usage (FILE *stream)
 371 {
 372   fprintf (stream,
 373       _("AVR options:\n"
 374         "  -mmcu=[avr-name] select microcontroller variant\n"
 375         "                   [avr-name] can be:\n"
 376         "                   avr1  - classic AVR core without data RAM\n"
 377         "                   avr2  - classic AVR core with up to 8K program memory\n"
 378         "                   avr25 - classic AVR core with up to 8K program memory\n"
 379         "                           plus the MOVW instruction\n"
 380         "                   avr3  - classic AVR core with up to 64K program memory\n"
 381         "                   avr31 - classic AVR core with up to 128K program memory\n"
 382         "                   avr35 - classic AVR core with up to 64K program memory\n"
 383         "                           plus the MOVW instruction\n"
 384         "                   avr4  - enhanced AVR core with up to 8K program memory\n"
 385         "                   avr5  - enhanced AVR core with up to 64K program memory\n"
 386         "                   avr51 - enhanced AVR core with up to 128K program memory\n"
 387         "                   avr6  - enhanced AVR core with up to 256K program memory\n"
 388         "                   or immediate microcontroller name.\n"));
 389   fprintf (stream,
 390       _("  -mall-opcodes    accept all AVR opcodes, even if not supported by MCU\n"
 391         "  -mno-skip-bug    disable warnings for skipping two-word instructions\n"
 392         "                   (default for avr4, avr5)\n"
 393         "  -mno-wrap        reject rjmp/rcall instructions with 8K wrap-around\n"
 394         "                   (default for avr3, avr5)\n"));
 395   show_mcu_list (stream);
 396 }
 397
 398 static void
 399 avr_set_arch (int dummy ATTRIBUTE_UNUSED)
 400 {
 401   char str[20];
 402
 403   input_line_pointer = extract_word (input_line_pointer, str, 20);
 404   md_parse_option (OPTION_MMCU, str);
 405   bfd_set_arch_mach (stdoutput, TARGET_ARCH, avr_mcu->mach);
 406 }
 407
 408 int
 409 md_parse_option (int c, char *arg)
 410 {
 411   switch (c)
 412     {
 413     case OPTION_MMCU:
 414       {
 415         int i;
 416         char *s = alloca (strlen (arg) + 1);
 417
 418         {
 419           char *t = s;
 420           char *arg1 = arg;
 421
 422           do
 423             *t = TOLOWER (*arg1++);
 424           while (*t++);
 425         }
 426
 427         for (i = 0; mcu_types[i].name; ++i)
 428           if (strcmp (mcu_types[i].name, s) == 0)
 429             break;
 430
 431         if (!mcu_types[i].name)
 432           {
 433             show_mcu_list (stderr);
 434             as_fatal (_("unknown MCU: %s\n"), arg);
 435           }
 436
 437         /* It is OK to redefine mcu type within the same avr[1-5] bfd machine
 438            type - this for allows passing -mmcu=... via gcc ASM_SPEC as well
 439            as .arch ... in the asm output at the same time.  */
 440         if (avr_mcu == &default_mcu || avr_mcu->mach == mcu_types[i].mach)
 441           avr_mcu = &mcu_types[i];
 442         else
 443           as_fatal (_("redefinition of mcu type `%s' to `%s'"),
 444                     avr_mcu->name, mcu_types[i].name);
 445         return 1;
 446       }
 447     case OPTION_ALL_OPCODES:
 448       avr_opt.all_opcodes = 1;
 449       return 1;
 450     case OPTION_NO_SKIP_BUG:
 451       avr_opt.no_skip_bug = 1;
 452       return 1;
 453     case OPTION_NO_WRAP:
 454       avr_opt.no_wrap = 1;
 455       return 1;
 456     }
 457
 458   return 0;
 459 }
 460
 461 symbolS *
 462 md_undefined_symbol (char *name ATTRIBUTE_UNUSED)
 463 {
 464   return NULL;
 465 }
 466
 467 char *
 468 md_atof (int type, char *litP, int *sizeP)
 469 {
 470   return ieee_md_atof (type, litP, sizeP, FALSE);
 471 }
 472
 473 void
 474 md_convert_frag (bfd *abfd ATTRIBUTE_UNUSED,
 475                  asection *sec ATTRIBUTE_UNUSED,
 476                  fragS *fragP ATTRIBUTE_UNUSED)
 477 {
 478   abort ();
 479 }
 480
 481 void
 482 md_begin (void)
 483 {
 484   unsigned int i;
 485   struct avr_opcodes_s *opcode;
 486
 487   avr_hash = hash_new ();
 488
 489   /* Insert unique names into hash table.  This hash table then provides a
 490      quick index to the first opcode with a particular name in the opcode
 491      table.  */
 492   for (opcode = avr_opcodes; opcode->name; opcode++)
 493     hash_insert (avr_hash, opcode->name, (char *) opcode);
 494
 495   avr_mod_hash = hash_new ();
 496
 497   for (i = 0; i < ARRAY_SIZE (exp_mod); ++i)
 498     {
 499       mod_index m;
 500
 501       m.index = i + 10;
 502       hash_insert (avr_mod_hash, EXP_MOD_NAME (i), m.ptr);
 503     }
 504
 505   bfd_set_arch_mach (stdoutput, TARGET_ARCH, avr_mcu->mach);
 506 }
 507
 508 /* Resolve STR as a constant expression and return the result.
 509    If result greater than MAX then error.  */
 510
 511 static unsigned int
 512 avr_get_constant (char *str, int max)
 513 {
 514   expressionS ex;
 515
 516   str = skip_space (str);
 517   input_line_pointer = str;
 518   expression (& ex);
 519
 520   if (ex.X_op != O_constant)
 521     as_bad (_("constant value required"));
 522
 523   if (ex.X_add_number > max || ex.X_add_number < 0)
 524     as_bad (_("number must be positive and less than %d"), max + 1);
 525
 526   return ex.X_add_number;
 527 }
 528
 529 /* Parse for ldd/std offset.  */
 530
 531 static void
 532 avr_offset_expression (expressionS *exp)
 533 {
 534   char *str = input_line_pointer;
 535   char *tmp;
 536   char op[8];
 537
 538   tmp = str;
 539   str = extract_word (str, op, sizeof (op));
 540
 541   input_line_pointer = tmp;
 542   expression (exp);
 543
 544   /* Warn about expressions that fail to use lo8 ().  */
 545   if (exp->X_op == O_constant)
 546     {
 547       int x = exp->X_add_number;
 548
 549       if (x < -255 || x > 255)
 550         as_warn (_("constant out of 8-bit range: %d"), x);
 551     }
 552 }
 553
 554 /* Parse ordinary expression.  */
 555
 556 static char *
 557 parse_exp (char *s, expressionS *op)
 558 {
 559   input_line_pointer = s;
 560   expression (op);
 561   if (op->X_op == O_absent)
 562     as_bad (_("missing operand"));
 563   return input_line_pointer;
 564 }
 565
 566 /* Parse special expressions (needed for LDI command):
 567    xx8 (address)
 568    xx8 (-address)
 569    pm_xx8 (address)
 570    pm_xx8 (-address)
 571    where xx is: hh, hi, lo.  */
 572
 573 static bfd_reloc_code_real_type
 574 avr_ldi_expression (expressionS *exp)
 575 {
 576   char *str = input_line_pointer;
 577   char *tmp;
 578   char op[8];
 579   int mod;
 580   int linker_stubs_should_be_generated = 0;
 581
 582   tmp = str;
 583
 584   str = extract_word (str, op, sizeof (op));
 585
 586   if (op[0])
 587     {
 588       mod_index m;
 589
 590       m.ptr = hash_find (avr_mod_hash, op);
 591       mod = m.index;
 592
 593       if (mod)
 594         {
 595           int closes = 0;
 596
 597           mod -= 10;
 598           str = skip_space (str);
 599
 600           if (*str == '(')
 601             {
 602               bfd_reloc_code_real_type  reloc_to_return;
 603               int neg_p = 0;
 604
 605               ++str;
 606
 607               if (strncmp ("pm(", str, 3) == 0
 608                   || strncmp ("gs(",str,3) == 0
 609                   || strncmp ("-(gs(",str,5) == 0
 610                   || strncmp ("-(pm(", str, 5) == 0)
 611                 {
 612                   if (HAVE_PM_P (mod))
 613                     {
 614                       ++mod;
 615                       ++closes;
 616                     }
 617                   else
 618                     as_bad (_("illegal expression"));
 619
 620                   if (str[0] == 'g' || str[2] == 'g')
 621                     linker_stubs_should_be_generated = 1;
 622
 623                   if (*str == '-')
 624                     {
 625                       neg_p = 1;
 626                       ++closes;
 627                       str += 5;
 628                     }
 629                   else
 630                     str += 3;
 631                 }
 632
 633               if (*str == '-' && *(str + 1) == '(')
 634                 {
 635                   neg_p ^= 1;
 636                   ++closes;
 637                   str += 2;
 638                 }
 639
 640               input_line_pointer = str;
 641               expression (exp);
 642
 643               do
 644                 {
 645                   if (*input_line_pointer != ')')
 646                     {
 647                       as_bad (_("`)' required"));
 648                       break;
 649                     }
 650                   input_line_pointer++;
 651                 }
 652               while (closes--);
 653
 654               reloc_to_return =
 655                 neg_p ? EXP_MOD_NEG_RELOC (mod) : EXP_MOD_RELOC (mod);
 656               if (linker_stubs_should_be_generated)
 657                 {
 658                   switch (reloc_to_return)
 659                     {
 660                     case BFD_RELOC_AVR_LO8_LDI_PM:
 661                       reloc_to_return = BFD_RELOC_AVR_LO8_LDI_GS;
 662                       break;
 663                     case BFD_RELOC_AVR_HI8_LDI_PM:
 664                       reloc_to_return = BFD_RELOC_AVR_HI8_LDI_GS;
 665                       break;
 666
 667                     default:
 668                       /* PR 5523: Do not generate a warning here,
 669                          legitimate code can trigger this case.  */
 670                       break;
 671                     }
 672                 }
 673               return reloc_to_return;
 674             }
 675         }
 676     }
 677
 678   input_line_pointer = tmp;
 679   expression (exp);
 680
 681   /* Warn about expressions that fail to use lo8 ().  */
 682   if (exp->X_op == O_constant)
 683     {
 684       int x = exp->X_add_number;
 685
 686       if (x < -255 || x > 255)
 687         as_warn (_("constant out of 8-bit range: %d"), x);
 688     }
 689
 690   return BFD_RELOC_AVR_LDI;
 691 }
 692
 693 /* Parse one instruction operand.
 694    Return operand bitmask.  Also fixups can be generated.  */
 695
 696 static unsigned int
 697 avr_operand (struct avr_opcodes_s *opcode,
 698              int where,
 699              char *op,
 700              char **line)
 701 {
 702   expressionS op_expr;
 703   unsigned int op_mask = 0;
 704   char *str = skip_space (*line);
 705
 706   switch (*op)
 707     {
 708       /* Any register operand.  */
 709     case 'w':
 710     case 'd':
 711     case 'r':
 712     case 'a':
 713     case 'v':
 714       if (*str == 'r' || *str == 'R')
 715         {
 716           char r_name[20];
 717
 718           str = extract_word (str, r_name, sizeof (r_name));
 719           op_mask = 0xff;
 720           if (ISDIGIT (r_name[1]))
 721             {
 722               if (r_name[2] == '\0')
 723                 op_mask = r_name[1] - '0';
 724               else if (r_name[1] != '0'
 725                        && ISDIGIT (r_name[2])
 726                        && r_name[3] == '\0')
 727                 op_mask = (r_name[1] - '0') * 10 + r_name[2] - '0';
 728             }
 729         }
 730       else
 731         {
 732           op_mask = avr_get_constant (str, 31);
 733           str = input_line_pointer;
 734         }
 735
 736       if (op_mask <= 31)
 737         {
 738           switch (*op)
 739             {
 740             case 'a':
 741               if (op_mask < 16 || op_mask > 23)
 742                 as_bad (_("register r16-r23 required"));
 743               op_mask -= 16;
 744               break;
 745
 746             case 'd':
 747               if (op_mask < 16)
 748                 as_bad (_("register number above 15 required"));
 749               op_mask -= 16;
 750               break;
 751
 752             case 'v':
 753               if (op_mask & 1)
 754                 as_bad (_("even register number required"));
 755               op_mask >>= 1;
 756               break;
 757
 758             case 'w':
 759               if ((op_mask & 1) || op_mask < 24)
 760                 as_bad (_("register r24, r26, r28 or r30 required"));
 761               op_mask = (op_mask - 24) >> 1;
 762               break;
 763             }
 764           break;
 765         }
 766       as_bad (_("register name or number from 0 to 31 required"));
 767       break;
 768
 769     case 'e':
 770       {
 771         char c;
 772
 773         if (*str == '-')
 774           {
 775             str = skip_space (str + 1);
 776             op_mask = 0x1002;
 777           }
 778         c = TOLOWER (*str);
 779         if (c == 'x')
 780           op_mask |= 0x100c;
 781         else if (c == 'y')
 782           op_mask |= 0x8;
 783         else if (c != 'z')
 784           as_bad (_("pointer register (X, Y or Z) required"));
 785
 786         str = skip_space (str + 1);
 787         if (*str == '+')
 788           {
 789             ++str;
 790             if (op_mask & 2)
 791               as_bad (_("cannot both predecrement and postincrement"));
 792             op_mask |= 0x1001;
 793           }
 794
 795         /* avr1 can do "ld r,Z" and "st Z,r" but no other pointer
 796            registers, no predecrement, no postincrement.  */
 797         if (!avr_opt.all_opcodes && (op_mask & 0x100F)
 798             && !(avr_mcu->isa & AVR_ISA_SRAM))
 799           as_bad (_("addressing mode not supported"));
 800       }
 801       break;
 802
 803     case 'z':
 804       if (*str == '-')
 805         as_bad (_("can't predecrement"));
 806
 807       if (! (*str == 'z' || *str == 'Z'))
 808         as_bad (_("pointer register Z required"));
 809
 810       str = skip_space (str + 1);
 811
 812       if (*str == '+')
 813         {
 814           ++str;
 815           op_mask |= 1;
 816         }
 817
 818       /* attiny26 can do "lpm" and "lpm r,Z" but not "lpm r,Z+".  */
 819       if (!avr_opt.all_opcodes
 820           && (op_mask & 0x0001)
 821           && !(avr_mcu->isa & AVR_ISA_MOVW))
 822         as_bad (_("postincrement not supported"));
 823       break;
 824
 825     case 'b':
 826       {
 827         char c = TOLOWER (*str++);
 828
 829         if (c == 'y')
 830           op_mask |= 0x8;
 831         else if (c != 'z')
 832           as_bad (_("pointer register (Y or Z) required"));
 833         str = skip_space (str);
 834         if (*str++ == '+')
 835           {
 836             input_line_pointer = str;
 837             avr_offset_expression (& op_expr);
 838             str = input_line_pointer;
 839             fix_new_exp (frag_now, where, 3,
 840                          &op_expr, FALSE, BFD_RELOC_AVR_6);
 841           }
 842       }
 843       break;
 844
 845     case 'h':
 846       str = parse_exp (str, &op_expr);
 847       fix_new_exp (frag_now, where, opcode->insn_size * 2,
 848                    &op_expr, FALSE, BFD_RELOC_AVR_CALL);
 849       break;
 850
 851     case 'L':
 852       str = parse_exp (str, &op_expr);
 853       fix_new_exp (frag_now, where, opcode->insn_size * 2,
 854                    &op_expr, TRUE, BFD_RELOC_AVR_13_PCREL);
 855       break;
 856
 857     case 'l':
 858       str = parse_exp (str, &op_expr);
 859       fix_new_exp (frag_now, where, opcode->insn_size * 2,
 860                    &op_expr, TRUE, BFD_RELOC_AVR_7_PCREL);
 861       break;
 862
 863     case 'i':
 864       str = parse_exp (str, &op_expr);
 865       fix_new_exp (frag_now, where + 2, opcode->insn_size * 2,
 866                    &op_expr, FALSE, BFD_RELOC_16);
 867       break;
 868
 869     case 'M':
 870       {
 871         bfd_reloc_code_real_type r_type;
 872
 873         input_line_pointer = str;
 874         r_type = avr_ldi_expression (&op_expr);
 875         str = input_line_pointer;
 876         fix_new_exp (frag_now, where, 3,
 877                      &op_expr, FALSE, r_type);
 878       }
 879       break;
 880
 881     case 'n':
 882       {
 883         unsigned int x;
 884
 885         x = ~avr_get_constant (str, 255);
 886         str = input_line_pointer;
 887         op_mask |= (x & 0xf) | ((x << 4) & 0xf00);
 888       }
 889       break;
 890
 891     case 'K':
 892       input_line_pointer = str;
 893       avr_offset_expression (& op_expr);
 894       str = input_line_pointer;
 895       fix_new_exp (frag_now, where, 3,
 896                    & op_expr, FALSE, BFD_RELOC_AVR_6_ADIW);
 897       break;
 898
 899     case 'S':
 900     case 's':
 901       {
 902         unsigned int x;
 903
 904         x = avr_get_constant (str, 7);
 905         str = input_line_pointer;
 906         if (*op == 'S')
 907           x <<= 4;
 908         op_mask |= x;
 909       }
 910       break;
 911
 912     case 'P':
 913       {
 914         unsigned int x;
 915
 916         x = avr_get_constant (str, 63);
 917         str = input_line_pointer;
 918         op_mask |= (x & 0xf) | ((x & 0x30) << 5);
 919       }
 920       break;
 921
 922     case 'p':
 923       {
 924         unsigned int x;
 925
 926         x = avr_get_constant (str, 31);
 927         str = input_line_pointer;
 928         op_mask |= x << 3;
 929       }
 930       break;
 931
 932     case '?':
 933       break;
 934
 935     default:
 936       as_bad (_("unknown constraint `%c'"), *op);
 937     }
 938
 939   *line = str;
 940   return op_mask;
 941 }
 942
 943 /* Parse instruction operands.
 944    Return binary opcode.  */
 945
 946 static unsigned int
 947 avr_operands (struct avr_opcodes_s *opcode, char **line)
 948 {
 949   char *op = opcode->constraints;
 950   unsigned int bin = opcode->bin_opcode;
 951   char *frag = frag_more (opcode->insn_size * 2);
 952   char *str = *line;
 953   int where = frag - frag_now->fr_literal;
 954   static unsigned int prev = 0;  /* Previous opcode.  */
 955
 956   /* Opcode have operands.  */
 957   if (*op)
 958     {
 959       unsigned int reg1 = 0;
 960       unsigned int reg2 = 0;
 961       int reg1_present = 0;
 962       int reg2_present = 0;
 963
 964       /* Parse first operand.  */
 965       if (REGISTER_P (*op))
 966         reg1_present = 1;
 967       reg1 = avr_operand (opcode, where, op, &str);
 968       ++op;
 969
 970       /* Parse second operand.  */
 971       if (*op)
 972         {
 973           if (*op == ',')
 974             ++op;
 975
 976           if (*op == '=')
 977             {
 978               reg2 = reg1;
 979               reg2_present = 1;
 980             }
 981           else
 982             {
 983               if (REGISTER_P (*op))
 984                 reg2_present = 1;
 985
 986               str = skip_space (str);
 987               if (*str++ != ',')
 988                 as_bad (_("`,' required"));
 989               str = skip_space (str);
 990
 991               reg2 = avr_operand (opcode, where, op, &str);
 992             }
 993
 994           if (reg1_present && reg2_present)
 995             reg2 = (reg2 & 0xf) | ((reg2 << 5) & 0x200);
 996           else if (reg2_present)
 997             reg2 <<= 4;
 998         }
 999       if (reg1_present)
1000         reg1 <<= 4;
1001       bin |= reg1 | reg2;
1002     }
1003
1004   /* Detect undefined combinations (like ld r31,Z+).  */
1005   if (!avr_opt.all_opcodes && AVR_UNDEF_P (bin))
1006     as_warn (_("undefined combination of operands"));
1007
1008   if (opcode->insn_size == 2)
1009     {
1010       /* Warn if the previous opcode was cpse/sbic/sbis/sbrc/sbrs
1011          (AVR core bug, fixed in the newer devices).  */
1012       if (!(avr_opt.no_skip_bug ||
1013             (avr_mcu->isa & (AVR_ISA_MUL | AVR_ISA_MOVW)))
1014           && AVR_SKIP_P (prev))
1015         as_warn (_("skipping two-word instruction"));
1016
1017       bfd_putl32 ((bfd_vma) bin, frag);
1018     }
1019   else
1020     bfd_putl16 ((bfd_vma) bin, frag);
1021
1022   prev = bin;
1023   *line = str;
1024   return bin;
1025 }
1026
1027 /* GAS will call this function for each section at the end of the assembly,
1028    to permit the CPU backend to adjust the alignment of a section.  */
1029
1030 valueT
1031 md_section_align (asection *seg, valueT addr)
1032 {
1033   int align = bfd_get_section_alignment (stdoutput, seg);
1034   return ((addr + (1 << align) - 1) & (-1 << align));
1035 }
1036
1037 /* If you define this macro, it should return the offset between the
1038    address of a PC relative fixup and the position from which the PC
1039    relative adjustment should be made.  On many processors, the base
1040    of a PC relative instruction is the next instruction, so this
1041    macro would return the length of an instruction.  */
1042
1043 long
1044 md_pcrel_from_section (fixS *fixp, segT sec)
1045 {
1046   if (fixp->fx_addsy != (symbolS *) NULL
1047       && (!S_IS_DEFINED (fixp->fx_addsy)
1048           || (S_GET_SEGMENT (fixp->fx_addsy) != sec)))
1049     return 0;
1050
1051   return fixp->fx_frag->fr_address + fixp->fx_where;
1052 }
1053
1054 /* GAS will call this for each fixup.  It should store the correct
1055    value in the object file.  */
1056
1057 void
1058 md_apply_fix (fixS *fixP, valueT * valP, segT seg)
1059 {
1060   unsigned char *where;
1061   unsigned long insn;
1062   long value = *valP;
1063
1064   if (fixP->fx_addsy == (symbolS *) NULL)
1065     fixP->fx_done = 1;
1066
1067   else if (fixP->fx_pcrel)
1068     {
1069       segT s = S_GET_SEGMENT (fixP->fx_addsy);
1070
1071       if (s == seg || s == absolute_section)
1072         {
1073           value += S_GET_VALUE (fixP->fx_addsy);
1074           fixP->fx_done = 1;
1075         }
1076     }
1077
1078   /* We don't actually support subtracting a symbol.  */
1079   if (fixP->fx_subsy != (symbolS *) NULL)
1080     as_bad_where (fixP->fx_file, fixP->fx_line, _("expression too complex"));
1081
1082   switch (fixP->fx_r_type)
1083     {
1084     default:
1085       fixP->fx_no_overflow = 1;
1086       break;
1087     case BFD_RELOC_AVR_7_PCREL:
1088     case BFD_RELOC_AVR_13_PCREL:
1089     case BFD_RELOC_32:
1090     case BFD_RELOC_16:
1091     case BFD_RELOC_AVR_CALL:
1092       break;
1093     }
1094
1095   if (fixP->fx_done)
1096     {
1097       /* Fetch the instruction, insert the fully resolved operand
1098          value, and stuff the instruction back again.  */
1099       where = (unsigned char *) fixP->fx_frag->fr_literal + fixP->fx_where;
1100       insn = bfd_getl16 (where);
1101
1102       switch (fixP->fx_r_type)
1103         {
1104         case BFD_RELOC_AVR_7_PCREL:
1105           if (value & 1)
1106             as_bad_where (fixP->fx_file, fixP->fx_line,
1107                           _("odd address operand: %ld"), value);
1108
1109           /* Instruction addresses are always right-shifted by 1.  */
1110           value >>= 1;
1111           --value;                      /* Correct PC.  */
1112
1113           if (value < -64 || value > 63)
1114             as_bad_where (fixP->fx_file, fixP->fx_line,
1115                           _("operand out of range: %ld"), value);
1116           value = (value << 3) & 0x3f8;
1117           bfd_putl16 ((bfd_vma) (value | insn), where);
1118           break;
1119
1120         case BFD_RELOC_AVR_13_PCREL:
1121           if (value & 1)
1122             as_bad_where (fixP->fx_file, fixP->fx_line,
1123                           _("odd address operand: %ld"), value);
1124
1125           /* Instruction addresses are always right-shifted by 1.  */
1126           value >>= 1;
1127           --value;                      /* Correct PC.  */
1128
1129           if (value < -2048 || value > 2047)
1130             {
1131               /* No wrap for devices with >8K of program memory.  */
1132               if ((avr_mcu->isa & AVR_ISA_MEGA) || avr_opt.no_wrap)
1133                 as_bad_where (fixP->fx_file, fixP->fx_line,
1134                               _("operand out of range: %ld"), value);
1135             }
1136
1137           value &= 0xfff;
1138           bfd_putl16 ((bfd_vma) (value | insn), where);
1139           break;
1140
1141         case BFD_RELOC_32:
1142           bfd_putl16 ((bfd_vma) value, where);
1143           break;
1144
1145         case BFD_RELOC_16:
1146           bfd_putl16 ((bfd_vma) value, where);
1147           break;
1148
1149         case BFD_RELOC_AVR_16_PM:
1150           bfd_putl16 ((bfd_vma) (value >> 1), where);
1151           break;
1152
1153         case BFD_RELOC_AVR_LDI:
1154           if (value > 255)
1155             as_bad_where (fixP->fx_file, fixP->fx_line,
1156                           _("operand out of range: %ld"), value);
1157           bfd_putl16 ((bfd_vma) insn | LDI_IMMEDIATE (value), where);
1158           break;
1159
1160         case BFD_RELOC_AVR_6:
1161           if ((value > 63) || (value < 0))
1162             as_bad_where (fixP->fx_file, fixP->fx_line,
1163                           _("operand out of range: %ld"), value);
1164           bfd_putl16 ((bfd_vma) insn | ((value & 7) | ((value & (3 << 3)) << 7) | ((value & (1 << 5)) << 8)), where);
1165           break;
1166
1167         case BFD_RELOC_AVR_6_ADIW:
1168           if ((value > 63) || (value < 0))
1169             as_bad_where (fixP->fx_file, fixP->fx_line,
1170                           _("operand out of range: %ld"), value);
1171           bfd_putl16 ((bfd_vma) insn | (value & 0xf) | ((value & 0x30) << 2), where);
1172           break;
1173
1174         case BFD_RELOC_AVR_LO8_LDI:
1175           bfd_putl16 ((bfd_vma) insn | LDI_IMMEDIATE (value), where);
1176           break;
1177
1178         case BFD_RELOC_AVR_HI8_LDI:
1179           bfd_putl16 ((bfd_vma) insn | LDI_IMMEDIATE (value >> 8), where);
1180           break;
1181
1182         case BFD_RELOC_AVR_MS8_LDI:
1183           bfd_putl16 ((bfd_vma) insn | LDI_IMMEDIATE (value >> 24), where);
1184           break;
1185
1186         case BFD_RELOC_AVR_HH8_LDI:
1187           bfd_putl16 ((bfd_vma) insn | LDI_IMMEDIATE (value >> 16), where);
1188           break;
1189
1190         case BFD_RELOC_AVR_LO8_LDI_NEG:
1191           bfd_putl16 ((bfd_vma) insn | LDI_IMMEDIATE (-value), where);
1192           break;
1193
1194         case BFD_RELOC_AVR_HI8_LDI_NEG:
1195           bfd_putl16 ((bfd_vma) insn | LDI_IMMEDIATE (-value >> 8), where);
1196           break;
1197
1198         case BFD_RELOC_AVR_MS8_LDI_NEG:
1199           bfd_putl16 ((bfd_vma) insn | LDI_IMMEDIATE (-value >> 24), where);
1200           break;
1201
1202         case BFD_RELOC_AVR_HH8_LDI_NEG:
1203           bfd_putl16 ((bfd_vma) insn | LDI_IMMEDIATE (-value >> 16), where);
1204           break;
1205
1206         case BFD_RELOC_AVR_LO8_LDI_PM:
1207           bfd_putl16 ((bfd_vma) insn | LDI_IMMEDIATE (value >> 1), where);
1208           break;
1209
1210         case BFD_RELOC_AVR_HI8_LDI_PM:
1211           bfd_putl16 ((bfd_vma) insn | LDI_IMMEDIATE (value >> 9), where);
1212           break;
1213
1214         case BFD_RELOC_AVR_HH8_LDI_PM:
1215           bfd_putl16 ((bfd_vma) insn | LDI_IMMEDIATE (value >> 17), where);
1216           break;
1217
1218         case BFD_RELOC_AVR_LO8_LDI_PM_NEG:
1219           bfd_putl16 ((bfd_vma) insn | LDI_IMMEDIATE (-value >> 1), where);
1220           break;
1221
1222         case BFD_RELOC_AVR_HI8_LDI_PM_NEG:
1223           bfd_putl16 ((bfd_vma) insn | LDI_IMMEDIATE (-value >> 9), where);
1224           break;
1225
1226         case BFD_RELOC_AVR_HH8_LDI_PM_NEG:
1227           bfd_putl16 ((bfd_vma) insn | LDI_IMMEDIATE (-value >> 17), where);
1228           break;
1229
1230         case BFD_RELOC_AVR_CALL:
1231           {
1232             unsigned long x;
1233
1234             x = bfd_getl16 (where);
1235             if (value & 1)
1236               as_bad_where (fixP->fx_file, fixP->fx_line,
1237                             _("odd address operand: %ld"), value);
1238             value >>= 1;
1239             x |= ((value & 0x10000) | ((value << 3) & 0x1f00000)) >> 16;
1240             bfd_putl16 ((bfd_vma) x, where);
1241             bfd_putl16 ((bfd_vma) (value & 0xffff), where + 2);
1242           }
1243           break;
1244
1245         default:
1246           as_fatal (_("line %d: unknown relocation type: 0x%x"),
1247                     fixP->fx_line, fixP->fx_r_type);
1248           break;
1249         }
1250     }
1251   else
1252     {
1253       switch ((int) fixP->fx_r_type)
1254         {
1255         case -BFD_RELOC_AVR_HI8_LDI_NEG:
1256         case -BFD_RELOC_AVR_HI8_LDI:
1257         case -BFD_RELOC_AVR_LO8_LDI_NEG:
1258         case -BFD_RELOC_AVR_LO8_LDI:
1259           as_bad_where (fixP->fx_file, fixP->fx_line,
1260                         _("only constant expression allowed"));
1261           fixP->fx_done = 1;
1262           break;
1263         default:
1264           break;
1265         }
1266     }
1267 }
1268
1269 /* GAS will call this to generate a reloc, passing the resulting reloc
1270    to `bfd_install_relocation'.  This currently works poorly, as
1271    `bfd_install_relocation' often does the wrong thing, and instances of
1272    `tc_gen_reloc' have been written to work around the problems, which
1273    in turns makes it difficult to fix `bfd_install_relocation'.  */
1274
1275 /* If while processing a fixup, a reloc really needs to be created
1276    then it is done here.  */
1277
1278 arelent *
1279 tc_gen_reloc (asection *seg ATTRIBUTE_UNUSED,
1280               fixS *fixp)
1281 {
1282   arelent *reloc;
1283
1284   if (fixp->fx_addsy && fixp->fx_subsy)
1285     {
1286       long value = 0;
1287
1288       if ((S_GET_SEGMENT (fixp->fx_addsy) != S_GET_SEGMENT (fixp->fx_subsy))
1289           || S_GET_SEGMENT (fixp->fx_addsy) == undefined_section)
1290         {
1291           as_bad_where (fixp->fx_file, fixp->fx_line,
1292               "Difference of symbols in different sections is not supported");
1293           return NULL;
1294         }
1295
1296       /* We are dealing with two symbols defined in the same section.
1297          Let us fix-up them here.  */
1298       value += S_GET_VALUE (fixp->fx_addsy);
1299       value -= S_GET_VALUE (fixp->fx_subsy);
1300
1301       /* When fx_addsy and fx_subsy both are zero, md_apply_fix
1302          only takes it's second operands for the fixup value.  */
1303       fixp->fx_addsy = NULL;
1304       fixp->fx_subsy = NULL;
1305       md_apply_fix (fixp, (valueT *) &value, NULL);
1306
1307       return NULL;
1308     }
1309
1310   reloc = xmalloc (sizeof (arelent));
1311
1312   reloc->sym_ptr_ptr = xmalloc (sizeof (asymbol *));
1313   *reloc->sym_ptr_ptr = symbol_get_bfdsym (fixp->fx_addsy);
1314
1315   reloc->address = fixp->fx_frag->fr_address + fixp->fx_where;
1316   reloc->howto = bfd_reloc_type_lookup (stdoutput, fixp->fx_r_type);
1317   if (reloc->howto == (reloc_howto_type *) NULL)
1318     {
1319       as_bad_where (fixp->fx_file, fixp->fx_line,
1320                     _("reloc %d not supported by object file format"),
1321                     (int) fixp->fx_r_type);
1322       return NULL;
1323     }
1324
1325   if (fixp->fx_r_type == BFD_RELOC_VTABLE_INHERIT
1326       || fixp->fx_r_type == BFD_RELOC_VTABLE_ENTRY)
1327     reloc->address = fixp->fx_offset;
1328
1329   reloc->addend = fixp->fx_offset;
1330
1331   return reloc;
1332 }
1333
1334 void
1335 md_assemble (char *str)
1336 {
1337   struct avr_opcodes_s *opcode;
1338   char op[11];
1339
1340   str = skip_space (extract_word (str, op, sizeof (op)));
1341
1342   if (!op[0])
1343     as_bad (_("can't find opcode "));
1344
1345   opcode = (struct avr_opcodes_s *) hash_find (avr_hash, op);
1346
1347   if (opcode == NULL)
1348     {
1349       as_bad (_("unknown opcode `%s'"), op);
1350       return;
1351     }
1352
1353   /* Special case for opcodes with optional operands (lpm, elpm) -
1354      version with operands exists in avr_opcodes[] in the next entry.  */
1355
1356   if (*str && *opcode->constraints == '?')
1357     ++opcode;
1358
1359   if (!avr_opt.all_opcodes && (opcode->isa & avr_mcu->isa) != opcode->isa)
1360     as_bad (_("illegal opcode %s for mcu %s"), opcode->name, avr_mcu->name);
1361
1362   /* We used to set input_line_pointer to the result of get_operands,
1363      but that is wrong.  Our caller assumes we don't change it.  */
1364   {
1365     char *t = input_line_pointer;
1366
1367     avr_operands (opcode, &str);
1368     if (*skip_space (str))
1369       as_bad (_("garbage at end of line"));
1370     input_line_pointer = t;
1371   }
1372 }
1373
1374 /* Flag to pass `pm' mode between `avr_parse_cons_expression' and
1375    `avr_cons_fix_new'.  */
1376 static int exp_mod_pm = 0;
1377
1378 /* Parse special CONS expression: pm (expression)
1379    or alternatively: gs (expression).
1380    These are used for addressing program memory.
1381    Relocation: BFD_RELOC_AVR_16_PM.  */
1382
1383 void
1384 avr_parse_cons_expression (expressionS *exp, int nbytes)
1385 {
1386   char *tmp;
1387
1388   exp_mod_pm = 0;
1389
1390   tmp = input_line_pointer = skip_space (input_line_pointer);
1391
1392   if (nbytes == 2)
1393     {
1394       char *pm_name1 = "pm";
1395       char *pm_name2 = "gs";
1396       int len = strlen (pm_name1);
1397       /* len must be the same for both pm identifiers.  */
1398
1399       if (strncasecmp (input_line_pointer, pm_name1, len) == 0
1400           || strncasecmp (input_line_pointer, pm_name2, len) == 0)
1401         {
1402           input_line_pointer = skip_space (input_line_pointer + len);
1403
1404           if (*input_line_pointer == '(')
1405             {
1406               input_line_pointer = skip_space (input_line_pointer + 1);
1407               exp_mod_pm = 1;
1408               expression (exp);
1409
1410               if (*input_line_pointer == ')')
1411                 ++input_line_pointer;
1412               else
1413                 {
1414                   as_bad (_("`)' required"));
1415                   exp_mod_pm = 0;
1416                 }
1417
1418               return;
1419             }
1420
1421           input_line_pointer = tmp;
1422         }
1423     }
1424
1425   expression (exp);
1426 }
1427
1428 void
1429 avr_cons_fix_new (fragS *frag,
1430                   int where,
1431                   int nbytes,
1432                   expressionS *exp)
1433 {
1434   if (exp_mod_pm == 0)
1435     {
1436       if (nbytes == 2)
1437         fix_new_exp (frag, where, nbytes, exp, FALSE, BFD_RELOC_16);
1438       else if (nbytes == 4)
1439         fix_new_exp (frag, where, nbytes, exp, FALSE, BFD_RELOC_32);
1440       else
1441         as_bad (_("illegal %srelocation size: %d"), "", nbytes);
1442     }
1443   else
1444     {
1445       if (nbytes == 2)
1446         fix_new_exp (frag, where, nbytes, exp, FALSE, BFD_RELOC_AVR_16_PM);
1447       else
1448         as_bad (_("illegal %srelocation size: %d"), "`pm' ", nbytes);
1449       exp_mod_pm = 0;
1450     }
1451 }