gas/config/tc-avr.c

   1 /* tc-avr.c -- Assembler code for the ATMEL AVR
   2
   3    Copyright (C) 1999-2014 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 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 "safe-ctype.h"
  25 #include "subsegs.h"
  26 #include "dwarf2dbg.h"
  27 #include "dw2gencfi.h"
  28
  29
  30 struct avr_opcodes_s
  31 {
  32   char *        name;
  33   char *        constraints;
  34   char *        opcode;
  35   int           insn_size;              /* In words.  */
  36   int           isa;
  37   unsigned int  bin_opcode;
  38 };
  39
  40 #define AVR_INSN(NAME, CONSTR, OPCODE, SIZE, ISA, BIN) \
  41 {#NAME, CONSTR, OPCODE, SIZE, ISA, BIN},
  42
  43 struct avr_opcodes_s avr_opcodes[] =
  44 {
  45   #include "opcode/avr.h"
  46   {NULL, NULL, NULL, 0, 0, 0}
  47 };
  48
  49 const char comment_chars[] = ";";
  50 const char line_comment_chars[] = "#";
  51 const char line_separator_chars[] = "$";
  52
  53 const char *md_shortopts = "m:";
  54 struct mcu_type_s
  55 {
  56   char *name;
  57   int isa;
  58   int mach;
  59 };
  60
  61 /* XXX - devices that don't seem to exist (renamed, replaced with larger
  62    ones, or planned but never produced), left here for compatibility.  */
  63
  64 static struct mcu_type_s mcu_types[] =
  65 {
  66   {"avr1",       AVR_ISA_AVR1,    bfd_mach_avr1},
  67 /* TODO: insruction set for avr2 architecture should be AVR_ISA_AVR2,
  68  but set to AVR_ISA_AVR25 for some following version
  69  of GCC (from 4.3) for backward compatibility.  */
  70   {"avr2",       AVR_ISA_AVR25,   bfd_mach_avr2},
  71   {"avr25",      AVR_ISA_AVR25,   bfd_mach_avr25},
  72 /* TODO: insruction set for avr3 architecture should be AVR_ISA_AVR3,
  73  but set to AVR_ISA_AVR3_ALL for some following version
  74  of GCC (from 4.3) for backward compatibility.  */
  75   {"avr3",       AVR_ISA_AVR3_ALL, bfd_mach_avr3},
  76   {"avr31",      AVR_ISA_AVR31,   bfd_mach_avr31},
  77   {"avr35",      AVR_ISA_AVR35,   bfd_mach_avr35},
  78   {"avr4",       AVR_ISA_AVR4,    bfd_mach_avr4},
  79 /* TODO: insruction set for avr5 architecture should be AVR_ISA_AVR5,
  80  but set to AVR_ISA_AVR51 for some following version
  81  of GCC (from 4.3) for backward compatibility.  */
  82   {"avr5",       AVR_ISA_AVR51,   bfd_mach_avr5},
  83   {"avr51",      AVR_ISA_AVR51,   bfd_mach_avr51},
  84   {"avr6",       AVR_ISA_AVR6,    bfd_mach_avr6},
  85   {"avrxmega1",  AVR_ISA_XMEGA,   bfd_mach_avrxmega1},
  86   {"avrxmega2",  AVR_ISA_XMEGA,   bfd_mach_avrxmega2},
  87   {"avrxmega3",  AVR_ISA_XMEGA,   bfd_mach_avrxmega3},
  88   {"avrxmega4",  AVR_ISA_XMEGA,   bfd_mach_avrxmega4},
  89   {"avrxmega5",  AVR_ISA_XMEGA,   bfd_mach_avrxmega5},
  90   {"avrxmega6",  AVR_ISA_XMEGA,   bfd_mach_avrxmega6},
  91   {"avrxmega7",  AVR_ISA_XMEGA,   bfd_mach_avrxmega7},
  92   {"avrtiny",    AVR_ISA_AVRTINY, bfd_mach_avrtiny},
  93   {"at90s1200",  AVR_ISA_1200,    bfd_mach_avr1},
  94   {"attiny11",   AVR_ISA_AVR1,    bfd_mach_avr1},
  95   {"attiny12",   AVR_ISA_AVR1,    bfd_mach_avr1},
  96   {"attiny15",   AVR_ISA_AVR1,    bfd_mach_avr1},
  97   {"attiny28",   AVR_ISA_AVR1,    bfd_mach_avr1},
  98   {"at90s2313",  AVR_ISA_AVR2,    bfd_mach_avr2},
  99   {"at90s2323",  AVR_ISA_AVR2,    bfd_mach_avr2},
 100   {"at90s2333",  AVR_ISA_AVR2,    bfd_mach_avr2}, /* XXX -> 4433 */
 101   {"at90s2343",  AVR_ISA_AVR2,    bfd_mach_avr2},
 102   {"attiny22",   AVR_ISA_AVR2,    bfd_mach_avr2}, /* XXX -> 2343 */
 103   {"attiny26",   AVR_ISA_2xxe,    bfd_mach_avr2},
 104   {"at90s4414",  AVR_ISA_AVR2,    bfd_mach_avr2}, /* XXX -> 8515 */
 105   {"at90s4433",  AVR_ISA_AVR2,    bfd_mach_avr2},
 106   {"at90s4434",  AVR_ISA_AVR2,    bfd_mach_avr2}, /* XXX -> 8535 */
 107   {"at90s8515",  AVR_ISA_AVR2,    bfd_mach_avr2},
 108   {"at90c8534",  AVR_ISA_AVR2,    bfd_mach_avr2},
 109   {"at90s8535",  AVR_ISA_AVR2,    bfd_mach_avr2},
 110   {"ata5272",    AVR_ISA_AVR25,   bfd_mach_avr25},
 111   {"attiny13",   AVR_ISA_AVR25,   bfd_mach_avr25},
 112   {"attiny13a",  AVR_ISA_AVR25,   bfd_mach_avr25},
 113   {"attiny2313", AVR_ISA_AVR25,   bfd_mach_avr25},
 114   {"attiny2313a",AVR_ISA_AVR25,   bfd_mach_avr25},
 115   {"attiny24",   AVR_ISA_AVR25,   bfd_mach_avr25},
 116   {"attiny24a",  AVR_ISA_AVR25,   bfd_mach_avr25},
 117   {"attiny4313", AVR_ISA_AVR25,   bfd_mach_avr25},
 118   {"attiny44",   AVR_ISA_AVR25,   bfd_mach_avr25},
 119   {"attiny44a",  AVR_ISA_AVR25,   bfd_mach_avr25},
 120   {"attiny84",   AVR_ISA_AVR25,   bfd_mach_avr25},
 121   {"attiny84a",  AVR_ISA_AVR25,   bfd_mach_avr25},
 122   {"attiny25",   AVR_ISA_AVR25,   bfd_mach_avr25},
 123   {"attiny45",   AVR_ISA_AVR25,   bfd_mach_avr25},
 124   {"attiny85",   AVR_ISA_AVR25,   bfd_mach_avr25},
 125   {"attiny261",  AVR_ISA_AVR25,   bfd_mach_avr25},
 126   {"attiny261a", AVR_ISA_AVR25,   bfd_mach_avr25},
 127   {"attiny461",  AVR_ISA_AVR25,   bfd_mach_avr25},
 128   {"attiny461a", AVR_ISA_AVR25,   bfd_mach_avr25},
 129   {"attiny861",  AVR_ISA_AVR25,   bfd_mach_avr25},
 130   {"attiny861a", AVR_ISA_AVR25,   bfd_mach_avr25},
 131   {"attiny87",   AVR_ISA_AVR25,   bfd_mach_avr25},
 132   {"attiny43u",  AVR_ISA_AVR25,   bfd_mach_avr25},
 133   {"attiny48",   AVR_ISA_AVR25,   bfd_mach_avr25},
 134   {"attiny88",   AVR_ISA_AVR25,   bfd_mach_avr25},
 135   {"attiny828",  AVR_ISA_AVR25,   bfd_mach_avr25},
 136   {"at86rf401",  AVR_ISA_RF401,   bfd_mach_avr25},
 137   {"at43usb355", AVR_ISA_AVR3,    bfd_mach_avr3},
 138   {"at76c711",   AVR_ISA_AVR3,    bfd_mach_avr3},
 139   {"atmega103",  AVR_ISA_AVR31,   bfd_mach_avr31},
 140   {"at43usb320", AVR_ISA_AVR31,   bfd_mach_avr31},
 141   {"attiny167",  AVR_ISA_AVR35,   bfd_mach_avr35},
 142   {"at90usb82",  AVR_ISA_AVR35,   bfd_mach_avr35},
 143   {"at90usb162", AVR_ISA_AVR35,   bfd_mach_avr35},
 144   {"ata5505",    AVR_ISA_AVR35,   bfd_mach_avr35},
 145   {"atmega8u2",  AVR_ISA_AVR35,   bfd_mach_avr35},
 146   {"atmega16u2", AVR_ISA_AVR35,   bfd_mach_avr35},
 147   {"atmega32u2", AVR_ISA_AVR35,   bfd_mach_avr35},
 148   {"attiny1634", AVR_ISA_AVR35,   bfd_mach_avr35},
 149   {"atmega8",    AVR_ISA_M8,      bfd_mach_avr4},
 150   {"ata6289",    AVR_ISA_AVR4,    bfd_mach_avr4},
 151   {"atmega8a",   AVR_ISA_M8,      bfd_mach_avr4},
 152   {"ata6285",    AVR_ISA_AVR4,    bfd_mach_avr4},
 153   {"ata6286",    AVR_ISA_AVR4,    bfd_mach_avr4},
 154   {"atmega48",   AVR_ISA_AVR4,    bfd_mach_avr4},
 155   {"atmega48a",  AVR_ISA_AVR4,    bfd_mach_avr4},
 156   {"atmega48pa", AVR_ISA_AVR4,    bfd_mach_avr4},
 157   {"atmega48p",  AVR_ISA_AVR4,    bfd_mach_avr4},
 158   {"atmega88",   AVR_ISA_AVR4,    bfd_mach_avr4},
 159   {"atmega88a",  AVR_ISA_AVR4,    bfd_mach_avr4},
 160   {"atmega88p",  AVR_ISA_AVR4,    bfd_mach_avr4},
 161   {"atmega88pa", AVR_ISA_AVR4,    bfd_mach_avr4},
 162   {"atmega8515", AVR_ISA_M8,      bfd_mach_avr4},
 163   {"atmega8535", AVR_ISA_M8,      bfd_mach_avr4},
 164   {"atmega8hva", AVR_ISA_AVR4,    bfd_mach_avr4},
 165   {"at90pwm1",   AVR_ISA_AVR4,    bfd_mach_avr4},
 166   {"at90pwm2",   AVR_ISA_AVR4,    bfd_mach_avr4},
 167   {"at90pwm2b",  AVR_ISA_AVR4,    bfd_mach_avr4},
 168   {"at90pwm3",   AVR_ISA_AVR4,    bfd_mach_avr4},
 169   {"at90pwm3b",  AVR_ISA_AVR4,    bfd_mach_avr4},
 170   {"at90pwm81",  AVR_ISA_AVR4,    bfd_mach_avr4},
 171   {"at90pwm161", AVR_ISA_AVR5,    bfd_mach_avr5},
 172   {"ata5790",    AVR_ISA_AVR5,    bfd_mach_avr5},
 173   {"ata5795",    AVR_ISA_AVR5,    bfd_mach_avr5},
 174   {"atmega16",   AVR_ISA_AVR5,    bfd_mach_avr5},
 175   {"atmega16a",  AVR_ISA_AVR5,    bfd_mach_avr5},
 176   {"atmega161",  AVR_ISA_M161,    bfd_mach_avr5},
 177   {"atmega162",  AVR_ISA_AVR5,    bfd_mach_avr5},
 178   {"atmega163",  AVR_ISA_M161,    bfd_mach_avr5},
 179   {"atmega164a", AVR_ISA_AVR5,    bfd_mach_avr5},
 180   {"atmega164p", AVR_ISA_AVR5,    bfd_mach_avr5},
 181   {"atmega164pa",AVR_ISA_AVR5,    bfd_mach_avr5},
 182   {"atmega165",  AVR_ISA_AVR5,    bfd_mach_avr5},
 183   {"atmega165a", AVR_ISA_AVR5,    bfd_mach_avr5},
 184   {"atmega165p", AVR_ISA_AVR5,    bfd_mach_avr5},
 185   {"atmega165pa",AVR_ISA_AVR5,    bfd_mach_avr5},
 186   {"atmega168",  AVR_ISA_AVR5,    bfd_mach_avr5},
 187   {"atmega168a", AVR_ISA_AVR5,    bfd_mach_avr5},
 188   {"atmega168p", AVR_ISA_AVR5,    bfd_mach_avr5},
 189   {"atmega168pa",AVR_ISA_AVR5,    bfd_mach_avr5},
 190   {"atmega169",  AVR_ISA_AVR5,    bfd_mach_avr5},
 191   {"atmega169a", AVR_ISA_AVR5,    bfd_mach_avr5},
 192   {"atmega169p", AVR_ISA_AVR5,    bfd_mach_avr5},
 193   {"atmega169pa",AVR_ISA_AVR5,    bfd_mach_avr5},
 194   {"atmega32",   AVR_ISA_AVR5,    bfd_mach_avr5},
 195   {"atmega32a",  AVR_ISA_AVR5,    bfd_mach_avr5},
 196   {"atmega323",  AVR_ISA_AVR5,    bfd_mach_avr5},
 197   {"atmega324a", AVR_ISA_AVR5,    bfd_mach_avr5},
 198   {"atmega324p", AVR_ISA_AVR5,    bfd_mach_avr5},
 199   {"atmega324pa",AVR_ISA_AVR5,    bfd_mach_avr5},
 200   {"atmega325",  AVR_ISA_AVR5,    bfd_mach_avr5},
 201   {"atmega325a", AVR_ISA_AVR5,    bfd_mach_avr5},
 202   {"atmega325p", AVR_ISA_AVR5,    bfd_mach_avr5},
 203   {"atmega325pa",AVR_ISA_AVR5,    bfd_mach_avr5},
 204   {"atmega3250", AVR_ISA_AVR5,    bfd_mach_avr5},
 205   {"atmega3250a",AVR_ISA_AVR5,    bfd_mach_avr5},
 206   {"atmega3250p",AVR_ISA_AVR5,    bfd_mach_avr5},
 207   {"atmega3250pa",AVR_ISA_AVR5,   bfd_mach_avr5},
 208   {"atmega328",  AVR_ISA_AVR5,    bfd_mach_avr5},
 209   {"atmega328p", AVR_ISA_AVR5,    bfd_mach_avr5},
 210   {"atmega329",  AVR_ISA_AVR5,    bfd_mach_avr5},
 211   {"atmega329a", AVR_ISA_AVR5,    bfd_mach_avr5},
 212   {"atmega329p", AVR_ISA_AVR5,    bfd_mach_avr5},
 213   {"atmega329pa",AVR_ISA_AVR5,    bfd_mach_avr5},
 214   {"atmega3290", AVR_ISA_AVR5,    bfd_mach_avr5},
 215   {"atmega3290a",AVR_ISA_AVR5,    bfd_mach_avr5},
 216   {"atmega3290p",AVR_ISA_AVR5,    bfd_mach_avr5},
 217   {"atmega3290pa",AVR_ISA_AVR5,   bfd_mach_avr5},
 218   {"atmega406",  AVR_ISA_AVR5,    bfd_mach_avr5},
 219   {"atmega64rfr2", AVR_ISA_AVR5,  bfd_mach_avr5},
 220   {"atmega644rfr2",AVR_ISA_AVR5,  bfd_mach_avr5},
 221   {"atmega64",   AVR_ISA_AVR5,    bfd_mach_avr5},
 222   {"atmega64a",  AVR_ISA_AVR5,    bfd_mach_avr5},
 223   {"atmega640",  AVR_ISA_AVR5,    bfd_mach_avr5},
 224   {"atmega644",  AVR_ISA_AVR5,    bfd_mach_avr5},
 225   {"atmega644a", AVR_ISA_AVR5,    bfd_mach_avr5},
 226   {"atmega644p", AVR_ISA_AVR5,    bfd_mach_avr5},
 227   {"atmega644pa",AVR_ISA_AVR5,    bfd_mach_avr5},
 228   {"atmega645",  AVR_ISA_AVR5,    bfd_mach_avr5},
 229   {"atmega645a", AVR_ISA_AVR5,    bfd_mach_avr5},
 230   {"atmega645p", AVR_ISA_AVR5,    bfd_mach_avr5},
 231   {"atmega649",  AVR_ISA_AVR5,    bfd_mach_avr5},
 232   {"atmega649a", AVR_ISA_AVR5,    bfd_mach_avr5},
 233   {"atmega649p", AVR_ISA_AVR5,    bfd_mach_avr5},
 234   {"atmega6450", AVR_ISA_AVR5,    bfd_mach_avr5},
 235   {"atmega6450a",AVR_ISA_AVR5,    bfd_mach_avr5},
 236   {"atmega6450p",AVR_ISA_AVR5,    bfd_mach_avr5},
 237   {"atmega6490", AVR_ISA_AVR5,    bfd_mach_avr5},
 238   {"atmega6490a",AVR_ISA_AVR5,    bfd_mach_avr5},
 239   {"atmega6490p",AVR_ISA_AVR5,    bfd_mach_avr5},
 240   {"atmega64rfr2",AVR_ISA_AVR5,   bfd_mach_avr5},
 241   {"atmega644rfr2",AVR_ISA_AVR5,  bfd_mach_avr5},
 242   {"atmega16hva",AVR_ISA_AVR5,    bfd_mach_avr5},
 243   {"atmega16hva2",AVR_ISA_AVR5,   bfd_mach_avr5},
 244   {"atmega16hvb",AVR_ISA_AVR5,    bfd_mach_avr5},
 245   {"atmega16hvbrevb",AVR_ISA_AVR5,bfd_mach_avr5},
 246   {"atmega32hvb",AVR_ISA_AVR5,    bfd_mach_avr5},
 247   {"atmega32hvbrevb",AVR_ISA_AVR5,bfd_mach_avr5},
 248   {"atmega64hve",AVR_ISA_AVR5,    bfd_mach_avr5},
 249   {"at90can32" , AVR_ISA_AVR5,    bfd_mach_avr5},
 250   {"at90can64" , AVR_ISA_AVR5,    bfd_mach_avr5},
 251   {"at90pwm161", AVR_ISA_AVR5,    bfd_mach_avr5},
 252   {"at90pwm216", AVR_ISA_AVR5,    bfd_mach_avr5},
 253   {"at90pwm316", AVR_ISA_AVR5,    bfd_mach_avr5},
 254   {"atmega32c1", AVR_ISA_AVR5,    bfd_mach_avr5},
 255   {"atmega64c1", AVR_ISA_AVR5,    bfd_mach_avr5},
 256   {"atmega16m1", AVR_ISA_AVR5,    bfd_mach_avr5},
 257   {"atmega32m1", AVR_ISA_AVR5,    bfd_mach_avr5},
 258   {"atmega64m1", AVR_ISA_AVR5,    bfd_mach_avr5},
 259   {"atmega16u4", AVR_ISA_AVR5,    bfd_mach_avr5},
 260   {"atmega32u4", AVR_ISA_AVR5,    bfd_mach_avr5},
 261   {"atmega32u6", AVR_ISA_AVR5,    bfd_mach_avr5},
 262   {"at90usb646", AVR_ISA_AVR5,    bfd_mach_avr5},
 263   {"at90usb647", AVR_ISA_AVR5,    bfd_mach_avr5},
 264   {"at90scr100", AVR_ISA_AVR5,    bfd_mach_avr5},
 265   {"at94k",      AVR_ISA_94K,     bfd_mach_avr5},
 266   {"m3000",      AVR_ISA_AVR5,    bfd_mach_avr5},
 267   {"atmega128",  AVR_ISA_AVR51,   bfd_mach_avr51},
 268   {"atmega128a", AVR_ISA_AVR51,   bfd_mach_avr51},
 269   {"atmega1280", AVR_ISA_AVR51,   bfd_mach_avr51},
 270   {"atmega1281", AVR_ISA_AVR51,   bfd_mach_avr51},
 271   {"atmega1284", AVR_ISA_AVR51,   bfd_mach_avr51},
 272   {"atmega1284p",AVR_ISA_AVR51,   bfd_mach_avr51},
 273   {"atmega128rfa1",AVR_ISA_AVR51, bfd_mach_avr51},
 274   {"atmega128rfr2",AVR_ISA_AVR51, bfd_mach_avr51},
 275   {"atmega1284rfr2",AVR_ISA_AVR51, bfd_mach_avr51},
 276   {"at90can128", AVR_ISA_AVR51,   bfd_mach_avr51},
 277   {"at90usb1286",AVR_ISA_AVR51,   bfd_mach_avr51},
 278   {"at90usb1287",AVR_ISA_AVR51,   bfd_mach_avr51},
 279   {"atmega2560", AVR_ISA_AVR6,    bfd_mach_avr6},
 280   {"atmega2561", AVR_ISA_AVR6,    bfd_mach_avr6},
 281   {"atmega256rfr2", AVR_ISA_AVR6, bfd_mach_avr6},
 282   {"atmega2564rfr2", AVR_ISA_AVR6, bfd_mach_avr6},
 283   {"atxmega16a4", AVR_ISA_XMEGA,  bfd_mach_avrxmega2},
 284   {"atxmega16a4u",AVR_ISA_XMEGAU, bfd_mach_avrxmega2},
 285   {"atxmega16c4", AVR_ISA_XMEGAU, bfd_mach_avrxmega2},
 286   {"atxmega16d4", AVR_ISA_XMEGA,  bfd_mach_avrxmega2},
 287   {"atxmega32a4", AVR_ISA_XMEGA,  bfd_mach_avrxmega2},
 288   {"atxmega32a4u",AVR_ISA_XMEGAU, bfd_mach_avrxmega2},
 289   {"atxmega32c4", AVR_ISA_XMEGAU, bfd_mach_avrxmega2},
 290   {"atxmega32d4", AVR_ISA_XMEGA,  bfd_mach_avrxmega2},
 291   {"atxmega32e5", AVR_ISA_XMEGA,  bfd_mach_avrxmega2},
 292   {"atxmega16e5", AVR_ISA_XMEGA,  bfd_mach_avrxmega2},
 293   {"atxmega8e5",  AVR_ISA_XMEGA,  bfd_mach_avrxmega2},
 294   {"atxmega32x1", AVR_ISA_XMEGA,  bfd_mach_avrxmega2},
 295   {"atxmega64a3", AVR_ISA_XMEGA,  bfd_mach_avrxmega4},
 296   {"atxmega64a3u",AVR_ISA_XMEGAU, bfd_mach_avrxmega4},
 297   {"atxmega64a4u",AVR_ISA_XMEGAU, bfd_mach_avrxmega4},
 298   {"atxmega64b1", AVR_ISA_XMEGAU, bfd_mach_avrxmega4},
 299   {"atxmega64b3", AVR_ISA_XMEGAU, bfd_mach_avrxmega4},
 300   {"atxmega64c3", AVR_ISA_XMEGAU, bfd_mach_avrxmega4},
 301   {"atxmega64d3", AVR_ISA_XMEGA,  bfd_mach_avrxmega4},
 302   {"atxmega64d4", AVR_ISA_XMEGA,  bfd_mach_avrxmega4},
 303   {"atxmega64a1", AVR_ISA_XMEGA,  bfd_mach_avrxmega5},
 304   {"atxmega64a1u",AVR_ISA_XMEGAU, bfd_mach_avrxmega5},
 305   {"atxmega128a3", AVR_ISA_XMEGA, bfd_mach_avrxmega6},
 306   {"atxmega128a3u",AVR_ISA_XMEGAU,bfd_mach_avrxmega6},
 307   {"atxmega128b1", AVR_ISA_XMEGAU, bfd_mach_avrxmega6},
 308   {"atxmega128b3", AVR_ISA_XMEGAU,bfd_mach_avrxmega6},
 309   {"atxmega128c3", AVR_ISA_XMEGAU,bfd_mach_avrxmega6},
 310   {"atxmega128d3", AVR_ISA_XMEGA, bfd_mach_avrxmega6},
 311   {"atxmega128d4", AVR_ISA_XMEGA, bfd_mach_avrxmega6},
 312   {"atxmega192a3", AVR_ISA_XMEGA, bfd_mach_avrxmega6},
 313   {"atxmega192a3u",AVR_ISA_XMEGAU,bfd_mach_avrxmega6},
 314   {"atxmega192c3", AVR_ISA_XMEGAU, bfd_mach_avrxmega6},
 315   {"atxmega192d3", AVR_ISA_XMEGA, bfd_mach_avrxmega6},
 316   {"atxmega256a3", AVR_ISA_XMEGA, bfd_mach_avrxmega6},
 317   {"atxmega256a3u",AVR_ISA_XMEGAU,bfd_mach_avrxmega6},
 318   {"atxmega256a3b",AVR_ISA_XMEGA, bfd_mach_avrxmega6},
 319   {"atxmega256a3bu",AVR_ISA_XMEGAU, bfd_mach_avrxmega6},
 320   {"atxmega256c3", AVR_ISA_XMEGAU,bfd_mach_avrxmega6},
 321   {"atxmega256d3", AVR_ISA_XMEGA, bfd_mach_avrxmega6},
 322   {"atxmega384c3", AVR_ISA_XMEGAU,bfd_mach_avrxmega6},
 323   {"atxmega384d3", AVR_ISA_XMEGA, bfd_mach_avrxmega6},
 324   {"atxmega128a1", AVR_ISA_XMEGA, bfd_mach_avrxmega7},
 325   {"atxmega128a1u", AVR_ISA_XMEGAU, bfd_mach_avrxmega7},
 326   {"atxmega128a4u", AVR_ISA_XMEGAU, bfd_mach_avrxmega7},
 327   {"attiny4",      AVR_ISA_AVRTINY, bfd_mach_avrtiny},
 328   {"attiny5",      AVR_ISA_AVRTINY, bfd_mach_avrtiny},
 329   {"attiny9",      AVR_ISA_AVRTINY, bfd_mach_avrtiny},
 330   {"attiny10",     AVR_ISA_AVRTINY, bfd_mach_avrtiny},
 331   {"attiny20",     AVR_ISA_AVRTINY, bfd_mach_avrtiny},
 332   {"attiny40",     AVR_ISA_AVRTINY, bfd_mach_avrtiny},
 333   {NULL, 0, 0}
 334 };
 335
 336
 337 /* Current MCU type.  */
 338 static struct mcu_type_s   default_mcu = {"avr2", AVR_ISA_AVR2, bfd_mach_avr2};
 339 static struct mcu_type_s   specified_mcu;
 340 static struct mcu_type_s * avr_mcu = & default_mcu;
 341
 342 /* AVR target-specific switches.  */
 343 struct avr_opt_s
 344 {
 345   int all_opcodes;  /* -mall-opcodes: accept all known AVR opcodes.  */
 346   int no_skip_bug;  /* -mno-skip-bug: no warnings for skipping 2-word insns.  */
 347   int no_wrap;      /* -mno-wrap: reject rjmp/rcall with 8K wrap-around.  */
 348   int link_relax;   /* -mlink-relax: generate relocations for linker
 349                        relaxation.  */
 350 };
 351
 352 static struct avr_opt_s avr_opt = { 0, 0, 0, 0 };
 353
 354 const char EXP_CHARS[] = "eE";
 355 const char FLT_CHARS[] = "dD";
 356
 357 static void avr_set_arch (int);
 358
 359 /* The target specific pseudo-ops which we support.  */
 360 const pseudo_typeS md_pseudo_table[] =
 361 {
 362   {"arch", avr_set_arch,        0},
 363   { NULL,       NULL,           0}
 364 };
 365
 366 #define LDI_IMMEDIATE(x) (((x) & 0xf) | (((x) << 4) & 0xf00))
 367
 368 #define EXP_MOD_NAME(i)       exp_mod[i].name
 369 #define EXP_MOD_RELOC(i)      exp_mod[i].reloc
 370 #define EXP_MOD_NEG_RELOC(i)  exp_mod[i].neg_reloc
 371 #define HAVE_PM_P(i)          exp_mod[i].have_pm
 372
 373 struct exp_mod_s
 374 {
 375   char *                    name;
 376   bfd_reloc_code_real_type  reloc;
 377   bfd_reloc_code_real_type  neg_reloc;
 378   int                       have_pm;
 379 };
 380
 381 static struct exp_mod_s exp_mod[] =
 382 {
 383   {"hh8",    BFD_RELOC_AVR_HH8_LDI,    BFD_RELOC_AVR_HH8_LDI_NEG,    1},
 384   {"pm_hh8", BFD_RELOC_AVR_HH8_LDI_PM, BFD_RELOC_AVR_HH8_LDI_PM_NEG, 0},
 385   {"hi8",    BFD_RELOC_AVR_HI8_LDI,    BFD_RELOC_AVR_HI8_LDI_NEG,    1},
 386   {"pm_hi8", BFD_RELOC_AVR_HI8_LDI_PM, BFD_RELOC_AVR_HI8_LDI_PM_NEG, 0},
 387   {"lo8",    BFD_RELOC_AVR_LO8_LDI,    BFD_RELOC_AVR_LO8_LDI_NEG,    1},
 388   {"pm_lo8", BFD_RELOC_AVR_LO8_LDI_PM, BFD_RELOC_AVR_LO8_LDI_PM_NEG, 0},
 389   {"hlo8",   BFD_RELOC_AVR_HH8_LDI,    BFD_RELOC_AVR_HH8_LDI_NEG,    0},
 390   {"hhi8",   BFD_RELOC_AVR_MS8_LDI,    BFD_RELOC_AVR_MS8_LDI_NEG,    0},
 391 };
 392
 393 /* A union used to store indicies into the exp_mod[] array
 394    in a hash table which expects void * data types.  */
 395 typedef union
 396 {
 397   void * ptr;
 398   int    index;
 399 } mod_index;
 400
 401 /* Opcode hash table.  */
 402 static struct hash_control *avr_hash;
 403
 404 /* Reloc modifiers hash control (hh8,hi8,lo8,pm_xx).  */
 405 static struct hash_control *avr_mod_hash;
 406
 407 #define OPTION_MMCU 'm'
 408 enum options
 409 {
 410   OPTION_ALL_OPCODES = OPTION_MD_BASE + 1,
 411   OPTION_NO_SKIP_BUG,
 412   OPTION_NO_WRAP,
 413   OPTION_ISA_RMW,
 414   OPTION_LINK_RELAX
 415 };
 416
 417 struct option md_longopts[] =
 418 {
 419   { "mmcu",   required_argument, NULL, OPTION_MMCU        },
 420   { "mall-opcodes", no_argument, NULL, OPTION_ALL_OPCODES },
 421   { "mno-skip-bug", no_argument, NULL, OPTION_NO_SKIP_BUG },
 422   { "mno-wrap",     no_argument, NULL, OPTION_NO_WRAP     },
 423   { "mrmw",         no_argument, NULL, OPTION_ISA_RMW     },
 424   { "mlink-relax",  no_argument, NULL, OPTION_LINK_RELAX  },
 425   { NULL, no_argument, NULL, 0 }
 426 };
 427
 428 size_t md_longopts_size = sizeof (md_longopts);
 429
 430 /* Display nicely formatted list of known MCU names.  */
 431
 432 static void
 433 show_mcu_list (FILE *stream)
 434 {
 435   int i, x;
 436
 437   fprintf (stream, _("Known MCU names:"));
 438   x = 1000;
 439
 440   for (i = 0; mcu_types[i].name; i++)
 441     {
 442       int len = strlen (mcu_types[i].name);
 443
 444       x += len + 1;
 445
 446       if (x < 75)
 447         fprintf (stream, " %s", mcu_types[i].name);
 448       else
 449         {
 450           fprintf (stream, "\n  %s", mcu_types[i].name);
 451           x = len + 2;
 452         }
 453     }
 454
 455   fprintf (stream, "\n");
 456 }
 457
 458 static inline char *
 459 skip_space (char *s)
 460 {
 461   while (*s == ' ' || *s == '\t')
 462     ++s;
 463   return s;
 464 }
 465
 466 /* Extract one word from FROM and copy it to TO.  */
 467
 468 static char *
 469 extract_word (char *from, char *to, int limit)
 470 {
 471   char *op_end;
 472   int size = 0;
 473
 474   /* Drop leading whitespace.  */
 475   from = skip_space (from);
 476   *to = 0;
 477
 478   /* Find the op code end.  */
 479   for (op_end = from; *op_end != 0 && is_part_of_name (*op_end);)
 480     {
 481       to[size++] = *op_end++;
 482       if (size + 1 >= limit)
 483         break;
 484     }
 485
 486   to[size] = 0;
 487   return op_end;
 488 }
 489
 490 int
 491 md_estimate_size_before_relax (fragS *fragp ATTRIBUTE_UNUSED,
 492                                asection *seg ATTRIBUTE_UNUSED)
 493 {
 494   abort ();
 495   return 0;
 496 }
 497
 498 void
 499 md_show_usage (FILE *stream)
 500 {
 501   fprintf (stream,
 502       _("AVR Assembler options:\n"
 503         "  -mmcu=[avr-name] select microcontroller variant\n"
 504         "                   [avr-name] can be:\n"
 505         "                   avr1  - classic AVR core without data RAM\n"
 506         "                   avr2  - classic AVR core with up to 8K program memory\n"
 507         "                   avr25 - classic AVR core with up to 8K program memory\n"
 508         "                           plus the MOVW instruction\n"
 509         "                   avr3  - classic AVR core with up to 64K program memory\n"
 510         "                   avr31 - classic AVR core with up to 128K program memory\n"
 511         "                   avr35 - classic AVR core with up to 64K program memory\n"
 512         "                           plus the MOVW instruction\n"
 513         "                   avr4  - enhanced AVR core with up to 8K program memory\n"
 514         "                   avr5  - enhanced AVR core with up to 64K program memory\n"
 515         "                   avr51 - enhanced AVR core with up to 128K program memory\n"
 516         "                   avr6  - enhanced AVR core with up to 256K program memory\n"
 517         "                   avrxmega2 - XMEGA, > 8K, < 64K FLASH, < 64K RAM\n"
 518         "                   avrxmega3 - XMEGA, > 8K, <= 64K FLASH, > 64K RAM\n"
 519         "                   avrxmega4 - XMEGA, > 64K, <= 128K FLASH, <= 64K RAM\n"
 520         "                   avrxmega5 - XMEGA, > 64K, <= 128K FLASH, > 64K RAM\n"
 521         "                   avrxmega6 - XMEGA, > 128K, <= 256K FLASH, <= 64K RAM\n"
 522         "                   avrxmega7 - XMEGA, > 128K, <= 256K FLASH, > 64K RAM\n"
 523         "                   avrtiny   - AVR Tiny core with 16 gp registers\n"));
 524   fprintf (stream,
 525       _("  -mall-opcodes    accept all AVR opcodes, even if not supported by MCU\n"
 526         "  -mno-skip-bug    disable warnings for skipping two-word instructions\n"
 527         "                   (default for avr4, avr5)\n"
 528         "  -mno-wrap        reject rjmp/rcall instructions with 8K wrap-around\n"
 529         "                   (default for avr3, avr5)\n"
 530         "  -mrmw            accept Read-Modify-Write instructions\n"
 531     "  -mlink-relax     generate relocations for linker relaxation\n"
 532     ));
 533   show_mcu_list (stream);
 534 }
 535
 536 static void
 537 avr_set_arch (int dummy ATTRIBUTE_UNUSED)
 538 {
 539   char str[20];
 540
 541   input_line_pointer = extract_word (input_line_pointer, str, 20);
 542   md_parse_option (OPTION_MMCU, str);
 543   bfd_set_arch_mach (stdoutput, TARGET_ARCH, avr_mcu->mach);
 544 }
 545
 546 int
 547 md_parse_option (int c, char *arg)
 548 {
 549   switch (c)
 550     {
 551     case OPTION_MMCU:
 552       {
 553         int i;
 554         char *s = alloca (strlen (arg) + 1);
 555
 556         {
 557           char *t = s;
 558           char *arg1 = arg;
 559
 560           do
 561             *t = TOLOWER (*arg1++);
 562           while (*t++);
 563         }
 564
 565         for (i = 0; mcu_types[i].name; ++i)
 566           if (strcmp (mcu_types[i].name, s) == 0)
 567             break;
 568
 569         if (!mcu_types[i].name)
 570           {
 571             show_mcu_list (stderr);
 572             as_fatal (_("unknown MCU: %s\n"), arg);
 573           }
 574
 575         /* It is OK to redefine mcu type within the same avr[1-5] bfd machine
 576            type - this for allows passing -mmcu=... via gcc ASM_SPEC as well
 577            as .arch ... in the asm output at the same time.  */
 578         if (avr_mcu == &default_mcu || avr_mcu->mach == mcu_types[i].mach)
 579       {
 580         specified_mcu.name = mcu_types[i].name;
 581         specified_mcu.isa  |= mcu_types[i].isa;
 582         specified_mcu.mach = mcu_types[i].mach;
 583         avr_mcu = &specified_mcu;
 584       }
 585         else
 586           as_fatal (_("redefinition of mcu type `%s' to `%s'"),
 587                     avr_mcu->name, mcu_types[i].name);
 588         return 1;
 589       }
 590     case OPTION_ALL_OPCODES:
 591       avr_opt.all_opcodes = 1;
 592       return 1;
 593     case OPTION_NO_SKIP_BUG:
 594       avr_opt.no_skip_bug = 1;
 595       return 1;
 596     case OPTION_NO_WRAP:
 597       avr_opt.no_wrap = 1;
 598       return 1;
 599     case OPTION_ISA_RMW:
 600       specified_mcu.isa |= AVR_ISA_RMW;
 601       return 1;
 602     case OPTION_LINK_RELAX:
 603       avr_opt.link_relax = 1;
 604       return 1;
 605     }
 606
 607   return 0;
 608 }
 609
 610 symbolS *
 611 md_undefined_symbol (char *name ATTRIBUTE_UNUSED)
 612 {
 613   return NULL;
 614 }
 615
 616 char *
 617 md_atof (int type, char *litP, int *sizeP)
 618 {
 619   return ieee_md_atof (type, litP, sizeP, FALSE);
 620 }
 621
 622 void
 623 md_convert_frag (bfd *abfd ATTRIBUTE_UNUSED,
 624                  asection *sec ATTRIBUTE_UNUSED,
 625                  fragS *fragP ATTRIBUTE_UNUSED)
 626 {
 627   abort ();
 628 }
 629
 630 void
 631 md_begin (void)
 632 {
 633   unsigned int i;
 634   struct avr_opcodes_s *opcode;
 635
 636   avr_hash = hash_new ();
 637
 638   /* Insert unique names into hash table.  This hash table then provides a
 639      quick index to the first opcode with a particular name in the opcode
 640      table.  */
 641   for (opcode = avr_opcodes; opcode->name; opcode++)
 642     hash_insert (avr_hash, opcode->name, (char *) opcode);
 643
 644   avr_mod_hash = hash_new ();
 645
 646   for (i = 0; i < ARRAY_SIZE (exp_mod); ++i)
 647     {
 648       mod_index m;
 649
 650       m.index = i + 10;
 651       hash_insert (avr_mod_hash, EXP_MOD_NAME (i), m.ptr);
 652     }
 653
 654   bfd_set_arch_mach (stdoutput, TARGET_ARCH, avr_mcu->mach);
 655   linkrelax = avr_opt.link_relax;
 656 }
 657
 658 /* Resolve STR as a constant expression and return the result.
 659    If result greater than MAX then error.  */
 660
 661 static unsigned int
 662 avr_get_constant (char *str, int max)
 663 {
 664   expressionS ex;
 665
 666   str = skip_space (str);
 667   input_line_pointer = str;
 668   expression (& ex);
 669
 670   if (ex.X_op != O_constant)
 671     as_bad (_("constant value required"));
 672
 673   if (ex.X_add_number > max || ex.X_add_number < 0)
 674     as_bad (_("number must be positive and less than %d"), max + 1);
 675
 676   return ex.X_add_number;
 677 }
 678
 679 /* Parse for ldd/std offset.  */
 680
 681 static void
 682 avr_offset_expression (expressionS *exp)
 683 {
 684   char *str = input_line_pointer;
 685   char *tmp;
 686   char op[8];
 687
 688   tmp = str;
 689   str = extract_word (str, op, sizeof (op));
 690
 691   input_line_pointer = tmp;
 692   expression (exp);
 693
 694   /* Warn about expressions that fail to use lo8 ().  */
 695   if (exp->X_op == O_constant)
 696     {
 697       int x = exp->X_add_number;
 698
 699       if (x < -255 || x > 255)
 700         as_warn (_("constant out of 8-bit range: %d"), x);
 701     }
 702 }
 703
 704 /* Parse ordinary expression.  */
 705
 706 static char *
 707 parse_exp (char *s, expressionS *op)
 708 {
 709   input_line_pointer = s;
 710   expression (op);
 711   if (op->X_op == O_absent)
 712     as_bad (_("missing operand"));
 713   return input_line_pointer;
 714 }
 715
 716 /* Parse special expressions (needed for LDI command):
 717    xx8 (address)
 718    xx8 (-address)
 719    pm_xx8 (address)
 720    pm_xx8 (-address)
 721    where xx is: hh, hi, lo.  */
 722
 723 static bfd_reloc_code_real_type
 724 avr_ldi_expression (expressionS *exp)
 725 {
 726   char *str = input_line_pointer;
 727   char *tmp;
 728   char op[8];
 729   int mod;
 730   int linker_stubs_should_be_generated = 0;
 731
 732   tmp = str;
 733
 734   str = extract_word (str, op, sizeof (op));
 735
 736   if (op[0])
 737     {
 738       mod_index m;
 739
 740       m.ptr = hash_find (avr_mod_hash, op);
 741       mod = m.index;
 742
 743       if (mod)
 744         {
 745           int closes = 0;
 746
 747           mod -= 10;
 748           str = skip_space (str);
 749
 750           if (*str == '(')
 751             {
 752               bfd_reloc_code_real_type  reloc_to_return;
 753               int neg_p = 0;
 754
 755               ++str;
 756
 757               if (strncmp ("pm(", str, 3) == 0
 758                   || strncmp ("gs(",str,3) == 0
 759                   || strncmp ("-(gs(",str,5) == 0
 760                   || strncmp ("-(pm(", str, 5) == 0)
 761                 {
 762                   if (HAVE_PM_P (mod))
 763                     {
 764                       ++mod;
 765                       ++closes;
 766                     }
 767                   else
 768                     as_bad (_("illegal expression"));
 769
 770                   if (str[0] == 'g' || str[2] == 'g')
 771                     linker_stubs_should_be_generated = 1;
 772
 773                   if (*str == '-')
 774                     {
 775                       neg_p = 1;
 776                       ++closes;
 777                       str += 5;
 778                     }
 779                   else
 780                     str += 3;
 781                 }
 782
 783               if (*str == '-' && *(str + 1) == '(')
 784                 {
 785                   neg_p ^= 1;
 786                   ++closes;
 787                   str += 2;
 788                 }
 789
 790               input_line_pointer = str;
 791               expression (exp);
 792
 793               do
 794                 {
 795                   if (*input_line_pointer != ')')
 796                     {
 797                       as_bad (_("`)' required"));
 798                       break;
 799                     }
 800                   input_line_pointer++;
 801                 }
 802               while (closes--);
 803
 804               reloc_to_return =
 805                 neg_p ? EXP_MOD_NEG_RELOC (mod) : EXP_MOD_RELOC (mod);
 806               if (linker_stubs_should_be_generated)
 807                 {
 808                   switch (reloc_to_return)
 809                     {
 810                     case BFD_RELOC_AVR_LO8_LDI_PM:
 811                       reloc_to_return = BFD_RELOC_AVR_LO8_LDI_GS;
 812                       break;
 813                     case BFD_RELOC_AVR_HI8_LDI_PM:
 814                       reloc_to_return = BFD_RELOC_AVR_HI8_LDI_GS;
 815                       break;
 816
 817                     default:
 818                       /* PR 5523: Do not generate a warning here,
 819                          legitimate code can trigger this case.  */
 820                       break;
 821                     }
 822                 }
 823               return reloc_to_return;
 824             }
 825         }
 826     }
 827
 828   input_line_pointer = tmp;
 829   expression (exp);
 830
 831   /* Warn about expressions that fail to use lo8 ().  */
 832   if (exp->X_op == O_constant)
 833     {
 834       int x = exp->X_add_number;
 835
 836       if (x < -255 || x > 255)
 837         as_warn (_("constant out of 8-bit range: %d"), x);
 838     }
 839
 840   return BFD_RELOC_AVR_LDI;
 841 }
 842
 843 /* Parse one instruction operand.
 844    Return operand bitmask.  Also fixups can be generated.  */
 845
 846 static unsigned int
 847 avr_operand (struct avr_opcodes_s *opcode,
 848              int where,
 849              char *op,
 850              char **line)
 851 {
 852   expressionS op_expr;
 853   unsigned int op_mask = 0;
 854   char *str = skip_space (*line);
 855
 856   switch (*op)
 857     {
 858       /* Any register operand.  */
 859     case 'w':
 860     case 'd':
 861     case 'r':
 862     case 'a':
 863     case 'v':
 864       {
 865         char * old_str = str;
 866         char *lower;
 867         char r_name[20];
 868
 869         str = extract_word (str, r_name, sizeof (r_name));
 870         for (lower = r_name; *lower; ++lower)
 871           {
 872             if (*lower >= 'A' && *lower <= 'Z')
 873               *lower += 'a' - 'A';
 874           }
 875
 876         if (r_name[0] == 'r' && ISDIGIT (r_name[1]) && r_name[2] == 0)
 877           /* Single-digit register number, ie r0-r9.  */
 878           op_mask = r_name[1] - '0';
 879         else if (r_name[0] == 'r' && ISDIGIT (r_name[1])
 880                  && ISDIGIT (r_name[2]) && r_name[3] == 0)
 881           /* Double-digit register number, ie r10 - r32.  */
 882           op_mask = (r_name[1] - '0') * 10 + r_name[2] - '0';
 883         else if (r_name[0] >= 'x' && r_name[0] <= 'z'
 884                  && (r_name[1] == 'l' || r_name[1] == 'h') && r_name[2] == 0)
 885           /* Registers r26-r31 referred to by name, ie xl, xh, yl, yh, zl, zh.  */
 886           op_mask = (r_name[0] - 'x') * 2 + (r_name[1] == 'h') + 26;
 887         else if ((*op == 'v' || *op == 'w')
 888                  && r_name[0] >= 'x' && r_name[0] <= 'z' && r_name[1] == 0)
 889           /* For the movw and addiw instructions, refer to registers x, y and z by name.  */
 890           op_mask = (r_name[0] - 'x') * 2 + 26;
 891         else
 892           {
 893             /* Numeric or symbolic constant register number.  */
 894             op_mask = avr_get_constant (old_str, 31);
 895             str = input_line_pointer;
 896           }
 897       }
 898
 899       if (avr_mcu->mach == bfd_mach_avrtiny)
 900         {
 901           if (op_mask < 16 || op_mask > 31)
 902             {
 903               as_bad (_("register name or number from 16 to 31 required"));
 904               break;
 905             }
 906         }
 907       else if (op_mask > 31)
 908         {
 909           as_bad (_("register name or number from 0 to 31 required"));
 910           break;
 911         }
 912
 913           switch (*op)
 914             {
 915             case 'a':
 916               if (op_mask < 16 || op_mask > 23)
 917                 as_bad (_("register r16-r23 required"));
 918               op_mask -= 16;
 919               break;
 920
 921             case 'd':
 922               if (op_mask < 16)
 923                 as_bad (_("register number above 15 required"));
 924               op_mask -= 16;
 925               break;
 926
 927             case 'v':
 928               if (op_mask & 1)
 929                 as_bad (_("even register number required"));
 930               op_mask >>= 1;
 931               break;
 932
 933             case 'w':
 934               if ((op_mask & 1) || op_mask < 24)
 935                 as_bad (_("register r24, r26, r28 or r30 required"));
 936               op_mask = (op_mask - 24) >> 1;
 937               break;
 938             }
 939           break;
 940
 941     case 'e':
 942       {
 943         char c;
 944
 945         if (*str == '-')
 946           {
 947             str = skip_space (str + 1);
 948             op_mask = 0x1002;
 949           }
 950         c = TOLOWER (*str);
 951         if (c == 'x')
 952           op_mask |= 0x100c;
 953         else if (c == 'y')
 954           op_mask |= 0x8;
 955         else if (c != 'z')
 956           as_bad (_("pointer register (X, Y or Z) required"));
 957
 958         str = skip_space (str + 1);
 959         if (*str == '+')
 960           {
 961             ++str;
 962             if (op_mask & 2)
 963               as_bad (_("cannot both predecrement and postincrement"));
 964             op_mask |= 0x1001;
 965           }
 966
 967         /* avr1 can do "ld r,Z" and "st Z,r" but no other pointer
 968            registers, no predecrement, no postincrement.  */
 969         if (!avr_opt.all_opcodes && (op_mask & 0x100F)
 970             && !(avr_mcu->isa & AVR_ISA_SRAM))
 971           as_bad (_("addressing mode not supported"));
 972       }
 973       break;
 974
 975     case 'z':
 976       if (*str == '-')
 977         as_bad (_("can't predecrement"));
 978
 979       if (! (*str == 'z' || *str == 'Z'))
 980         as_bad (_("pointer register Z required"));
 981
 982       str = skip_space (str + 1);
 983
 984       if (*str == '+')
 985         {
 986           ++str;
 987           char *s;
 988           for (s = opcode->opcode; *s; ++s)
 989             {
 990               if (*s == '+')
 991                 op_mask |= (1 << (15 - (s - opcode->opcode)));
 992             }
 993         }
 994
 995       /* attiny26 can do "lpm" and "lpm r,Z" but not "lpm r,Z+".  */
 996       if (!avr_opt.all_opcodes
 997           && (op_mask & 0x0001)
 998           && !(avr_mcu->isa & AVR_ISA_MOVW))
 999         as_bad (_("postincrement not supported"));
1000       break;
1001
1002     case 'b':
1003       {
1004         char c = TOLOWER (*str++);
1005
1006         if (c == 'y')
1007           op_mask |= 0x8;
1008         else if (c != 'z')
1009           as_bad (_("pointer register (Y or Z) required"));
1010         str = skip_space (str);
1011         if (*str++ == '+')
1012           {
1013             input_line_pointer = str;
1014             avr_offset_expression (& op_expr);
1015             str = input_line_pointer;
1016             fix_new_exp (frag_now, where, 3,
1017                          &op_expr, FALSE, BFD_RELOC_AVR_6);
1018           }
1019       }
1020       break;
1021
1022     case 'h':
1023       str = parse_exp (str, &op_expr);
1024       fix_new_exp (frag_now, where, opcode->insn_size * 2,
1025                    &op_expr, FALSE, BFD_RELOC_AVR_CALL);
1026       break;
1027
1028     case 'L':
1029       str = parse_exp (str, &op_expr);
1030       fix_new_exp (frag_now, where, opcode->insn_size * 2,
1031                    &op_expr, TRUE, BFD_RELOC_AVR_13_PCREL);
1032       break;
1033
1034     case 'l':
1035       str = parse_exp (str, &op_expr);
1036       fix_new_exp (frag_now, where, opcode->insn_size * 2,
1037                    &op_expr, TRUE, BFD_RELOC_AVR_7_PCREL);
1038       break;
1039
1040     case 'i':
1041       str = parse_exp (str, &op_expr);
1042       fix_new_exp (frag_now, where + 2, opcode->insn_size * 2,
1043                    &op_expr, FALSE, BFD_RELOC_16);
1044       break;
1045
1046     case 'j':
1047       str = parse_exp (str, &op_expr);
1048       fix_new_exp (frag_now, where, opcode->insn_size * 2,
1049                    &op_expr, FALSE, BFD_RELOC_AVR_LDS_STS_16);
1050       break;
1051
1052     case 'M':
1053       {
1054         bfd_reloc_code_real_type r_type;
1055
1056         input_line_pointer = str;
1057         r_type = avr_ldi_expression (&op_expr);
1058         str = input_line_pointer;
1059         fix_new_exp (frag_now, where, 3,
1060                      &op_expr, FALSE, r_type);
1061       }
1062       break;
1063
1064     case 'n':
1065       {
1066         unsigned int x;
1067
1068         x = ~avr_get_constant (str, 255);
1069         str = input_line_pointer;
1070         op_mask |= (x & 0xf) | ((x << 4) & 0xf00);
1071       }
1072       break;
1073
1074     case 'K':
1075       input_line_pointer = str;
1076       avr_offset_expression (& op_expr);
1077       str = input_line_pointer;
1078       fix_new_exp (frag_now, where, 3,
1079                    & op_expr, FALSE, BFD_RELOC_AVR_6_ADIW);
1080       break;
1081
1082     case 'S':
1083     case 's':
1084       {
1085         unsigned int x;
1086
1087         x = avr_get_constant (str, 7);
1088         str = input_line_pointer;
1089         if (*op == 'S')
1090           x <<= 4;
1091         op_mask |= x;
1092       }
1093       break;
1094
1095     case 'P':
1096       str = parse_exp (str, &op_expr);
1097       fix_new_exp (frag_now, where, opcode->insn_size * 2,
1098                      &op_expr, FALSE, BFD_RELOC_AVR_PORT6);
1099       break;
1100
1101     case 'p':
1102       str = parse_exp (str, &op_expr);
1103       fix_new_exp (frag_now, where, opcode->insn_size * 2,
1104                      &op_expr, FALSE, BFD_RELOC_AVR_PORT5);
1105       break;
1106
1107     case 'E':
1108       {
1109         unsigned int x;
1110
1111         x = avr_get_constant (str, 15);
1112         str = input_line_pointer;
1113         op_mask |= (x << 4);
1114       }
1115       break;
1116
1117     case '?':
1118       break;
1119
1120     default:
1121       as_bad (_("unknown constraint `%c'"), *op);
1122     }
1123
1124   *line = str;
1125   return op_mask;
1126 }
1127
1128 /* Parse instruction operands.
1129    Return binary opcode.  */
1130
1131 static unsigned int
1132 avr_operands (struct avr_opcodes_s *opcode, char **line)
1133 {
1134   char *op = opcode->constraints;
1135   unsigned int bin = opcode->bin_opcode;
1136   char *frag = frag_more (opcode->insn_size * 2);
1137   char *str = *line;
1138   int where = frag - frag_now->fr_literal;
1139   static unsigned int prev = 0;  /* Previous opcode.  */
1140
1141   /* Opcode have operands.  */
1142   if (*op)
1143     {
1144       unsigned int reg1 = 0;
1145       unsigned int reg2 = 0;
1146       int reg1_present = 0;
1147       int reg2_present = 0;
1148
1149       /* Parse first operand.  */
1150       if (REGISTER_P (*op))
1151         reg1_present = 1;
1152       reg1 = avr_operand (opcode, where, op, &str);
1153       ++op;
1154
1155       /* Parse second operand.  */
1156       if (*op)
1157         {
1158           if (*op == ',')
1159             ++op;
1160
1161           if (*op == '=')
1162             {
1163               reg2 = reg1;
1164               reg2_present = 1;
1165             }
1166           else
1167             {
1168               if (REGISTER_P (*op))
1169                 reg2_present = 1;
1170
1171               str = skip_space (str);
1172               if (*str++ != ',')
1173                 as_bad (_("`,' required"));
1174               str = skip_space (str);
1175
1176               reg2 = avr_operand (opcode, where, op, &str);
1177             }
1178
1179           if (reg1_present && reg2_present)
1180             reg2 = (reg2 & 0xf) | ((reg2 << 5) & 0x200);
1181           else if (reg2_present)
1182             reg2 <<= 4;
1183         }
1184       if (reg1_present)
1185         reg1 <<= 4;
1186       bin |= reg1 | reg2;
1187     }
1188
1189   /* Detect undefined combinations (like ld r31,Z+).  */
1190   if (!avr_opt.all_opcodes && AVR_UNDEF_P (bin))
1191     as_warn (_("undefined combination of operands"));
1192
1193   if (opcode->insn_size == 2)
1194     {
1195       /* Warn if the previous opcode was cpse/sbic/sbis/sbrc/sbrs
1196          (AVR core bug, fixed in the newer devices).  */
1197       if (!(avr_opt.no_skip_bug ||
1198             (avr_mcu->isa & (AVR_ISA_MUL | AVR_ISA_MOVW)))
1199           && AVR_SKIP_P (prev))
1200         as_warn (_("skipping two-word instruction"));
1201
1202       bfd_putl32 ((bfd_vma) bin, frag);
1203     }
1204   else
1205     bfd_putl16 ((bfd_vma) bin, frag);
1206
1207   prev = bin;
1208   *line = str;
1209   return bin;
1210 }
1211
1212 /* GAS will call this function for each section at the end of the assembly,
1213    to permit the CPU backend to adjust the alignment of a section.  */
1214
1215 valueT
1216 md_section_align (asection *seg, valueT addr)
1217 {
1218   int align = bfd_get_section_alignment (stdoutput, seg);
1219   return ((addr + (1 << align) - 1) & (-1 << align));
1220 }
1221
1222 /* If you define this macro, it should return the offset between the
1223    address of a PC relative fixup and the position from which the PC
1224    relative adjustment should be made.  On many processors, the base
1225    of a PC relative instruction is the next instruction, so this
1226    macro would return the length of an instruction.  */
1227
1228 long
1229 md_pcrel_from_section (fixS *fixp, segT sec)
1230 {
1231   if (fixp->fx_addsy != (symbolS *) NULL
1232       && (!S_IS_DEFINED (fixp->fx_addsy)
1233           || (S_GET_SEGMENT (fixp->fx_addsy) != sec)))
1234     return 0;
1235
1236   return fixp->fx_frag->fr_address + fixp->fx_where;
1237 }
1238
1239 static bfd_boolean
1240 relaxable_section (asection *sec)
1241 {
1242   return (sec->flags & SEC_DEBUGGING) == 0;
1243 }
1244
1245 /* Does whatever the xtensa port does.  */
1246 int
1247 avr_validate_fix_sub (fixS *fix)
1248 {
1249   segT add_symbol_segment, sub_symbol_segment;
1250
1251   /* The difference of two symbols should be resolved by the assembler when
1252      linkrelax is not set.  If the linker may relax the section containing
1253      the symbols, then an Xtensa DIFF relocation must be generated so that
1254      the linker knows to adjust the difference value.  */
1255   if (!linkrelax || fix->fx_addsy == NULL)
1256     return 0;
1257
1258   /* Make sure both symbols are in the same segment, and that segment is
1259      "normal" and relaxable.  If the segment is not "normal", then the
1260      fix is not valid.  If the segment is not "relaxable", then the fix
1261      should have been handled earlier.  */
1262   add_symbol_segment = S_GET_SEGMENT (fix->fx_addsy);
1263   if (! SEG_NORMAL (add_symbol_segment) ||
1264       ! relaxable_section (add_symbol_segment))
1265     return 0;
1266
1267   sub_symbol_segment = S_GET_SEGMENT (fix->fx_subsy);
1268   return (sub_symbol_segment == add_symbol_segment);
1269 }
1270
1271 /* TC_FORCE_RELOCATION hook */
1272
1273 /* If linkrelax is turned on, and the symbol to relocate
1274    against is in a relaxable segment, don't compute the value -
1275    generate a relocation instead.  */
1276 int
1277 avr_force_relocation (fixS *fix)
1278 {
1279   if (linkrelax && fix->fx_addsy
1280       && relaxable_section (S_GET_SEGMENT (fix->fx_addsy)))
1281     return 1;
1282
1283   return generic_force_reloc (fix);
1284 }
1285
1286 /* GAS will call this for each fixup.  It should store the correct
1287    value in the object file.  */
1288
1289 void
1290 md_apply_fix (fixS *fixP, valueT * valP, segT seg)
1291 {
1292   unsigned char *where;
1293   unsigned long insn;
1294   long value = *valP;
1295
1296   if (fixP->fx_addsy == (symbolS *) NULL)
1297     fixP->fx_done = 1;
1298
1299   else if (fixP->fx_pcrel)
1300     {
1301       segT s = S_GET_SEGMENT (fixP->fx_addsy);
1302
1303       if (s == seg || s == absolute_section)
1304         {
1305           value += S_GET_VALUE (fixP->fx_addsy);
1306           fixP->fx_done = 1;
1307         }
1308     }
1309   else if (linkrelax && fixP->fx_subsy)
1310     {
1311       /* For a subtraction relocation expression, generate one
1312          of the DIFF relocs, with the value being the difference.
1313          Note that a sym1 - sym2 expression is adjusted into a
1314          section_start_sym + sym4_offset_from_section_start - sym1
1315          expression. fixP->fx_addsy holds the section start symbol,
1316          fixP->fx_offset holds sym2's offset, and fixP->fx_subsy
1317          holds sym1. Calculate the current difference and write value,
1318          but leave fx_offset as is - during relaxation,
1319          fx_offset - value gives sym1's value.  */
1320
1321        switch (fixP->fx_r_type)
1322          {
1323            case BFD_RELOC_8:
1324              fixP->fx_r_type = BFD_RELOC_AVR_DIFF8;
1325              break;
1326            case BFD_RELOC_16:
1327              fixP->fx_r_type = BFD_RELOC_AVR_DIFF16;
1328              break;
1329            case BFD_RELOC_32:
1330              fixP->fx_r_type = BFD_RELOC_AVR_DIFF32;
1331              break;
1332            default:
1333              as_bad_where (fixP->fx_file, fixP->fx_line, _("expression too complex"));
1334              break;
1335          }
1336
1337       value = S_GET_VALUE (fixP->fx_addsy) +
1338           fixP->fx_offset - S_GET_VALUE (fixP->fx_subsy);
1339
1340       fixP->fx_subsy = NULL;
1341   }
1342   /* We don't actually support subtracting a symbol.  */
1343   if (fixP->fx_subsy != (symbolS *) NULL)
1344     as_bad_where (fixP->fx_file, fixP->fx_line, _("expression too complex"));
1345
1346   /* For the DIFF relocs, write the value into the object file while still
1347      keeping fx_done FALSE, as both the difference (recorded in the object file)
1348      and the sym offset (part of fixP) are needed at link relax time.  */
1349   where = (unsigned char *) fixP->fx_frag->fr_literal + fixP->fx_where;
1350   switch (fixP->fx_r_type)
1351     {
1352     default:
1353       fixP->fx_no_overflow = 1;
1354       break;
1355     case BFD_RELOC_AVR_7_PCREL:
1356     case BFD_RELOC_AVR_13_PCREL:
1357     case BFD_RELOC_32:
1358     case BFD_RELOC_16:
1359       break;
1360     case BFD_RELOC_AVR_DIFF8:
1361       *where = value;
1362           break;
1363     case BFD_RELOC_AVR_DIFF16:
1364       bfd_putl16 ((bfd_vma) value, where);
1365       break;
1366     case BFD_RELOC_AVR_DIFF32:
1367       bfd_putl32 ((bfd_vma) value, where);
1368       break;
1369     case BFD_RELOC_AVR_CALL:
1370       break;
1371     }
1372
1373   if (fixP->fx_done)
1374     {
1375       /* Fetch the instruction, insert the fully resolved operand
1376          value, and stuff the instruction back again.  */
1377       where = (unsigned char *) fixP->fx_frag->fr_literal + fixP->fx_where;
1378       insn = bfd_getl16 (where);
1379
1380       switch (fixP->fx_r_type)
1381         {
1382         case BFD_RELOC_AVR_7_PCREL:
1383           if (value & 1)
1384             as_bad_where (fixP->fx_file, fixP->fx_line,
1385                           _("odd address operand: %ld"), value);
1386
1387           /* Instruction addresses are always right-shifted by 1.  */
1388           value >>= 1;
1389           --value;                      /* Correct PC.  */
1390
1391           if (value < -64 || value > 63)
1392             as_bad_where (fixP->fx_file, fixP->fx_line,
1393                           _("operand out of range: %ld"), value);
1394           value = (value << 3) & 0x3f8;
1395           bfd_putl16 ((bfd_vma) (value | insn), where);
1396           break;
1397
1398         case BFD_RELOC_AVR_13_PCREL:
1399           if (value & 1)
1400             as_bad_where (fixP->fx_file, fixP->fx_line,
1401                           _("odd address operand: %ld"), value);
1402
1403           /* Instruction addresses are always right-shifted by 1.  */
1404           value >>= 1;
1405           --value;                      /* Correct PC.  */
1406
1407           if (value < -2048 || value > 2047)
1408             {
1409               /* No wrap for devices with >8K of program memory.  */
1410               if ((avr_mcu->isa & AVR_ISA_MEGA) || avr_opt.no_wrap)
1411                 as_bad_where (fixP->fx_file, fixP->fx_line,
1412                               _("operand out of range: %ld"), value);
1413             }
1414
1415           value &= 0xfff;
1416           bfd_putl16 ((bfd_vma) (value | insn), where);
1417           break;
1418
1419         case BFD_RELOC_32:
1420           bfd_putl32 ((bfd_vma) value, where);
1421           break;
1422
1423         case BFD_RELOC_16:
1424           bfd_putl16 ((bfd_vma) value, where);
1425           break;
1426
1427         case BFD_RELOC_8:
1428           if (value > 255 || value < -128)
1429             as_warn_where (fixP->fx_file, fixP->fx_line,
1430                            _("operand out of range: %ld"), value);
1431           *where = value;
1432           break;
1433
1434         case BFD_RELOC_AVR_16_PM:
1435           bfd_putl16 ((bfd_vma) (value >> 1), where);
1436           break;
1437
1438         case BFD_RELOC_AVR_LDI:
1439           if (value > 255)
1440             as_bad_where (fixP->fx_file, fixP->fx_line,
1441                           _("operand out of range: %ld"), value);
1442           bfd_putl16 ((bfd_vma) insn | LDI_IMMEDIATE (value), where);
1443           break;
1444
1445         case BFD_RELOC_AVR_LDS_STS_16:
1446           if ((value < 0x40) || (value > 0xBF))
1447             as_warn_where (fixP->fx_file, fixP->fx_line,
1448                            _("operand out of range: 0x%lx"),
1449                            (unsigned long)value);
1450           insn |= ((value & 0xF) | ((value & 0x30) << 5) | ((value & 0x40) << 2));
1451           bfd_putl16 ((bfd_vma) insn, where);
1452           break;
1453
1454         case BFD_RELOC_AVR_6:
1455           if ((value > 63) || (value < 0))
1456             as_bad_where (fixP->fx_file, fixP->fx_line,
1457                           _("operand out of range: %ld"), value);
1458           bfd_putl16 ((bfd_vma) insn | ((value & 7) | ((value & (3 << 3)) << 7)
1459                                         | ((value & (1 << 5)) << 8)), where);
1460           break;
1461
1462         case BFD_RELOC_AVR_6_ADIW:
1463           if ((value > 63) || (value < 0))
1464             as_bad_where (fixP->fx_file, fixP->fx_line,
1465                           _("operand out of range: %ld"), value);
1466           bfd_putl16 ((bfd_vma) insn | (value & 0xf) | ((value & 0x30) << 2), where);
1467           break;
1468
1469         case BFD_RELOC_AVR_LO8_LDI:
1470           bfd_putl16 ((bfd_vma) insn | LDI_IMMEDIATE (value), where);
1471           break;
1472
1473         case BFD_RELOC_AVR_HI8_LDI:
1474           bfd_putl16 ((bfd_vma) insn | LDI_IMMEDIATE (value >> 8), where);
1475           break;
1476
1477         case BFD_RELOC_AVR_MS8_LDI:
1478           bfd_putl16 ((bfd_vma) insn | LDI_IMMEDIATE (value >> 24), where);
1479           break;
1480
1481         case BFD_RELOC_AVR_HH8_LDI:
1482           bfd_putl16 ((bfd_vma) insn | LDI_IMMEDIATE (value >> 16), where);
1483           break;
1484
1485         case BFD_RELOC_AVR_LO8_LDI_NEG:
1486           bfd_putl16 ((bfd_vma) insn | LDI_IMMEDIATE (-value), where);
1487           break;
1488
1489         case BFD_RELOC_AVR_HI8_LDI_NEG:
1490           bfd_putl16 ((bfd_vma) insn | LDI_IMMEDIATE (-value >> 8), where);
1491           break;
1492
1493         case BFD_RELOC_AVR_MS8_LDI_NEG:
1494           bfd_putl16 ((bfd_vma) insn | LDI_IMMEDIATE (-value >> 24), where);
1495           break;
1496
1497         case BFD_RELOC_AVR_HH8_LDI_NEG:
1498           bfd_putl16 ((bfd_vma) insn | LDI_IMMEDIATE (-value >> 16), where);
1499           break;
1500
1501         case BFD_RELOC_AVR_LO8_LDI_PM:
1502           bfd_putl16 ((bfd_vma) insn | LDI_IMMEDIATE (value >> 1), where);
1503           break;
1504
1505         case BFD_RELOC_AVR_HI8_LDI_PM:
1506           bfd_putl16 ((bfd_vma) insn | LDI_IMMEDIATE (value >> 9), where);
1507           break;
1508
1509         case BFD_RELOC_AVR_HH8_LDI_PM:
1510           bfd_putl16 ((bfd_vma) insn | LDI_IMMEDIATE (value >> 17), where);
1511           break;
1512
1513         case BFD_RELOC_AVR_LO8_LDI_PM_NEG:
1514           bfd_putl16 ((bfd_vma) insn | LDI_IMMEDIATE (-value >> 1), where);
1515           break;
1516
1517         case BFD_RELOC_AVR_HI8_LDI_PM_NEG:
1518           bfd_putl16 ((bfd_vma) insn | LDI_IMMEDIATE (-value >> 9), where);
1519           break;
1520
1521         case BFD_RELOC_AVR_HH8_LDI_PM_NEG:
1522           bfd_putl16 ((bfd_vma) insn | LDI_IMMEDIATE (-value >> 17), where);
1523           break;
1524
1525         case BFD_RELOC_AVR_CALL:
1526           {
1527             unsigned long x;
1528
1529             x = bfd_getl16 (where);
1530             if (value & 1)
1531               as_bad_where (fixP->fx_file, fixP->fx_line,
1532                             _("odd address operand: %ld"), value);
1533             value >>= 1;
1534             x |= ((value & 0x10000) | ((value << 3) & 0x1f00000)) >> 16;
1535             bfd_putl16 ((bfd_vma) x, where);
1536             bfd_putl16 ((bfd_vma) (value & 0xffff), where + 2);
1537           }
1538           break;
1539
1540         case BFD_RELOC_AVR_8_LO:
1541           *where = 0xff & value;
1542           break;
1543
1544         case BFD_RELOC_AVR_8_HI:
1545           *where = 0xff & (value >> 8);
1546           break;
1547
1548         case BFD_RELOC_AVR_8_HLO:
1549           *where = 0xff & (value >> 16);
1550           break;
1551
1552         default:
1553           as_fatal (_("line %d: unknown relocation type: 0x%x"),
1554                     fixP->fx_line, fixP->fx_r_type);
1555           break;
1556
1557         case BFD_RELOC_AVR_PORT6:
1558           if (value > 63)
1559             as_bad_where (fixP->fx_file, fixP->fx_line,
1560                           _("operand out of range: %ld"), value);
1561           bfd_putl16 ((bfd_vma) insn | ((value & 0x30) << 5) | (value & 0x0f), where);
1562           break;
1563
1564         case BFD_RELOC_AVR_PORT5:
1565           if (value > 31)
1566             as_bad_where (fixP->fx_file, fixP->fx_line,
1567                           _("operand out of range: %ld"), value);
1568           bfd_putl16 ((bfd_vma) insn | ((value & 0x1f) << 3), where);
1569           break;
1570         }
1571     }
1572   else
1573     {
1574       switch ((int) fixP->fx_r_type)
1575         {
1576         case -BFD_RELOC_AVR_HI8_LDI_NEG:
1577         case -BFD_RELOC_AVR_HI8_LDI:
1578         case -BFD_RELOC_AVR_LO8_LDI_NEG:
1579         case -BFD_RELOC_AVR_LO8_LDI:
1580           as_bad_where (fixP->fx_file, fixP->fx_line,
1581                         _("only constant expression allowed"));
1582           fixP->fx_done = 1;
1583           break;
1584         default:
1585           break;
1586         }
1587     }
1588 }
1589
1590 /* GAS will call this to generate a reloc, passing the resulting reloc
1591    to `bfd_install_relocation'.  This currently works poorly, as
1592    `bfd_install_relocation' often does the wrong thing, and instances of
1593    `tc_gen_reloc' have been written to work around the problems, which
1594    in turns makes it difficult to fix `bfd_install_relocation'.  */
1595
1596 /* If while processing a fixup, a reloc really needs to be created
1597    then it is done here.  */
1598
1599 arelent *
1600 tc_gen_reloc (asection *seg ATTRIBUTE_UNUSED,
1601               fixS *fixp)
1602 {
1603   arelent *reloc;
1604
1605   if (fixp->fx_subsy != NULL)
1606     {
1607       as_bad_where (fixp->fx_file, fixp->fx_line, _("expression too complex"));
1608       return NULL;
1609     }
1610
1611   reloc = xmalloc (sizeof (arelent));
1612
1613   reloc->sym_ptr_ptr = xmalloc (sizeof (asymbol *));
1614   *reloc->sym_ptr_ptr = symbol_get_bfdsym (fixp->fx_addsy);
1615
1616   reloc->address = fixp->fx_frag->fr_address + fixp->fx_where;
1617   reloc->howto = bfd_reloc_type_lookup (stdoutput, fixp->fx_r_type);
1618   if (reloc->howto == (reloc_howto_type *) NULL)
1619     {
1620       as_bad_where (fixp->fx_file, fixp->fx_line,
1621                     _("reloc %d not supported by object file format"),
1622                     (int) fixp->fx_r_type);
1623       return NULL;
1624     }
1625
1626   if (fixp->fx_r_type == BFD_RELOC_VTABLE_INHERIT
1627       || fixp->fx_r_type == BFD_RELOC_VTABLE_ENTRY)
1628     reloc->address = fixp->fx_offset;
1629
1630   reloc->addend = fixp->fx_offset;
1631
1632   return reloc;
1633 }
1634
1635 void
1636 md_assemble (char *str)
1637 {
1638   struct avr_opcodes_s *opcode;
1639   char op[11];
1640
1641   str = skip_space (extract_word (str, op, sizeof (op)));
1642
1643   if (!op[0])
1644     as_bad (_("can't find opcode "));
1645
1646   opcode = (struct avr_opcodes_s *) hash_find (avr_hash, op);
1647
1648   if (opcode && !avr_opt.all_opcodes)
1649     {
1650       /* Check if the instruction's ISA bit is ON in the ISA bits of the part
1651          specified by the user.  If not look for other instructions
1652          specifications with same mnemonic who's ISA bits matches.
1653
1654          This requires include/opcode/avr.h to have the instructions with
1655          same mnenomic to be specified in sequence.  */
1656
1657       while ((opcode->isa & avr_mcu->isa) != opcode->isa)
1658         {
1659           opcode++;
1660
1661           if (opcode->name && strcmp(op, opcode->name))
1662             {
1663               as_bad (_("illegal opcode %s for mcu %s"),
1664                       opcode->name, avr_mcu->name);
1665               return;
1666             }
1667         }
1668     }
1669
1670   if (opcode == NULL)
1671     {
1672       as_bad (_("unknown opcode `%s'"), op);
1673       return;
1674     }
1675
1676   /* Special case for opcodes with optional operands (lpm, elpm) -
1677      version with operands exists in avr_opcodes[] in the next entry.  */
1678
1679   if (*str && *opcode->constraints == '?')
1680     ++opcode;
1681
1682   dwarf2_emit_insn (0);
1683
1684   /* We used to set input_line_pointer to the result of get_operands,
1685      but that is wrong.  Our caller assumes we don't change it.  */
1686   {
1687     char *t = input_line_pointer;
1688
1689     avr_operands (opcode, &str);
1690     if (*skip_space (str))
1691       as_bad (_("garbage at end of line"));
1692     input_line_pointer = t;
1693   }
1694 }
1695
1696 const exp_mod_data_t exp_mod_data[] =
1697 {
1698   /* Default, must be first.  */
1699   { "", 0, BFD_RELOC_16, "" },
1700   /* Divides by 2 to get word address.  Generate Stub.  */
1701   { "gs", 2, BFD_RELOC_AVR_16_PM, "`gs' " },
1702   { "pm", 2, BFD_RELOC_AVR_16_PM, "`pm' " },
1703   /* The following are used together with avr-gcc's __memx address space
1704      in order to initialize a 24-bit pointer variable with a 24-bit address.
1705      For address in flash, hlo8 will contain the flash segment if the
1706      symbol is located in flash. If the symbol is located in RAM; hlo8
1707      will contain 0x80 which matches avr-gcc's notion of how 24-bit RAM/flash
1708      addresses linearize address space.  */
1709   { "lo8",  1, BFD_RELOC_AVR_8_LO,  "`lo8' "  },
1710   { "hi8",  1, BFD_RELOC_AVR_8_HI,  "`hi8' "  },
1711   { "hlo8", 1, BFD_RELOC_AVR_8_HLO, "`hlo8' " },
1712   { "hh8",  1, BFD_RELOC_AVR_8_HLO, "`hh8' "  },
1713   /* End of list.  */
1714   { NULL, 0, 0, NULL }
1715 };
1716
1717 /* Parse special CONS expression: pm (expression) or alternatively
1718    gs (expression).  These are used for addressing program memory.  Moreover,
1719    define lo8 (expression), hi8 (expression) and hlo8 (expression).  */
1720
1721 const exp_mod_data_t *
1722 avr_parse_cons_expression (expressionS *exp, int nbytes)
1723 {
1724   const exp_mod_data_t *pexp = &exp_mod_data[0];
1725   char *tmp;
1726
1727   tmp = input_line_pointer = skip_space (input_line_pointer);
1728
1729   /* The first entry of exp_mod_data[] contains an entry if no
1730      expression modifier is present.  Skip it.  */
1731
1732   for (pexp++; pexp->name; pexp++)
1733     {
1734       int len = strlen (pexp->name);
1735
1736       if (nbytes == pexp->nbytes
1737           && strncasecmp (input_line_pointer, pexp->name, len) == 0)
1738         {
1739           input_line_pointer = skip_space (input_line_pointer + len);
1740
1741           if (*input_line_pointer == '(')
1742             {
1743               input_line_pointer = skip_space (input_line_pointer + 1);
1744               expression (exp);
1745
1746               if (*input_line_pointer == ')')
1747                 {
1748                   ++input_line_pointer;
1749                   return pexp;
1750                 }
1751               else
1752                 {
1753                   as_bad (_("`)' required"));
1754                   return &exp_mod_data[0];
1755                 }
1756             }
1757
1758           input_line_pointer = tmp;
1759
1760           break;
1761         }
1762     }
1763
1764   expression (exp);
1765   return &exp_mod_data[0];
1766 }
1767
1768 void
1769 avr_cons_fix_new (fragS *frag,
1770                   int where,
1771                   int nbytes,
1772                   expressionS *exp,
1773                   const exp_mod_data_t *pexp_mod_data)
1774 {
1775   int bad = 0;
1776
1777   switch (pexp_mod_data->reloc)
1778     {
1779     default:
1780       if (nbytes == 1)
1781         fix_new_exp (frag, where, nbytes, exp, FALSE, BFD_RELOC_8);
1782       else if (nbytes == 2)
1783         fix_new_exp (frag, where, nbytes, exp, FALSE, BFD_RELOC_16);
1784       else if (nbytes == 4)
1785         fix_new_exp (frag, where, nbytes, exp, FALSE, BFD_RELOC_32);
1786       else
1787         bad = 1;
1788       break;
1789
1790     case BFD_RELOC_AVR_16_PM:
1791     case BFD_RELOC_AVR_8_LO:
1792     case BFD_RELOC_AVR_8_HI:
1793     case BFD_RELOC_AVR_8_HLO:
1794       if (nbytes == pexp_mod_data->nbytes)
1795         fix_new_exp (frag, where, nbytes, exp, FALSE, pexp_mod_data->reloc);
1796       else
1797         bad = 1;
1798       break;
1799     }
1800
1801   if (bad)
1802     as_bad (_("illegal %srelocation size: %d"), pexp_mod_data->error, nbytes);
1803 }
1804
1805 static bfd_boolean
1806 mcu_has_3_byte_pc (void)
1807 {
1808   int mach = avr_mcu->mach;
1809
1810   return mach == bfd_mach_avr6
1811     || mach == bfd_mach_avrxmega6
1812     || mach == bfd_mach_avrxmega7;
1813 }
1814
1815 void
1816 tc_cfi_frame_initial_instructions (void)
1817 {
1818   /* AVR6 pushes 3 bytes for calls.  */
1819   int return_size = (mcu_has_3_byte_pc () ? 3 : 2);
1820
1821   /* The CFA is the caller's stack location before the call insn.  */
1822   /* Note that the stack pointer is dwarf register number 32.  */
1823   cfi_add_CFA_def_cfa (32, return_size);
1824
1825   /* Note that AVR consistently uses post-decrement, which means that things
1826      do not line up the same way as for targers that use pre-decrement.  */
1827   cfi_add_CFA_offset (DWARF2_DEFAULT_RETURN_COLUMN, 1-return_size);
1828 }
1829
1830 bfd_boolean
1831 avr_allow_local_subtract (expressionS * left,
1832                              expressionS * right,
1833                              segT section)
1834 {
1835   /* If we are not in relaxation mode, subtraction is OK.  */
1836   if (!linkrelax)
1837     return TRUE;
1838
1839   /* If the symbols are not in a code section then they are OK.  */
1840   if ((section->flags & SEC_CODE) == 0)
1841     return TRUE;
1842
1843   if (left->X_add_symbol == right->X_add_symbol)
1844     return TRUE;
1845
1846   /* We have to assume that there may be instructions between the
1847      two symbols and that relaxation may increase the distance between
1848      them.  */
1849   return FALSE;
1850 }