gas/config/tc-m68k.c

   1 /* tc-m68k.c -- Assemble for the m68k family
   2    Copyright 1987, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999,
   3    2000, 2001, 2002, 2003, 2004, 2005, 2006 Free Software Foundation, Inc.
   4
   5    This file is part of GAS, the GNU Assembler.
   6
   7    GAS is free software; you can redistribute it and/or modify
   8    it under the terms of the GNU General Public License as published by
   9    the Free Software Foundation; either version 2, or (at your option)
  10    any later version.
  11
  12    GAS is distributed in the hope that it will be useful,
  13    but WITHOUT ANY WARRANTY; without even the implied warranty of
  14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15    GNU General Public License for more details.
  16
  17    You should have received a copy of the GNU General Public License
  18    along with GAS; see the file COPYING.  If not, write to the Free
  19    Software Foundation, 51 Franklin Street - Fifth Floor, Boston, MA
  20    02110-1301, USA.  */
  21
  22 #include "as.h"
  23 #include "safe-ctype.h"
  24 #include "obstack.h"
  25 #include "subsegs.h"
  26 #include "dwarf2dbg.h"
  27 #include "dw2gencfi.h"
  28
  29 #include "opcode/m68k.h"
  30 #include "m68k-parse.h"
  31
  32 #if defined (OBJ_ELF)
  33 #include "elf/m68k.h"
  34 #endif
  35
  36 #ifdef M68KCOFF
  37 #include "obj-coff.h"
  38 #endif
  39
  40 /* This string holds the chars that always start a comment.  If the
  41    pre-processor is disabled, these aren't very useful.  The macro
  42    tc_comment_chars points to this.  We use this, rather than the
  43    usual comment_chars, so that the --bitwise-or option will work.  */
  44 #if defined (TE_SVR4) || defined (TE_DELTA)
  45 const char *m68k_comment_chars = "|#";
  46 #else
  47 const char *m68k_comment_chars = "|";
  48 #endif
  49
  50 /* This array holds the chars that only start a comment at the beginning of
  51    a line.  If the line seems to have the form '# 123 filename'
  52    .line and .file directives will appear in the pre-processed output */
  53 /* Note that input_file.c hand checks for '#' at the beginning of the
  54    first line of the input file.  This is because the compiler outputs
  55    #NO_APP at the beginning of its output.  */
  56 /* Also note that comments like this one will always work.  */
  57 const char line_comment_chars[] = "#*";
  58
  59 const char line_separator_chars[] = ";";
  60
  61 /* Chars that can be used to separate mant from exp in floating point nums.  */
  62 const char EXP_CHARS[] = "eE";
  63
  64 /* Chars that mean this number is a floating point constant, as
  65    in "0f12.456" or "0d1.2345e12".  */
  66
  67 const char FLT_CHARS[] = "rRsSfFdDxXeEpP";
  68
  69 /* Also be aware that MAXIMUM_NUMBER_OF_CHARS_FOR_FLOAT may have to be
  70    changed in read.c .  Ideally it shouldn't have to know about it at all,
  71    but nothing is ideal around here.  */
  72
  73 /* Are we trying to generate PIC code?  If so, absolute references
  74    ought to be made into linkage table references or pc-relative
  75    references.  Not implemented.  For ELF there are other means
  76    to denote pic relocations.  */
  77 int flag_want_pic;
  78
  79 static int flag_short_refs;     /* -l option.  */
  80 static int flag_long_jumps;     /* -S option.  */
  81 static int flag_keep_pcrel;     /* --pcrel option.  */
  82
  83 #ifdef REGISTER_PREFIX_OPTIONAL
  84 int flag_reg_prefix_optional = REGISTER_PREFIX_OPTIONAL;
  85 #else
  86 int flag_reg_prefix_optional;
  87 #endif
  88
  89 /* Whether --register-prefix-optional was used on the command line.  */
  90 static int reg_prefix_optional_seen;
  91
  92 /* The floating point coprocessor to use by default.  */
  93 static enum m68k_register m68k_float_copnum = COP1;
  94
  95 /* If this is non-zero, then references to number(%pc) will be taken
  96    to refer to number, rather than to %pc + number.  */
  97 static int m68k_abspcadd;
  98
  99 /* If this is non-zero, then the quick forms of the move, add, and sub
 100    instructions are used when possible.  */
 101 static int m68k_quick = 1;
 102
 103 /* If this is non-zero, then if the size is not specified for a base
 104    or outer displacement, the assembler assumes that the size should
 105    be 32 bits.  */
 106 static int m68k_rel32 = 1;
 107
 108 /* This is non-zero if m68k_rel32 was set from the command line.  */
 109 static int m68k_rel32_from_cmdline;
 110
 111 /* The default width to use for an index register when using a base
 112    displacement.  */
 113 static enum m68k_size m68k_index_width_default = SIZE_LONG;
 114
 115 /* We want to warn if any text labels are misaligned.  In order to get
 116    the right line number, we need to record the line number for each
 117    label.  */
 118 struct label_line
 119 {
 120   struct label_line *next;
 121   symbolS *label;
 122   char *file;
 123   unsigned int line;
 124   int text;
 125 };
 126
 127 /* The list of labels.  */
 128
 129 static struct label_line *labels;
 130
 131 /* The current label.  */
 132
 133 static struct label_line *current_label;
 134
 135 /* Pointer to list holding the opcodes sorted by name.  */
 136 static struct m68k_opcode const ** m68k_sorted_opcodes;
 137
 138 /* Its an arbitrary name:  This means I don't approve of it.
 139    See flames below.  */
 140 static struct obstack robyn;
 141
 142 struct m68k_incant
 143   {
 144     const char *m_operands;
 145     unsigned long m_opcode;
 146     short m_opnum;
 147     short m_codenum;
 148     int m_arch;
 149     struct m68k_incant *m_next;
 150   };
 151
 152 #define getone(x)       ((((x)->m_opcode)>>16)&0xffff)
 153 #define gettwo(x)       (((x)->m_opcode)&0xffff)
 154
 155 static const enum m68k_register m68000_control_regs[] = { 0 };
 156 static const enum m68k_register m68010_control_regs[] = {
 157   SFC, DFC, USP, VBR,
 158   0
 159 };
 160 static const enum m68k_register m68020_control_regs[] = {
 161   SFC, DFC, USP, VBR, CACR, CAAR, MSP, ISP,
 162   0
 163 };
 164 static const enum m68k_register m68040_control_regs[] = {
 165   SFC, DFC, CACR, TC, ITT0, ITT1, DTT0, DTT1,
 166   USP, VBR, MSP, ISP, MMUSR, URP, SRP,
 167   0
 168 };
 169 static const enum m68k_register m68060_control_regs[] = {
 170   SFC, DFC, CACR, TC, ITT0, ITT1, DTT0, DTT1, BUSCR,
 171   USP, VBR, URP, SRP, PCR,
 172   0
 173 };
 174 static const enum m68k_register mcf_control_regs[] = {
 175   CACR, TC, ACR0, ACR1, ACR2, ACR3, VBR, ROMBAR,
 176   RAMBAR0, RAMBAR1, MBAR,
 177   0
 178 };
 179 static const enum m68k_register mcf5208_control_regs[] = {
 180   CACR, ACR0, ACR1, VBR, RAMBAR1,
 181   0
 182 };
 183 static const enum m68k_register mcf5213_control_regs[] = {
 184   VBR, RAMBAR, FLASHBAR,
 185   0
 186 };
 187 static const enum m68k_register mcf5329_control_regs[] = {
 188   CACR, ACR0, ACR1, VBR, RAMBAR,
 189   0
 190 };
 191 static const enum m68k_register mcf5249_control_regs[] = {
 192   CACR, ACR0, ACR1, VBR, RAMBAR0, RAMBAR1, MBAR, MBAR2,
 193   0
 194 };
 195 static const enum m68k_register mcf528x_control_regs[] = {
 196   CACR, ACR0, ACR1, VBR, FLASHBAR, RAMBAR,
 197   0
 198 };
 199 static const enum m68k_register mcfv4e_control_regs[] = {
 200   CACR, TC, ITT0, ITT1, DTT0, DTT1, BUSCR, VBR, PC, ROMBAR,
 201   ROMBAR1, RAMBAR0, RAMBAR1, MPCR, EDRAMBAR, SECMBAR, MBAR, MBAR0, MBAR1,
 202   PCR1U0, PCR1L0, PCR1U1, PCR1L1, PCR2U0, PCR2L0, PCR2U1, PCR2L1,
 203   PCR3U0, PCR3L0, PCR3U1, PCR3L1,
 204   0
 205 };
 206 #define cpu32_control_regs m68010_control_regs
 207
 208 static const enum m68k_register *control_regs;
 209
 210 /* Internal form of a 68020 instruction.  */
 211 struct m68k_it
 212 {
 213   const char *error;
 214   const char *args;             /* List of opcode info.  */
 215   int numargs;
 216
 217   int numo;                     /* Number of shorts in opcode.  */
 218   short opcode[11];
 219
 220   struct m68k_op operands[6];
 221
 222   int nexp;                     /* Number of exprs in use.  */
 223   struct m68k_exp exprs[4];
 224
 225   int nfrag;                    /* Number of frags we have to produce.  */
 226   struct
 227     {
 228       int fragoff;              /* Where in the current opcode the frag ends.  */
 229       symbolS *fadd;
 230       offsetT foff;
 231       int fragty;
 232     }
 233   fragb[4];
 234
 235   int nrel;                     /* Num of reloc strucs in use.  */
 236   struct
 237     {
 238       int n;
 239       expressionS exp;
 240       char wid;
 241       char pcrel;
 242       /* In a pc relative address the difference between the address
 243          of the offset and the address that the offset is relative
 244          to.  This depends on the addressing mode.  Basically this
 245          is the value to put in the offset field to address the
 246          first byte of the offset, without regarding the special
 247          significance of some values (in the branch instruction, for
 248          example).  */
 249       int pcrel_fix;
 250 #ifdef OBJ_ELF
 251       /* Whether this expression needs special pic relocation, and if
 252          so, which.  */
 253       enum pic_relocation pic_reloc;
 254 #endif
 255     }
 256   reloc[5];                     /* Five is enough???  */
 257 };
 258
 259 #define cpu_of_arch(x)          ((x) & (m68000up | mcfisa_a))
 260 #define float_of_arch(x)        ((x) & mfloat)
 261 #define mmu_of_arch(x)          ((x) & mmmu)
 262 #define arch_coldfire_p(x)      ((x) & mcfisa_a)
 263 #define arch_coldfire_fpu(x)    ((x) & cfloat)
 264
 265 /* Macros for determining if cpu supports a specific addressing mode.  */
 266 #define HAVE_LONG_BRANCH(x)     ((x) & (m68020|m68030|m68040|m68060|cpu32|mcfisa_b))
 267
 268 static struct m68k_it the_ins;  /* The instruction being assembled.  */
 269
 270 #define op(ex)          ((ex)->exp.X_op)
 271 #define adds(ex)        ((ex)->exp.X_add_symbol)
 272 #define subs(ex)        ((ex)->exp.X_op_symbol)
 273 #define offs(ex)        ((ex)->exp.X_add_number)
 274
 275 /* Macros for adding things to the m68k_it struct.  */
 276 #define addword(w)      (the_ins.opcode[the_ins.numo++] = (w))
 277
 278 /* Like addword, but goes BEFORE general operands.  */
 279
 280 static void
 281 insop (int w, const struct m68k_incant *opcode)
 282 {
 283   int z;
 284   for (z = the_ins.numo; z > opcode->m_codenum; --z)
 285     the_ins.opcode[z] = the_ins.opcode[z - 1];
 286   for (z = 0; z < the_ins.nrel; z++)
 287     the_ins.reloc[z].n += 2;
 288   for (z = 0; z < the_ins.nfrag; z++)
 289     the_ins.fragb[z].fragoff++;
 290   the_ins.opcode[opcode->m_codenum] = w;
 291   the_ins.numo++;
 292 }
 293
 294 /* The numo+1 kludge is so we can hit the low order byte of the prev word.
 295    Blecch.  */
 296 static void
 297 add_fix (int width, struct m68k_exp *exp, int pc_rel, int pc_fix)
 298 {
 299   the_ins.reloc[the_ins.nrel].n = (width == 'B' || width == '3'
 300                                    ? the_ins.numo * 2 - 1
 301                                    : (width == 'b'
 302                                       ? the_ins.numo * 2 + 1
 303                                       : the_ins.numo * 2));
 304   the_ins.reloc[the_ins.nrel].exp = exp->exp;
 305   the_ins.reloc[the_ins.nrel].wid = width;
 306   the_ins.reloc[the_ins.nrel].pcrel_fix = pc_fix;
 307 #ifdef OBJ_ELF
 308   the_ins.reloc[the_ins.nrel].pic_reloc = exp->pic_reloc;
 309 #endif
 310   the_ins.reloc[the_ins.nrel++].pcrel = pc_rel;
 311 }
 312
 313 /* Cause an extra frag to be generated here, inserting up to 10 bytes
 314    (that value is chosen in the frag_var call in md_assemble).  TYPE
 315    is the subtype of the frag to be generated; its primary type is
 316    rs_machine_dependent.
 317
 318    The TYPE parameter is also used by md_convert_frag_1 and
 319    md_estimate_size_before_relax.  The appropriate type of fixup will
 320    be emitted by md_convert_frag_1.
 321
 322    ADD becomes the FR_SYMBOL field of the frag, and OFF the FR_OFFSET.  */
 323 static void
 324 add_frag (symbolS *add, offsetT off, int type)
 325 {
 326   the_ins.fragb[the_ins.nfrag].fragoff = the_ins.numo;
 327   the_ins.fragb[the_ins.nfrag].fadd = add;
 328   the_ins.fragb[the_ins.nfrag].foff = off;
 329   the_ins.fragb[the_ins.nfrag++].fragty = type;
 330 }
 331
 332 #define isvar(ex) \
 333   (op (ex) != O_constant && op (ex) != O_big)
 334
 335 static char *crack_operand (char *str, struct m68k_op *opP);
 336 static int get_num (struct m68k_exp *exp, int ok);
 337 static int reverse_16_bits (int in);
 338 static int reverse_8_bits (int in);
 339 static void install_gen_operand (int mode, int val);
 340 static void install_operand (int mode, int val);
 341 static void s_bss (int);
 342 static void s_data1 (int);
 343 static void s_data2 (int);
 344 static void s_even (int);
 345 static void s_proc (int);
 346 static void s_chip (int);
 347 static void s_fopt (int);
 348 static void s_opt (int);
 349 static void s_reg (int);
 350 static void s_restore (int);
 351 static void s_save (int);
 352 static void s_mri_if (int);
 353 static void s_mri_else (int);
 354 static void s_mri_endi (int);
 355 static void s_mri_break (int);
 356 static void s_mri_next (int);
 357 static void s_mri_for (int);
 358 static void s_mri_endf (int);
 359 static void s_mri_repeat (int);
 360 static void s_mri_until (int);
 361 static void s_mri_while (int);
 362 static void s_mri_endw (int);
 363 static void s_m68k_cpu (int);
 364 static void s_m68k_arch (int);
 365
 366 struct m68k_cpu
 367 {
 368   unsigned long arch;   /* Architecture features.  */
 369   unsigned long chip;   /* Specific chip */
 370   const char *name;     /* Name */
 371   unsigned alias;
 372 };
 373
 374 /* We hold flags for features explicitly enabled and explicitly
 375    disabled.  */
 376 static int current_architecture;
 377 static int not_current_architecture;
 378 static int current_chip;
 379 static const struct m68k_cpu *selected_arch;
 380 static const struct m68k_cpu *selected_cpu;
 381 static int initialized;
 382
 383 /* Architecture models.  */
 384 static const struct m68k_cpu m68k_archs[] =
 385 {
 386   {m68000,                                      cpu_m68000, "68000", 0},
 387   {m68010,                                      cpu_m68010, "68010", 0},
 388   {m68020|m68881|m68851,                        cpu_m68020, "68020", 0},
 389   {m68030|m68881|m68851,                        cpu_m68030, "68030", 0},
 390   {m68040,                                      cpu_m68040, "68040", 0},
 391   {m68060,                                      cpu_m68060, "68060", 0},
 392   {cpu32|m68881,                                cpu_cpu32, "cpu32", 0},
 393   {mcfisa_a|mcfhwdiv,                           0, "isaa", 0},
 394   {mcfisa_a|mcfhwdiv|mcfisa_aa,                 0, "isaaplus", 0},
 395   {mcfisa_a|mcfhwdiv|mcfisa_b,                  0, "isab", 0},
 396   {mcfisa_a|mcfhwdiv|mcfisa_b|mcfemac|mcfusp|cfloat,
 397    cpu_cf547x, "cfv4e", 0},
 398   {0,0,NULL, 0}
 399 };
 400
 401 /* Architecture extensions.  */
 402 static const struct m68k_cpu m68k_extensions[] =
 403 {
 404   {m68851,                                      0, "68851", 0},
 405   {m68881,                                      0, "68881", 0},
 406   {m68881,                                      0, "68882", 0},
 407
 408   {mcfhwdiv,                                    0, "div", 1},
 409   {mcfusp,                                      0, "usp", 1},
 410   {cfloat,                                      0, "float", 1},
 411   {mcfmac,                                      0, "mac", 1},
 412   {mcfemac,                                     0, "emac", 1},
 413
 414   {0,0,NULL, 0}
 415 };
 416
 417 /* Processor list */
 418 static const struct m68k_cpu m68k_cpus[] =
 419 {
 420   { m68000,                                     cpu_m68000, "68000", 0},
 421   { m68010,                                     cpu_m68010, "68010", 0},
 422   { m68020|m68881|m68851,                       cpu_m68020, "68020", 0},
 423   { m68030|m68881|m68851,                       cpu_m68030, "68030", 0},
 424   { m68040,                                     cpu_m68040, "68040", 0},
 425   { m68060,                                     cpu_m68060, "68060", 0},
 426   { cpu32|m68881,                               cpu_cpu32, "cpu32",  0},
 427   { mcfisa_a,                                   cpu_cf5200, "5200", 0},
 428   { mcfisa_a|mcfhwdiv|mcfmac,                   cpu_cf5206e, "5206e", 0},
 429   { mcfisa_a|mcfisa_aa|mcfhwdiv|mcfmac, cpu_cf5208, "5208", 0},
 430   { mcfisa_a|mcfisa_aa|mcfhwdiv|mcfmac, cpu_cf5213, "5213", 0},
 431   { mcfisa_a|mcfisa_aa|mcfhwdiv|mcfemac|mcfusp,cpu_cf521x, "521x", 0},
 432   { mcfisa_a|mcfhwdiv|mcfemac,          cpu_cf5249, "5249", 0},
 433   { mcfisa_a|mcfisa_aa|mcfhwdiv|mcfemac|mcfusp,cpu_cf528x, "528x", 0},
 434   { mcfisa_a|mcfhwdiv|mcfmac,                   cpu_cf5307, "5307", 0},
 435   { mcfisa_a|mcfisa_aa|mcfhwdiv|mcfemac,        cpu_cf5329, "5329", 0},
 436   { mcfisa_a|mcfhwdiv|mcfisa_b|mcfmac,  cpu_cf5407, "5407",0},
 437   { mcfisa_a|mcfhwdiv|mcfisa_b|mcfemac|mcfusp|cfloat,
 438     cpu_cf547x, "547x", 0},
 439   { mcfisa_a|mcfhwdiv|mcfisa_b|mcfemac|mcfusp|cfloat,
 440                                                 cpu_cf548x, "548x", 0},
 441   /* Aliases (effectively, so far as gas is concerned) for the above
 442      cpus.  */
 443   { m68020|m68881|m68851,                       cpu_m68020, "68k", 1},
 444   { m68000,                                     cpu_m68000, "68008", 1},
 445   { m68000,                                     cpu_m68000, "68302", 1},
 446   { m68000,                                     cpu_m68000, "68306", 1},
 447   { m68000,                                     cpu_m68000, "68307", 1},
 448   { m68000,                                     cpu_m68000, "68322", 1},
 449   { m68000,                                     cpu_m68000, "68356", 1},
 450   { m68000,                                     cpu_m68000, "68ec000", 1},
 451   { m68000,                                     cpu_m68000, "68hc000", 1},
 452   { m68000,                                     cpu_m68000, "68hc001", 1},
 453   { m68020|m68881|m68851,                       cpu_m68020, "68ec020", 1},
 454   { m68030|m68881|m68851,                       cpu_m68030, "68ec030", 1},
 455   { m68040,                                     cpu_m68040, "68ec040", 1},
 456   { m68060,                                     cpu_m68060, "68ec060", 1},
 457   { cpu32|m68881,                               cpu_cpu32, "68330", 1},
 458   { cpu32|m68881,                               cpu_cpu32, "68331", 1},
 459   { cpu32|m68881,                               cpu_cpu32, "68332", 1},
 460   { cpu32|m68881,                               cpu_cpu32, "68333", 1},
 461   { cpu32|m68881,                               cpu_cpu32, "68334", 1},
 462   { cpu32|m68881,                               cpu_cpu32, "68336", 1},
 463   { cpu32|m68881,                               cpu_cpu32, "68340", 1},
 464   { cpu32|m68881,                               cpu_cpu32, "68341", 1},
 465   { cpu32|m68881,                               cpu_cpu32, "68349", 1},
 466   { cpu32|m68881,                               cpu_cpu32, "68360", 1},
 467   { mcfisa_a,                                   cpu_cf5200, "5202", 1},
 468   { mcfisa_a,                                   cpu_cf5200, "5204", 1},
 469   { mcfisa_a,                                   cpu_cf5200, "5206", 1},
 470   { mcfisa_a|mcfisa_aa|mcfhwdiv|mcfmac,         cpu_cf5208, "5207", 1},
 471   { mcfisa_a|mcfisa_aa|mcfhwdiv|mcfmac,         cpu_cf5213, "5211", 1},
 472   { mcfisa_a|mcfisa_aa|mcfhwdiv|mcfmac,         cpu_cf5213, "5212", 1},
 473   { mcfisa_a|mcfhwdiv|mcfisa_aa|mcfemac,        cpu_cf521x, "5214", 1},
 474   { mcfisa_a|mcfhwdiv|mcfisa_aa|mcfemac,        cpu_cf521x, "5216", 1},
 475   { mcfisa_a|mcfisa_aa|mcfhwdiv|mcfemac,        cpu_cf5329, "5327", 1},
 476   { mcfisa_a|mcfisa_aa|mcfhwdiv|mcfemac,        cpu_cf5329, "5328", 1},
 477   { mcfisa_a|mcfisa_aa|mcfhwdiv|mcfemac,        cpu_cf528x, "5280", 1},
 478   { mcfisa_a|mcfisa_aa|mcfhwdiv|mcfemac,        cpu_cf528x, "5281", 1},
 479   { mcfisa_a|mcfisa_aa|mcfhwdiv|mcfemac,        cpu_cf528x, "5282", 1},
 480   { mcfisa_a|mcfhwdiv|mcfisa_b|mcfmac,  cpu_cf5407,     "cfv4", 1 },
 481   { mcfisa_a|mcfhwdiv|mcfisa_b|mcfemac|mcfusp|cfloat,
 482     cpu_cf547x, "cfv4e", 1 },
 483   { mcfisa_a|mcfhwdiv|mcfisa_b|mcfemac|mcfusp|cfloat,
 484     cpu_cf547x, "5470", 1 },
 485   { mcfisa_a|mcfhwdiv|mcfisa_b|mcfemac|mcfusp|cfloat,
 486     cpu_cf547x, "5471", 1 },
 487   { mcfisa_a|mcfhwdiv|mcfisa_b|mcfemac|mcfusp|cfloat,
 488     cpu_cf547x, "5472", 1 },
 489   { mcfisa_a|mcfhwdiv|mcfisa_b|mcfemac|mcfusp|cfloat,
 490     cpu_cf547x, "5473", 1 },
 491   { mcfisa_a|mcfhwdiv|mcfisa_b|mcfemac|mcfusp|cfloat,
 492     cpu_cf547x, "5474", 1 },
 493   { mcfisa_a|mcfhwdiv|mcfisa_b|mcfemac|mcfusp|cfloat,
 494     cpu_cf547x, "5475", 1 },
 495   { mcfisa_a|mcfhwdiv|mcfisa_b|mcfemac|mcfusp|cfloat,
 496     cpu_cf548x, "5480", 1 },
 497   { mcfisa_a|mcfhwdiv|mcfisa_b|mcfemac|mcfusp|cfloat,
 498     cpu_cf548x, "5481", 1 },
 499   { mcfisa_a|mcfhwdiv|mcfisa_b|mcfemac|mcfusp|cfloat,
 500     cpu_cf548x, "5482", 1 },
 501   { mcfisa_a|mcfhwdiv|mcfisa_b|mcfemac|mcfusp|cfloat,
 502     cpu_cf548x, "5483", 1 },
 503   { mcfisa_a|mcfhwdiv|mcfisa_b|mcfemac|mcfusp|cfloat,
 504     cpu_cf548x, "5484", 1 },
 505   { mcfisa_a|mcfhwdiv|mcfisa_b|mcfemac|mcfusp|cfloat,
 506     cpu_cf548x, "5485", 1 },
 507   {0,0,NULL, 0}
 508   };
 509
 510 #define CPU_ALLOW_MC 1
 511 #define CPU_ALLOW_NEGATION 4
 512
 513 static const struct m68k_cpu *m68k_lookup_cpu
 514 (const char *, const struct m68k_cpu *, int, int *);
 515 static int m68k_set_arch (const char *, int, int);
 516 static int m68k_set_cpu (const char *, int, int);
 517 static int m68k_set_extension (const char *, int, int);
 518 static void m68k_init_arch (void);
 519
 520 /* This is the assembler relaxation table for m68k. m68k is a rich CISC
 521    architecture and we have a lot of relaxation modes.  */
 522
 523 /* Macros used in the relaxation code.  */
 524 #define TAB(x,y)        (((x) << 2) + (y))
 525 #define TABTYPE(x)      ((x) >> 2)
 526
 527 /* Relaxation states.  */
 528 #define BYTE            0
 529 #define SHORT           1
 530 #define LONG            2
 531 #define SZ_UNDEF        3
 532
 533 /* Here are all the relaxation modes we support.  First we can relax ordinary
 534    branches.  On 68020 and higher and on CPU32 all branch instructions take
 535    three forms, so on these CPUs all branches always remain as such.  When we
 536    have to expand to the LONG form on a 68000, though, we substitute an
 537    absolute jump instead.  This is a direct replacement for unconditional
 538    branches and a branch over a jump for conditional branches.  However, if the
 539    user requires PIC and disables this with --pcrel, we can only relax between
 540    BYTE and SHORT forms, punting if that isn't enough.  This gives us four
 541    different relaxation modes for branches:  */
 542
 543 #define BRANCHBWL       0       /* Branch byte, word, or long.  */
 544 #define BRABSJUNC       1       /* Absolute jump for LONG, unconditional.  */
 545 #define BRABSJCOND      2       /* Absolute jump for LONG, conditional.  */
 546 #define BRANCHBW        3       /* Branch byte or word.  */
 547
 548 /* We also relax coprocessor branches and DBcc's.  All CPUs that support
 549    coprocessor branches support them in word and long forms, so we have only
 550    one relaxation mode for them.  DBcc's are word only on all CPUs.  We can
 551    relax them to the LONG form with a branch-around sequence.  This sequence
 552    can use a long branch (if available) or an absolute jump (if acceptable).
 553    This gives us two relaxation modes.  If long branches are not available and
 554    absolute jumps are not acceptable, we don't relax DBcc's.  */
 555
 556 #define FBRANCH         4       /* Coprocessor branch.  */
 557 #define DBCCLBR         5       /* DBcc relaxable with a long branch.  */
 558 #define DBCCABSJ        6       /* DBcc relaxable with an absolute jump.  */
 559
 560 /* That's all for instruction relaxation.  However, we also relax PC-relative
 561    operands.  Specifically, we have three operand relaxation modes.  On the
 562    68000 PC-relative operands can only be 16-bit, but on 68020 and higher and
 563    on CPU32 they may be 16-bit or 32-bit.  For the latter we relax between the
 564    two.  Also PC+displacement+index operands in their simple form (with a non-
 565    suppressed index without memory indirection) are supported on all CPUs, but
 566    on the 68000 the displacement can be 8-bit only, whereas on 68020 and higher
 567    and on CPU32 we relax it to SHORT and LONG forms as well using the extended
 568    form of the PC+displacement+index operand.  Finally, some absolute operands
 569    can be relaxed down to 16-bit PC-relative.  */
 570
 571 #define PCREL1632       7       /* 16-bit or 32-bit PC-relative.  */
 572 #define PCINDEX         8       /* PC + displacement + index. */
 573 #define ABSTOPCREL      9       /* Absolute relax down to 16-bit PC-relative.  */
 574
 575 /* Note that calls to frag_var need to specify the maximum expansion
 576    needed; this is currently 10 bytes for DBCC.  */
 577
 578 /* The fields are:
 579    How far Forward this mode will reach:
 580    How far Backward this mode will reach:
 581    How many bytes this mode will add to the size of the frag
 582    Which mode to go to if the offset won't fit in this one
 583
 584    Please check tc-m68k.h:md_prepare_relax_scan if changing this table.  */
 585 relax_typeS md_relax_table[] =
 586 {
 587   {   127,   -128,  0, TAB (BRANCHBWL, SHORT) },
 588   { 32767, -32768,  2, TAB (BRANCHBWL, LONG) },
 589   {     0,      0,  4, 0 },
 590   {     1,      1,  0, 0 },
 591
 592   {   127,   -128,  0, TAB (BRABSJUNC, SHORT) },
 593   { 32767, -32768,  2, TAB (BRABSJUNC, LONG) },
 594   {     0,      0,  4, 0 },
 595   {     1,      1,  0, 0 },
 596
 597   {   127,   -128,  0, TAB (BRABSJCOND, SHORT) },
 598   { 32767, -32768,  2, TAB (BRABSJCOND, LONG) },
 599   {     0,      0,  6, 0 },
 600   {     1,      1,  0, 0 },
 601
 602   {   127,   -128,  0, TAB (BRANCHBW, SHORT) },
 603   {     0,      0,  2, 0 },
 604   {     1,      1,  0, 0 },
 605   {     1,      1,  0, 0 },
 606
 607   {     1,      1,  0, 0 },             /* FBRANCH doesn't come BYTE.  */
 608   { 32767, -32768,  2, TAB (FBRANCH, LONG) },
 609   {     0,      0,  4, 0 },
 610   {     1,      1,  0, 0 },
 611
 612   {     1,      1,  0, 0 },             /* DBCC doesn't come BYTE.  */
 613   { 32767, -32768,  2, TAB (DBCCLBR, LONG) },
 614   {     0,      0, 10, 0 },
 615   {     1,      1,  0, 0 },
 616
 617   {     1,      1,  0, 0 },             /* DBCC doesn't come BYTE.  */
 618   { 32767, -32768,  2, TAB (DBCCABSJ, LONG) },
 619   {     0,      0, 10, 0 },
 620   {     1,      1,  0, 0 },
 621
 622   {     1,      1,  0, 0 },             /* PCREL1632 doesn't come BYTE.  */
 623   { 32767, -32768,  2, TAB (PCREL1632, LONG) },
 624   {     0,      0,  6, 0 },
 625   {     1,      1,  0, 0 },
 626
 627   {   125,   -130,  0, TAB (PCINDEX, SHORT) },
 628   { 32765, -32770,  2, TAB (PCINDEX, LONG) },
 629   {     0,      0,  4, 0 },
 630   {     1,      1,  0, 0 },
 631
 632   {     1,      1,  0, 0 },             /* ABSTOPCREL doesn't come BYTE.  */
 633   { 32767, -32768,  2, TAB (ABSTOPCREL, LONG) },
 634   {     0,      0,  4, 0 },
 635   {     1,      1,  0, 0 },
 636 };
 637
 638 /* These are the machine dependent pseudo-ops.  These are included so
 639    the assembler can work on the output from the SUN C compiler, which
 640    generates these.  */
 641
 642 /* This table describes all the machine specific pseudo-ops the assembler
 643    has to support.  The fields are:
 644    pseudo-op name without dot
 645    function to call to execute this pseudo-op
 646    Integer arg to pass to the function.  */
 647 const pseudo_typeS md_pseudo_table[] =
 648 {
 649   {"data1", s_data1, 0},
 650   {"data2", s_data2, 0},
 651   {"bss", s_bss, 0},
 652   {"even", s_even, 0},
 653   {"skip", s_space, 0},
 654   {"proc", s_proc, 0},
 655 #if defined (TE_SUN3) || defined (OBJ_ELF)
 656   {"align", s_align_bytes, 0},
 657 #endif
 658 #ifdef OBJ_ELF
 659   {"swbeg", s_ignore, 0},
 660 #endif
 661   {"extend", float_cons, 'x'},
 662   {"ldouble", float_cons, 'x'},
 663
 664   {"arch", s_m68k_arch, 0},
 665   {"cpu", s_m68k_cpu, 0},
 666
 667   /* The following pseudo-ops are supported for MRI compatibility.  */
 668   {"chip", s_chip, 0},
 669   {"comline", s_space, 1},
 670   {"fopt", s_fopt, 0},
 671   {"mask2", s_ignore, 0},
 672   {"opt", s_opt, 0},
 673   {"reg", s_reg, 0},
 674   {"restore", s_restore, 0},
 675   {"save", s_save, 0},
 676
 677   {"if", s_mri_if, 0},
 678   {"if.b", s_mri_if, 'b'},
 679   {"if.w", s_mri_if, 'w'},
 680   {"if.l", s_mri_if, 'l'},
 681   {"else", s_mri_else, 0},
 682   {"else.s", s_mri_else, 's'},
 683   {"else.l", s_mri_else, 'l'},
 684   {"endi", s_mri_endi, 0},
 685   {"break", s_mri_break, 0},
 686   {"break.s", s_mri_break, 's'},
 687   {"break.l", s_mri_break, 'l'},
 688   {"next", s_mri_next, 0},
 689   {"next.s", s_mri_next, 's'},
 690   {"next.l", s_mri_next, 'l'},
 691   {"for", s_mri_for, 0},
 692   {"for.b", s_mri_for, 'b'},
 693   {"for.w", s_mri_for, 'w'},
 694   {"for.l", s_mri_for, 'l'},
 695   {"endf", s_mri_endf, 0},
 696   {"repeat", s_mri_repeat, 0},
 697   {"until", s_mri_until, 0},
 698   {"until.b", s_mri_until, 'b'},
 699   {"until.w", s_mri_until, 'w'},
 700   {"until.l", s_mri_until, 'l'},
 701   {"while", s_mri_while, 0},
 702   {"while.b", s_mri_while, 'b'},
 703   {"while.w", s_mri_while, 'w'},
 704   {"while.l", s_mri_while, 'l'},
 705   {"endw", s_mri_endw, 0},
 706
 707   {0, 0, 0}
 708 };
 709
 710 /* The mote pseudo ops are put into the opcode table, since they
 711    don't start with a . they look like opcodes to gas.  */
 712
 713 const pseudo_typeS mote_pseudo_table[] =
 714 {
 715
 716   {"dcl", cons, 4},
 717   {"dc", cons, 2},
 718   {"dcw", cons, 2},
 719   {"dcb", cons, 1},
 720
 721   {"dsl", s_space, 4},
 722   {"ds", s_space, 2},
 723   {"dsw", s_space, 2},
 724   {"dsb", s_space, 1},
 725
 726   {"xdef", s_globl, 0},
 727 #ifdef OBJ_ELF
 728   {"align", s_align_bytes, 0},
 729 #else
 730   {"align", s_align_ptwo, 0},
 731 #endif
 732 #ifdef M68KCOFF
 733   {"sect", obj_coff_section, 0},
 734   {"section", obj_coff_section, 0},
 735 #endif
 736   {0, 0, 0}
 737 };
 738
 739 /* Truncate and sign-extend at 32 bits, so that building on a 64-bit host
 740    gives identical results to a 32-bit host.  */
 741 #define TRUNC(X)        ((valueT) (X) & 0xffffffff)
 742 #define SEXT(X)         ((TRUNC (X) ^ 0x80000000) - 0x80000000)
 743
 744 #define issbyte(x)      ((valueT) SEXT (x) + 0x80 < 0x100)
 745 #define isubyte(x)      ((valueT) TRUNC (x) < 0x100)
 746 #define issword(x)      ((valueT) SEXT (x) + 0x8000 < 0x10000)
 747 #define isuword(x)      ((valueT) TRUNC (x) < 0x10000)
 748
 749 #define isbyte(x)       ((valueT) SEXT (x) + 0xff < 0x1ff)
 750 #define isword(x)       ((valueT) SEXT (x) + 0xffff < 0x1ffff)
 751 #define islong(x)       (1)
 752
 753 static char notend_table[256];
 754 static char alt_notend_table[256];
 755 #define notend(s)                                               \
 756   (! (notend_table[(unsigned char) *s]                          \
 757       || (*s == ':'                                             \
 758           && alt_notend_table[(unsigned char) s[1]])))
 759
 760 /* Return a human readable string holding the list of chips that are
 761    valid for a particular architecture, suppressing aliases (unless
 762    there is only one of them).  */
 763
 764 static char *
 765 find_cf_chip (int architecture)
 766 {
 767   static char buf[1024];
 768   int i, j, n_chips, n_alias;
 769   char *cp;
 770
 771   strcpy (buf, " (");
 772   cp = buf + strlen (buf);
 773
 774   for (i = 0, n_chips = 0, n_alias = 0; m68k_cpus[i].name; ++i)
 775     if (m68k_cpus[i].arch & architecture)
 776       {
 777         n_chips++;
 778         if (m68k_cpus[i].alias)
 779           n_alias++;
 780       }
 781
 782   if (n_chips == 0)
 783     as_fatal (_("no matching ColdFire architectures found"));
 784
 785   if (n_alias > 1)
 786     n_chips -= n_alias;
 787
 788   for (i = 0, j = 0; m68k_cpus[i].name && j < n_chips; ++i)
 789     if (m68k_cpus[i].arch & architecture)
 790       {
 791         if (j)
 792           {
 793             if ((j == n_chips - 1 && !(n_alias > 1)) || ! n_alias)
 794               {
 795                 if (n_chips == 2)
 796                   {
 797                     strncpy (cp, _(" or "), (sizeof (buf) - (cp - buf)));
 798                     cp += strlen (cp);
 799                   }
 800                 else
 801                   {
 802                     strncpy (cp, _(", or "), (sizeof (buf) - (cp - buf)));
 803                     cp += strlen (cp);
 804                   }
 805               }
 806             else
 807               {
 808                 strncpy (cp, ", ", (sizeof (buf) - (cp - buf)));
 809                 cp += strlen (cp);
 810               }
 811           }
 812         strncpy (cp, m68k_cpus[i].name, (sizeof (buf) - (cp - buf)));
 813         cp += strlen (cp);
 814         j++;
 815       }
 816
 817   if (n_alias > 1)
 818     {
 819       strncpy (cp, _(", or aliases"), (sizeof (buf) - (cp - buf)));
 820       cp += strlen (cp);
 821     }
 822
 823   strncpy (cp, ")", (sizeof (buf) - (cp - buf)));
 824
 825   return buf;
 826 }
 827
 828 #ifdef OBJ_ELF
 829
 830 /* Return zero if the reference to SYMBOL from within the same segment may
 831    be relaxed.  */
 832
 833 /* On an ELF system, we can't relax an externally visible symbol,
 834    because it may be overridden by a shared library.  However, if
 835    TARGET_OS is "elf", then we presume that we are assembling for an
 836    embedded system, in which case we don't have to worry about shared
 837    libraries, and we can relax any external sym.  */
 838
 839 #define relaxable_symbol(symbol) \
 840   (!((S_IS_EXTERNAL (symbol) && EXTERN_FORCE_RELOC) \
 841      || S_IS_WEAK (symbol)))
 842
 843 /* Compute the relocation code for a fixup of SIZE bytes, using pc
 844    relative relocation if PCREL is non-zero.  PIC says whether a special
 845    pic relocation was requested.  */
 846
 847 static bfd_reloc_code_real_type
 848 get_reloc_code (int size, int pcrel, enum pic_relocation pic)
 849 {
 850   switch (pic)
 851     {
 852     case pic_got_pcrel:
 853       switch (size)
 854         {
 855         case 1:
 856           return BFD_RELOC_8_GOT_PCREL;
 857         case 2:
 858           return BFD_RELOC_16_GOT_PCREL;
 859         case 4:
 860           return BFD_RELOC_32_GOT_PCREL;
 861         }
 862       break;
 863
 864     case pic_got_off:
 865       switch (size)
 866         {
 867         case 1:
 868           return BFD_RELOC_8_GOTOFF;
 869         case 2:
 870           return BFD_RELOC_16_GOTOFF;
 871         case 4:
 872           return BFD_RELOC_32_GOTOFF;
 873         }
 874       break;
 875
 876     case pic_plt_pcrel:
 877       switch (size)
 878         {
 879         case 1:
 880           return BFD_RELOC_8_PLT_PCREL;
 881         case 2:
 882           return BFD_RELOC_16_PLT_PCREL;
 883         case 4:
 884           return BFD_RELOC_32_PLT_PCREL;
 885         }
 886       break;
 887
 888     case pic_plt_off:
 889       switch (size)
 890         {
 891         case 1:
 892           return BFD_RELOC_8_PLTOFF;
 893         case 2:
 894           return BFD_RELOC_16_PLTOFF;
 895         case 4:
 896           return BFD_RELOC_32_PLTOFF;
 897         }
 898       break;
 899
 900     case pic_none:
 901       if (pcrel)
 902         {
 903           switch (size)
 904             {
 905             case 1:
 906               return BFD_RELOC_8_PCREL;
 907             case 2:
 908               return BFD_RELOC_16_PCREL;
 909             case 4:
 910               return BFD_RELOC_32_PCREL;
 911             }
 912         }
 913       else
 914         {
 915           switch (size)
 916             {
 917             case 1:
 918               return BFD_RELOC_8;
 919             case 2:
 920               return BFD_RELOC_16;
 921             case 4:
 922               return BFD_RELOC_32;
 923             }
 924         }
 925     }
 926
 927   if (pcrel)
 928     {
 929       if (pic == pic_none)
 930         as_bad (_("Can not do %d byte pc-relative relocation"), size);
 931       else
 932         as_bad (_("Can not do %d byte pc-relative pic relocation"), size);
 933     }
 934   else
 935     {
 936       if (pic == pic_none)
 937         as_bad (_("Can not do %d byte relocation"), size);
 938       else
 939         as_bad (_("Can not do %d byte pic relocation"), size);
 940     }
 941
 942   return BFD_RELOC_NONE;
 943 }
 944
 945 /* Here we decide which fixups can be adjusted to make them relative
 946    to the beginning of the section instead of the symbol.  Basically
 947    we need to make sure that the dynamic relocations are done
 948    correctly, so in some cases we force the original symbol to be
 949    used.  */
 950 int
 951 tc_m68k_fix_adjustable (fixS *fixP)
 952 {
 953   /* Adjust_reloc_syms doesn't know about the GOT.  */
 954   switch (fixP->fx_r_type)
 955     {
 956     case BFD_RELOC_8_GOT_PCREL:
 957     case BFD_RELOC_16_GOT_PCREL:
 958     case BFD_RELOC_32_GOT_PCREL:
 959     case BFD_RELOC_8_GOTOFF:
 960     case BFD_RELOC_16_GOTOFF:
 961     case BFD_RELOC_32_GOTOFF:
 962     case BFD_RELOC_8_PLT_PCREL:
 963     case BFD_RELOC_16_PLT_PCREL:
 964     case BFD_RELOC_32_PLT_PCREL:
 965     case BFD_RELOC_8_PLTOFF:
 966     case BFD_RELOC_16_PLTOFF:
 967     case BFD_RELOC_32_PLTOFF:
 968       return 0;
 969
 970     case BFD_RELOC_VTABLE_INHERIT:
 971     case BFD_RELOC_VTABLE_ENTRY:
 972       return 0;
 973
 974     default:
 975       return 1;
 976     }
 977 }
 978
 979 #else /* !OBJ_ELF */
 980
 981 #define get_reloc_code(SIZE,PCREL,OTHER) NO_RELOC
 982
 983 #define relaxable_symbol(symbol) 1
 984
 985 #endif /* OBJ_ELF */
 986
 987 arelent *
 988 tc_gen_reloc (asection *section ATTRIBUTE_UNUSED, fixS *fixp)
 989 {
 990   arelent *reloc;
 991   bfd_reloc_code_real_type code;
 992
 993   /* If the tcbit is set, then this was a fixup of a negative value
 994      that was never resolved.  We do not have a reloc to handle this,
 995      so just return.  We assume that other code will have detected this
 996      situation and produced a helpful error message, so we just tell the
 997      user that the reloc cannot be produced.  */
 998   if (fixp->fx_tcbit)
 999     {
1000       if (fixp->fx_addsy)
1001         as_bad_where (fixp->fx_file, fixp->fx_line,
1002                       _("Unable to produce reloc against symbol '%s'"),
1003                       S_GET_NAME (fixp->fx_addsy));
1004       return NULL;
1005     }
1006
1007   if (fixp->fx_r_type != BFD_RELOC_NONE)
1008     {
1009       code = fixp->fx_r_type;
1010
1011       /* Since DIFF_EXPR_OK is defined in tc-m68k.h, it is possible
1012          that fixup_segment converted a non-PC relative reloc into a
1013          PC relative reloc.  In such a case, we need to convert the
1014          reloc code.  */
1015       if (fixp->fx_pcrel)
1016         {
1017           switch (code)
1018             {
1019             case BFD_RELOC_8:
1020               code = BFD_RELOC_8_PCREL;
1021               break;
1022             case BFD_RELOC_16:
1023               code = BFD_RELOC_16_PCREL;
1024               break;
1025             case BFD_RELOC_32:
1026               code = BFD_RELOC_32_PCREL;
1027               break;
1028             case BFD_RELOC_8_PCREL:
1029             case BFD_RELOC_16_PCREL:
1030             case BFD_RELOC_32_PCREL:
1031             case BFD_RELOC_8_GOT_PCREL:
1032             case BFD_RELOC_16_GOT_PCREL:
1033             case BFD_RELOC_32_GOT_PCREL:
1034             case BFD_RELOC_8_GOTOFF:
1035             case BFD_RELOC_16_GOTOFF:
1036             case BFD_RELOC_32_GOTOFF:
1037             case BFD_RELOC_8_PLT_PCREL:
1038             case BFD_RELOC_16_PLT_PCREL:
1039             case BFD_RELOC_32_PLT_PCREL:
1040             case BFD_RELOC_8_PLTOFF:
1041             case BFD_RELOC_16_PLTOFF:
1042             case BFD_RELOC_32_PLTOFF:
1043               break;
1044             default:
1045               as_bad_where (fixp->fx_file, fixp->fx_line,
1046                             _("Cannot make %s relocation PC relative"),
1047                             bfd_get_reloc_code_name (code));
1048             }
1049         }
1050     }
1051   else
1052     {
1053 #define F(SZ,PCREL)             (((SZ) << 1) + (PCREL))
1054       switch (F (fixp->fx_size, fixp->fx_pcrel))
1055         {
1056 #define MAP(SZ,PCREL,TYPE)      case F(SZ,PCREL): code = (TYPE); break
1057           MAP (1, 0, BFD_RELOC_8);
1058           MAP (2, 0, BFD_RELOC_16);
1059           MAP (4, 0, BFD_RELOC_32);
1060           MAP (1, 1, BFD_RELOC_8_PCREL);
1061           MAP (2, 1, BFD_RELOC_16_PCREL);
1062           MAP (4, 1, BFD_RELOC_32_PCREL);
1063         default:
1064           abort ();
1065         }
1066     }
1067 #undef F
1068 #undef MAP
1069
1070   reloc = (arelent *) xmalloc (sizeof (arelent));
1071   reloc->sym_ptr_ptr = (asymbol **) xmalloc (sizeof (asymbol *));
1072   *reloc->sym_ptr_ptr = symbol_get_bfdsym (fixp->fx_addsy);
1073   reloc->address = fixp->fx_frag->fr_address + fixp->fx_where;
1074 #ifndef OBJ_ELF
1075   if (fixp->fx_pcrel)
1076     reloc->addend = fixp->fx_addnumber;
1077   else
1078     reloc->addend = 0;
1079 #else
1080   if (!fixp->fx_pcrel)
1081     reloc->addend = fixp->fx_addnumber;
1082   else
1083     reloc->addend = (section->vma
1084                      /* Explicit sign extension in case char is
1085                         unsigned.  */
1086                      + ((fixp->fx_pcrel_adjust & 0xff) ^ 0x80) - 0x80
1087                      + fixp->fx_addnumber
1088                      + md_pcrel_from (fixp));
1089 #endif
1090
1091   reloc->howto = bfd_reloc_type_lookup (stdoutput, code);
1092   assert (reloc->howto != 0);
1093
1094   return reloc;
1095 }
1096
1097 /* Handle of the OPCODE hash table.  NULL means any use before
1098    m68k_ip_begin() will crash.  */
1099 static struct hash_control *op_hash;
1100 \f
1101 /* Assemble an m68k instruction.  */
1102
1103 static void
1104 m68k_ip (char *instring)
1105 {
1106   register char *p;
1107   register struct m68k_op *opP;
1108   register const struct m68k_incant *opcode;
1109   register const char *s;
1110   register int tmpreg = 0, baseo = 0, outro = 0, nextword;
1111   char *pdot, *pdotmove;
1112   enum m68k_size siz1, siz2;
1113   char c;
1114   int losing;
1115   int opsfound;
1116   struct m68k_op operands_backup[6];
1117   LITTLENUM_TYPE words[6];
1118   LITTLENUM_TYPE *wordp;
1119   unsigned long ok_arch = 0;
1120
1121   if (*instring == ' ')
1122     instring++;                 /* Skip leading whitespace.  */
1123
1124   /* Scan up to end of operation-code, which MUST end in end-of-string
1125      or exactly 1 space.  */
1126   pdot = 0;
1127   for (p = instring; *p != '\0'; p++)
1128     {
1129       if (*p == ' ')
1130         break;
1131       if (*p == '.')
1132         pdot = p;
1133     }
1134
1135   if (p == instring)
1136     {
1137       the_ins.error = _("No operator");
1138       return;
1139     }
1140
1141   /* p now points to the end of the opcode name, probably whitespace.
1142      Make sure the name is null terminated by clobbering the
1143      whitespace, look it up in the hash table, then fix it back.
1144      Remove a dot, first, since the opcode tables have none.  */
1145   if (pdot != NULL)
1146     {
1147       for (pdotmove = pdot; pdotmove < p; pdotmove++)
1148         *pdotmove = pdotmove[1];
1149       p--;
1150     }
1151
1152   c = *p;
1153   *p = '\0';
1154   opcode = (const struct m68k_incant *) hash_find (op_hash, instring);
1155   *p = c;
1156
1157   if (pdot != NULL)
1158     {
1159       for (pdotmove = p; pdotmove > pdot; pdotmove--)
1160         *pdotmove = pdotmove[-1];
1161       *pdot = '.';
1162       ++p;
1163     }
1164
1165   if (opcode == NULL)
1166     {
1167       the_ins.error = _("Unknown operator");
1168       return;
1169     }
1170
1171   /* Found a legitimate opcode, start matching operands.  */
1172   while (*p == ' ')
1173     ++p;
1174
1175   if (opcode->m_operands == 0)
1176     {
1177       char *old = input_line_pointer;
1178       *old = '\n';
1179       input_line_pointer = p;
1180       /* Ahh - it's a motorola style psuedo op.  */
1181       mote_pseudo_table[opcode->m_opnum].poc_handler
1182         (mote_pseudo_table[opcode->m_opnum].poc_val);
1183       input_line_pointer = old;
1184       *old = 0;
1185
1186       return;
1187     }
1188
1189   if (flag_mri && opcode->m_opnum == 0)
1190     {
1191       /* In MRI mode, random garbage is allowed after an instruction
1192          which accepts no operands.  */
1193       the_ins.args = opcode->m_operands;
1194       the_ins.numargs = opcode->m_opnum;
1195       the_ins.numo = opcode->m_codenum;
1196       the_ins.opcode[0] = getone (opcode);
1197       the_ins.opcode[1] = gettwo (opcode);
1198       return;
1199     }
1200
1201   for (opP = &the_ins.operands[0]; *p; opP++)
1202     {
1203       p = crack_operand (p, opP);
1204
1205       if (opP->error)
1206         {
1207           the_ins.error = opP->error;
1208           return;
1209         }
1210     }
1211
1212   opsfound = opP - &the_ins.operands[0];
1213
1214   /* This ugly hack is to support the floating pt opcodes in their
1215      standard form.  Essentially, we fake a first enty of type COP#1 */
1216   if (opcode->m_operands[0] == 'I')
1217     {
1218       int n;
1219
1220       for (n = opsfound; n > 0; --n)
1221         the_ins.operands[n] = the_ins.operands[n - 1];
1222
1223       memset (&the_ins.operands[0], '\0', sizeof (the_ins.operands[0]));
1224       the_ins.operands[0].mode = CONTROL;
1225       the_ins.operands[0].reg = m68k_float_copnum;
1226       opsfound++;
1227     }
1228
1229   /* We've got the operands.  Find an opcode that'll accept them.  */
1230   for (losing = 0;;)
1231     {
1232       /* If we didn't get the right number of ops, or we have no
1233          common model with this pattern then reject this pattern.  */
1234
1235       ok_arch |= opcode->m_arch;
1236       if (opsfound != opcode->m_opnum
1237           || ((opcode->m_arch & current_architecture) == 0))
1238         ++losing;
1239       else
1240         {
1241           int i;
1242
1243           /* Make a copy of the operands of this insn so that
1244              we can modify them safely, should we want to.  */
1245           assert (opsfound <= (int) ARRAY_SIZE (operands_backup));
1246           for (i = 0; i < opsfound; i++)
1247             operands_backup[i] = the_ins.operands[i];
1248
1249           for (s = opcode->m_operands, opP = &operands_backup[0];
1250                *s && !losing;
1251                s += 2, opP++)
1252             {
1253               /* Warning: this switch is huge! */
1254               /* I've tried to organize the cases into this order:
1255                  non-alpha first, then alpha by letter.  Lower-case
1256                  goes directly before uppercase counterpart.  */
1257               /* Code with multiple case ...: gets sorted by the lowest
1258                  case ... it belongs to.  I hope this makes sense.  */
1259               switch (*s)
1260                 {
1261                 case '!':
1262                   switch (opP->mode)
1263                     {
1264                     case IMMED:
1265                     case DREG:
1266                     case AREG:
1267                     case FPREG:
1268                     case CONTROL:
1269                     case AINC:
1270                     case ADEC:
1271                     case REGLST:
1272                       losing++;
1273                       break;
1274                     default:
1275                       break;
1276                     }
1277                   break;
1278
1279                 case '<':
1280                   switch (opP->mode)
1281                     {
1282                     case DREG:
1283                     case AREG:
1284                     case FPREG:
1285                     case CONTROL:
1286                     case IMMED:
1287                     case ADEC:
1288                     case REGLST:
1289                       losing++;
1290                       break;
1291                     default:
1292                       break;
1293                     }
1294                   break;
1295
1296                 case '>':
1297                   switch (opP->mode)
1298                     {
1299                     case DREG:
1300                     case AREG:
1301                     case FPREG:
1302                     case CONTROL:
1303                     case IMMED:
1304                     case AINC:
1305                     case REGLST:
1306                       losing++;
1307                       break;
1308                     case ABSL:
1309                       break;
1310                     default:
1311                       if (opP->reg == PC
1312                           || opP->reg == ZPC)
1313                         losing++;
1314                       break;
1315                     }
1316                   break;
1317
1318                 case 'm':
1319                   switch (opP->mode)
1320                     {
1321                     case DREG:
1322                     case AREG:
1323                     case AINDR:
1324                     case AINC:
1325                     case ADEC:
1326                       break;
1327                     default:
1328                       losing++;
1329                     }
1330                   break;
1331
1332                 case 'n':
1333                   switch (opP->mode)
1334                     {
1335                     case DISP:
1336                       break;
1337                     default:
1338                       losing++;
1339                     }
1340                   break;
1341
1342                 case 'o':
1343                   switch (opP->mode)
1344                     {
1345                     case BASE:
1346                     case ABSL:
1347                     case IMMED:
1348                       break;
1349                     default:
1350                       losing++;
1351                     }
1352                   break;
1353
1354                 case 'p':
1355                   switch (opP->mode)
1356                     {
1357                     case DREG:
1358                     case AREG:
1359                     case AINDR:
1360                     case AINC:
1361                     case ADEC:
1362                       break;
1363                     case DISP:
1364                       if (opP->reg == PC || opP->reg == ZPC)
1365                         losing++;
1366                       break;
1367                     default:
1368                       losing++;
1369                     }
1370                   break;
1371
1372                 case 'q':
1373                   switch (opP->mode)
1374                     {
1375                     case DREG:
1376                     case AINDR:
1377                     case AINC:
1378                     case ADEC:
1379                       break;
1380                     case DISP:
1381                       if (opP->reg == PC || opP->reg == ZPC)
1382                         losing++;
1383                       break;
1384                     default:
1385                       losing++;
1386                       break;
1387                     }
1388                   break;
1389
1390                 case 'v':
1391                   switch (opP->mode)
1392                     {
1393                     case DREG:
1394                     case AINDR:
1395                     case AINC:
1396                     case ADEC:
1397                     case ABSL:
1398                       break;
1399                     case DISP:
1400                       if (opP->reg == PC || opP->reg == ZPC)
1401                         losing++;
1402                       break;
1403                     default:
1404                       losing++;
1405                       break;
1406                     }
1407                   break;
1408
1409                 case '#':
1410                   if (opP->mode != IMMED)
1411                     losing++;
1412                   else if (s[1] == 'b'
1413                            && ! isvar (&opP->disp)
1414                            && (opP->disp.exp.X_op != O_constant
1415                                || ! isbyte (opP->disp.exp.X_add_number)))
1416                     losing++;
1417                   else if (s[1] == 'B'
1418                            && ! isvar (&opP->disp)
1419                            && (opP->disp.exp.X_op != O_constant
1420                                || ! issbyte (opP->disp.exp.X_add_number)))
1421                     losing++;
1422                   else if (s[1] == 'w'
1423                            && ! isvar (&opP->disp)
1424                            && (opP->disp.exp.X_op != O_constant
1425                                || ! isword (opP->disp.exp.X_add_number)))
1426                     losing++;
1427                   else if (s[1] == 'W'
1428                            && ! isvar (&opP->disp)
1429                            && (opP->disp.exp.X_op != O_constant
1430                                || ! issword (opP->disp.exp.X_add_number)))
1431                     losing++;
1432                   break;
1433
1434                 case '^':
1435                 case 'T':
1436                   if (opP->mode != IMMED)
1437                     losing++;
1438                   break;
1439
1440                 case '$':
1441                   if (opP->mode == AREG
1442                       || opP->mode == CONTROL
1443                       || opP->mode == FPREG
1444                       || opP->mode == IMMED
1445                       || opP->mode == REGLST
1446                       || (opP->mode != ABSL
1447                           && (opP->reg == PC
1448                               || opP->reg == ZPC)))
1449                     losing++;
1450                   break;
1451
1452                 case '%':
1453                   if (opP->mode == CONTROL
1454                       || opP->mode == FPREG
1455                       || opP->mode == REGLST
1456                       || opP->mode == IMMED
1457                       || (opP->mode != ABSL
1458                           && (opP->reg == PC
1459                               || opP->reg == ZPC)))
1460                     losing++;
1461                   break;
1462
1463                 case '&':
1464                   switch (opP->mode)
1465                     {
1466                     case DREG:
1467                     case AREG:
1468                     case FPREG:
1469                     case CONTROL:
1470                     case IMMED:
1471                     case AINC:
1472                     case ADEC:
1473                     case REGLST:
1474                       losing++;
1475                       break;
1476                     case ABSL:
1477                       break;
1478                     default:
1479                       if (opP->reg == PC
1480                           || opP->reg == ZPC)
1481                         losing++;
1482                       break;
1483                     }
1484                   break;
1485
1486                 case '*':
1487                   if (opP->mode == CONTROL
1488                       || opP->mode == FPREG
1489                       || opP->mode == REGLST)
1490                     losing++;
1491                   break;
1492
1493                 case '+':
1494                   if (opP->mode != AINC)
1495                     losing++;
1496                   break;
1497
1498                 case '-':
1499                   if (opP->mode != ADEC)
1500                     losing++;
1501                   break;
1502
1503                 case '/':
1504                   switch (opP->mode)
1505                     {
1506                     case AREG:
1507                     case CONTROL:
1508                     case FPREG:
1509                     case AINC:
1510                     case ADEC:
1511                     case IMMED:
1512                     case REGLST:
1513                       losing++;
1514                       break;
1515                     default:
1516                       break;
1517                     }
1518                   break;
1519
1520                 case ';':
1521                   switch (opP->mode)
1522                     {
1523                     case AREG:
1524                     case CONTROL:
1525                     case FPREG:
1526                     case REGLST:
1527                       losing++;
1528                       break;
1529                     default:
1530                       break;
1531                     }
1532                   break;
1533
1534                 case '?':
1535                   switch (opP->mode)
1536                     {
1537                     case AREG:
1538                     case CONTROL:
1539                     case FPREG:
1540                     case AINC:
1541                     case ADEC:
1542                     case IMMED:
1543                     case REGLST:
1544                       losing++;
1545                       break;
1546                     case ABSL:
1547                       break;
1548                     default:
1549                       if (opP->reg == PC || opP->reg == ZPC)
1550                         losing++;
1551                       break;
1552                     }
1553                   break;
1554
1555                 case '@':
1556                   switch (opP->mode)
1557                     {
1558                     case AREG:
1559                     case CONTROL:
1560                     case FPREG:
1561                     case IMMED:
1562                     case REGLST:
1563                       losing++;
1564                       break;
1565                     default:
1566                       break;
1567                     }
1568                   break;
1569
1570                 case '~':       /* For now! (JF FOO is this right?) */
1571                   switch (opP->mode)
1572                     {
1573                     case DREG:
1574                     case AREG:
1575                     case CONTROL:
1576                     case FPREG:
1577                     case IMMED:
1578                     case REGLST:
1579                       losing++;
1580                       break;
1581                     case ABSL:
1582                       break;
1583                     default:
1584                       if (opP->reg == PC
1585                           || opP->reg == ZPC)
1586                         losing++;
1587                       break;
1588                     }
1589                   break;
1590
1591                 case '3':
1592                   if (opP->mode != CONTROL
1593                       || (opP->reg != TT0 && opP->reg != TT1))
1594                     losing++;
1595                   break;
1596
1597                 case 'A':
1598                   if (opP->mode != AREG)
1599                     losing++;
1600                   break;
1601
1602                 case 'a':
1603                   if (opP->mode != AINDR)
1604                     ++losing;
1605                   break;
1606
1607                 case '4':
1608                   if (opP->mode != AINDR && opP->mode != AINC && opP->mode != ADEC
1609                       && (opP->mode != DISP
1610                            || opP->reg < ADDR0
1611                            || opP->reg > ADDR7))
1612                     ++losing;
1613                   break;
1614
1615                 case 'B':       /* FOO */
1616                   if (opP->mode != ABSL
1617                       || (flag_long_jumps
1618                           && strncmp (instring, "jbsr", 4) == 0))
1619                     losing++;
1620                   break;
1621
1622                 case 'b':
1623                   switch (opP->mode)
1624                     {
1625                     case IMMED:
1626                     case ABSL:
1627                     case AREG:
1628                     case FPREG:
1629                     case CONTROL:
1630                     case POST:
1631                     case PRE:
1632                     case REGLST:
1633                       losing++;
1634                       break;
1635                     default:
1636                       break;
1637                     }
1638                   break;
1639
1640                 case 'C':
1641                   if (opP->mode != CONTROL || opP->reg != CCR)
1642                     losing++;
1643                   break;
1644
1645                 case 'd':
1646                   if (opP->mode != DISP
1647                       || opP->reg < ADDR0
1648                       || opP->reg > ADDR7)
1649                     losing++;
1650                   break;
1651
1652                 case 'D':
1653                   if (opP->mode != DREG)
1654                     losing++;
1655                   break;
1656
1657                 case 'E':
1658                   if (opP->reg != ACC)
1659                     losing++;
1660                   break;
1661
1662                 case 'e':
1663                   if (opP->reg != ACC && opP->reg != ACC1
1664                       && opP->reg != ACC2 && opP->reg != ACC3)
1665                     losing++;
1666                   break;
1667
1668                 case 'F':
1669                   if (opP->mode != FPREG)
1670                     losing++;
1671                   break;
1672
1673                 case 'G':
1674                   if (opP->reg != MACSR)
1675                     losing++;
1676                   break;
1677
1678                 case 'g':
1679                   if (opP->reg != ACCEXT01 && opP->reg != ACCEXT23)
1680                     losing++;
1681                   break;
1682
1683                 case 'H':
1684                   if (opP->reg != MASK)
1685                     losing++;
1686                   break;
1687
1688                 case 'I':
1689                   if (opP->mode != CONTROL
1690                       || opP->reg < COP0
1691                       || opP->reg > COP7)
1692                     losing++;
1693                   break;
1694
1695                 case 'i':
1696                   if (opP->mode != LSH && opP->mode != RSH)
1697                     losing++;
1698                   break;
1699
1700                 case 'J':
1701                   if (opP->mode != CONTROL
1702                       || opP->reg < USP
1703                       || opP->reg > last_movec_reg)
1704                     losing++;
1705                   else
1706                     {
1707                       const enum m68k_register *rp;
1708                       for (rp = control_regs; *rp; rp++)
1709                         if (*rp == opP->reg)
1710                           break;
1711                       if (*rp == 0)
1712                         losing++;
1713                     }
1714                   break;
1715
1716                 case 'k':
1717                   if (opP->mode != IMMED)
1718                     losing++;
1719                   break;
1720
1721                 case 'l':
1722                 case 'L':
1723                   if (opP->mode == DREG
1724                       || opP->mode == AREG
1725                       || opP->mode == FPREG)
1726                     {
1727                       if (s[1] == '8')
1728                         losing++;
1729                       else
1730                         {
1731                           switch (opP->mode)
1732                             {
1733                             case DREG:
1734                               opP->mask = 1 << (opP->reg - DATA0);
1735                               break;
1736                             case AREG:
1737                               opP->mask = 1 << (opP->reg - ADDR0 + 8);
1738                               break;
1739                             case FPREG:
1740                               opP->mask = 1 << (opP->reg - FP0 + 16);
1741                               break;
1742                             default:
1743                               abort ();
1744                             }
1745                           opP->mode = REGLST;
1746                         }
1747                     }
1748                   else if (opP->mode == CONTROL)
1749                     {
1750                       if (s[1] != '8')
1751                         losing++;
1752                       else
1753                         {
1754                           switch (opP->reg)
1755                             {
1756                             case FPI:
1757                               opP->mask = 1 << 24;
1758                               break;
1759                             case FPS:
1760                               opP->mask = 1 << 25;
1761                               break;
1762                             case FPC:
1763                               opP->mask = 1 << 26;
1764                               break;
1765                             default:
1766                               losing++;
1767                               break;
1768                             }
1769                           opP->mode = REGLST;
1770                         }
1771                     }
1772                   else if (opP->mode != REGLST)
1773                     losing++;
1774                   else if (s[1] == '8' && (opP->mask & 0x0ffffff) != 0)
1775                     losing++;
1776                   else if (s[1] == '3' && (opP->mask & 0x7000000) != 0)
1777                     losing++;
1778                   break;
1779
1780                 case 'M':
1781                   if (opP->mode != IMMED)
1782                     losing++;
1783                   else if (opP->disp.exp.X_op != O_constant
1784                            || ! issbyte (opP->disp.exp.X_add_number))
1785                     losing++;
1786                   else if (! m68k_quick
1787                            && instring[3] != 'q'
1788                            && instring[4] != 'q')
1789                     losing++;
1790                   break;
1791
1792                 case 'O':
1793                   if (opP->mode != DREG
1794                       && opP->mode != IMMED
1795                       && opP->mode != ABSL)
1796                     losing++;
1797                   break;
1798
1799                 case 'Q':
1800                   if (opP->mode != IMMED)
1801                     losing++;
1802                   else if (opP->disp.exp.X_op != O_constant
1803                            || TRUNC (opP->disp.exp.X_add_number) - 1 > 7)
1804                     losing++;
1805                   else if (! m68k_quick
1806                            && (strncmp (instring, "add", 3) == 0
1807                                || strncmp (instring, "sub", 3) == 0)
1808                            && instring[3] != 'q')
1809                     losing++;
1810                   break;
1811
1812                 case 'R':
1813                   if (opP->mode != DREG && opP->mode != AREG)
1814                     losing++;
1815                   break;
1816
1817                 case 'r':
1818                   if (opP->mode != AINDR
1819                       && (opP->mode != BASE
1820                           || (opP->reg != 0
1821                               && opP->reg != ZADDR0)
1822                           || opP->disp.exp.X_op != O_absent
1823                           || ((opP->index.reg < DATA0
1824                                || opP->index.reg > DATA7)
1825                               && (opP->index.reg < ADDR0
1826                                   || opP->index.reg > ADDR7))
1827                           || opP->index.size != SIZE_UNSPEC
1828                           || opP->index.scale != 1))
1829                     losing++;
1830                   break;
1831
1832                 case 's':
1833                   if (opP->mode != CONTROL
1834                       || ! (opP->reg == FPI
1835                             || opP->reg == FPS
1836                             || opP->reg == FPC))
1837                     losing++;
1838                   break;
1839
1840                 case 'S':
1841                   if (opP->mode != CONTROL || opP->reg != SR)
1842                     losing++;
1843                   break;
1844
1845                 case 't':
1846                   if (opP->mode != IMMED)
1847                     losing++;
1848                   else if (opP->disp.exp.X_op != O_constant
1849                            || TRUNC (opP->disp.exp.X_add_number) > 7)
1850                     losing++;
1851                   break;
1852
1853                 case 'U':
1854                   if (opP->mode != CONTROL || opP->reg != USP)
1855                     losing++;
1856                   break;
1857
1858                 case 'x':
1859                   if (opP->mode != IMMED)
1860                     losing++;
1861                   else if (opP->disp.exp.X_op != O_constant
1862                            || (TRUNC (opP->disp.exp.X_add_number) != 0xffffffff
1863                                && TRUNC (opP->disp.exp.X_add_number) - 1 > 6))
1864                     losing++;
1865                   break;
1866
1867                   /* JF these are out of order.  We could put them
1868                      in order if we were willing to put up with
1869                      bunches of #ifdef m68851s in the code.
1870
1871                      Don't forget that you need these operands
1872                      to use 68030 MMU instructions.  */
1873 #ifndef NO_68851
1874                   /* Memory addressing mode used by pflushr.  */
1875                 case '|':
1876                   if (opP->mode == CONTROL
1877                       || opP->mode == FPREG
1878                       || opP->mode == DREG
1879                       || opP->mode == AREG
1880                       || opP->mode == REGLST)
1881                     losing++;
1882                   /* We should accept immediate operands, but they
1883                      supposedly have to be quad word, and we don't
1884                      handle that.  I would like to see what a Motorola
1885                      assembler does before doing something here.  */
1886                   if (opP->mode == IMMED)
1887                     losing++;
1888                   break;
1889
1890                 case 'f':
1891                   if (opP->mode != CONTROL
1892                       || (opP->reg != SFC && opP->reg != DFC))
1893                     losing++;
1894                   break;
1895
1896                 case '0':
1897                   if (opP->mode != CONTROL || opP->reg != TC)
1898                     losing++;
1899                   break;
1900
1901                 case '1':
1902                   if (opP->mode != CONTROL || opP->reg != AC)
1903                     losing++;
1904                   break;
1905
1906                 case '2':
1907                   if (opP->mode != CONTROL
1908                       || (opP->reg != CAL
1909                           && opP->reg != VAL
1910                           && opP->reg != SCC))
1911                     losing++;
1912                   break;
1913
1914                 case 'V':
1915                   if (opP->mode != CONTROL
1916                       || opP->reg != VAL)
1917                     losing++;
1918                   break;
1919
1920                 case 'W':
1921                   if (opP->mode != CONTROL
1922                       || (opP->reg != DRP
1923                           && opP->reg != SRP
1924                           && opP->reg != CRP))
1925                     losing++;
1926                   break;
1927
1928                 case 'w':
1929                   switch (opP->mode)
1930                     {
1931                       case IMMED:
1932                       case ABSL:
1933                       case AREG:
1934                       case DREG:
1935                       case FPREG:
1936                       case CONTROL:
1937                       case POST:
1938                       case PRE:
1939                       case REGLST:
1940                         losing++;
1941                         break;
1942                       default:
1943                         break;
1944                     }
1945                   break;
1946
1947                 case 'X':
1948                   if (opP->mode != CONTROL
1949                       || (!(opP->reg >= BAD && opP->reg <= BAD + 7)
1950                           && !(opP->reg >= BAC && opP->reg <= BAC + 7)))
1951                     losing++;
1952                   break;
1953
1954                 case 'Y':
1955                   if (opP->mode != CONTROL || opP->reg != PSR)
1956                     losing++;
1957                   break;
1958
1959                 case 'Z':
1960                   if (opP->mode != CONTROL || opP->reg != PCSR)
1961                     losing++;
1962                   break;
1963 #endif
1964                 case 'c':
1965                   if (opP->mode != CONTROL
1966                       || (opP->reg != NC
1967                           && opP->reg != IC
1968                           && opP->reg != DC
1969                           && opP->reg != BC))
1970                     losing++;
1971                   break;
1972
1973                 case '_':
1974                   if (opP->mode != ABSL)
1975                     ++losing;
1976                   break;
1977
1978                 case 'u':
1979                   if (opP->reg < DATA0L || opP->reg > ADDR7U)
1980                     losing++;
1981                   /* FIXME: kludge instead of fixing parser:
1982                      upper/lower registers are *not* CONTROL
1983                      registers, but ordinary ones.  */
1984                   if ((opP->reg >= DATA0L && opP->reg <= DATA7L)
1985                       || (opP->reg >= DATA0U && opP->reg <= DATA7U))
1986                     opP->mode = DREG;
1987                   else
1988                     opP->mode = AREG;
1989                   break;
1990
1991                  case 'y':
1992                    if (!(opP->mode == AINDR
1993                          || (opP->mode == DISP
1994                              && !(opP->reg == PC || opP->reg == ZPC))))
1995                      losing++;
1996                    break;
1997
1998                  case 'z':
1999                    if (!(opP->mode == AINDR || opP->mode == DISP))
2000                      losing++;
2001                    break;
2002
2003                 default:
2004                   abort ();
2005                 }
2006
2007               if (losing)
2008                 break;
2009             }
2010
2011           /* Since we have found the correct instruction, copy
2012              in the modifications that we may have made.  */
2013           if (!losing)
2014             for (i = 0; i < opsfound; i++)
2015               the_ins.operands[i] = operands_backup[i];
2016         }
2017
2018       if (!losing)
2019         break;
2020
2021       opcode = opcode->m_next;
2022
2023       if (!opcode)
2024         {
2025           if (ok_arch
2026               && !(ok_arch & current_architecture))
2027             {
2028               char buf[200], *cp;
2029
2030               strncpy (buf,
2031                        _("invalid instruction for this architecture; needs "),
2032                        sizeof (buf));
2033               cp = buf + strlen (buf);
2034               switch (ok_arch)
2035                 {
2036                 case mcfisa_a:
2037                   strncpy (cp, _("ColdFire ISA_A"),
2038                            sizeof (buf) - (cp - buf));
2039                   cp += strlen (cp);
2040                   strncpy (cp, find_cf_chip (ok_arch),
2041                            sizeof (buf) - (cp - buf));
2042                   cp += strlen (cp);
2043                   break;
2044                 case mcfhwdiv:
2045                   strncpy (cp, _("ColdFire hardware divide"),
2046                            sizeof (buf) - (cp - buf));
2047                   cp += strlen (cp);
2048                   strncpy (cp, find_cf_chip (ok_arch),
2049                            sizeof (buf) - (cp - buf));
2050                   cp += strlen (cp);
2051                   break;
2052                 case mcfisa_aa:
2053                   strncpy (cp, _("ColdFire ISA_A+"),
2054                            sizeof (buf) - (cp - buf));
2055                   cp += strlen (cp);
2056                   strncpy (cp, find_cf_chip (ok_arch),
2057                            sizeof (buf) - (cp - buf));
2058                   cp += strlen (cp);
2059                   break;
2060                 case mcfisa_b:
2061                   strncpy (cp, _("ColdFire ISA_B"),
2062                            sizeof (buf) - (cp - buf));
2063                   cp += strlen (cp);
2064                   strncpy (cp, find_cf_chip (ok_arch),
2065                            sizeof (buf) - (cp - buf));
2066                   cp += strlen (cp);
2067                   break;
2068                 case cfloat:
2069                   strncpy (cp, _("ColdFire fpu"), sizeof (buf) - (cp - buf));
2070                   cp += strlen (cp);
2071                   strncpy (cp, find_cf_chip (ok_arch),
2072                            sizeof (buf) - (cp - buf));
2073                   cp += strlen (cp);
2074                   break;
2075                 case mfloat:
2076                   strcpy (cp, _("fpu (68040, 68060 or 68881/68882)"));
2077                   break;
2078                 case mmmu:
2079                   strcpy (cp, _("mmu (68030 or 68851)"));
2080                   break;
2081                 case m68020up:
2082                   strcpy (cp, _("68020 or higher"));
2083                   break;
2084                 case m68000up:
2085                   strcpy (cp, _("68000 or higher"));
2086                   break;
2087                 case m68010up:
2088                   strcpy (cp, _("68010 or higher"));
2089                   break;
2090                 default:
2091                   {
2092                     int got_one = 0, idx;
2093
2094                     for (idx = 0; m68k_cpus[idx].name; idx++)
2095                       {
2096                         if ((m68k_cpus[idx].arch & ok_arch)
2097                             && ! m68k_cpus[idx].alias)
2098                           {
2099                             if (got_one)
2100                               {
2101                                 strcpy (cp, " or ");
2102                                 cp += strlen (cp);
2103                               }
2104                             got_one = 1;
2105                             strcpy (cp, m68k_cpus[idx].name);
2106                             cp += strlen (cp);
2107                           }
2108                       }
2109                   }
2110                 }
2111               cp = xmalloc (strlen (buf) + 1);
2112               strcpy (cp, buf);
2113               the_ins.error = cp;
2114             }
2115           else
2116             the_ins.error = _("operands mismatch");
2117           return;
2118         }
2119
2120       losing = 0;
2121     }
2122
2123   /* Now assemble it.  */
2124   the_ins.args = opcode->m_operands;
2125   the_ins.numargs = opcode->m_opnum;
2126   the_ins.numo = opcode->m_codenum;
2127   the_ins.opcode[0] = getone (opcode);
2128   the_ins.opcode[1] = gettwo (opcode);
2129
2130   for (s = the_ins.args, opP = &the_ins.operands[0]; *s; s += 2, opP++)
2131     {
2132       /* This switch is a doozy.
2133          Watch the first step; its a big one! */
2134       switch (s[0])
2135         {
2136
2137         case '*':
2138         case '~':
2139         case '%':
2140         case ';':
2141         case '@':
2142         case '!':
2143         case '&':
2144         case '$':
2145         case '?':
2146         case '/':
2147         case '<':
2148         case '>':
2149         case 'b':
2150         case 'm':
2151         case 'n':
2152         case 'o':
2153         case 'p':
2154         case 'q':
2155         case 'v':
2156         case 'w':
2157         case 'y':
2158         case 'z':
2159         case '4':
2160 #ifndef NO_68851
2161         case '|':
2162 #endif
2163           switch (opP->mode)
2164             {
2165             case IMMED:
2166               tmpreg = 0x3c;    /* 7.4 */
2167               if (strchr ("bwl", s[1]))
2168                 nextword = get_num (&opP->disp, 90);
2169               else
2170                 nextword = get_num (&opP->disp, 0);
2171               if (isvar (&opP->disp))
2172                 add_fix (s[1], &opP->disp, 0, 0);
2173               switch (s[1])
2174                 {
2175                 case 'b':
2176                   if (!isbyte (nextword))
2177                     opP->error = _("operand out of range");
2178                   addword (nextword);
2179                   baseo = 0;
2180                   break;
2181                 case 'w':
2182                   if (!isword (nextword))
2183                     opP->error = _("operand out of range");
2184                   addword (nextword);
2185                   baseo = 0;
2186                   break;
2187                 case 'W':
2188                   if (!issword (nextword))
2189                     opP->error = _("operand out of range");
2190                   addword (nextword);
2191                   baseo = 0;
2192                   break;
2193                 case 'l':
2194                   addword (nextword >> 16);
2195                   addword (nextword);
2196                   baseo = 0;
2197                   break;
2198
2199                 case 'f':
2200                   baseo = 2;
2201                   outro = 8;
2202                   break;
2203                 case 'F':
2204                   baseo = 4;
2205                   outro = 11;
2206                   break;
2207                 case 'x':
2208                   baseo = 6;
2209                   outro = 15;
2210                   break;
2211                 case 'p':
2212                   baseo = 6;
2213                   outro = -1;
2214                   break;
2215                 default:
2216                   abort ();
2217                 }
2218               if (!baseo)
2219                 break;
2220
2221               /* We gotta put out some float.  */
2222               if (op (&opP->disp) != O_big)
2223                 {
2224                   valueT val;
2225                   int gencnt;
2226
2227                   /* Can other cases happen here?  */
2228                   if (op (&opP->disp) != O_constant)
2229                     abort ();
2230
2231                   val = (valueT) offs (&opP->disp);
2232                   gencnt = 0;
2233                   do
2234                     {
2235                       generic_bignum[gencnt] = (LITTLENUM_TYPE) val;
2236                       val >>= LITTLENUM_NUMBER_OF_BITS;
2237                       ++gencnt;
2238                     }
2239                   while (val != 0);
2240                   offs (&opP->disp) = gencnt;
2241                 }
2242               if (offs (&opP->disp) > 0)
2243                 {
2244                   if (offs (&opP->disp) > baseo)
2245                     {
2246                       as_warn (_("Bignum too big for %c format; truncated"),
2247                                s[1]);
2248                       offs (&opP->disp) = baseo;
2249                     }
2250                   baseo -= offs (&opP->disp);
2251                   while (baseo--)
2252                     addword (0);
2253                   for (wordp = generic_bignum + offs (&opP->disp) - 1;
2254                        offs (&opP->disp)--;
2255                        --wordp)
2256                     addword (*wordp);
2257                   break;
2258                 }
2259               gen_to_words (words, baseo, (long) outro);
2260               for (wordp = words; baseo--; wordp++)
2261                 addword (*wordp);
2262               break;
2263             case DREG:
2264               tmpreg = opP->reg - DATA; /* 0.dreg */
2265               break;
2266             case AREG:
2267               tmpreg = 0x08 + opP->reg - ADDR;  /* 1.areg */
2268               break;
2269             case AINDR:
2270               tmpreg = 0x10 + opP->reg - ADDR;  /* 2.areg */
2271               break;
2272             case ADEC:
2273               tmpreg = 0x20 + opP->reg - ADDR;  /* 4.areg */
2274               break;
2275             case AINC:
2276               tmpreg = 0x18 + opP->reg - ADDR;  /* 3.areg */
2277               break;
2278             case DISP:
2279
2280               nextword = get_num (&opP->disp, 90);
2281
2282               /* Convert mode 5 addressing with a zero offset into
2283                  mode 2 addressing to reduce the instruction size by a
2284                  word.  */
2285               if (! isvar (&opP->disp)
2286                   && (nextword == 0)
2287                   && (opP->disp.size == SIZE_UNSPEC)
2288                   && (opP->reg >= ADDR0)
2289                   && (opP->reg <= ADDR7))
2290                 {
2291                   tmpreg = 0x10 + opP->reg - ADDR; /* 2.areg */
2292                   break;
2293                 }
2294
2295               if (opP->reg == PC
2296                   && ! isvar (&opP->disp)
2297                   && m68k_abspcadd)
2298                 {
2299                   opP->disp.exp.X_op = O_symbol;
2300                   opP->disp.exp.X_add_symbol =
2301                     section_symbol (absolute_section);
2302                 }
2303
2304               /* Force into index mode.  Hope this works.  */
2305
2306               /* We do the first bit for 32-bit displacements, and the
2307                  second bit for 16 bit ones.  It is possible that we
2308                  should make the default be WORD instead of LONG, but
2309                  I think that'd break GCC, so we put up with a little
2310                  inefficiency for the sake of working output.  */
2311
2312               if (!issword (nextword)
2313                   || (isvar (&opP->disp)
2314                       && ((opP->disp.size == SIZE_UNSPEC
2315                            && flag_short_refs == 0
2316                            && cpu_of_arch (current_architecture) >= m68020
2317                            && ! arch_coldfire_p (current_architecture))
2318                           || opP->disp.size == SIZE_LONG)))
2319                 {
2320                   if (cpu_of_arch (current_architecture) < m68020
2321                       || arch_coldfire_p (current_architecture))
2322                     opP->error =
2323                       _("displacement too large for this architecture; needs 68020 or higher");
2324                   if (opP->reg == PC)
2325                     tmpreg = 0x3B;      /* 7.3 */
2326                   else
2327                     tmpreg = 0x30 + opP->reg - ADDR;    /* 6.areg */
2328                   if (isvar (&opP->disp))
2329                     {
2330                       if (opP->reg == PC)
2331                         {
2332                           if (opP->disp.size == SIZE_LONG
2333 #ifdef OBJ_ELF
2334                               /* If the displacement needs pic
2335                                  relocation it cannot be relaxed.  */
2336                               || opP->disp.pic_reloc != pic_none
2337 #endif
2338                               )
2339                             {
2340                               addword (0x0170);
2341                               add_fix ('l', &opP->disp, 1, 2);
2342                             }
2343                           else
2344                             {
2345                               add_frag (adds (&opP->disp),
2346                                         SEXT (offs (&opP->disp)),
2347                                         TAB (PCREL1632, SZ_UNDEF));
2348                               break;
2349                             }
2350                         }
2351                       else
2352                         {
2353                           addword (0x0170);
2354                           add_fix ('l', &opP->disp, 0, 0);
2355                         }
2356                     }
2357                   else
2358                     addword (0x0170);
2359                   addword (nextword >> 16);
2360                 }
2361               else
2362                 {
2363                   if (opP->reg == PC)
2364                     tmpreg = 0x3A;      /* 7.2 */
2365                   else
2366                     tmpreg = 0x28 + opP->reg - ADDR;    /* 5.areg */
2367
2368                   if (isvar (&opP->disp))
2369                     {
2370                       if (opP->reg == PC)
2371                         {
2372                           add_fix ('w', &opP->disp, 1, 0);
2373                         }
2374                       else
2375                         add_fix ('w', &opP->disp, 0, 0);
2376                     }
2377                 }
2378               addword (nextword);
2379               break;
2380
2381             case POST:
2382             case PRE:
2383             case BASE:
2384               nextword = 0;
2385               baseo = get_num (&opP->disp, 90);
2386               if (opP->mode == POST || opP->mode == PRE)
2387                 outro = get_num (&opP->odisp, 90);
2388               /* Figure out the `addressing mode'.
2389                  Also turn on the BASE_DISABLE bit, if needed.  */
2390               if (opP->reg == PC || opP->reg == ZPC)
2391                 {
2392                   tmpreg = 0x3b;        /* 7.3 */
2393                   if (opP->reg == ZPC)
2394                     nextword |= 0x80;
2395                 }
2396               else if (opP->reg == 0)
2397                 {
2398                   nextword |= 0x80;
2399                   tmpreg = 0x30;        /* 6.garbage */
2400                 }
2401               else if (opP->reg >= ZADDR0 && opP->reg <= ZADDR7)
2402                 {
2403                   nextword |= 0x80;
2404                   tmpreg = 0x30 + opP->reg - ZADDR0;
2405                 }
2406               else
2407                 tmpreg = 0x30 + opP->reg - ADDR;        /* 6.areg */
2408
2409               siz1 = opP->disp.size;
2410               if (opP->mode == POST || opP->mode == PRE)
2411                 siz2 = opP->odisp.size;
2412               else
2413                 siz2 = SIZE_UNSPEC;
2414
2415               /* Index register stuff.  */
2416               if (opP->index.reg != 0
2417                   && opP->index.reg >= DATA
2418                   && opP->index.reg <= ADDR7)
2419                 {
2420                   nextword |= (opP->index.reg - DATA) << 12;
2421
2422                   if (opP->index.size == SIZE_LONG
2423                       || (opP->index.size == SIZE_UNSPEC
2424                           && m68k_index_width_default == SIZE_LONG))
2425                     nextword |= 0x800;
2426
2427                   if ((opP->index.scale != 1
2428                        && cpu_of_arch (current_architecture) < m68020)
2429                       || (opP->index.scale == 8
2430                           && (arch_coldfire_p (current_architecture)
2431                               && !arch_coldfire_fpu (current_architecture))))
2432                     {
2433                       opP->error =
2434                         _("scale factor invalid on this architecture; needs cpu32 or 68020 or higher");
2435                     }
2436
2437                   if (arch_coldfire_p (current_architecture)
2438                       && opP->index.size == SIZE_WORD)
2439                     opP->error = _("invalid index size for coldfire");
2440
2441                   switch (opP->index.scale)
2442                     {
2443                     case 1:
2444                       break;
2445                     case 2:
2446                       nextword |= 0x200;
2447                       break;
2448                     case 4:
2449                       nextword |= 0x400;
2450                       break;
2451                     case 8:
2452                       nextword |= 0x600;
2453                       break;
2454                     default:
2455                       abort ();
2456                     }
2457                   /* IF its simple,
2458                      GET US OUT OF HERE! */
2459
2460                   /* Must be INDEX, with an index register.  Address
2461                      register cannot be ZERO-PC, and either :b was
2462                      forced, or we know it will fit.  For a 68000 or
2463                      68010, force this mode anyways, because the
2464                      larger modes aren't supported.  */
2465                   if (opP->mode == BASE
2466                       && ((opP->reg >= ADDR0
2467                            && opP->reg <= ADDR7)
2468                           || opP->reg == PC))
2469                     {
2470                       if (siz1 == SIZE_BYTE
2471                           || cpu_of_arch (current_architecture) < m68020
2472                           || arch_coldfire_p (current_architecture)
2473                           || (siz1 == SIZE_UNSPEC
2474                               && ! isvar (&opP->disp)
2475                               && issbyte (baseo)))
2476                         {
2477                           nextword += baseo & 0xff;
2478                           addword (nextword);
2479                           if (isvar (&opP->disp))
2480                             {
2481                               /* Do a byte relocation.  If it doesn't
2482                                  fit (possible on m68000) let the
2483                                  fixup processing complain later.  */
2484                               if (opP->reg == PC)
2485                                 add_fix ('B', &opP->disp, 1, 1);
2486                               else
2487                                 add_fix ('B', &opP->disp, 0, 0);
2488                             }
2489                           else if (siz1 != SIZE_BYTE)
2490                             {
2491                               if (siz1 != SIZE_UNSPEC)
2492                                 as_warn (_("Forcing byte displacement"));
2493                               if (! issbyte (baseo))
2494                                 opP->error = _("byte displacement out of range");
2495                             }
2496
2497                           break;
2498                         }
2499                       else if (siz1 == SIZE_UNSPEC
2500                                && opP->reg == PC
2501                                && isvar (&opP->disp)
2502                                && subs (&opP->disp) == NULL
2503 #ifdef OBJ_ELF
2504                                /* If the displacement needs pic
2505                                   relocation it cannot be relaxed.  */
2506                                && opP->disp.pic_reloc == pic_none
2507 #endif
2508                                )
2509                         {
2510                           /* The code in md_convert_frag_1 needs to be
2511                              able to adjust nextword.  Call frag_grow
2512                              to ensure that we have enough space in
2513                              the frag obstack to make all the bytes
2514                              contiguous.  */
2515                           frag_grow (14);
2516                           nextword += baseo & 0xff;
2517                           addword (nextword);
2518                           add_frag (adds (&opP->disp),
2519                                     SEXT (offs (&opP->disp)),
2520                                     TAB (PCINDEX, SZ_UNDEF));
2521
2522                           break;
2523                         }
2524                     }
2525                 }
2526               else
2527                 {
2528                   nextword |= 0x40;     /* No index reg.  */
2529                   if (opP->index.reg >= ZDATA0
2530                       && opP->index.reg <= ZDATA7)
2531                     nextword |= (opP->index.reg - ZDATA0) << 12;
2532                   else if (opP->index.reg >= ZADDR0
2533                            || opP->index.reg <= ZADDR7)
2534                     nextword |= (opP->index.reg - ZADDR0 + 8) << 12;
2535                 }
2536
2537               /* It isn't simple.  */
2538
2539               if (cpu_of_arch (current_architecture) < m68020
2540                   || arch_coldfire_p (current_architecture))
2541                 opP->error =
2542                   _("invalid operand mode for this architecture; needs 68020 or higher");
2543
2544               nextword |= 0x100;
2545               /* If the guy specified a width, we assume that it is
2546                  wide enough.  Maybe it isn't.  If so, we lose.  */
2547               switch (siz1)
2548                 {
2549                 case SIZE_UNSPEC:
2550                   if (isvar (&opP->disp)
2551                       ? m68k_rel32
2552                       : ! issword (baseo))
2553                     {
2554                       siz1 = SIZE_LONG;
2555                       nextword |= 0x30;
2556                     }
2557                   else if (! isvar (&opP->disp) && baseo == 0)
2558                     nextword |= 0x10;
2559                   else
2560                     {
2561                       nextword |= 0x20;
2562                       siz1 = SIZE_WORD;
2563                     }
2564                   break;
2565                 case SIZE_BYTE:
2566                   as_warn (_(":b not permitted; defaulting to :w"));
2567                   /* Fall through.  */
2568                 case SIZE_WORD:
2569                   nextword |= 0x20;
2570                   break;
2571                 case SIZE_LONG:
2572                   nextword |= 0x30;
2573                   break;
2574                 }
2575
2576               /* Figure out inner displacement stuff.  */
2577               if (opP->mode == POST || opP->mode == PRE)
2578                 {
2579                   if (cpu_of_arch (current_architecture) & cpu32)
2580                     opP->error = _("invalid operand mode for this architecture; needs 68020 or higher");
2581                   switch (siz2)
2582                     {
2583                     case SIZE_UNSPEC:
2584                       if (isvar (&opP->odisp)
2585                           ? m68k_rel32
2586                           : ! issword (outro))
2587                         {
2588                           siz2 = SIZE_LONG;
2589                           nextword |= 0x3;
2590                         }
2591                       else if (! isvar (&opP->odisp) && outro == 0)
2592                         nextword |= 0x1;
2593                       else
2594                         {
2595                           nextword |= 0x2;
2596                           siz2 = SIZE_WORD;
2597                         }
2598                       break;
2599                     case 1:
2600                       as_warn (_(":b not permitted; defaulting to :w"));
2601                       /* Fall through.  */
2602                     case 2:
2603                       nextword |= 0x2;
2604                       break;
2605                     case 3:
2606                       nextword |= 0x3;
2607                       break;
2608                     }
2609                   if (opP->mode == POST
2610                       && (nextword & 0x40) == 0)
2611                     nextword |= 0x04;
2612                 }
2613               addword (nextword);
2614
2615               if (siz1 != SIZE_UNSPEC && isvar (&opP->disp))
2616                 {
2617                   if (opP->reg == PC || opP->reg == ZPC)
2618                     add_fix (siz1 == SIZE_LONG ? 'l' : 'w', &opP->disp, 1, 2);
2619                   else
2620                     add_fix (siz1 == SIZE_LONG ? 'l' : 'w', &opP->disp, 0, 0);
2621                 }
2622               if (siz1 == SIZE_LONG)
2623                 addword (baseo >> 16);
2624               if (siz1 != SIZE_UNSPEC)
2625                 addword (baseo);
2626
2627               if (siz2 != SIZE_UNSPEC && isvar (&opP->odisp))
2628                 add_fix (siz2 == SIZE_LONG ? 'l' : 'w', &opP->odisp, 0, 0);
2629               if (siz2 == SIZE_LONG)
2630                 addword (outro >> 16);
2631               if (siz2 != SIZE_UNSPEC)
2632                 addword (outro);
2633
2634               break;
2635
2636             case ABSL:
2637               nextword = get_num (&opP->disp, 90);
2638               switch (opP->disp.size)
2639                 {
2640                 default:
2641                   abort ();
2642                 case SIZE_UNSPEC:
2643                   if (!isvar (&opP->disp) && issword (offs (&opP->disp)))
2644                     {
2645                       tmpreg = 0x38;    /* 7.0 */
2646                       addword (nextword);
2647                       break;
2648                     }
2649                   if (isvar (&opP->disp)
2650                       && !subs (&opP->disp)
2651                       && adds (&opP->disp)
2652 #ifdef OBJ_ELF
2653                       /* If the displacement needs pic relocation it
2654                          cannot be relaxed.  */
2655                       && opP->disp.pic_reloc == pic_none
2656 #endif
2657                       && !flag_long_jumps
2658                       && !strchr ("~%&$?", s[0]))
2659                     {
2660                       tmpreg = 0x3A;    /* 7.2 */
2661                       add_frag (adds (&opP->disp),
2662                                 SEXT (offs (&opP->disp)),
2663                                 TAB (ABSTOPCREL, SZ_UNDEF));
2664                       break;
2665                     }
2666                   /* Fall through into long.  */
2667                 case SIZE_LONG:
2668                   if (isvar (&opP->disp))
2669                     add_fix ('l', &opP->disp, 0, 0);
2670
2671                   tmpreg = 0x39;/* 7.1 mode */
2672                   addword (nextword >> 16);
2673                   addword (nextword);
2674                   break;
2675
2676                 case SIZE_BYTE:
2677                   as_bad (_("unsupported byte value; use a different suffix"));
2678                   /* Fall through.  */
2679
2680                 case SIZE_WORD:
2681                   if (isvar (&opP->disp))
2682                     add_fix ('w', &opP->disp, 0, 0);
2683
2684                   tmpreg = 0x38;/* 7.0 mode */
2685                   addword (nextword);
2686                   break;
2687                 }
2688               break;
2689             case CONTROL:
2690             case FPREG:
2691             default:
2692               as_bad (_("unknown/incorrect operand"));
2693               /* abort (); */
2694             }
2695
2696           /* If s[0] is '4', then this is for the mac instructions
2697              that can have a trailing_ampersand set.  If so, set 0x100
2698              bit on tmpreg so install_gen_operand can check for it and
2699              set the appropriate bit (word2, bit 5).  */
2700           if (s[0] == '4')
2701             {
2702               if (opP->trailing_ampersand)
2703                 tmpreg |= 0x100;
2704             }
2705           install_gen_operand (s[1], tmpreg);
2706           break;
2707
2708         case '#':
2709         case '^':
2710           switch (s[1])
2711             {                   /* JF: I hate floating point! */
2712             case 'j':
2713               tmpreg = 70;
2714               break;
2715             case '8':
2716               tmpreg = 20;
2717               break;
2718             case 'C':
2719               tmpreg = 50;
2720               break;
2721             case '3':
2722             default:
2723               tmpreg = 90;
2724               break;
2725             }
2726           tmpreg = get_num (&opP->disp, tmpreg);
2727           if (isvar (&opP->disp))
2728             add_fix (s[1], &opP->disp, 0, 0);
2729           switch (s[1])
2730             {
2731             case 'b':           /* Danger:  These do no check for
2732                                    certain types of overflow.
2733                                    user beware! */
2734               if (!isbyte (tmpreg))
2735                 opP->error = _("out of range");
2736               insop (tmpreg, opcode);
2737               if (isvar (&opP->disp))
2738                 the_ins.reloc[the_ins.nrel - 1].n =
2739                   (opcode->m_codenum) * 2 + 1;
2740               break;
2741             case 'B':
2742               if (!issbyte (tmpreg))
2743                 opP->error = _("out of range");
2744               the_ins.opcode[the_ins.numo - 1] |= tmpreg & 0xff;
2745               if (isvar (&opP->disp))
2746                 the_ins.reloc[the_ins.nrel - 1].n = opcode->m_codenum * 2 - 1;
2747               break;
2748             case 'w':
2749               if (!isword (tmpreg))
2750                 opP->error = _("out of range");
2751               insop (tmpreg, opcode);
2752               if (isvar (&opP->disp))
2753                 the_ins.reloc[the_ins.nrel - 1].n = (opcode->m_codenum) * 2;
2754               break;
2755             case 'W':
2756               if (!issword (tmpreg))
2757                 opP->error = _("out of range");
2758               insop (tmpreg, opcode);
2759               if (isvar (&opP->disp))
2760                 the_ins.reloc[the_ins.nrel - 1].n = (opcode->m_codenum) * 2;
2761               break;
2762             case 'l':
2763               /* Because of the way insop works, we put these two out
2764                  backwards.  */
2765               insop (tmpreg, opcode);
2766               insop (tmpreg >> 16, opcode);
2767               if (isvar (&opP->disp))
2768                 the_ins.reloc[the_ins.nrel - 1].n = (opcode->m_codenum) * 2;
2769               break;
2770             case '3':
2771               tmpreg &= 0xFF;
2772             case '8':
2773             case 'C':
2774             case 'j':
2775               install_operand (s[1], tmpreg);
2776               break;
2777             default:
2778               abort ();
2779             }
2780           break;
2781
2782         case '+':
2783         case '-':
2784         case 'A':
2785         case 'a':
2786           install_operand (s[1], opP->reg - ADDR);
2787           break;
2788
2789         case 'B':
2790           tmpreg = get_num (&opP->disp, 90);
2791           switch (s[1])
2792             {
2793             case 'B':
2794               add_fix ('B', &opP->disp, 1, -1);
2795               break;
2796             case 'W':
2797               add_fix ('w', &opP->disp, 1, 0);
2798               addword (0);
2799               break;
2800             case 'L':
2801             long_branch:
2802               if (! HAVE_LONG_BRANCH (current_architecture))
2803                 as_warn (_("Can't use long branches on 68000/68010/5200"));
2804               the_ins.opcode[0] |= 0xff;
2805               add_fix ('l', &opP->disp, 1, 0);
2806               addword (0);
2807               addword (0);
2808               break;
2809             case 'g':
2810               if (subs (&opP->disp))    /* We can't relax it.  */
2811                 goto long_branch;
2812
2813 #ifdef OBJ_ELF
2814               /* If the displacement needs pic relocation it cannot be
2815                  relaxed.  */
2816               if (opP->disp.pic_reloc != pic_none)
2817                 goto long_branch;
2818 #endif
2819               /* This could either be a symbol, or an absolute
2820                  address.  If it's an absolute address, turn it into
2821                  an absolute jump right here and keep it out of the
2822                  relaxer.  */
2823               if (adds (&opP->disp) == 0)
2824                 {
2825                   if (the_ins.opcode[0] == 0x6000)      /* jbra */
2826                     the_ins.opcode[0] = 0x4EF9;
2827                   else if (the_ins.opcode[0] == 0x6100) /* jbsr */
2828                     the_ins.opcode[0] = 0x4EB9;
2829                   else                                  /* jCC */
2830                     {
2831                       the_ins.opcode[0] ^= 0x0100;
2832                       the_ins.opcode[0] |= 0x0006;
2833                       addword (0x4EF9);
2834                     }
2835                   add_fix ('l', &opP->disp, 0, 0);
2836                   addword (0);
2837                   addword (0);
2838                   break;
2839                 }
2840
2841               /* Now we know it's going into the relaxer.  Now figure
2842                  out which mode.  We try in this order of preference:
2843                  long branch, absolute jump, byte/word branches only.  */
2844               if (HAVE_LONG_BRANCH (current_architecture))
2845                 add_frag (adds (&opP->disp),
2846                           SEXT (offs (&opP->disp)),
2847                           TAB (BRANCHBWL, SZ_UNDEF));
2848               else if (! flag_keep_pcrel)
2849                 {
2850                   if ((the_ins.opcode[0] == 0x6000)
2851                       || (the_ins.opcode[0] == 0x6100))
2852                     add_frag (adds (&opP->disp),
2853                               SEXT (offs (&opP->disp)),
2854                               TAB (BRABSJUNC, SZ_UNDEF));
2855                   else
2856                     add_frag (adds (&opP->disp),
2857                               SEXT (offs (&opP->disp)),
2858                               TAB (BRABSJCOND, SZ_UNDEF));
2859                 }
2860               else
2861                 add_frag (adds (&opP->disp),
2862                           SEXT (offs (&opP->disp)),
2863                           TAB (BRANCHBW, SZ_UNDEF));
2864               break;
2865             case 'w':
2866               if (isvar (&opP->disp))
2867                 {
2868                   /* Check for DBcc instructions.  We can relax them,
2869                      but only if we have long branches and/or absolute
2870                      jumps.  */
2871                   if (((the_ins.opcode[0] & 0xf0f8) == 0x50c8)
2872                       && (HAVE_LONG_BRANCH (current_architecture)
2873                           || (! flag_keep_pcrel)))
2874                     {
2875                       if (HAVE_LONG_BRANCH (current_architecture))
2876                         add_frag (adds (&opP->disp),
2877                                   SEXT (offs (&opP->disp)),
2878                                   TAB (DBCCLBR, SZ_UNDEF));
2879                       else
2880                         add_frag (adds (&opP->disp),
2881                                   SEXT (offs (&opP->disp)),
2882                                   TAB (DBCCABSJ, SZ_UNDEF));
2883                       break;
2884                     }
2885                   add_fix ('w', &opP->disp, 1, 0);
2886                 }
2887               addword (0);
2888               break;
2889             case 'C':           /* Fixed size LONG coproc branches.  */
2890               add_fix ('l', &opP->disp, 1, 0);
2891               addword (0);
2892               addword (0);
2893               break;
2894             case 'c':           /* Var size Coprocesssor branches.  */
2895               if (subs (&opP->disp) || (adds (&opP->disp) == 0))
2896                 {
2897                   the_ins.opcode[the_ins.numo - 1] |= 0x40;
2898                   add_fix ('l', &opP->disp, 1, 0);
2899                   addword (0);
2900                   addword (0);
2901                 }
2902               else
2903                 add_frag (adds (&opP->disp),
2904                           SEXT (offs (&opP->disp)),
2905                           TAB (FBRANCH, SZ_UNDEF));
2906               break;
2907             default:
2908               abort ();
2909             }
2910           break;
2911
2912         case 'C':               /* Ignore it.  */
2913           break;
2914
2915         case 'd':               /* JF this is a kludge.  */
2916           install_operand ('s', opP->reg - ADDR);
2917           tmpreg = get_num (&opP->disp, 90);
2918           if (!issword (tmpreg))
2919             {
2920               as_warn (_("Expression out of range, using 0"));
2921               tmpreg = 0;
2922             }
2923           addword (tmpreg);
2924           break;
2925
2926         case 'D':
2927           install_operand (s[1], opP->reg - DATA);
2928           break;
2929
2930         case 'e':  /* EMAC ACCx, reg/reg.  */
2931           install_operand (s[1], opP->reg - ACC);
2932           break;
2933
2934         case 'E':               /* Ignore it.  */
2935           break;
2936
2937         case 'F':
2938           install_operand (s[1], opP->reg - FP0);
2939           break;
2940
2941         case 'g':  /* EMAC ACCEXTx.  */
2942           install_operand (s[1], opP->reg - ACCEXT01);
2943           break;
2944
2945         case 'G':               /* Ignore it.  */
2946         case 'H':
2947           break;
2948
2949         case 'I':
2950           tmpreg = opP->reg - COP0;
2951           install_operand (s[1], tmpreg);
2952           break;
2953
2954         case 'i':  /* MAC/EMAC scale factor.  */
2955           install_operand (s[1], opP->mode == LSH ? 0x1 : 0x3);
2956           break;
2957
2958         case 'J':               /* JF foo.  */
2959           switch (opP->reg)
2960             {
2961             case SFC:
2962               tmpreg = 0x000;
2963               break;
2964             case DFC:
2965               tmpreg = 0x001;
2966               break;
2967             case CACR:
2968               tmpreg = 0x002;
2969               break;
2970             case TC:
2971               tmpreg = 0x003;
2972               break;
2973             case ACR0:
2974             case ITT0:
2975               tmpreg = 0x004;
2976               break;
2977             case ACR1:
2978             case ITT1:
2979               tmpreg = 0x005;
2980               break;
2981             case ACR2:
2982             case DTT0:
2983               tmpreg = 0x006;
2984               break;
2985             case ACR3:
2986             case DTT1:
2987               tmpreg = 0x007;
2988               break;
2989             case BUSCR:
2990               tmpreg = 0x008;
2991               break;
2992
2993             case USP:
2994               tmpreg = 0x800;
2995               break;
2996             case VBR:
2997               tmpreg = 0x801;
2998               break;
2999             case CAAR:
3000               tmpreg = 0x802;
3001               break;
3002             case MSP:
3003               tmpreg = 0x803;
3004               break;
3005             case ISP:
3006               tmpreg = 0x804;
3007               break;
3008             case MMUSR:
3009               tmpreg = 0x805;
3010               break;
3011             case URP:
3012               tmpreg = 0x806;
3013               break;
3014             case SRP:
3015               tmpreg = 0x807;
3016               break;
3017             case PCR:
3018               tmpreg = 0x808;
3019               break;
3020             case ROMBAR:
3021               tmpreg = 0xC00;
3022               break;
3023             case ROMBAR1:
3024               tmpreg = 0xC01;
3025               break;
3026             case FLASHBAR:
3027             case RAMBAR0:
3028               tmpreg = 0xC04;
3029               break;
3030             case RAMBAR:
3031             case RAMBAR1:
3032               tmpreg = 0xC05;
3033               break;
3034             case MPCR:
3035               tmpreg = 0xC0C;
3036               break;
3037             case EDRAMBAR:
3038               tmpreg = 0xC0D;
3039               break;
3040             case MBAR0:
3041             case MBAR2:
3042             case SECMBAR:
3043               tmpreg = 0xC0E;
3044               break;
3045             case MBAR1:
3046             case MBAR:
3047               tmpreg = 0xC0F;
3048               break;
3049             case PCR1U0:
3050               tmpreg = 0xD02;
3051               break;
3052             case PCR1L0:
3053               tmpreg = 0xD03;
3054               break;
3055             case PCR2U0:
3056               tmpreg = 0xD04;
3057               break;
3058             case PCR2L0:
3059               tmpreg = 0xD05;
3060               break;
3061             case PCR3U0:
3062               tmpreg = 0xD06;
3063               break;
3064             case PCR3L0:
3065               tmpreg = 0xD07;
3066               break;
3067             case PCR1L1:
3068               tmpreg = 0xD0A;
3069               break;
3070             case PCR1U1:
3071               tmpreg = 0xD0B;
3072               break;
3073             case PCR2L1:
3074               tmpreg = 0xD0C;
3075               break;
3076             case PCR2U1:
3077               tmpreg = 0xD0D;
3078               break;
3079             case PCR3L1:
3080               tmpreg = 0xD0E;
3081               break;
3082             case PCR3U1:
3083               tmpreg = 0xD0F;
3084               break;
3085             default:
3086               abort ();
3087             }
3088           install_operand (s[1], tmpreg);
3089           break;
3090
3091         case 'k':
3092           tmpreg = get_num (&opP->disp, 55);
3093           install_operand (s[1], tmpreg & 0x7f);
3094           break;
3095
3096         case 'l':
3097           tmpreg = opP->mask;
3098           if (s[1] == 'w')
3099             {
3100               if (tmpreg & 0x7FF0000)
3101                 as_bad (_("Floating point register in register list"));
3102               insop (reverse_16_bits (tmpreg), opcode);
3103             }
3104           else
3105             {
3106               if (tmpreg & 0x700FFFF)
3107                 as_bad (_("Wrong register in floating-point reglist"));
3108               install_operand (s[1], reverse_8_bits (tmpreg >> 16));
3109             }
3110           break;
3111
3112         case 'L':
3113           tmpreg = opP->mask;
3114           if (s[1] == 'w')
3115             {
3116               if (tmpreg & 0x7FF0000)
3117                 as_bad (_("Floating point register in register list"));
3118               insop (tmpreg, opcode);
3119             }
3120           else if (s[1] == '8')
3121             {
3122               if (tmpreg & 0x0FFFFFF)
3123                 as_bad (_("incorrect register in reglist"));
3124               install_operand (s[1], tmpreg >> 24);
3125             }
3126           else
3127             {
3128               if (tmpreg & 0x700FFFF)
3129                 as_bad (_("wrong register in floating-point reglist"));
3130               else
3131                 install_operand (s[1], tmpreg >> 16);
3132             }
3133           break;
3134
3135         case 'M':
3136           install_operand (s[1], get_num (&opP->disp, 60));
3137           break;
3138
3139         case 'O':
3140           tmpreg = ((opP->mode == DREG)
3141                     ? 0x20 + (int) (opP->reg - DATA)
3142                     : (get_num (&opP->disp, 40) & 0x1F));
3143           install_operand (s[1], tmpreg);
3144           break;
3145
3146         case 'Q':
3147           tmpreg = get_num (&opP->disp, 10);
3148           if (tmpreg == 8)
3149             tmpreg = 0;
3150           install_operand (s[1], tmpreg);
3151           break;
3152
3153         case 'R':
3154           /* This depends on the fact that ADDR registers are eight
3155              more than their corresponding DATA regs, so the result
3156              will have the ADDR_REG bit set.  */
3157           install_operand (s[1], opP->reg - DATA);
3158           break;
3159
3160         case 'r':
3161           if (opP->mode == AINDR)
3162             install_operand (s[1], opP->reg - DATA);
3163           else
3164             install_operand (s[1], opP->index.reg - DATA);
3165           break;
3166
3167         case 's':
3168           if (opP->reg == FPI)
3169             tmpreg = 0x1;
3170           else if (opP->reg == FPS)
3171             tmpreg = 0x2;
3172           else if (opP->reg == FPC)
3173             tmpreg = 0x4;
3174           else
3175             abort ();
3176           install_operand (s[1], tmpreg);
3177           break;
3178
3179         case 'S':               /* Ignore it.  */
3180           break;
3181
3182         case 'T':
3183           install_operand (s[1], get_num (&opP->disp, 30));
3184           break;
3185
3186         case 'U':               /* Ignore it.  */
3187           break;
3188
3189         case 'c':
3190           switch (opP->reg)
3191             {
3192             case NC:
3193               tmpreg = 0;
3194               break;
3195             case DC:
3196               tmpreg = 1;
3197               break;
3198             case IC:
3199               tmpreg = 2;
3200               break;
3201             case BC:
3202               tmpreg = 3;
3203               break;
3204             default:
3205               as_fatal (_("failed sanity check"));
3206             }                   /* switch on cache token.  */
3207           install_operand (s[1], tmpreg);
3208           break;
3209 #ifndef NO_68851
3210           /* JF: These are out of order, I fear.  */
3211         case 'f':
3212           switch (opP->reg)
3213             {
3214             case SFC:
3215               tmpreg = 0;
3216               break;
3217             case DFC:
3218               tmpreg = 1;
3219               break;
3220             default:
3221               abort ();
3222             }
3223           install_operand (s[1], tmpreg);
3224           break;
3225
3226         case '0':
3227         case '1':
3228         case '2':
3229           switch (opP->reg)
3230             {
3231             case TC:
3232               tmpreg = 0;
3233               break;
3234             case CAL:
3235               tmpreg = 4;
3236               break;
3237             case VAL:
3238               tmpreg = 5;
3239               break;
3240             case SCC:
3241               tmpreg = 6;
3242               break;
3243             case AC:
3244               tmpreg = 7;
3245               break;
3246             default:
3247               abort ();
3248             }
3249           install_operand (s[1], tmpreg);
3250           break;
3251
3252         case 'V':
3253           if (opP->reg == VAL)
3254             break;
3255           abort ();
3256
3257         case 'W':
3258           switch (opP->reg)
3259             {
3260             case DRP:
3261               tmpreg = 1;
3262               break;
3263             case SRP:
3264               tmpreg = 2;
3265               break;
3266             case CRP:
3267               tmpreg = 3;
3268               break;
3269             default:
3270               abort ();
3271             }
3272           install_operand (s[1], tmpreg);
3273           break;
3274
3275         case 'X':
3276           switch (opP->reg)
3277             {
3278             case BAD:
3279             case BAD + 1:
3280             case BAD + 2:
3281             case BAD + 3:
3282             case BAD + 4:
3283             case BAD + 5:
3284             case BAD + 6:
3285             case BAD + 7:
3286               tmpreg = (4 << 10) | ((opP->reg - BAD) << 2);
3287               break;
3288
3289             case BAC:
3290             case BAC + 1:
3291             case BAC + 2:
3292             case BAC + 3:
3293             case BAC + 4:
3294             case BAC + 5:
3295             case BAC + 6:
3296             case BAC + 7:
3297               tmpreg = (5 << 10) | ((opP->reg - BAC) << 2);
3298               break;
3299
3300             default:
3301               abort ();
3302             }
3303           install_operand (s[1], tmpreg);
3304           break;
3305         case 'Y':
3306           know (opP->reg == PSR);
3307           break;
3308         case 'Z':
3309           know (opP->reg == PCSR);
3310           break;
3311 #endif /* m68851 */
3312         case '3':
3313           switch (opP->reg)
3314             {
3315             case TT0:
3316               tmpreg = 2;
3317               break;
3318             case TT1:
3319               tmpreg = 3;
3320               break;
3321             default:
3322               abort ();
3323             }
3324           install_operand (s[1], tmpreg);
3325           break;
3326         case 't':
3327           tmpreg = get_num (&opP->disp, 20);
3328           install_operand (s[1], tmpreg);
3329           break;
3330         case '_':       /* used only for move16 absolute 32-bit address.  */
3331           if (isvar (&opP->disp))
3332             add_fix ('l', &opP->disp, 0, 0);
3333           tmpreg = get_num (&opP->disp, 90);
3334           addword (tmpreg >> 16);
3335           addword (tmpreg & 0xFFFF);
3336           break;
3337         case 'u':
3338           install_operand (s[1], opP->reg - DATA0L);
3339           opP->reg -= (DATA0L);
3340           opP->reg &= 0x0F;     /* remove upper/lower bit.  */
3341           break;
3342         case 'x':
3343           tmpreg = get_num (&opP->disp, 80);
3344           if (tmpreg == -1)
3345             tmpreg = 0;
3346           install_operand (s[1], tmpreg);
3347           break;
3348         default:
3349           abort ();
3350         }
3351     }
3352
3353   /* By the time whe get here (FINALLY) the_ins contains the complete
3354      instruction, ready to be emitted. . .  */
3355 }
3356
3357 static int
3358 reverse_16_bits (int in)
3359 {
3360   int out = 0;
3361   int n;
3362
3363   static int mask[16] =
3364   {
3365     0x0001, 0x0002, 0x0004, 0x0008, 0x0010, 0x0020, 0x0040, 0x0080,
3366     0x0100, 0x0200, 0x0400, 0x0800, 0x1000, 0x2000, 0x4000, 0x8000
3367   };
3368   for (n = 0; n < 16; n++)
3369     {
3370       if (in & mask[n])
3371         out |= mask[15 - n];
3372     }
3373   return out;
3374 }                               /* reverse_16_bits() */
3375
3376 static int
3377 reverse_8_bits (int in)
3378 {
3379   int out = 0;
3380   int n;
3381
3382   static int mask[8] =
3383   {
3384     0x0001, 0x0002, 0x0004, 0x0008, 0x0010, 0x0020, 0x0040, 0x0080,
3385   };
3386
3387   for (n = 0; n < 8; n++)
3388     {
3389       if (in & mask[n])
3390         out |= mask[7 - n];
3391     }
3392   return out;
3393 }                               /* reverse_8_bits() */
3394
3395 /* Cause an extra frag to be generated here, inserting up to 10 bytes
3396    (that value is chosen in the frag_var call in md_assemble).  TYPE
3397    is the subtype of the frag to be generated; its primary type is
3398    rs_machine_dependent.
3399
3400    The TYPE parameter is also used by md_convert_frag_1 and
3401    md_estimate_size_before_relax.  The appropriate type of fixup will
3402    be emitted by md_convert_frag_1.
3403
3404    ADD becomes the FR_SYMBOL field of the frag, and OFF the FR_OFFSET.  */
3405 static void
3406 install_operand (int mode, int val)
3407 {
3408   switch (mode)
3409     {
3410     case 's':
3411       the_ins.opcode[0] |= val & 0xFF;  /* JF FF is for M kludge.  */
3412       break;
3413     case 'd':
3414       the_ins.opcode[0] |= val << 9;
3415       break;
3416     case '1':
3417       the_ins.opcode[1] |= val << 12;
3418       break;
3419     case '2':
3420       the_ins.opcode[1] |= val << 6;
3421       break;
3422     case '3':
3423       the_ins.opcode[1] |= val;
3424       break;
3425     case '4':
3426       the_ins.opcode[2] |= val << 12;
3427       break;
3428     case '5':
3429       the_ins.opcode[2] |= val << 6;
3430       break;
3431     case '6':
3432       /* DANGER!  This is a hack to force cas2l and cas2w cmds to be
3433          three words long! */
3434       the_ins.numo++;
3435       the_ins.opcode[2] |= val;
3436       break;
3437     case '7':
3438       the_ins.opcode[1] |= val << 7;
3439       break;
3440     case '8':
3441       the_ins.opcode[1] |= val << 10;
3442       break;
3443 #ifndef NO_68851
3444     case '9':
3445       the_ins.opcode[1] |= val << 5;
3446       break;
3447 #endif
3448
3449     case 't':
3450       the_ins.opcode[1] |= (val << 10) | (val << 7);
3451       break;
3452     case 'D':
3453       the_ins.opcode[1] |= (val << 12) | val;
3454       break;
3455     case 'g':
3456       the_ins.opcode[0] |= val = 0xff;
3457       break;
3458     case 'i':
3459       the_ins.opcode[0] |= val << 9;
3460       break;
3461     case 'C':
3462       the_ins.opcode[1] |= val;
3463       break;
3464     case 'j':
3465       the_ins.opcode[1] |= val;
3466       the_ins.numo++;           /* What a hack.  */
3467       break;
3468     case 'k':
3469       the_ins.opcode[1] |= val << 4;
3470       break;
3471     case 'b':
3472     case 'w':
3473     case 'W':
3474     case 'l':
3475       break;
3476     case 'e':
3477       the_ins.opcode[0] |= (val << 6);
3478       break;
3479     case 'L':
3480       the_ins.opcode[1] = (val >> 16);
3481       the_ins.opcode[2] = val & 0xffff;
3482       break;
3483     case 'm':
3484       the_ins.opcode[0] |= ((val & 0x8) << (6 - 3));
3485       the_ins.opcode[0] |= ((val & 0x7) << 9);
3486       the_ins.opcode[1] |= ((val & 0x10) << (7 - 4));
3487       break;
3488     case 'n': /* MAC/EMAC Rx on !load.  */
3489       the_ins.opcode[0] |= ((val & 0x8) << (6 - 3));
3490       the_ins.opcode[0] |= ((val & 0x7) << 9);
3491       the_ins.opcode[1] |= ((val & 0x10) << (7 - 4));
3492       break;
3493     case 'o': /* MAC/EMAC Rx on load.  */
3494       the_ins.opcode[1] |= val << 12;
3495       the_ins.opcode[1] |= ((val & 0x10) << (7 - 4));
3496       break;
3497     case 'M': /* MAC/EMAC Ry on !load.  */
3498       the_ins.opcode[0] |= (val & 0xF);
3499       the_ins.opcode[1] |= ((val & 0x10) << (6 - 4));
3500       break;
3501     case 'N': /* MAC/EMAC Ry on load.  */
3502       the_ins.opcode[1] |= (val & 0xF);
3503       the_ins.opcode[1] |= ((val & 0x10) << (6 - 4));
3504       break;
3505     case 'h':
3506       the_ins.opcode[1] |= ((val != 1) << 10);
3507       break;
3508     case 'F':
3509       the_ins.opcode[0] |= ((val & 0x3) << 9);
3510       break;
3511     case 'f':
3512       the_ins.opcode[0] |= ((val & 0x3) << 0);
3513       break;
3514     case 'G':  /* EMAC accumulator in a EMAC load instruction.  */
3515       the_ins.opcode[0] |= ((~val & 0x1) << 7);
3516       the_ins.opcode[1] |= ((val & 0x2) << (4 - 1));
3517       break;
3518     case 'H':  /* EMAC accumulator in a EMAC non-load instruction.  */
3519       the_ins.opcode[0] |= ((val & 0x1) << 7);
3520       the_ins.opcode[1] |= ((val & 0x2) << (4 - 1));
3521       break;
3522     case 'I':
3523       the_ins.opcode[1] |= ((val & 0x3) << 9);
3524       break;
3525     case ']':
3526       the_ins.opcode[0] |= (val & 0x1) <<10;
3527       break;
3528     case 'c':
3529     default:
3530       as_fatal (_("failed sanity check."));
3531     }
3532 }
3533
3534 static void
3535 install_gen_operand (int mode, int val)
3536 {
3537   switch (mode)
3538     {
3539     case '/':  /* Special for mask loads for mac/msac insns with
3540                   possible mask; trailing_ampersend set in bit 8.  */
3541       the_ins.opcode[0] |= (val & 0x3f);
3542       the_ins.opcode[1] |= (((val & 0x100) >> 8) << 5);
3543       break;
3544     case 's':
3545       the_ins.opcode[0] |= val;
3546       break;
3547     case 'd':
3548       /* This is a kludge!!! */
3549       the_ins.opcode[0] |= (val & 0x07) << 9 | (val & 0x38) << 3;
3550       break;
3551     case 'b':
3552     case 'w':
3553     case 'l':
3554     case 'f':
3555     case 'F':
3556     case 'x':
3557     case 'p':
3558       the_ins.opcode[0] |= val;
3559       break;
3560       /* more stuff goes here.  */
3561     default:
3562       as_fatal (_("failed sanity check."));
3563     }
3564 }
3565
3566 /* Verify that we have some number of paren pairs, do m68k_ip_op(), and
3567    then deal with the bitfield hack.  */
3568
3569 static char *
3570 crack_operand (char *str, struct m68k_op *opP)
3571 {
3572   register int parens;
3573   register int c;
3574   register char *beg_str;
3575   int inquote = 0;
3576
3577   if (!str)
3578     {
3579       return str;
3580     }
3581   beg_str = str;
3582   for (parens = 0; *str && (parens > 0 || inquote || notend (str)); str++)
3583     {
3584       if (! inquote)
3585         {
3586           if (*str == '(')
3587             parens++;
3588           else if (*str == ')')
3589             {
3590               if (!parens)
3591                 {                       /* ERROR.  */
3592                   opP->error = _("Extra )");
3593                   return str;
3594                 }
3595               --parens;
3596             }
3597         }
3598       if (flag_mri && *str == '\'')
3599         inquote = ! inquote;
3600     }
3601   if (!*str && parens)
3602     {                           /* ERROR.  */
3603       opP->error = _("Missing )");
3604       return str;
3605     }
3606   c = *str;
3607   *str = '\0';
3608   if (m68k_ip_op (beg_str, opP) != 0)
3609     {
3610       *str = c;
3611       return str;
3612     }
3613   *str = c;
3614   if (c == '}')
3615     c = *++str;                 /* JF bitfield hack.  */
3616   if (c)
3617     {
3618       c = *++str;
3619       if (!c)
3620         as_bad (_("Missing operand"));
3621     }
3622
3623   /* Detect MRI REG symbols and convert them to REGLSTs.  */
3624   if (opP->mode == CONTROL && (int)opP->reg < 0)
3625     {
3626       opP->mode = REGLST;
3627       opP->mask = ~(int)opP->reg;
3628       opP->reg = 0;
3629     }
3630
3631   return str;
3632 }
3633
3634 /* This is the guts of the machine-dependent assembler.  STR points to a
3635    machine dependent instruction.  This function is supposed to emit
3636    the frags/bytes it assembles to.
3637    */
3638
3639 static void
3640 insert_reg (const char *regname, int regnum)
3641 {
3642   char buf[100];
3643   int i;
3644
3645 #ifdef REGISTER_PREFIX
3646   if (!flag_reg_prefix_optional)
3647     {
3648       buf[0] = REGISTER_PREFIX;
3649       strcpy (buf + 1, regname);
3650       regname = buf;
3651     }
3652 #endif
3653
3654   symbol_table_insert (symbol_new (regname, reg_section, regnum,
3655                                    &zero_address_frag));
3656
3657   for (i = 0; regname[i]; i++)
3658     buf[i] = TOUPPER (regname[i]);
3659   buf[i] = '\0';
3660
3661   symbol_table_insert (symbol_new (buf, reg_section, regnum,
3662                                    &zero_address_frag));
3663 }
3664
3665 struct init_entry
3666   {
3667     const char *name;
3668     int number;
3669   };
3670
3671 static const struct init_entry init_table[] =
3672 {
3673   { "d0", DATA0 },
3674   { "d1", DATA1 },
3675   { "d2", DATA2 },
3676   { "d3", DATA3 },
3677   { "d4", DATA4 },
3678   { "d5", DATA5 },
3679   { "d6", DATA6 },
3680   { "d7", DATA7 },
3681   { "a0", ADDR0 },
3682   { "a1", ADDR1 },
3683   { "a2", ADDR2 },
3684   { "a3", ADDR3 },
3685   { "a4", ADDR4 },
3686   { "a5", ADDR5 },
3687   { "a6", ADDR6 },
3688   { "fp", ADDR6 },
3689   { "a7", ADDR7 },
3690   { "sp", ADDR7 },
3691   { "ssp", ADDR7 },
3692   { "fp0", FP0 },
3693   { "fp1", FP1 },
3694   { "fp2", FP2 },
3695   { "fp3", FP3 },
3696   { "fp4", FP4 },
3697   { "fp5", FP5 },
3698   { "fp6", FP6 },
3699   { "fp7", FP7 },
3700   { "fpi", FPI },
3701   { "fpiar", FPI },
3702   { "fpc", FPI },
3703   { "fps", FPS },
3704   { "fpsr", FPS },
3705   { "fpc", FPC },
3706   { "fpcr", FPC },
3707   { "control", FPC },
3708   { "status", FPS },
3709   { "iaddr", FPI },
3710
3711   { "cop0", COP0 },
3712   { "cop1", COP1 },
3713   { "cop2", COP2 },
3714   { "cop3", COP3 },
3715   { "cop4", COP4 },
3716   { "cop5", COP5 },
3717   { "cop6", COP6 },
3718   { "cop7", COP7 },
3719   { "pc", PC },
3720   { "zpc", ZPC },
3721   { "sr", SR },
3722
3723   { "ccr", CCR },
3724   { "cc", CCR },
3725
3726   { "acc", ACC },
3727   { "acc0", ACC },
3728   { "acc1", ACC1 },
3729   { "acc2", ACC2 },
3730   { "acc3", ACC3 },
3731   { "accext01", ACCEXT01 },
3732   { "accext23", ACCEXT23 },
3733   { "macsr", MACSR },
3734   { "mask", MASK },
3735
3736   /* Control registers.  */
3737   { "sfc", SFC },               /* Source Function Code.  */
3738   { "sfcr", SFC },
3739   { "dfc", DFC },               /* Destination Function Code.  */
3740   { "dfcr", DFC },
3741   { "cacr", CACR },             /* Cache Control Register.  */
3742   { "caar", CAAR },             /* Cache Address Register.  */
3743
3744   { "usp", USP },               /* User Stack Pointer.  */
3745   { "vbr", VBR },               /* Vector Base Register.  */
3746   { "msp", MSP },               /* Master Stack Pointer.  */
3747   { "isp", ISP },               /* Interrupt Stack Pointer.  */
3748
3749   { "itt0", ITT0 },             /* Instruction Transparent Translation Reg 0.  */
3750   { "itt1", ITT1 },             /* Instruction Transparent Translation Reg 1.  */
3751   { "dtt0", DTT0 },             /* Data Transparent Translation Register 0.  */
3752   { "dtt1", DTT1 },             /* Data Transparent Translation Register 1.  */
3753
3754   /* 68ec040 versions of same */
3755   { "iacr0", ITT0 },            /* Instruction Access Control Register 0.  */
3756   { "iacr1", ITT1 },            /* Instruction Access Control Register 0.  */
3757   { "dacr0", DTT0 },            /* Data Access Control Register 0.  */
3758   { "dacr1", DTT1 },            /* Data Access Control Register 0.  */
3759
3760   /* mcf5200 versions of same.  The ColdFire programmer's reference
3761      manual indicated that the order is 2,3,0,1, but Ken Rose
3762      <rose@netcom.com> says that 0,1,2,3 is the correct order.  */
3763   { "acr0", ACR0 },             /* Access Control Unit 0.  */
3764   { "acr1", ACR1 },             /* Access Control Unit 1.  */
3765   { "acr2", ACR2 },             /* Access Control Unit 2.  */
3766   { "acr3", ACR3 },             /* Access Control Unit 3.  */
3767
3768   { "tc", TC },                 /* MMU Translation Control Register.  */
3769   { "tcr", TC },
3770
3771   { "mmusr", MMUSR },           /* MMU Status Register.  */
3772   { "srp", SRP },               /* User Root Pointer.  */
3773   { "urp", URP },               /* Supervisor Root Pointer.  */
3774
3775   { "buscr", BUSCR },
3776   { "pcr", PCR },
3777
3778   { "rombar", ROMBAR },         /* ROM Base Address Register.  */
3779   { "rambar0", RAMBAR0 },       /* ROM Base Address Register.  */
3780   { "rambar1", RAMBAR1 },       /* ROM Base Address Register.  */
3781   { "mbar", MBAR },             /* Module Base Address Register.  */
3782
3783   { "mbar0",    MBAR0 },        /* mcfv4e registers.  */
3784   { "mbar1",    MBAR1 },        /* mcfv4e registers.  */
3785   { "rombar0",  ROMBAR },       /* mcfv4e registers.  */
3786   { "rombar1",  ROMBAR1 },      /* mcfv4e registers.  */
3787   { "mpcr",     MPCR },         /* mcfv4e registers.  */
3788   { "edrambar", EDRAMBAR },     /* mcfv4e registers.  */
3789   { "secmbar",  SECMBAR },      /* mcfv4e registers.  */
3790   { "asid",     TC },           /* mcfv4e registers.  */
3791   { "mmubar",   BUSCR },        /* mcfv4e registers.  */
3792   { "pcr1u0",   PCR1U0 },       /* mcfv4e registers.  */
3793   { "pcr1l0",   PCR1L0 },       /* mcfv4e registers.  */
3794   { "pcr2u0",   PCR2U0 },       /* mcfv4e registers.  */
3795   { "pcr2l0",   PCR2L0 },       /* mcfv4e registers.  */
3796   { "pcr3u0",   PCR3U0 },       /* mcfv4e registers.  */
3797   { "pcr3l0",   PCR3L0 },       /* mcfv4e registers.  */
3798   { "pcr1u1",   PCR1U1 },       /* mcfv4e registers.  */
3799   { "pcr1l1",   PCR1L1 },       /* mcfv4e registers.  */
3800   { "pcr2u1",   PCR2U1 },       /* mcfv4e registers.  */
3801   { "pcr2l1",   PCR2L1 },       /* mcfv4e registers.  */
3802   { "pcr3u1",   PCR3U1 },       /* mcfv4e registers.  */
3803   { "pcr3l1",   PCR3L1 },       /* mcfv4e registers.  */
3804
3805   { "flashbar", FLASHBAR },     /* mcf528x registers.  */
3806   { "rambar",   RAMBAR },       /* mcf528x registers.  */
3807
3808   { "mbar2",    MBAR2 },        /* mcf5249 registers.  */
3809   /* End of control registers.  */
3810
3811   { "ac", AC },
3812   { "bc", BC },
3813   { "cal", CAL },
3814   { "crp", CRP },
3815   { "drp", DRP },
3816   { "pcsr", PCSR },
3817   { "psr", PSR },
3818   { "scc", SCC },
3819   { "val", VAL },
3820   { "bad0", BAD0 },
3821   { "bad1", BAD1 },
3822   { "bad2", BAD2 },
3823   { "bad3", BAD3 },
3824   { "bad4", BAD4 },
3825   { "bad5", BAD5 },
3826   { "bad6", BAD6 },
3827   { "bad7", BAD7 },
3828   { "bac0", BAC0 },
3829   { "bac1", BAC1 },
3830   { "bac2", BAC2 },
3831   { "bac3", BAC3 },
3832   { "bac4", BAC4 },
3833   { "bac5", BAC5 },
3834   { "bac6", BAC6 },
3835   { "bac7", BAC7 },
3836
3837   { "ic", IC },
3838   { "dc", DC },
3839   { "nc", NC },
3840
3841   { "tt0", TT0 },
3842   { "tt1", TT1 },
3843   /* 68ec030 versions of same.  */
3844   { "ac0", TT0 },
3845   { "ac1", TT1 },
3846   /* 68ec030 access control unit, identical to 030 MMU status reg.  */
3847   { "acusr", PSR },
3848
3849   /* Suppressed data and address registers.  */
3850   { "zd0", ZDATA0 },
3851   { "zd1", ZDATA1 },
3852   { "zd2", ZDATA2 },
3853   { "zd3", ZDATA3 },
3854   { "zd4", ZDATA4 },
3855   { "zd5", ZDATA5 },
3856   { "zd6", ZDATA6 },
3857   { "zd7", ZDATA7 },
3858   { "za0", ZADDR0 },
3859   { "za1", ZADDR1 },
3860   { "za2", ZADDR2 },
3861   { "za3", ZADDR3 },
3862   { "za4", ZADDR4 },
3863   { "za5", ZADDR5 },
3864   { "za6", ZADDR6 },
3865   { "za7", ZADDR7 },
3866
3867   /* Upper and lower data and address registers, used by macw and msacw.  */
3868   { "d0l", DATA0L },
3869   { "d1l", DATA1L },
3870   { "d2l", DATA2L },
3871   { "d3l", DATA3L },
3872   { "d4l", DATA4L },
3873   { "d5l", DATA5L },
3874   { "d6l", DATA6L },
3875   { "d7l", DATA7L },
3876
3877   { "a0l", ADDR0L },
3878   { "a1l", ADDR1L },
3879   { "a2l", ADDR2L },
3880   { "a3l", ADDR3L },
3881   { "a4l", ADDR4L },
3882   { "a5l", ADDR5L },
3883   { "a6l", ADDR6L },
3884   { "a7l", ADDR7L },
3885
3886   { "d0u", DATA0U },
3887   { "d1u", DATA1U },
3888   { "d2u", DATA2U },
3889   { "d3u", DATA3U },
3890   { "d4u", DATA4U },
3891   { "d5u", DATA5U },
3892   { "d6u", DATA6U },
3893   { "d7u", DATA7U },
3894
3895   { "a0u", ADDR0U },
3896   { "a1u", ADDR1U },
3897   { "a2u", ADDR2U },
3898   { "a3u", ADDR3U },
3899   { "a4u", ADDR4U },
3900   { "a5u", ADDR5U },
3901   { "a6u", ADDR6U },
3902   { "a7u", ADDR7U },
3903
3904   { 0, 0 }
3905 };
3906
3907 static void
3908 init_regtable (void)
3909 {
3910   int i;
3911   for (i = 0; init_table[i].name; i++)
3912     insert_reg (init_table[i].name, init_table[i].number);
3913 }
3914
3915 void
3916 md_assemble (char *str)
3917 {
3918   const char *er;
3919   short *fromP;
3920   char *toP = NULL;
3921   int m, n = 0;
3922   char *to_beg_P;
3923   int shorts_this_frag;
3924   fixS *fixP;
3925
3926   if (!selected_cpu && !selected_arch)
3927     {
3928       /* We've not selected an architecture yet.  Set the default
3929          now.  We do this lazily so that an initial .cpu or .arch directive
3930          can specify.  */
3931       if (!m68k_set_cpu (TARGET_CPU, 1, 1))
3932         as_bad (_("unrecognized default cpu `%s'"), TARGET_CPU);
3933     }
3934   if (!initialized)
3935     m68k_init_arch ();
3936
3937   /* In MRI mode, the instruction and operands are separated by a
3938      space.  Anything following the operands is a comment.  The label
3939      has already been removed.  */
3940   if (flag_mri)
3941     {
3942       char *s;
3943       int fields = 0;
3944       int infield = 0;
3945       int inquote = 0;
3946
3947       for (s = str; *s != '\0'; s++)
3948         {
3949           if ((*s == ' ' || *s == '\t') && ! inquote)
3950             {
3951               if (infield)
3952                 {
3953                   ++fields;
3954                   if (fields >= 2)
3955                     {
3956                       *s = '\0';
3957                       break;
3958                     }
3959                   infield = 0;
3960                 }
3961             }
3962           else
3963             {
3964               if (! infield)
3965                 infield = 1;
3966               if (*s == '\'')
3967                 inquote = ! inquote;
3968             }
3969         }
3970     }
3971
3972   memset (&the_ins, '\0', sizeof (the_ins));
3973   m68k_ip (str);
3974   er = the_ins.error;
3975   if (!er)
3976     {
3977       for (n = 0; n < the_ins.numargs; n++)
3978         if (the_ins.operands[n].error)
3979           {
3980             er = the_ins.operands[n].error;
3981             break;
3982           }
3983     }
3984   if (er)
3985     {
3986       as_bad (_("%s -- statement `%s' ignored"), er, str);
3987       return;
3988     }
3989
3990   /* If there is a current label, record that it marks an instruction.  */
3991   if (current_label != NULL)
3992     {
3993       current_label->text = 1;
3994       current_label = NULL;
3995     }
3996
3997 #ifdef OBJ_ELF
3998   /* Tie dwarf2 debug info to the address at the start of the insn.  */
3999   dwarf2_emit_insn (0);
4000 #endif
4001
4002   if (the_ins.nfrag == 0)
4003     {
4004       /* No frag hacking involved; just put it out.  */
4005       toP = frag_more (2 * the_ins.numo);
4006       fromP = &the_ins.opcode[0];
4007       for (m = the_ins.numo; m; --m)
4008         {
4009           md_number_to_chars (toP, (long) (*fromP), 2);
4010           toP += 2;
4011           fromP++;
4012         }
4013       /* Put out symbol-dependent info.  */
4014       for (m = 0; m < the_ins.nrel; m++)
4015         {
4016           switch (the_ins.reloc[m].wid)
4017             {
4018             case 'B':
4019               n = 1;
4020               break;
4021             case 'b':
4022               n = 1;
4023               break;
4024             case '3':
4025               n = 1;
4026               break;
4027             case 'w':
4028             case 'W':
4029               n = 2;
4030               break;
4031             case 'l':
4032               n = 4;
4033               break;
4034             default:
4035               as_fatal (_("Don't know how to figure width of %c in md_assemble()"),
4036                         the_ins.reloc[m].wid);
4037             }
4038
4039           fixP = fix_new_exp (frag_now,
4040                               ((toP - frag_now->fr_literal)
4041                                - the_ins.numo * 2 + the_ins.reloc[m].n),
4042                               n,
4043                               &the_ins.reloc[m].exp,
4044                               the_ins.reloc[m].pcrel,
4045                               get_reloc_code (n, the_ins.reloc[m].pcrel,
4046                                               the_ins.reloc[m].pic_reloc));
4047           fixP->fx_pcrel_adjust = the_ins.reloc[m].pcrel_fix;
4048           if (the_ins.reloc[m].wid == 'B')
4049             fixP->fx_signed = 1;
4050         }
4051       return;
4052     }
4053
4054   /* There's some frag hacking.  */
4055   {
4056     /* Calculate the max frag size.  */
4057     int wid;
4058
4059     wid = 2 * the_ins.fragb[0].fragoff;
4060     for (n = 1; n < the_ins.nfrag; n++)
4061       wid += 2 * (the_ins.numo - the_ins.fragb[n - 1].fragoff);
4062     /* frag_var part.  */
4063     wid += 10;
4064     /* Make sure the whole insn fits in one chunk, in particular that
4065        the var part is attached, as we access one byte before the
4066        variable frag for byte branches.  */
4067     frag_grow (wid);
4068   }
4069
4070   for (n = 0, fromP = &the_ins.opcode[0]; n < the_ins.nfrag; n++)
4071     {
4072       int wid;
4073
4074       if (n == 0)
4075         wid = 2 * the_ins.fragb[n].fragoff;
4076       else
4077         wid = 2 * (the_ins.numo - the_ins.fragb[n - 1].fragoff);
4078       toP = frag_more (wid);
4079       to_beg_P = toP;
4080       shorts_this_frag = 0;
4081       for (m = wid / 2; m; --m)
4082         {
4083           md_number_to_chars (toP, (long) (*fromP), 2);
4084           toP += 2;
4085           fromP++;
4086           shorts_this_frag++;
4087         }
4088       for (m = 0; m < the_ins.nrel; m++)
4089         {
4090           if ((the_ins.reloc[m].n) >= 2 * shorts_this_frag)
4091             {
4092               the_ins.reloc[m].n -= 2 * shorts_this_frag;
4093               break;
4094             }
4095           wid = the_ins.reloc[m].wid;
4096           if (wid == 0)
4097             continue;
4098           the_ins.reloc[m].wid = 0;
4099           wid = (wid == 'b') ? 1 : (wid == 'w') ? 2 : (wid == 'l') ? 4 : 4000;
4100
4101           fixP = fix_new_exp (frag_now,
4102                               ((toP - frag_now->fr_literal)
4103                                - the_ins.numo * 2 + the_ins.reloc[m].n),
4104                               wid,
4105                               &the_ins.reloc[m].exp,
4106                               the_ins.reloc[m].pcrel,
4107                               get_reloc_code (wid, the_ins.reloc[m].pcrel,
4108                                               the_ins.reloc[m].pic_reloc));
4109           fixP->fx_pcrel_adjust = the_ins.reloc[m].pcrel_fix;
4110         }
4111       (void) frag_var (rs_machine_dependent, 10, 0,
4112                        (relax_substateT) (the_ins.fragb[n].fragty),
4113                        the_ins.fragb[n].fadd, the_ins.fragb[n].foff, to_beg_P);
4114     }
4115   n = (the_ins.numo - the_ins.fragb[n - 1].fragoff);
4116   shorts_this_frag = 0;
4117   if (n)
4118     {
4119       toP = frag_more (n * 2);
4120       while (n--)
4121         {
4122           md_number_to_chars (toP, (long) (*fromP), 2);
4123           toP += 2;
4124           fromP++;
4125           shorts_this_frag++;
4126         }
4127     }
4128   for (m = 0; m < the_ins.nrel; m++)
4129     {
4130       int wid;
4131
4132       wid = the_ins.reloc[m].wid;
4133       if (wid == 0)
4134         continue;
4135       the_ins.reloc[m].wid = 0;
4136       wid = (wid == 'b') ? 1 : (wid == 'w') ? 2 : (wid == 'l') ? 4 : 4000;
4137
4138       fixP = fix_new_exp (frag_now,
4139                           ((the_ins.reloc[m].n + toP - frag_now->fr_literal)
4140                            - shorts_this_frag * 2),
4141                           wid,
4142                           &the_ins.reloc[m].exp,
4143                           the_ins.reloc[m].pcrel,
4144                           get_reloc_code (wid, the_ins.reloc[m].pcrel,
4145                                           the_ins.reloc[m].pic_reloc));
4146       fixP->fx_pcrel_adjust = the_ins.reloc[m].pcrel_fix;
4147     }
4148 }
4149
4150 /* Comparison function used by qsort to rank the opcode entries by name.  */
4151
4152 static int
4153 m68k_compare_opcode (const void * v1, const void * v2)
4154 {
4155   struct m68k_opcode * op1, * op2;
4156   int ret;
4157
4158   if (v1 == v2)
4159     return 0;
4160
4161   op1 = *(struct m68k_opcode **) v1;
4162   op2 = *(struct m68k_opcode **) v2;
4163
4164   /* Compare the two names.  If different, return the comparison.
4165      If the same, return the order they are in the opcode table.  */
4166   ret = strcmp (op1->name, op2->name);
4167   if (ret)
4168     return ret;
4169   if (op1 < op2)
4170     return -1;
4171   return 1;
4172 }
4173
4174 void
4175 md_begin (void)
4176 {
4177   const struct m68k_opcode *ins;
4178   struct m68k_incant *hack, *slak;
4179   const char *retval = 0;       /* Empty string, or error msg text.  */
4180   int i;
4181
4182   /* Set up hash tables with 68000 instructions.
4183      similar to what the vax assembler does.  */
4184   /* RMS claims the thing to do is take the m68k-opcode.h table, and make
4185      a copy of it at runtime, adding in the information we want but isn't
4186      there.  I think it'd be better to have an awk script hack the table
4187      at compile time.  Or even just xstr the table and use it as-is.  But
4188      my lord ghod hath spoken, so we do it this way.  Excuse the ugly var
4189      names.  */
4190
4191   if (flag_mri)
4192     {
4193       flag_reg_prefix_optional = 1;
4194       m68k_abspcadd = 1;
4195       if (! m68k_rel32_from_cmdline)
4196         m68k_rel32 = 0;
4197     }
4198
4199   /* First sort the opcode table into alphabetical order to seperate
4200      the order that the assembler wants to see the opcodes from the
4201      order that the disassembler wants to see them.  */
4202   m68k_sorted_opcodes = xmalloc (m68k_numopcodes * sizeof (* m68k_sorted_opcodes));
4203   if (!m68k_sorted_opcodes)
4204     as_fatal (_("Internal Error:  Can't allocate m68k_sorted_opcodes of size %d"),
4205               m68k_numopcodes * ((int) sizeof (* m68k_sorted_opcodes)));
4206
4207   for (i = m68k_numopcodes; i--;)
4208     m68k_sorted_opcodes[i] = m68k_opcodes + i;
4209
4210   qsort (m68k_sorted_opcodes, m68k_numopcodes,
4211          sizeof (m68k_sorted_opcodes[0]), m68k_compare_opcode);
4212
4213   op_hash = hash_new ();
4214
4215   obstack_begin (&robyn, 4000);
4216   for (i = 0; i < m68k_numopcodes; i++)
4217     {
4218       hack = slak = (struct m68k_incant *) obstack_alloc (&robyn, sizeof (struct m68k_incant));
4219       do
4220         {
4221           ins = m68k_sorted_opcodes[i];
4222
4223           /* We *could* ignore insns that don't match our
4224              arch here by just leaving them out of the hash.  */
4225           slak->m_operands = ins->args;
4226           slak->m_opnum = strlen (slak->m_operands) / 2;
4227           slak->m_arch = ins->arch;
4228           slak->m_opcode = ins->opcode;
4229           /* This is kludgey.  */
4230           slak->m_codenum = ((ins->match) & 0xffffL) ? 2 : 1;
4231           if (i + 1 != m68k_numopcodes
4232               && !strcmp (ins->name, m68k_sorted_opcodes[i + 1]->name))
4233             {
4234               slak->m_next = obstack_alloc (&robyn, sizeof (struct m68k_incant));
4235               i++;
4236             }
4237           else
4238             slak->m_next = 0;
4239           slak = slak->m_next;
4240         }
4241       while (slak);
4242
4243       retval = hash_insert (op_hash, ins->name, (char *) hack);
4244       if (retval)
4245         as_fatal (_("Internal Error:  Can't hash %s: %s"), ins->name, retval);
4246     }
4247
4248   for (i = 0; i < m68k_numaliases; i++)
4249     {
4250       const char *name = m68k_opcode_aliases[i].primary;
4251       const char *alias = m68k_opcode_aliases[i].alias;
4252       PTR val = hash_find (op_hash, name);
4253
4254       if (!val)
4255         as_fatal (_("Internal Error: Can't find %s in hash table"), name);
4256       retval = hash_insert (op_hash, alias, val);
4257       if (retval)
4258         as_fatal (_("Internal Error: Can't hash %s: %s"), alias, retval);
4259     }
4260
4261   /* In MRI mode, all unsized branches are variable sized.  Normally,
4262      they are word sized.  */
4263   if (flag_mri)
4264     {
4265       static struct m68k_opcode_alias mri_aliases[] =
4266         {
4267           { "bhi",      "jhi", },
4268           { "bls",      "jls", },
4269           { "bcc",      "jcc", },
4270           { "bcs",      "jcs", },
4271           { "bne",      "jne", },
4272           { "beq",      "jeq", },
4273           { "bvc",      "jvc", },
4274           { "bvs",      "jvs", },
4275           { "bpl",      "jpl", },
4276           { "bmi",      "jmi", },
4277           { "bge",      "jge", },
4278           { "blt",      "jlt", },
4279           { "bgt",      "jgt", },
4280           { "ble",      "jle", },
4281           { "bra",      "jra", },
4282           { "bsr",      "jbsr", },
4283         };
4284
4285       for (i = 0;
4286            i < (int) (sizeof mri_aliases / sizeof mri_aliases[0]);
4287            i++)
4288         {
4289           const char *name = mri_aliases[i].primary;
4290           const char *alias = mri_aliases[i].alias;
4291           PTR val = hash_find (op_hash, name);
4292
4293           if (!val)
4294             as_fatal (_("Internal Error: Can't find %s in hash table"), name);
4295           retval = hash_jam (op_hash, alias, val);
4296           if (retval)
4297             as_fatal (_("Internal Error: Can't hash %s: %s"), alias, retval);
4298         }
4299     }
4300
4301   for (i = 0; i < (int) sizeof (notend_table); i++)
4302     {
4303       notend_table[i] = 0;
4304       alt_notend_table[i] = 0;
4305     }
4306
4307   notend_table[','] = 1;
4308   notend_table['{'] = 1;
4309   notend_table['}'] = 1;
4310   alt_notend_table['a'] = 1;
4311   alt_notend_table['A'] = 1;
4312   alt_notend_table['d'] = 1;
4313   alt_notend_table['D'] = 1;
4314   alt_notend_table['#'] = 1;
4315   alt_notend_table['&'] = 1;
4316   alt_notend_table['f'] = 1;
4317   alt_notend_table['F'] = 1;
4318 #ifdef REGISTER_PREFIX
4319   alt_notend_table[REGISTER_PREFIX] = 1;
4320 #endif
4321
4322   /* We need to put '(' in alt_notend_table to handle
4323        cas2 %d0:%d2,%d3:%d4,(%a0):(%a1)  */
4324   alt_notend_table['('] = 1;
4325
4326   /* We need to put '@' in alt_notend_table to handle
4327        cas2 %d0:%d2,%d3:%d4,@(%d0):@(%d1)  */
4328   alt_notend_table['@'] = 1;
4329
4330   /* We need to put digits in alt_notend_table to handle
4331        bfextu %d0{24:1},%d0  */
4332   alt_notend_table['0'] = 1;
4333   alt_notend_table['1'] = 1;
4334   alt_notend_table['2'] = 1;
4335   alt_notend_table['3'] = 1;
4336   alt_notend_table['4'] = 1;
4337   alt_notend_table['5'] = 1;
4338   alt_notend_table['6'] = 1;
4339   alt_notend_table['7'] = 1;
4340   alt_notend_table['8'] = 1;
4341   alt_notend_table['9'] = 1;
4342
4343 #ifndef MIT_SYNTAX_ONLY
4344   /* Insert pseudo ops, these have to go into the opcode table since
4345      gas expects pseudo ops to start with a dot.  */
4346   {
4347     int n = 0;
4348
4349     while (mote_pseudo_table[n].poc_name)
4350       {
4351         hack = obstack_alloc (&robyn, sizeof (struct m68k_incant));
4352         hash_insert (op_hash,
4353                      mote_pseudo_table[n].poc_name, (char *) hack);
4354         hack->m_operands = 0;
4355         hack->m_opnum = n;
4356         n++;
4357       }
4358   }
4359 #endif
4360
4361   init_regtable ();
4362
4363 #ifdef OBJ_ELF
4364   record_alignment (text_section, 2);
4365   record_alignment (data_section, 2);
4366   record_alignment (bss_section, 2);
4367 #endif
4368 }
4369
4370 static void
4371 select_control_regs (void)
4372 {
4373   /* Note which set of "movec" control registers is available.  */
4374   switch (current_chip)
4375     {
4376     case 0:
4377       if (verbose)
4378         as_warn (_("architecture not yet selected: defaulting to 68020"));
4379       control_regs = m68020_control_regs;
4380       break;
4381
4382     case cpu_m68000:
4383       control_regs = m68000_control_regs;
4384       break;
4385     case cpu_m68010:
4386       control_regs = m68010_control_regs;
4387       break;
4388     case cpu_m68020:
4389     case cpu_m68030:
4390       control_regs = m68020_control_regs;
4391       break;
4392     case cpu_m68040:
4393       control_regs = m68040_control_regs;
4394       break;
4395     case cpu_m68060:
4396       control_regs = m68060_control_regs;
4397       break;
4398     case cpu_cpu32:
4399       control_regs = cpu32_control_regs;
4400       break;
4401     case cpu_cf5200:
4402     case cpu_cf5206e:
4403     case cpu_cf5307:
4404     case cpu_cf5407:
4405       control_regs = mcf_control_regs;
4406       break;
4407     case cpu_cf5249:
4408       control_regs = mcf5249_control_regs;
4409       break;
4410     case cpu_cf528x:
4411     case cpu_cf521x:
4412       control_regs = mcf528x_control_regs;
4413       break;
4414     case cpu_cf547x:
4415     case cpu_cf548x:
4416       control_regs = mcfv4e_control_regs;
4417       break;
4418     case cpu_cf5208:
4419       control_regs = mcf5208_control_regs;
4420       break;
4421     case cpu_cf5213:
4422       control_regs = mcf5213_control_regs;
4423       break;
4424     case cpu_cf5329:
4425       control_regs = mcf5329_control_regs;
4426       break;
4427     default:
4428       abort ();
4429     }
4430 }
4431
4432 \f
4433 /* This is called when a label is defined.  */
4434
4435 void
4436 m68k_frob_label (symbolS *sym)
4437 {
4438   struct label_line *n;
4439
4440   n = (struct label_line *) xmalloc (sizeof *n);
4441   n->next = labels;
4442   n->label = sym;
4443   as_where (&n->file, &n->line);
4444   n->text = 0;
4445   labels = n;
4446   current_label = n;
4447
4448 #ifdef OBJ_ELF
4449   dwarf2_emit_label (sym);
4450 #endif
4451 }
4452
4453 /* This is called when a value that is not an instruction is emitted.  */
4454
4455 void
4456 m68k_flush_pending_output (void)
4457 {
4458   current_label = NULL;
4459 }
4460
4461 /* This is called at the end of the assembly, when the final value of
4462    the label is known.  We warn if this is a text symbol aligned at an
4463    odd location.  */
4464
4465 void
4466 m68k_frob_symbol (symbolS *sym)
4467 {
4468   if (S_GET_SEGMENT (sym) == reg_section
4469       && (int) S_GET_VALUE (sym) < 0)
4470     {
4471       S_SET_SEGMENT (sym, absolute_section);
4472       S_SET_VALUE (sym, ~(int)S_GET_VALUE (sym));
4473     }
4474   else if ((S_GET_VALUE (sym) & 1) != 0)
4475     {
4476       struct label_line *l;
4477
4478       for (l = labels; l != NULL; l = l->next)
4479         {
4480           if (l->label == sym)
4481             {
4482               if (l->text)
4483                 as_warn_where (l->file, l->line,
4484                                _("text label `%s' aligned to odd boundary"),
4485                                S_GET_NAME (sym));
4486               break;
4487             }
4488         }
4489     }
4490 }
4491 \f
4492 /* This is called if we go in or out of MRI mode because of the .mri
4493    pseudo-op.  */
4494
4495 void
4496 m68k_mri_mode_change (int on)
4497 {
4498   if (on)
4499     {
4500       if (! flag_reg_prefix_optional)
4501         {
4502           flag_reg_prefix_optional = 1;
4503 #ifdef REGISTER_PREFIX
4504           init_regtable ();
4505 #endif
4506         }
4507       m68k_abspcadd = 1;
4508       if (! m68k_rel32_from_cmdline)
4509         m68k_rel32 = 0;
4510     }
4511   else
4512     {
4513       if (! reg_prefix_optional_seen)
4514         {
4515 #ifdef REGISTER_PREFIX_OPTIONAL
4516           flag_reg_prefix_optional = REGISTER_PREFIX_OPTIONAL;
4517 #else
4518           flag_reg_prefix_optional = 0;
4519 #endif
4520 #ifdef REGISTER_PREFIX
4521           init_regtable ();
4522 #endif
4523         }
4524       m68k_abspcadd = 0;
4525       if (! m68k_rel32_from_cmdline)
4526         m68k_rel32 = 1;
4527     }
4528 }
4529
4530 /* Equal to MAX_PRECISION in atof-ieee.c.  */
4531 #define MAX_LITTLENUMS 6
4532
4533 /* Turn a string in input_line_pointer into a floating point constant
4534    of type TYPE, and store the appropriate bytes in *LITP.  The number
4535    of LITTLENUMS emitted is stored in *SIZEP.  An error message is
4536    returned, or NULL on OK.  */
4537
4538 char *
4539 md_atof (int type, char *litP, int *sizeP)
4540 {
4541   int prec;
4542   LITTLENUM_TYPE words[MAX_LITTLENUMS];
4543   LITTLENUM_TYPE *wordP;
4544   char *t;
4545
4546   switch (type)
4547     {
4548     case 'f':
4549     case 'F':
4550     case 's':
4551     case 'S':
4552       prec = 2;
4553       break;
4554
4555     case 'd':
4556     case 'D':
4557     case 'r':
4558     case 'R':
4559       prec = 4;
4560       break;
4561
4562     case 'x':
4563     case 'X':
4564       prec = 6;
4565       break;
4566
4567     case 'p':
4568     case 'P':
4569       prec = 6;
4570       break;
4571
4572     default:
4573       *sizeP = 0;
4574       return _("Bad call to MD_ATOF()");
4575     }
4576   t = atof_ieee (input_line_pointer, type, words);
4577   if (t)
4578     input_line_pointer = t;
4579
4580   *sizeP = prec * sizeof (LITTLENUM_TYPE);
4581   for (wordP = words; prec--;)
4582     {
4583       md_number_to_chars (litP, (long) (*wordP++), sizeof (LITTLENUM_TYPE));
4584       litP += sizeof (LITTLENUM_TYPE);
4585     }
4586   return 0;
4587 }
4588
4589 void
4590 md_number_to_chars (char *buf, valueT val, int n)
4591 {
4592   number_to_chars_bigendian (buf, val, n);
4593 }
4594
4595 void
4596 md_apply_fix (fixS *fixP, valueT *valP, segT seg ATTRIBUTE_UNUSED)
4597 {
4598   offsetT val = *valP;
4599   addressT upper_limit;
4600   offsetT lower_limit;
4601
4602   /* This is unnecessary but it convinces the native rs6000 compiler
4603      to generate the code we want.  */
4604   char *buf = fixP->fx_frag->fr_literal;
4605   buf += fixP->fx_where;
4606   /* End ibm compiler workaround.  */
4607
4608   val = SEXT (val);
4609
4610   if (fixP->fx_addsy == NULL && fixP->fx_pcrel == 0)
4611     fixP->fx_done = 1;
4612
4613 #ifdef OBJ_ELF
4614   if (fixP->fx_addsy)
4615     {
4616       memset (buf, 0, fixP->fx_size);
4617       fixP->fx_addnumber = val; /* Remember value for emit_reloc.  */
4618
4619       if (fixP->fx_r_type == BFD_RELOC_VTABLE_INHERIT
4620           && !S_IS_DEFINED (fixP->fx_addsy)
4621           && !S_IS_WEAK (fixP->fx_addsy))
4622         S_SET_WEAK (fixP->fx_addsy);
4623       return;
4624     }
4625 #endif
4626
4627   if (fixP->fx_r_type == BFD_RELOC_VTABLE_INHERIT
4628       || fixP->fx_r_type == BFD_RELOC_VTABLE_ENTRY)
4629     return;
4630
4631   switch (fixP->fx_size)
4632     {
4633       /* The cast to offsetT below are necessary to make code
4634          correct for machines where ints are smaller than offsetT.  */
4635     case 1:
4636       *buf++ = val;
4637       upper_limit = 0x7f;
4638       lower_limit = - (offsetT) 0x80;
4639       break;
4640     case 2:
4641       *buf++ = (val >> 8);
4642       *buf++ = val;
4643       upper_limit = 0x7fff;
4644       lower_limit = - (offsetT) 0x8000;
4645       break;
4646     case 4:
4647       *buf++ = (val >> 24);
4648       *buf++ = (val >> 16);
4649       *buf++ = (val >> 8);
4650       *buf++ = val;
4651       upper_limit = 0x7fffffff;
4652       lower_limit = - (offsetT) 0x7fffffff - 1; /* Avoid constant overflow.  */
4653       break;
4654     default:
4655       BAD_CASE (fixP->fx_size);
4656     }
4657
4658   /* Fix up a negative reloc.  */
4659   if (fixP->fx_addsy == NULL && fixP->fx_subsy != NULL)
4660     {
4661       fixP->fx_addsy = fixP->fx_subsy;
4662       fixP->fx_subsy = NULL;
4663       fixP->fx_tcbit = 1;
4664     }
4665
4666   /* For non-pc-relative values, it's conceivable we might get something
4667      like "0xff" for a byte field.  So extend the upper part of the range
4668      to accept such numbers.  We arbitrarily disallow "-0xff" or "0xff+0xff",
4669      so that we can do any range checking at all.  */
4670   if (! fixP->fx_pcrel && ! fixP->fx_signed)
4671     upper_limit = upper_limit * 2 + 1;
4672
4673   if ((addressT) val > upper_limit
4674       && (val > 0 || val < lower_limit))
4675     as_bad_where (fixP->fx_file, fixP->fx_line, _("value out of range"));
4676
4677   /* A one byte PC-relative reloc means a short branch.  We can't use
4678      a short branch with a value of 0 or -1, because those indicate
4679      different opcodes (branches with longer offsets).  fixup_segment
4680      in write.c may have clobbered fx_pcrel, so we need to examine the
4681      reloc type.  */
4682   if ((fixP->fx_pcrel
4683        || fixP->fx_r_type == BFD_RELOC_8_PCREL)
4684       && fixP->fx_size == 1
4685       && (fixP->fx_addsy == NULL
4686           || S_IS_DEFINED (fixP->fx_addsy))
4687       && (val == 0 || val == -1))
4688     as_bad_where (fixP->fx_file, fixP->fx_line, _("invalid byte branch offset"));
4689 }
4690
4691 /* *fragP has been relaxed to its final size, and now needs to have
4692    the bytes inside it modified to conform to the new size  There is UGLY
4693    MAGIC here. ..
4694    */
4695 static void
4696 md_convert_frag_1 (fragS *fragP)
4697 {
4698   long disp;
4699   fixS *fixP;
4700
4701   /* Address in object code of the displacement.  */
4702   register int object_address = fragP->fr_fix + fragP->fr_address;
4703
4704   /* Address in gas core of the place to store the displacement.  */
4705   /* This convinces the native rs6000 compiler to generate the code we
4706      want.  */
4707   register char *buffer_address = fragP->fr_literal;
4708   buffer_address += fragP->fr_fix;
4709   /* End ibm compiler workaround.  */
4710
4711   /* The displacement of the address, from current location.  */
4712   disp = fragP->fr_symbol ? S_GET_VALUE (fragP->fr_symbol) : 0;
4713   disp = (disp + fragP->fr_offset) - object_address;
4714
4715   switch (fragP->fr_subtype)
4716     {
4717     case TAB (BRANCHBWL, BYTE):
4718     case TAB (BRABSJUNC, BYTE):
4719     case TAB (BRABSJCOND, BYTE):
4720     case TAB (BRANCHBW, BYTE):
4721       know (issbyte (disp));
4722       if (disp == 0)
4723         as_bad_where (fragP->fr_file, fragP->fr_line,
4724                       _("short branch with zero offset: use :w"));
4725       fixP = fix_new (fragP, fragP->fr_fix - 1, 1, fragP->fr_symbol,
4726                       fragP->fr_offset, 1, RELAX_RELOC_PC8);
4727       fixP->fx_pcrel_adjust = -1;
4728       break;
4729     case TAB (BRANCHBWL, SHORT):
4730     case TAB (BRABSJUNC, SHORT):
4731     case TAB (BRABSJCOND, SHORT):
4732     case TAB (BRANCHBW, SHORT):
4733       fragP->fr_opcode[1] = 0x00;
4734       fix_new (fragP, fragP->fr_fix, 2, fragP->fr_symbol, fragP->fr_offset,
4735                1, RELAX_RELOC_PC16);
4736       fragP->fr_fix += 2;
4737       break;
4738     case TAB (BRANCHBWL, LONG):
4739       fragP->fr_opcode[1] = (char) 0xFF;
4740       fix_new (fragP, fragP->fr_fix, 4, fragP->fr_symbol, fragP->fr_offset,
4741                1, RELAX_RELOC_PC32);
4742       fragP->fr_fix += 4;
4743       break;
4744     case TAB (BRABSJUNC, LONG):
4745       if (fragP->fr_opcode[0] == 0x61)          /* jbsr */
4746         {
4747           if (flag_keep_pcrel)
4748             as_fatal (_("Tried to convert PC relative BSR to absolute JSR"));
4749           fragP->fr_opcode[0] = 0x4E;
4750           fragP->fr_opcode[1] = (char) 0xB9; /* JSR with ABSL LONG operand.  */
4751           fix_new (fragP, fragP->fr_fix, 4, fragP->fr_symbol, fragP->fr_offset,
4752                    0, RELAX_RELOC_ABS32);
4753           fragP->fr_fix += 4;
4754         }
4755       else if (fragP->fr_opcode[0] == 0x60)     /* jbra */
4756         {
4757           if (flag_keep_pcrel)
4758             as_fatal (_("Tried to convert PC relative branch to absolute jump"));
4759           fragP->fr_opcode[0] = 0x4E;
4760           fragP->fr_opcode[1] = (char) 0xF9; /* JMP with ABSL LONG operand.  */
4761           fix_new (fragP, fragP->fr_fix, 4, fragP->fr_symbol, fragP->fr_offset,
4762                    0, RELAX_RELOC_ABS32);
4763           fragP->fr_fix += 4;
4764         }
4765       else
4766         {
4767           /* This cannot happen, because jbsr and jbra are the only two
4768              unconditional branches.  */
4769           abort ();
4770         }
4771       break;
4772     case TAB (BRABSJCOND, LONG):
4773       if (flag_keep_pcrel)
4774         as_fatal (_("Tried to convert PC relative conditional branch to absolute jump"));
4775
4776       /* Only Bcc 68000 instructions can come here
4777          Change bcc into b!cc/jmp absl long.  */
4778       fragP->fr_opcode[0] ^= 0x01;      /* Invert bcc.  */
4779       fragP->fr_opcode[1]  = 0x06;      /* Branch offset = 6.  */
4780
4781       /* JF: these used to be fr_opcode[2,3], but they may be in a
4782            different frag, in which case referring to them is a no-no.
4783            Only fr_opcode[0,1] are guaranteed to work.  */
4784       *buffer_address++ = 0x4e; /* put in jmp long (0x4ef9) */
4785       *buffer_address++ = (char) 0xf9;
4786       fragP->fr_fix += 2;       /* Account for jmp instruction.  */
4787       fix_new (fragP, fragP->fr_fix, 4, fragP->fr_symbol,
4788                fragP->fr_offset, 0, RELAX_RELOC_ABS32);
4789       fragP->fr_fix += 4;
4790       break;
4791     case TAB (FBRANCH, SHORT):
4792       know ((fragP->fr_opcode[1] & 0x40) == 0);
4793       fix_new (fragP, fragP->fr_fix, 2, fragP->fr_symbol, fragP->fr_offset,
4794                1, RELAX_RELOC_PC16);
4795       fragP->fr_fix += 2;
4796       break;
4797     case TAB (FBRANCH, LONG):
4798       fragP->fr_opcode[1] |= 0x40;      /* Turn on LONG bit.  */
4799       fix_new (fragP, fragP->fr_fix, 4, fragP->fr_symbol, fragP->fr_offset,
4800                1, RELAX_RELOC_PC32);
4801       fragP->fr_fix += 4;
4802       break;
4803     case TAB (DBCCLBR, SHORT):
4804     case TAB (DBCCABSJ, SHORT):
4805       fix_new (fragP, fragP->fr_fix, 2, fragP->fr_symbol, fragP->fr_offset,
4806                1, RELAX_RELOC_PC16);
4807       fragP->fr_fix += 2;
4808       break;
4809     case TAB (DBCCLBR, LONG):
4810       /* Only DBcc instructions can come here.
4811          Change dbcc into dbcc/bral.
4812          JF: these used to be fr_opcode[2-7], but that's wrong.  */
4813       if (flag_keep_pcrel)
4814         as_fatal (_("Tried to convert DBcc to absolute jump"));
4815
4816       *buffer_address++ = 0x00; /* Branch offset = 4.  */
4817       *buffer_address++ = 0x04;
4818       *buffer_address++ = 0x60; /* Put in bra pc+6.  */
4819       *buffer_address++ = 0x06;
4820       *buffer_address++ = 0x60;     /* Put in bral (0x60ff).  */
4821       *buffer_address++ = (char) 0xff;
4822
4823       fragP->fr_fix += 6;       /* Account for bra/jmp instructions.  */
4824       fix_new (fragP, fragP->fr_fix, 4, fragP->fr_symbol, fragP->fr_offset, 1,
4825                RELAX_RELOC_PC32);
4826       fragP->fr_fix += 4;
4827       break;
4828     case TAB (DBCCABSJ, LONG):
4829       /* Only DBcc instructions can come here.
4830          Change dbcc into dbcc/jmp.
4831          JF: these used to be fr_opcode[2-7], but that's wrong.  */
4832       if (flag_keep_pcrel)
4833         as_fatal (_("Tried to convert PC relative conditional branch to absolute jump"));
4834
4835       *buffer_address++ = 0x00;         /* Branch offset = 4.  */
4836       *buffer_address++ = 0x04;
4837       *buffer_address++ = 0x60;         /* Put in bra pc + 6.  */
4838       *buffer_address++ = 0x06;
4839       *buffer_address++ = 0x4e;         /* Put in jmp long (0x4ef9).  */
4840       *buffer_address++ = (char) 0xf9;
4841
4842       fragP->fr_fix += 6;               /* Account for bra/jmp instructions.  */
4843       fix_new (fragP, fragP->fr_fix, 4, fragP->fr_symbol, fragP->fr_offset, 0,
4844                RELAX_RELOC_ABS32);
4845       fragP->fr_fix += 4;
4846       break;
4847     case TAB (PCREL1632, SHORT):
4848       fragP->fr_opcode[1] &= ~0x3F;
4849       fragP->fr_opcode[1] |= 0x3A; /* 072 - mode 7.2 */
4850       fix_new (fragP, (int) (fragP->fr_fix), 2, fragP->fr_symbol,
4851                fragP->fr_offset, 1, RELAX_RELOC_PC16);
4852       fragP->fr_fix += 2;
4853       break;
4854     case TAB (PCREL1632, LONG):
4855       /* Already set to mode 7.3; this indicates: PC indirect with
4856          suppressed index, 32-bit displacement.  */
4857       *buffer_address++ = 0x01;
4858       *buffer_address++ = 0x70;
4859       fragP->fr_fix += 2;
4860       fixP = fix_new (fragP, (int) (fragP->fr_fix), 4, fragP->fr_symbol,
4861                       fragP->fr_offset, 1, RELAX_RELOC_PC32);
4862       fixP->fx_pcrel_adjust = 2;
4863       fragP->fr_fix += 4;
4864       break;
4865     case TAB (PCINDEX, BYTE):
4866       assert (fragP->fr_fix >= 2);
4867       buffer_address[-2] &= ~1;
4868       fixP = fix_new (fragP, fragP->fr_fix - 1, 1, fragP->fr_symbol,
4869                       fragP->fr_offset, 1, RELAX_RELOC_PC8);
4870       fixP->fx_pcrel_adjust = 1;
4871       break;
4872     case TAB (PCINDEX, SHORT):
4873       assert (fragP->fr_fix >= 2);
4874       buffer_address[-2] |= 0x1;
4875       buffer_address[-1] = 0x20;
4876       fixP = fix_new (fragP, (int) (fragP->fr_fix), 2, fragP->fr_symbol,
4877                       fragP->fr_offset, 1, RELAX_RELOC_PC16);
4878       fixP->fx_pcrel_adjust = 2;
4879       fragP->fr_fix += 2;
4880       break;
4881     case TAB (PCINDEX, LONG):
4882       assert (fragP->fr_fix >= 2);
4883       buffer_address[-2] |= 0x1;
4884       buffer_address[-1] = 0x30;
4885       fixP = fix_new (fragP, (int) (fragP->fr_fix), 4, fragP->fr_symbol,
4886                       fragP->fr_offset, 1, RELAX_RELOC_PC32);
4887       fixP->fx_pcrel_adjust = 2;
4888       fragP->fr_fix += 4;
4889       break;
4890     case TAB (ABSTOPCREL, SHORT):
4891       fix_new (fragP, fragP->fr_fix, 2, fragP->fr_symbol, fragP->fr_offset,
4892                1, RELAX_RELOC_PC16);
4893       fragP->fr_fix += 2;
4894       break;
4895     case TAB (ABSTOPCREL, LONG):
4896       if (flag_keep_pcrel)
4897         as_fatal (_("Tried to convert PC relative conditional branch to absolute jump"));
4898       /* The thing to do here is force it to ABSOLUTE LONG, since
4899          ABSTOPCREL is really trying to shorten an ABSOLUTE address anyway.  */
4900       if ((fragP->fr_opcode[1] & 0x3F) != 0x3A)
4901         abort ();
4902       fragP->fr_opcode[1] &= ~0x3F;
4903       fragP->fr_opcode[1] |= 0x39;      /* Mode 7.1 */
4904       fix_new (fragP, fragP->fr_fix, 4, fragP->fr_symbol, fragP->fr_offset,
4905                0, RELAX_RELOC_ABS32);
4906       fragP->fr_fix += 4;
4907       break;
4908     }
4909 }
4910
4911 void
4912 md_convert_frag (bfd *abfd ATTRIBUTE_UNUSED,
4913                  segT sec ATTRIBUTE_UNUSED,
4914                  fragS *fragP)
4915 {
4916   md_convert_frag_1 (fragP);
4917 }
4918
4919 /* Force truly undefined symbols to their maximum size, and generally set up
4920    the frag list to be relaxed
4921    */
4922 int
4923 md_estimate_size_before_relax (fragS *fragP, segT segment)
4924 {
4925   /* Handle SZ_UNDEF first, it can be changed to BYTE or SHORT.  */
4926   switch (fragP->fr_subtype)
4927     {
4928     case TAB (BRANCHBWL, SZ_UNDEF):
4929     case TAB (BRABSJUNC, SZ_UNDEF):
4930     case TAB (BRABSJCOND, SZ_UNDEF):
4931       {
4932         if (S_GET_SEGMENT (fragP->fr_symbol) == segment
4933             && relaxable_symbol (fragP->fr_symbol))
4934           {
4935             fragP->fr_subtype = TAB (TABTYPE (fragP->fr_subtype), BYTE);
4936           }
4937         else if (flag_short_refs)
4938           {
4939             /* Symbol is undefined and we want short ref.  */
4940             fragP->fr_subtype = TAB (TABTYPE (fragP->fr_subtype), SHORT);
4941           }
4942         else
4943           {
4944             /* Symbol is still undefined.  Make it LONG.  */
4945             fragP->fr_subtype = TAB (TABTYPE (fragP->fr_subtype), LONG);
4946           }
4947         break;
4948       }
4949
4950     case TAB (BRANCHBW, SZ_UNDEF):
4951       {
4952         if (S_GET_SEGMENT (fragP->fr_symbol) == segment
4953             && relaxable_symbol (fragP->fr_symbol))
4954           {
4955             fragP->fr_subtype = TAB (TABTYPE (fragP->fr_subtype), BYTE);
4956           }
4957         else
4958           {
4959             /* Symbol is undefined and we don't have long branches.  */
4960             fragP->fr_subtype = TAB (TABTYPE (fragP->fr_subtype), SHORT);
4961           }
4962         break;
4963       }
4964
4965     case TAB (FBRANCH, SZ_UNDEF):
4966     case TAB (DBCCLBR, SZ_UNDEF):
4967     case TAB (DBCCABSJ, SZ_UNDEF):
4968     case TAB (PCREL1632, SZ_UNDEF):
4969       {
4970         if ((S_GET_SEGMENT (fragP->fr_symbol) == segment
4971              && relaxable_symbol (fragP->fr_symbol))
4972             || flag_short_refs)
4973           {
4974             fragP->fr_subtype = TAB (TABTYPE (fragP->fr_subtype), SHORT);
4975           }
4976         else
4977           {
4978             fragP->fr_subtype = TAB (TABTYPE (fragP->fr_subtype), LONG);
4979           }
4980         break;
4981       }
4982
4983     case TAB (PCINDEX, SZ_UNDEF):
4984       if ((S_GET_SEGMENT (fragP->fr_symbol) == segment
4985            && relaxable_symbol (fragP->fr_symbol)))
4986         {
4987           fragP->fr_subtype = TAB (PCINDEX, BYTE);
4988         }
4989       else
4990         {
4991           fragP->fr_subtype = TAB (PCINDEX, LONG);
4992         }
4993       break;
4994
4995     case TAB (ABSTOPCREL, SZ_UNDEF):
4996       {
4997         if ((S_GET_SEGMENT (fragP->fr_symbol) == segment
4998              && relaxable_symbol (fragP->fr_symbol)))
4999           {
5000             fragP->fr_subtype = TAB (ABSTOPCREL, SHORT);
5001           }
5002         else
5003           {
5004             fragP->fr_subtype = TAB (ABSTOPCREL, LONG);
5005           }
5006         break;
5007       }
5008
5009     default:
5010       break;
5011     }
5012
5013   /* Now that SZ_UNDEF are taken care of, check others.  */
5014   switch (fragP->fr_subtype)
5015     {
5016     case TAB (BRANCHBWL, BYTE):
5017     case TAB (BRABSJUNC, BYTE):
5018     case TAB (BRABSJCOND, BYTE):
5019     case TAB (BRANCHBW, BYTE):
5020       /* We can't do a short jump to the next instruction, so in that
5021          case we force word mode.  If the symbol is at the start of a
5022          frag, and it is the next frag with any data in it (usually
5023          this is just the next frag, but assembler listings may
5024          introduce empty frags), we must use word mode.  */
5025       if (fragP->fr_symbol)
5026         {
5027           fragS *sym_frag;
5028
5029           sym_frag = symbol_get_frag (fragP->fr_symbol);
5030           if (S_GET_VALUE (fragP->fr_symbol) == sym_frag->fr_address)
5031             {
5032               fragS *l;
5033
5034               for (l = fragP->fr_next; l && l != sym_frag; l = l->fr_next)
5035                 if (l->fr_fix != 0)
5036                   break;
5037               if (l == sym_frag)
5038                 fragP->fr_subtype = TAB (TABTYPE (fragP->fr_subtype), SHORT);
5039             }
5040         }
5041       break;
5042     default:
5043       break;
5044     }
5045   return md_relax_table[fragP->fr_subtype].rlx_length;
5046 }
5047
5048 #if defined(OBJ_AOUT) | defined(OBJ_BOUT)
5049 /* the bit-field entries in the relocation_info struct plays hell
5050    with the byte-order problems of cross-assembly.  So as a hack,
5051    I added this mach. dependent ri twiddler.  Ugly, but it gets
5052    you there. -KWK  */
5053 /* on m68k: first 4 bytes are normal unsigned long, next three bytes
5054    are symbolnum, most sig. byte first.  Last byte is broken up with
5055    bit 7 as pcrel, bits 6 & 5 as length, bit 4 as pcrel, and the lower
5056    nibble as nuthin. (on Sun 3 at least) */
5057 /* Translate the internal relocation information into target-specific
5058    format.  */
5059 #ifdef comment
5060 void
5061 md_ri_to_chars (char *the_bytes, struct reloc_info_generic *ri)
5062 {
5063   /* This is easy.  */
5064   md_number_to_chars (the_bytes, ri->r_address, 4);
5065   /* Now the fun stuff.  */
5066   the_bytes[4] = (ri->r_symbolnum >> 16) & 0x0ff;
5067   the_bytes[5] = (ri->r_symbolnum >>  8) & 0x0ff;
5068   the_bytes[6] =  ri->r_symbolnum        & 0x0ff;
5069   the_bytes[7] = (((ri->r_pcrel << 7) & 0x80)
5070                   | ((ri->r_length << 5) & 0x60)
5071                   | ((ri->r_extern << 4) & 0x10));
5072 }
5073
5074 #endif
5075
5076 #endif /* OBJ_AOUT or OBJ_BOUT */
5077
5078 #ifndef WORKING_DOT_WORD
5079 int md_short_jump_size = 4;
5080 int md_long_jump_size = 6;
5081
5082 void
5083 md_create_short_jump (char *ptr, addressT from_addr, addressT to_addr,
5084                       fragS *frag ATTRIBUTE_UNUSED,
5085                       symbolS *to_symbol ATTRIBUTE_UNUSED)
5086 {
5087   valueT offset;
5088
5089   offset = to_addr - (from_addr + 2);
5090
5091   md_number_to_chars (ptr, (valueT) 0x6000, 2);
5092   md_number_to_chars (ptr + 2, (valueT) offset, 2);
5093 }
5094
5095 void
5096 md_create_long_jump (char *ptr, addressT from_addr, addressT to_addr,
5097                      fragS *frag, symbolS *to_symbol)
5098 {
5099   valueT offset;
5100
5101   if (!HAVE_LONG_BRANCH (current_architecture))
5102     {
5103       if (flag_keep_pcrel)
5104         as_fatal (_("Tried to convert PC relative branch to absolute jump"));
5105       offset = to_addr - S_GET_VALUE (to_symbol);
5106       md_number_to_chars (ptr, (valueT) 0x4EF9, 2);
5107       md_number_to_chars (ptr + 2, (valueT) offset, 4);
5108       fix_new (frag, (ptr + 2) - frag->fr_literal, 4, to_symbol, (offsetT) 0,
5109                0, NO_RELOC);
5110     }
5111   else
5112     {
5113       offset = to_addr - (from_addr + 2);
5114       md_number_to_chars (ptr, (valueT) 0x60ff, 2);
5115       md_number_to_chars (ptr + 2, (valueT) offset, 4);
5116     }
5117 }
5118
5119 #endif
5120
5121 /* Different values of OK tell what its OK to return.  Things that
5122    aren't OK are an error (what a shock, no?)
5123
5124    0:  Everything is OK
5125    10:  Absolute 1:8       only
5126    20:  Absolute 0:7       only
5127    30:  absolute 0:15      only
5128    40:  Absolute 0:31      only
5129    50:  absolute 0:127     only
5130    55:  absolute -64:63    only
5131    60:  absolute -128:127  only
5132    70:  absolute 0:4095    only
5133    80:  absolute -1, 1:7   only
5134    90:  No bignums.          */
5135
5136 static int
5137 get_num (struct m68k_exp *exp, int ok)
5138 {
5139   if (exp->exp.X_op == O_absent)
5140     {
5141       /* Do the same thing the VAX asm does.  */
5142       op (exp) = O_constant;
5143       adds (exp) = 0;
5144       subs (exp) = 0;
5145       offs (exp) = 0;
5146       if (ok == 10)
5147         {
5148           as_warn (_("expression out of range: defaulting to 1"));
5149           offs (exp) = 1;
5150         }
5151     }
5152   else if (exp->exp.X_op == O_constant)
5153     {
5154       switch (ok)
5155         {
5156         case 10:
5157           if ((valueT) TRUNC (offs (exp)) - 1 > 7)
5158             {
5159               as_warn (_("expression out of range: defaulting to 1"));
5160               offs (exp) = 1;
5161             }
5162           break;
5163         case 20:
5164           if ((valueT) TRUNC (offs (exp)) > 7)
5165             goto outrange;
5166           break;
5167         case 30:
5168           if ((valueT) TRUNC (offs (exp)) > 15)
5169             goto outrange;
5170           break;
5171         case 40:
5172           if ((valueT) TRUNC (offs (exp)) > 32)
5173             goto outrange;
5174           break;
5175         case 50:
5176           if ((valueT) TRUNC (offs (exp)) > 127)
5177             goto outrange;
5178           break;
5179         case 55:
5180           if ((valueT) SEXT (offs (exp)) + 64 > 127)
5181             goto outrange;
5182           break;
5183         case 60:
5184           if ((valueT) SEXT (offs (exp)) + 128 > 255)
5185             goto outrange;
5186           break;
5187         case 70:
5188           if ((valueT) TRUNC (offs (exp)) > 4095)
5189             {
5190             outrange:
5191               as_warn (_("expression out of range: defaulting to 0"));
5192               offs (exp) = 0;
5193             }
5194           break;
5195         case 80:
5196           if ((valueT) TRUNC (offs (exp)) != 0xffffffff
5197               && (valueT) TRUNC (offs (exp)) - 1 > 6)
5198             {
5199               as_warn (_("expression out of range: defaulting to 1"));
5200               offs (exp) = 1;
5201             }
5202           break;
5203         default:
5204           break;
5205         }
5206     }
5207   else if (exp->exp.X_op == O_big)
5208     {
5209       if (offs (exp) <= 0       /* flonum.  */
5210           && (ok == 90          /* no bignums */
5211               || (ok > 10       /* Small-int ranges including 0 ok.  */
5212                   /* If we have a flonum zero, a zero integer should
5213                      do as well (e.g., in moveq).  */
5214                   && generic_floating_point_number.exponent == 0
5215                   && generic_floating_point_number.low[0] == 0)))
5216         {
5217           /* HACK! Turn it into a long.  */
5218           LITTLENUM_TYPE words[6];
5219
5220           gen_to_words (words, 2, 8L);  /* These numbers are magic!  */
5221           op (exp) = O_constant;
5222           adds (exp) = 0;
5223           subs (exp) = 0;
5224           offs (exp) = words[1] | (words[0] << 16);
5225         }
5226       else if (ok != 0)
5227         {
5228           op (exp) = O_constant;
5229           adds (exp) = 0;
5230           subs (exp) = 0;
5231           offs (exp) = (ok == 10) ? 1 : 0;
5232           as_warn (_("Can't deal with expression; defaulting to %ld"),
5233                    (long) offs (exp));
5234         }
5235     }
5236   else
5237     {
5238       if (ok >= 10 && ok <= 80)
5239         {
5240           op (exp) = O_constant;
5241           adds (exp) = 0;
5242           subs (exp) = 0;
5243           offs (exp) = (ok == 10) ? 1 : 0;
5244           as_warn (_("Can't deal with expression; defaulting to %ld"),
5245                    (long) offs (exp));
5246         }
5247     }
5248
5249   if (exp->size != SIZE_UNSPEC)
5250     {
5251       switch (exp->size)
5252         {
5253         case SIZE_UNSPEC:
5254         case SIZE_LONG:
5255           break;
5256         case SIZE_BYTE:
5257           if (!isbyte (offs (exp)))
5258             as_warn (_("expression doesn't fit in BYTE"));
5259           break;
5260         case SIZE_WORD:
5261           if (!isword (offs (exp)))
5262             as_warn (_("expression doesn't fit in WORD"));
5263           break;
5264         }
5265     }
5266
5267   return offs (exp);
5268 }
5269
5270 /* These are the back-ends for the various machine dependent pseudo-ops.  */
5271
5272 static void
5273 s_data1 (int ignore ATTRIBUTE_UNUSED)
5274 {
5275   subseg_set (data_section, 1);
5276   demand_empty_rest_of_line ();
5277 }
5278
5279 static void
5280 s_data2 (int ignore ATTRIBUTE_UNUSED)
5281 {
5282   subseg_set (data_section, 2);
5283   demand_empty_rest_of_line ();
5284 }
5285
5286 static void
5287 s_bss (int ignore ATTRIBUTE_UNUSED)
5288 {
5289   /* We don't support putting frags in the BSS segment, we fake it
5290      by marking in_bss, then looking at s_skip for clues.  */
5291
5292   subseg_set (bss_section, 0);
5293   demand_empty_rest_of_line ();
5294 }
5295
5296 static void
5297 s_even (int ignore ATTRIBUTE_UNUSED)
5298 {
5299   register int temp;
5300   register long temp_fill;
5301
5302   temp = 1;                     /* JF should be 2? */
5303   temp_fill = get_absolute_expression ();
5304   if (!need_pass_2)             /* Never make frag if expect extra pass.  */
5305     frag_align (temp, (int) temp_fill, 0);
5306   demand_empty_rest_of_line ();
5307   record_alignment (now_seg, temp);
5308 }
5309
5310 static void
5311 s_proc (int ignore ATTRIBUTE_UNUSED)
5312 {
5313   demand_empty_rest_of_line ();
5314 }
5315 \f
5316 /* Pseudo-ops handled for MRI compatibility.  */
5317
5318 /* This function returns non-zero if the argument is a conditional
5319    pseudo-op.  This is called when checking whether a pending
5320    alignment is needed.  */
5321
5322 int
5323 m68k_conditional_pseudoop (pseudo_typeS *pop)
5324 {
5325   return (pop->poc_handler == s_mri_if
5326           || pop->poc_handler == s_mri_else);
5327 }
5328
5329 /* Handle an MRI style chip specification.  */
5330
5331 static void
5332 mri_chip (void)
5333 {
5334   char *s;
5335   char c;
5336   int i;
5337
5338   s = input_line_pointer;
5339   /* We can't use get_symbol_end since the processor names are not proper
5340      symbols.  */
5341   while (is_part_of_name (c = *input_line_pointer++))
5342     ;
5343   *--input_line_pointer = 0;
5344   for (i = 0; m68k_cpus[i].name; i++)
5345     if (strcasecmp (s, m68k_cpus[i].name) == 0)
5346       break;
5347   if (!m68k_cpus[i].name)
5348     {
5349       as_bad (_("%s: unrecognized processor name"), s);
5350       *input_line_pointer = c;
5351       ignore_rest_of_line ();
5352       return;
5353     }
5354   *input_line_pointer = c;
5355
5356   if (*input_line_pointer == '/')
5357     current_architecture = 0;
5358   else
5359     current_architecture &= m68881 | m68851;
5360   current_architecture |= m68k_cpus[i].arch & ~(m68881 | m68851);
5361   current_chip = m68k_cpus[i].chip;
5362
5363   while (*input_line_pointer == '/')
5364     {
5365       ++input_line_pointer;
5366       s = input_line_pointer;
5367       /* We can't use get_symbol_end since the processor names are not
5368          proper symbols.  */
5369       while (is_part_of_name (c = *input_line_pointer++))
5370         ;
5371       *--input_line_pointer = 0;
5372       if (strcmp (s, "68881") == 0)
5373         current_architecture |= m68881;
5374       else if (strcmp (s, "68851") == 0)
5375         current_architecture |= m68851;
5376       *input_line_pointer = c;
5377     }
5378
5379   /* Update info about available control registers.  */
5380   select_control_regs ();
5381 }
5382
5383 /* The MRI CHIP pseudo-op.  */
5384
5385 static void
5386 s_chip (int ignore ATTRIBUTE_UNUSED)
5387 {
5388   char *stop = NULL;
5389   char stopc;
5390
5391   if (flag_mri)
5392     stop = mri_comment_field (&stopc);
5393   mri_chip ();
5394   if (flag_mri)
5395     mri_comment_end (stop, stopc);
5396   demand_empty_rest_of_line ();
5397 }
5398
5399 /* The MRI FOPT pseudo-op.  */
5400
5401 static void
5402 s_fopt (int ignore ATTRIBUTE_UNUSED)
5403 {
5404   SKIP_WHITESPACE ();
5405
5406   if (strncasecmp (input_line_pointer, "ID=", 3) == 0)
5407     {
5408       int temp;
5409
5410       input_line_pointer += 3;
5411       temp = get_absolute_expression ();
5412       if (temp < 0 || temp > 7)
5413         as_bad (_("bad coprocessor id"));
5414       else
5415         m68k_float_copnum = COP0 + temp;
5416     }
5417   else
5418     {
5419       as_bad (_("unrecognized fopt option"));
5420       ignore_rest_of_line ();
5421       return;
5422     }
5423
5424   demand_empty_rest_of_line ();
5425 }
5426
5427 /* The structure used to handle the MRI OPT pseudo-op.  */
5428
5429 struct opt_action
5430 {
5431   /* The name of the option.  */
5432   const char *name;
5433
5434   /* If this is not NULL, just call this function.  The first argument
5435      is the ARG field of this structure, the second argument is
5436      whether the option was negated.  */
5437   void (*pfn) (int arg, int on);
5438
5439   /* If this is not NULL, and the PFN field is NULL, set the variable
5440      this points to.  Set it to the ARG field if the option was not
5441      negated, and the NOTARG field otherwise.  */
5442   int *pvar;
5443
5444   /* The value to pass to PFN or to assign to *PVAR.  */
5445   int arg;
5446
5447   /* The value to assign to *PVAR if the option is negated.  If PFN is
5448      NULL, and PVAR is not NULL, and ARG and NOTARG are the same, then
5449      the option may not be negated.  */
5450   int notarg;
5451 };
5452
5453 /* The table used to handle the MRI OPT pseudo-op.  */
5454
5455 static void skip_to_comma (int, int);
5456 static void opt_nest (int, int);
5457 static void opt_chip (int, int);
5458 static void opt_list (int, int);
5459 static void opt_list_symbols (int, int);
5460
5461 static const struct opt_action opt_table[] =
5462 {
5463   { "abspcadd", 0, &m68k_abspcadd, 1, 0 },
5464
5465   /* We do relaxing, so there is little use for these options.  */
5466   { "b", 0, 0, 0, 0 },
5467   { "brs", 0, 0, 0, 0 },
5468   { "brb", 0, 0, 0, 0 },
5469   { "brl", 0, 0, 0, 0 },
5470   { "brw", 0, 0, 0, 0 },
5471
5472   { "c", 0, 0, 0, 0 },
5473   { "cex", 0, 0, 0, 0 },
5474   { "case", 0, &symbols_case_sensitive, 1, 0 },
5475   { "cl", 0, 0, 0, 0 },
5476   { "cre", 0, 0, 0, 0 },
5477   { "d", 0, &flag_keep_locals, 1, 0 },
5478   { "e", 0, 0, 0, 0 },
5479   { "f", 0, &flag_short_refs, 1, 0 },
5480   { "frs", 0, &flag_short_refs, 1, 0 },
5481   { "frl", 0, &flag_short_refs, 0, 1 },
5482   { "g", 0, 0, 0, 0 },
5483   { "i", 0, 0, 0, 0 },
5484   { "m", 0, 0, 0, 0 },
5485   { "mex", 0, 0, 0, 0 },
5486   { "mc", 0, 0, 0, 0 },
5487   { "md", 0, 0, 0, 0 },
5488   { "nest", opt_nest, 0, 0, 0 },
5489   { "next", skip_to_comma, 0, 0, 0 },
5490   { "o", 0, 0, 0, 0 },
5491   { "old", 0, 0, 0, 0 },
5492   { "op", skip_to_comma, 0, 0, 0 },
5493   { "pco", 0, 0, 0, 0 },
5494   { "p", opt_chip, 0, 0, 0 },
5495   { "pcr", 0, 0, 0, 0 },
5496   { "pcs", 0, 0, 0, 0 },
5497   { "r", 0, 0, 0, 0 },
5498   { "quick", 0, &m68k_quick, 1, 0 },
5499   { "rel32", 0, &m68k_rel32, 1, 0 },
5500   { "s", opt_list, 0, 0, 0 },
5501   { "t", opt_list_symbols, 0, 0, 0 },
5502   { "w", 0, &flag_no_warnings, 0, 1 },
5503   { "x", 0, 0, 0, 0 }
5504 };
5505
5506 #define OPTCOUNT ((int) (sizeof opt_table / sizeof opt_table[0]))
5507
5508 /* The MRI OPT pseudo-op.  */
5509
5510 static void
5511 s_opt (int ignore ATTRIBUTE_UNUSED)
5512 {
5513   do
5514     {
5515       int t;
5516       char *s;
5517       char c;
5518       int i;
5519       const struct opt_action *o;
5520
5521       SKIP_WHITESPACE ();
5522
5523       t = 1;
5524       if (*input_line_pointer == '-')
5525         {
5526           ++input_line_pointer;
5527           t = 0;
5528         }
5529       else if (strncasecmp (input_line_pointer, "NO", 2) == 0)
5530         {
5531           input_line_pointer += 2;
5532           t = 0;
5533         }
5534
5535       s = input_line_pointer;
5536       c = get_symbol_end ();
5537
5538       for (i = 0, o = opt_table; i < OPTCOUNT; i++, o++)
5539         {
5540           if (strcasecmp (s, o->name) == 0)
5541             {
5542               if (o->pfn)
5543                 {
5544                   /* Restore input_line_pointer now in case the option
5545                      takes arguments.  */
5546                   *input_line_pointer = c;
5547                   (*o->pfn) (o->arg, t);
5548                 }
5549               else if (o->pvar != NULL)
5550                 {
5551                   if (! t && o->arg == o->notarg)
5552                     as_bad (_("option `%s' may not be negated"), s);
5553                   *input_line_pointer = c;
5554                   *o->pvar = t ? o->arg : o->notarg;
5555                 }
5556               else
5557                 *input_line_pointer = c;
5558               break;
5559             }
5560         }
5561       if (i >= OPTCOUNT)
5562         {
5563           as_bad (_("option `%s' not recognized"), s);
5564           *input_line_pointer = c;
5565         }
5566     }
5567   while (*input_line_pointer++ == ',');
5568
5569   /* Move back to terminating character.  */
5570   --input_line_pointer;
5571   demand_empty_rest_of_line ();
5572 }
5573
5574 /* Skip ahead to a comma.  This is used for OPT options which we do
5575    not support and which take arguments.  */
5576
5577 static void
5578 skip_to_comma (int arg ATTRIBUTE_UNUSED, int on ATTRIBUTE_UNUSED)
5579 {
5580   while (*input_line_pointer != ','
5581          && ! is_end_of_line[(unsigned char) *input_line_pointer])
5582     ++input_line_pointer;
5583 }
5584
5585 /* Handle the OPT NEST=depth option.  */
5586
5587 static void
5588 opt_nest (int arg ATTRIBUTE_UNUSED, int on ATTRIBUTE_UNUSED)
5589 {
5590   if (*input_line_pointer != '=')
5591     {
5592       as_bad (_("bad format of OPT NEST=depth"));
5593       return;
5594     }
5595
5596   ++input_line_pointer;
5597   max_macro_nest = get_absolute_expression ();
5598 }
5599
5600 /* Handle the OPT P=chip option.  */
5601
5602 static void
5603 opt_chip (int arg ATTRIBUTE_UNUSED, int on ATTRIBUTE_UNUSED)
5604 {
5605   if (*input_line_pointer != '=')
5606     {
5607       /* This is just OPT P, which we do not support.  */
5608       return;
5609     }
5610
5611   ++input_line_pointer;
5612   mri_chip ();
5613 }
5614
5615 /* Handle the OPT S option.  */
5616
5617 static void
5618 opt_list (int arg ATTRIBUTE_UNUSED, int on)
5619 {
5620   listing_list (on);
5621 }
5622
5623 /* Handle the OPT T option.  */
5624
5625 static void
5626 opt_list_symbols (int arg ATTRIBUTE_UNUSED, int on)
5627 {
5628   if (on)
5629     listing |= LISTING_SYMBOLS;
5630   else
5631     listing &= ~LISTING_SYMBOLS;
5632 }
5633
5634 /* Handle the MRI REG pseudo-op.  */
5635
5636 static void
5637 s_reg (int ignore ATTRIBUTE_UNUSED)
5638 {
5639   char *s;
5640   int c;
5641   struct m68k_op rop;
5642   int mask;
5643   char *stop = NULL;
5644   char stopc;
5645
5646   if (line_label == NULL)
5647     {
5648       as_bad (_("missing label"));
5649       ignore_rest_of_line ();
5650       return;
5651     }
5652
5653   if (flag_mri)
5654     stop = mri_comment_field (&stopc);
5655
5656   SKIP_WHITESPACE ();
5657
5658   s = input_line_pointer;
5659   while (ISALNUM (*input_line_pointer)
5660 #ifdef REGISTER_PREFIX
5661          || *input_line_pointer == REGISTER_PREFIX
5662 #endif
5663          || *input_line_pointer == '/'
5664          || *input_line_pointer == '-')
5665     ++input_line_pointer;
5666   c = *input_line_pointer;
5667   *input_line_pointer = '\0';
5668
5669   if (m68k_ip_op (s, &rop) != 0)
5670     {
5671       if (rop.error == NULL)
5672         as_bad (_("bad register list"));
5673       else
5674         as_bad (_("bad register list: %s"), rop.error);
5675       *input_line_pointer = c;
5676       ignore_rest_of_line ();
5677       return;
5678     }
5679
5680   *input_line_pointer = c;
5681
5682   if (rop.mode == REGLST)
5683     mask = rop.mask;
5684   else if (rop.mode == DREG)
5685     mask = 1 << (rop.reg - DATA0);
5686   else if (rop.mode == AREG)
5687     mask = 1 << (rop.reg - ADDR0 + 8);
5688   else if (rop.mode == FPREG)
5689     mask = 1 << (rop.reg - FP0 + 16);
5690   else if (rop.mode == CONTROL
5691            && rop.reg == FPI)
5692     mask = 1 << 24;
5693   else if (rop.mode == CONTROL
5694            && rop.reg == FPS)
5695     mask = 1 << 25;
5696   else if (rop.mode == CONTROL
5697            && rop.reg == FPC)
5698     mask = 1 << 26;
5699   else
5700     {
5701       as_bad (_("bad register list"));
5702       ignore_rest_of_line ();
5703       return;
5704     }
5705
5706   S_SET_SEGMENT (line_label, reg_section);
5707   S_SET_VALUE (line_label, ~mask);
5708   symbol_set_frag (line_label, &zero_address_frag);
5709
5710   if (flag_mri)
5711     mri_comment_end (stop, stopc);
5712
5713   demand_empty_rest_of_line ();
5714 }
5715
5716 /* This structure is used for the MRI SAVE and RESTORE pseudo-ops.  */
5717
5718 struct save_opts
5719 {
5720   struct save_opts *next;
5721   int abspcadd;
5722   int symbols_case_sensitive;
5723   int keep_locals;
5724   int short_refs;
5725   int architecture;
5726   int chip;
5727   int quick;
5728   int rel32;
5729   int listing;
5730   int no_warnings;
5731   /* FIXME: We don't save OPT S.  */
5732 };
5733
5734 /* This variable holds the stack of saved options.  */
5735
5736 static struct save_opts *save_stack;
5737
5738 /* The MRI SAVE pseudo-op.  */
5739
5740 static void
5741 s_save (int ignore ATTRIBUTE_UNUSED)
5742 {
5743   struct save_opts *s;
5744
5745   s = (struct save_opts *) xmalloc (sizeof (struct save_opts));
5746   s->abspcadd = m68k_abspcadd;
5747   s->symbols_case_sensitive = symbols_case_sensitive;
5748   s->keep_locals = flag_keep_locals;
5749   s->short_refs = flag_short_refs;
5750   s->architecture = current_architecture;
5751   s->chip = current_chip;
5752   s->quick = m68k_quick;
5753   s->rel32 = m68k_rel32;
5754   s->listing = listing;
5755   s->no_warnings = flag_no_warnings;
5756
5757   s->next = save_stack;
5758   save_stack = s;
5759
5760   demand_empty_rest_of_line ();
5761 }
5762
5763 /* The MRI RESTORE pseudo-op.  */
5764
5765 static void
5766 s_restore (int ignore ATTRIBUTE_UNUSED)
5767 {
5768   struct save_opts *s;
5769
5770   if (save_stack == NULL)
5771     {
5772       as_bad (_("restore without save"));
5773       ignore_rest_of_line ();
5774       return;
5775     }
5776
5777   s = save_stack;
5778   save_stack = s->next;
5779
5780   m68k_abspcadd = s->abspcadd;
5781   symbols_case_sensitive = s->symbols_case_sensitive;
5782   flag_keep_locals = s->keep_locals;
5783   flag_short_refs = s->short_refs;
5784   current_architecture = s->architecture;
5785   current_chip = s->chip;
5786   m68k_quick = s->quick;
5787   m68k_rel32 = s->rel32;
5788   listing = s->listing;
5789   flag_no_warnings = s->no_warnings;
5790
5791   free (s);
5792
5793   demand_empty_rest_of_line ();
5794 }
5795
5796 /* Types of MRI structured control directives.  */
5797
5798 enum mri_control_type
5799 {
5800   mri_for,
5801   mri_if,
5802   mri_repeat,
5803   mri_while
5804 };
5805
5806 /* This structure is used to stack the MRI structured control
5807    directives.  */
5808
5809 struct mri_control_info
5810 {
5811   /* The directive within which this one is enclosed.  */
5812   struct mri_control_info *outer;
5813
5814   /* The type of directive.  */
5815   enum mri_control_type type;
5816
5817   /* Whether an ELSE has been in an IF.  */
5818   int else_seen;
5819
5820   /* The add or sub statement at the end of a FOR.  */
5821   char *incr;
5822
5823   /* The label of the top of a FOR or REPEAT loop.  */
5824   char *top;
5825
5826   /* The label to jump to for the next iteration, or the else
5827      expression of a conditional.  */
5828   char *next;
5829
5830   /* The label to jump to to break out of the loop, or the label past
5831      the end of a conditional.  */
5832   char *bottom;
5833 };
5834
5835 /* The stack of MRI structured control directives.  */
5836
5837 static struct mri_control_info *mri_control_stack;
5838
5839 /* The current MRI structured control directive index number, used to
5840    generate label names.  */
5841
5842 static int mri_control_index;
5843
5844 /* Assemble an instruction for an MRI structured control directive.  */
5845
5846 static void
5847 mri_assemble (char *str)
5848 {
5849   char *s;
5850
5851   /* md_assemble expects the opcode to be in lower case.  */
5852   for (s = str; *s != ' ' && *s != '\0'; s++)
5853     *s = TOLOWER (*s);
5854
5855   md_assemble (str);
5856 }
5857
5858 /* Generate a new MRI label structured control directive label name.  */
5859
5860 static char *
5861 mri_control_label (void)
5862 {
5863   char *n;
5864
5865   n = (char *) xmalloc (20);
5866   sprintf (n, "%smc%d", FAKE_LABEL_NAME, mri_control_index);
5867   ++mri_control_index;
5868   return n;
5869 }
5870
5871 /* Create a new MRI structured control directive.  */
5872
5873 static struct mri_control_info *
5874 push_mri_control (enum mri_control_type type)
5875 {
5876   struct mri_control_info *n;
5877
5878   n = (struct mri_control_info *) xmalloc (sizeof (struct mri_control_info));
5879
5880   n->type = type;
5881   n->else_seen = 0;
5882   if (type == mri_if || type == mri_while)
5883     n->top = NULL;
5884   else
5885     n->top = mri_control_label ();
5886   n->next = mri_control_label ();
5887   n->bottom = mri_control_label ();
5888
5889   n->outer = mri_control_stack;
5890   mri_control_stack = n;
5891
5892   return n;
5893 }
5894
5895 /* Pop off the stack of MRI structured control directives.  */
5896
5897 static void
5898 pop_mri_control (void)
5899 {
5900   struct mri_control_info *n;
5901
5902   n = mri_control_stack;
5903   mri_control_stack = n->outer;
5904   if (n->top != NULL)
5905     free (n->top);
5906   free (n->next);
5907   free (n->bottom);
5908   free (n);
5909 }
5910
5911 /* Recognize a condition code in an MRI structured control expression.  */
5912
5913 static int
5914 parse_mri_condition (int *pcc)
5915 {
5916   char c1, c2;
5917
5918   know (*input_line_pointer == '<');
5919
5920   ++input_line_pointer;
5921   c1 = *input_line_pointer++;
5922   c2 = *input_line_pointer++;
5923
5924   if (*input_line_pointer != '>')
5925     {
5926       as_bad (_("syntax error in structured control directive"));
5927       return 0;
5928     }
5929
5930   ++input_line_pointer;
5931   SKIP_WHITESPACE ();
5932
5933   c1 = TOLOWER (c1);
5934   c2 = TOLOWER (c2);
5935
5936   *pcc = (c1 << 8) | c2;
5937
5938   return 1;
5939 }
5940
5941 /* Parse a single operand in an MRI structured control expression.  */
5942
5943 static int
5944 parse_mri_control_operand (int *pcc, char **leftstart, char **leftstop,
5945                            char **rightstart, char **rightstop)
5946 {
5947   char *s;
5948
5949   SKIP_WHITESPACE ();
5950
5951   *pcc = -1;
5952   *leftstart = NULL;
5953   *leftstop = NULL;
5954   *rightstart = NULL;
5955   *rightstop = NULL;
5956
5957   if (*input_line_pointer == '<')
5958     {
5959       /* It's just a condition code.  */
5960       return parse_mri_condition (pcc);
5961     }
5962
5963   /* Look ahead for the condition code.  */
5964   for (s = input_line_pointer; *s != '\0'; ++s)
5965     {
5966       if (*s == '<' && s[1] != '\0' && s[2] != '\0' && s[3] == '>')
5967         break;
5968     }
5969   if (*s == '\0')
5970     {
5971       as_bad (_("missing condition code in structured control directive"));
5972       return 0;
5973     }
5974
5975   *leftstart = input_line_pointer;
5976   *leftstop = s;
5977   if (*leftstop > *leftstart
5978       && ((*leftstop)[-1] == ' ' || (*leftstop)[-1] == '\t'))
5979     --*leftstop;
5980
5981   input_line_pointer = s;
5982   if (! parse_mri_condition (pcc))
5983     return 0;
5984
5985   /* Look ahead for AND or OR or end of line.  */
5986   for (s = input_line_pointer; *s != '\0'; ++s)
5987     {
5988       /* We must make sure we don't misinterpret AND/OR at the end of labels!
5989          if d0 <eq> #FOOAND and d1 <ne> #BAROR then
5990                         ^^^                 ^^ */
5991       if ((s == input_line_pointer
5992            || *(s-1) == ' '
5993            || *(s-1) == '\t')
5994           && ((strncasecmp (s, "AND", 3) == 0
5995                && (s[3] == '.' || ! is_part_of_name (s[3])))
5996               || (strncasecmp (s, "OR", 2) == 0
5997                   && (s[2] == '.' || ! is_part_of_name (s[2])))))
5998         break;
5999     }
6000
6001   *rightstart = input_line_pointer;
6002   *rightstop = s;
6003   if (*rightstop > *rightstart
6004       && ((*rightstop)[-1] == ' ' || (*rightstop)[-1] == '\t'))
6005     --*rightstop;
6006
6007   input_line_pointer = s;
6008
6009   return 1;
6010 }
6011
6012 #define MCC(b1, b2) (((b1) << 8) | (b2))
6013
6014 /* Swap the sense of a condition.  This changes the condition so that
6015    it generates the same result when the operands are swapped.  */
6016
6017 static int
6018 swap_mri_condition (int cc)
6019 {
6020   switch (cc)
6021     {
6022     case MCC ('h', 'i'): return MCC ('c', 's');
6023     case MCC ('l', 's'): return MCC ('c', 'c');
6024     /* <HS> is an alias for <CC>.  */
6025     case MCC ('h', 's'):
6026     case MCC ('c', 'c'): return MCC ('l', 's');
6027     /* <LO> is an alias for <CS>.  */
6028     case MCC ('l', 'o'):
6029     case MCC ('c', 's'): return MCC ('h', 'i');
6030     case MCC ('p', 'l'): return MCC ('m', 'i');
6031     case MCC ('m', 'i'): return MCC ('p', 'l');
6032     case MCC ('g', 'e'): return MCC ('l', 'e');
6033     case MCC ('l', 't'): return MCC ('g', 't');
6034     case MCC ('g', 't'): return MCC ('l', 't');
6035     case MCC ('l', 'e'): return MCC ('g', 'e');
6036     /* Issue a warning for conditions we can not swap.  */
6037     case MCC ('n', 'e'): return MCC ('n', 'e'); // no problem here
6038     case MCC ('e', 'q'): return MCC ('e', 'q'); // also no problem
6039     case MCC ('v', 'c'):
6040     case MCC ('v', 's'):
6041     default :
6042            as_warn (_("Condition <%c%c> in structured control directive can not be encoded correctly"),
6043                          (char) (cc >> 8), (char) (cc));
6044       break;
6045     }
6046   return cc;
6047 }
6048
6049 /* Reverse the sense of a condition.  */
6050
6051 static int
6052 reverse_mri_condition (int cc)
6053 {
6054   switch (cc)
6055     {
6056     case MCC ('h', 'i'): return MCC ('l', 's');
6057     case MCC ('l', 's'): return MCC ('h', 'i');
6058     /* <HS> is an alias for <CC> */
6059     case MCC ('h', 's'): return MCC ('l', 'o');
6060     case MCC ('c', 'c'): return MCC ('c', 's');
6061     /* <LO> is an alias for <CS> */
6062     case MCC ('l', 'o'): return MCC ('h', 's');
6063     case MCC ('c', 's'): return MCC ('c', 'c');
6064     case MCC ('n', 'e'): return MCC ('e', 'q');
6065     case MCC ('e', 'q'): return MCC ('n', 'e');
6066     case MCC ('v', 'c'): return MCC ('v', 's');
6067     case MCC ('v', 's'): return MCC ('v', 'c');
6068     case MCC ('p', 'l'): return MCC ('m', 'i');
6069     case MCC ('m', 'i'): return MCC ('p', 'l');
6070     case MCC ('g', 'e'): return MCC ('l', 't');
6071     case MCC ('l', 't'): return MCC ('g', 'e');
6072     case MCC ('g', 't'): return MCC ('l', 'e');
6073     case MCC ('l', 'e'): return MCC ('g', 't');
6074     }
6075   return cc;
6076 }
6077
6078 /* Build an MRI structured control expression.  This generates test
6079    and branch instructions.  It goes to TRUELAB if the condition is
6080    true, and to FALSELAB if the condition is false.  Exactly one of
6081    TRUELAB and FALSELAB will be NULL, meaning to fall through.  QUAL
6082    is the size qualifier for the expression.  EXTENT is the size to
6083    use for the branch.  */
6084
6085 static void
6086 build_mri_control_operand (int qual, int cc, char *leftstart, char *leftstop,
6087                            char *rightstart, char *rightstop,
6088                            const char *truelab, const char *falselab,
6089                            int extent)
6090 {
6091   char *buf;
6092   char *s;
6093
6094   if (leftstart != NULL)
6095     {
6096       struct m68k_op leftop, rightop;
6097       char c;
6098
6099       /* Swap the compare operands, if necessary, to produce a legal
6100          m68k compare instruction.  Comparing a register operand with
6101          a non-register operand requires the register to be on the
6102          right (cmp, cmpa).  Comparing an immediate value with
6103          anything requires the immediate value to be on the left
6104          (cmpi).  */
6105
6106       c = *leftstop;
6107       *leftstop = '\0';
6108       (void) m68k_ip_op (leftstart, &leftop);
6109       *leftstop = c;
6110
6111       c = *rightstop;
6112       *rightstop = '\0';
6113       (void) m68k_ip_op (rightstart, &rightop);
6114       *rightstop = c;
6115
6116       if (rightop.mode == IMMED
6117           || ((leftop.mode == DREG || leftop.mode == AREG)
6118               && (rightop.mode != DREG && rightop.mode != AREG)))
6119         {
6120           char *temp;
6121
6122           /* Correct conditional handling:
6123              if #1 <lt> d0 then  ;means if (1 < d0)
6124                 ...
6125              endi
6126
6127              should assemble to:
6128
6129                 cmp #1,d0        if we do *not* swap the operands
6130                 bgt true         we need the swapped condition!
6131                 ble false
6132              true:
6133                 ...
6134              false:
6135           */
6136           temp = leftstart;
6137           leftstart = rightstart;
6138           rightstart = temp;
6139           temp = leftstop;
6140           leftstop = rightstop;
6141           rightstop = temp;
6142         }
6143       else
6144         {
6145           cc = swap_mri_condition (cc);
6146         }
6147     }
6148
6149   if (truelab == NULL)
6150     {
6151       cc = reverse_mri_condition (cc);
6152       truelab = falselab;
6153     }
6154
6155   if (leftstart != NULL)
6156     {
6157       buf = (char *) xmalloc (20
6158                               + (leftstop - leftstart)
6159                               + (rightstop - rightstart));
6160       s = buf;
6161       *s++ = 'c';
6162       *s++ = 'm';
6163       *s++ = 'p';
6164       if (qual != '\0')
6165         *s++ = TOLOWER (qual);
6166       *s++ = ' ';
6167       memcpy (s, leftstart, leftstop - leftstart);
6168       s += leftstop - leftstart;
6169       *s++ = ',';
6170       memcpy (s, rightstart, rightstop - rightstart);
6171       s += rightstop - rightstart;
6172       *s = '\0';
6173       mri_assemble (buf);
6174       free (buf);
6175     }
6176
6177   buf = (char *) xmalloc (20 + strlen (truelab));
6178   s = buf;
6179   *s++ = 'b';
6180   *s++ = cc >> 8;
6181   *s++ = cc & 0xff;
6182   if (extent != '\0')
6183     *s++ = TOLOWER (extent);
6184   *s++ = ' ';
6185   strcpy (s, truelab);
6186   mri_assemble (buf);
6187   free (buf);
6188 }
6189
6190 /* Parse an MRI structured control expression.  This generates test
6191    and branch instructions.  STOP is where the expression ends.  It
6192    goes to TRUELAB if the condition is true, and to FALSELAB if the
6193    condition is false.  Exactly one of TRUELAB and FALSELAB will be
6194    NULL, meaning to fall through.  QUAL is the size qualifier for the
6195    expression.  EXTENT is the size to use for the branch.  */
6196
6197 static void
6198 parse_mri_control_expression (char *stop, int qual, const char *truelab,
6199                               const char *falselab, int extent)
6200 {
6201   int c;
6202   int cc;
6203   char *leftstart;
6204   char *leftstop;
6205   char *rightstart;
6206   char *rightstop;
6207
6208   c = *stop;
6209   *stop = '\0';
6210
6211   if (! parse_mri_control_operand (&cc, &leftstart, &leftstop,
6212                                    &rightstart, &rightstop))
6213     {
6214       *stop = c;
6215       return;
6216     }
6217
6218   if (strncasecmp (input_line_pointer, "AND", 3) == 0)
6219     {
6220       const char *flab;
6221
6222       if (falselab != NULL)
6223         flab = falselab;
6224       else
6225         flab = mri_control_label ();
6226
6227       build_mri_control_operand (qual, cc, leftstart, leftstop, rightstart,
6228                                  rightstop, (const char *) NULL, flab, extent);
6229
6230       input_line_pointer += 3;
6231       if (*input_line_pointer != '.'
6232           || input_line_pointer[1] == '\0')
6233         qual = '\0';
6234       else
6235         {
6236           qual = input_line_pointer[1];
6237           input_line_pointer += 2;
6238         }
6239
6240       if (! parse_mri_control_operand (&cc, &leftstart, &leftstop,
6241                                        &rightstart, &rightstop))
6242         {
6243           *stop = c;
6244           return;
6245         }
6246
6247       build_mri_control_operand (qual, cc, leftstart, leftstop, rightstart,
6248                                  rightstop, truelab, falselab, extent);
6249
6250       if (falselab == NULL)
6251         colon (flab);
6252     }
6253   else if (strncasecmp (input_line_pointer, "OR", 2) == 0)
6254     {
6255       const char *tlab;
6256
6257       if (truelab != NULL)
6258         tlab = truelab;
6259       else
6260         tlab = mri_control_label ();
6261
6262       build_mri_control_operand (qual, cc, leftstart, leftstop, rightstart,
6263                                  rightstop, tlab, (const char *) NULL, extent);
6264
6265       input_line_pointer += 2;
6266       if (*input_line_pointer != '.'
6267           || input_line_pointer[1] == '\0')
6268         qual = '\0';
6269       else
6270         {
6271           qual = input_line_pointer[1];
6272           input_line_pointer += 2;
6273         }
6274
6275       if (! parse_mri_control_operand (&cc, &leftstart, &leftstop,
6276                                        &rightstart, &rightstop))
6277         {
6278           *stop = c;
6279           return;
6280         }
6281
6282       build_mri_control_operand (qual, cc, leftstart, leftstop, rightstart,
6283                                  rightstop, truelab, falselab, extent);
6284
6285       if (truelab == NULL)
6286         colon (tlab);
6287     }
6288   else
6289     {
6290       build_mri_control_operand (qual, cc, leftstart, leftstop, rightstart,
6291                                  rightstop, truelab, falselab, extent);
6292     }
6293
6294   *stop = c;
6295   if (input_line_pointer != stop)
6296     as_bad (_("syntax error in structured control directive"));
6297 }
6298
6299 /* Handle the MRI IF pseudo-op.  This may be a structured control
6300    directive, or it may be a regular assembler conditional, depending
6301    on its operands.  */
6302
6303 static void
6304 s_mri_if (int qual)
6305 {
6306   char *s;
6307   int c;
6308   struct mri_control_info *n;
6309
6310   /* A structured control directive must end with THEN with an
6311      optional qualifier.  */
6312   s = input_line_pointer;
6313   /* We only accept '*' as introduction of comments if preceded by white space
6314      or at first column of a line (I think this can't actually happen here?)
6315      This is important when assembling:
6316        if d0 <ne> 12(a0,d0*2) then
6317        if d0 <ne> #CONST*20   then.  */
6318   while (! (is_end_of_line[(unsigned char) *s]
6319             || (flag_mri
6320                 && *s == '*'
6321                 && (s == input_line_pointer
6322                     || *(s-1) == ' '
6323                     || *(s-1) == '\t'))))
6324     ++s;
6325   --s;
6326   while (s > input_line_pointer && (*s == ' ' || *s == '\t'))
6327     --s;
6328
6329   if (s - input_line_pointer > 1
6330       && s[-1] == '.')
6331     s -= 2;
6332
6333   if (s - input_line_pointer < 3
6334       || strncasecmp (s - 3, "THEN", 4) != 0)
6335     {
6336       if (qual != '\0')
6337         {
6338           as_bad (_("missing then"));
6339           ignore_rest_of_line ();
6340           return;
6341         }
6342
6343       /* It's a conditional.  */
6344       s_if (O_ne);
6345       return;
6346     }
6347
6348   /* Since this might be a conditional if, this pseudo-op will be
6349      called even if we are supported to be ignoring input.  Double
6350      check now.  Clobber *input_line_pointer so that ignore_input
6351      thinks that this is not a special pseudo-op.  */
6352   c = *input_line_pointer;
6353   *input_line_pointer = 0;
6354   if (ignore_input ())
6355     {
6356       *input_line_pointer = c;
6357       while (! is_end_of_line[(unsigned char) *input_line_pointer])
6358         ++input_line_pointer;
6359       demand_empty_rest_of_line ();
6360       return;
6361     }
6362   *input_line_pointer = c;
6363
6364   n = push_mri_control (mri_if);
6365
6366   parse_mri_control_expression (s - 3, qual, (const char *) NULL,
6367                                 n->next, s[1] == '.' ? s[2] : '\0');
6368
6369   if (s[1] == '.')
6370     input_line_pointer = s + 3;
6371   else
6372     input_line_pointer = s + 1;
6373
6374   if (flag_mri)
6375     {
6376       while (! is_end_of_line[(unsigned char) *input_line_pointer])
6377         ++input_line_pointer;
6378     }
6379
6380   demand_empty_rest_of_line ();
6381 }
6382
6383 /* Handle the MRI else pseudo-op.  If we are currently doing an MRI
6384    structured IF, associate the ELSE with the IF.  Otherwise, assume
6385    it is a conditional else.  */
6386
6387 static void
6388 s_mri_else (int qual)
6389 {
6390   int c;
6391   char *buf;
6392   char q[2];
6393
6394   if (qual == '\0'
6395       && (mri_control_stack == NULL
6396           || mri_control_stack->type != mri_if
6397           || mri_control_stack->else_seen))
6398     {
6399       s_else (0);
6400       return;
6401     }
6402
6403   c = *input_line_pointer;
6404   *input_line_pointer = 0;
6405   if (ignore_input ())
6406     {
6407       *input_line_pointer = c;
6408       while (! is_end_of_line[(unsigned char) *input_line_pointer])
6409         ++input_line_pointer;
6410       demand_empty_rest_of_line ();
6411       return;
6412     }
6413   *input_line_pointer = c;
6414
6415   if (mri_control_stack == NULL
6416       || mri_control_stack->type != mri_if
6417       || mri_control_stack->else_seen)
6418     {
6419       as_bad (_("else without matching if"));
6420       ignore_rest_of_line ();
6421       return;
6422     }
6423
6424   mri_control_stack->else_seen = 1;
6425
6426   buf = (char *) xmalloc (20 + strlen (mri_control_stack->bottom));
6427   q[0] = TOLOWER (qual);
6428   q[1] = '\0';
6429   sprintf (buf, "bra%s %s", q, mri_control_stack->bottom);
6430   mri_assemble (buf);
6431   free (buf);
6432
6433   colon (mri_control_stack->next);
6434
6435   if (flag_mri)
6436     {
6437       while (! is_end_of_line[(unsigned char) *input_line_pointer])
6438         ++input_line_pointer;
6439     }
6440
6441   demand_empty_rest_of_line ();
6442 }
6443
6444 /* Handle the MRI ENDI pseudo-op.  */
6445
6446 static void
6447 s_mri_endi (int ignore ATTRIBUTE_UNUSED)
6448 {
6449   if (mri_control_stack == NULL
6450       || mri_control_stack->type != mri_if)
6451     {
6452       as_bad (_("endi without matching if"));
6453       ignore_rest_of_line ();
6454       return;
6455     }
6456
6457   /* ignore_input will not return true for ENDI, so we don't need to
6458      worry about checking it again here.  */
6459
6460   if (! mri_control_stack->else_seen)
6461     colon (mri_control_stack->next);
6462   colon (mri_control_stack->bottom);
6463
6464   pop_mri_control ();
6465
6466   if (flag_mri)
6467     {
6468       while (! is_end_of_line[(unsigned char) *input_line_pointer])
6469         ++input_line_pointer;
6470     }
6471
6472   demand_empty_rest_of_line ();
6473 }
6474
6475 /* Handle the MRI BREAK pseudo-op.  */
6476
6477 static void
6478 s_mri_break (int extent)
6479 {
6480   struct mri_control_info *n;
6481   char *buf;
6482   char ex[2];
6483
6484   n = mri_control_stack;
6485   while (n != NULL
6486          && n->type != mri_for
6487          && n->type != mri_repeat
6488          && n->type != mri_while)
6489     n = n->outer;
6490   if (n == NULL)
6491     {
6492       as_bad (_("break outside of structured loop"));
6493       ignore_rest_of_line ();
6494       return;
6495     }
6496
6497   buf = (char *) xmalloc (20 + strlen (n->bottom));
6498   ex[0] = TOLOWER (extent);
6499   ex[1] = '\0';
6500   sprintf (buf, "bra%s %s", ex, n->bottom);
6501   mri_assemble (buf);
6502   free (buf);
6503
6504   if (flag_mri)
6505     {
6506       while (! is_end_of_line[(unsigned char) *input_line_pointer])
6507         ++input_line_pointer;
6508     }
6509
6510   demand_empty_rest_of_line ();
6511 }
6512
6513 /* Handle the MRI NEXT pseudo-op.  */
6514
6515 static void
6516 s_mri_next (int extent)
6517 {
6518   struct mri_control_info *n;
6519   char *buf;
6520   char ex[2];
6521
6522   n = mri_control_stack;
6523   while (n != NULL
6524          && n->type != mri_for
6525          && n->type != mri_repeat
6526          && n->type != mri_while)
6527     n = n->outer;
6528   if (n == NULL)
6529     {
6530       as_bad (_("next outside of structured loop"));
6531       ignore_rest_of_line ();
6532       return;
6533     }
6534
6535   buf = (char *) xmalloc (20 + strlen (n->next));
6536   ex[0] = TOLOWER (extent);
6537   ex[1] = '\0';
6538   sprintf (buf, "bra%s %s", ex, n->next);
6539   mri_assemble (buf);
6540   free (buf);
6541
6542   if (flag_mri)
6543     {
6544       while (! is_end_of_line[(unsigned char) *input_line_pointer])
6545         ++input_line_pointer;
6546     }
6547
6548   demand_empty_rest_of_line ();
6549 }
6550
6551 /* Handle the MRI FOR pseudo-op.  */
6552
6553 static void
6554 s_mri_for (int qual)
6555 {
6556   const char *varstart, *varstop;
6557   const char *initstart, *initstop;
6558   const char *endstart, *endstop;
6559   const char *bystart, *bystop;
6560   int up;
6561   int by;
6562   int extent;
6563   struct mri_control_info *n;
6564   char *buf;
6565   char *s;
6566   char ex[2];
6567
6568   /* The syntax is
6569        FOR.q var = init { TO | DOWNTO } end [ BY by ] DO.e
6570      */
6571
6572   SKIP_WHITESPACE ();
6573   varstart = input_line_pointer;
6574
6575   /* Look for the '='.  */
6576   while (! is_end_of_line[(unsigned char) *input_line_pointer]
6577          && *input_line_pointer != '=')
6578     ++input_line_pointer;
6579   if (*input_line_pointer != '=')
6580     {
6581       as_bad (_("missing ="));
6582       ignore_rest_of_line ();
6583       return;
6584     }
6585
6586   varstop = input_line_pointer;
6587   if (varstop > varstart
6588       && (varstop[-1] == ' ' || varstop[-1] == '\t'))
6589     --varstop;
6590
6591   ++input_line_pointer;
6592
6593   initstart = input_line_pointer;
6594
6595   /* Look for TO or DOWNTO.  */
6596   up = 1;
6597   initstop = NULL;
6598   while (! is_end_of_line[(unsigned char) *input_line_pointer])
6599     {
6600       if (strncasecmp (input_line_pointer, "TO", 2) == 0
6601           && ! is_part_of_name (input_line_pointer[2]))
6602         {
6603           initstop = input_line_pointer;
6604           input_line_pointer += 2;
6605           break;
6606         }
6607       if (strncasecmp (input_line_pointer, "DOWNTO", 6) == 0
6608           && ! is_part_of_name (input_line_pointer[6]))
6609         {
6610           initstop = input_line_pointer;
6611           up = 0;
6612           input_line_pointer += 6;
6613           break;
6614         }
6615       ++input_line_pointer;
6616     }
6617   if (initstop == NULL)
6618     {
6619       as_bad (_("missing to or downto"));
6620       ignore_rest_of_line ();
6621       return;
6622     }
6623   if (initstop > initstart
6624       && (initstop[-1] == ' ' || initstop[-1] == '\t'))
6625     --initstop;
6626
6627   SKIP_WHITESPACE ();
6628   endstart = input_line_pointer;
6629
6630   /* Look for BY or DO.  */
6631   by = 0;
6632   endstop = NULL;
6633   while (! is_end_of_line[(unsigned char) *input_line_pointer])
6634     {
6635       if (strncasecmp (input_line_pointer, "BY", 2) == 0
6636           && ! is_part_of_name (input_line_pointer[2]))
6637         {
6638           endstop = input_line_pointer;
6639           by = 1;
6640           input_line_pointer += 2;
6641           break;
6642         }
6643       if (strncasecmp (input_line_pointer, "DO", 2) == 0
6644           && (input_line_pointer[2] == '.'
6645               || ! is_part_of_name (input_line_pointer[2])))
6646         {
6647           endstop = input_line_pointer;
6648           input_line_pointer += 2;
6649           break;
6650         }
6651       ++input_line_pointer;
6652     }
6653   if (endstop == NULL)
6654     {
6655       as_bad (_("missing do"));
6656       ignore_rest_of_line ();
6657       return;
6658     }
6659   if (endstop > endstart
6660       && (endstop[-1] == ' ' || endstop[-1] == '\t'))
6661     --endstop;
6662
6663   if (! by)
6664     {
6665       bystart = "#1";
6666       bystop = bystart + 2;
6667     }
6668   else
6669     {
6670       SKIP_WHITESPACE ();
6671       bystart = input_line_pointer;
6672
6673       /* Look for DO.  */
6674       bystop = NULL;
6675       while (! is_end_of_line[(unsigned char) *input_line_pointer])
6676         {
6677           if (strncasecmp (input_line_pointer, "DO", 2) == 0
6678               && (input_line_pointer[2] == '.'
6679                   || ! is_part_of_name (input_line_pointer[2])))
6680             {
6681               bystop = input_line_pointer;
6682               input_line_pointer += 2;
6683               break;
6684             }
6685           ++input_line_pointer;
6686         }
6687       if (bystop == NULL)
6688         {
6689           as_bad (_("missing do"));
6690           ignore_rest_of_line ();
6691           return;
6692         }
6693       if (bystop > bystart
6694           && (bystop[-1] == ' ' || bystop[-1] == '\t'))
6695         --bystop;
6696     }
6697
6698   if (*input_line_pointer != '.')
6699     extent = '\0';
6700   else
6701     {
6702       extent = input_line_pointer[1];
6703       input_line_pointer += 2;
6704     }
6705
6706   /* We have fully parsed the FOR operands.  Now build the loop.  */
6707   n = push_mri_control (mri_for);
6708
6709   buf = (char *) xmalloc (50 + (input_line_pointer - varstart));
6710
6711   /* Move init,var.  */
6712   s = buf;
6713   *s++ = 'm';
6714   *s++ = 'o';
6715   *s++ = 'v';
6716   *s++ = 'e';
6717   if (qual != '\0')
6718     *s++ = TOLOWER (qual);
6719   *s++ = ' ';
6720   memcpy (s, initstart, initstop - initstart);
6721   s += initstop - initstart;
6722   *s++ = ',';
6723   memcpy (s, varstart, varstop - varstart);
6724   s += varstop - varstart;
6725   *s = '\0';
6726   mri_assemble (buf);
6727
6728   colon (n->top);
6729
6730   /* cmp end,var.  */
6731   s = buf;
6732   *s++ = 'c';
6733   *s++ = 'm';
6734   *s++ = 'p';
6735   if (qual != '\0')
6736     *s++ = TOLOWER (qual);
6737   *s++ = ' ';
6738   memcpy (s, endstart, endstop - endstart);
6739   s += endstop - endstart;
6740   *s++ = ',';
6741   memcpy (s, varstart, varstop - varstart);
6742   s += varstop - varstart;
6743   *s = '\0';
6744   mri_assemble (buf);
6745
6746   /* bcc bottom.  */
6747   ex[0] = TOLOWER (extent);
6748   ex[1] = '\0';
6749   if (up)
6750     sprintf (buf, "blt%s %s", ex, n->bottom);
6751   else
6752     sprintf (buf, "bgt%s %s", ex, n->bottom);
6753   mri_assemble (buf);
6754
6755   /* Put together the add or sub instruction used by ENDF.  */
6756   s = buf;
6757   if (up)
6758     strcpy (s, "add");
6759   else
6760     strcpy (s, "sub");
6761   s += 3;
6762   if (qual != '\0')
6763     *s++ = TOLOWER (qual);
6764   *s++ = ' ';
6765   memcpy (s, bystart, bystop - bystart);
6766   s += bystop - bystart;
6767   *s++ = ',';
6768   memcpy (s, varstart, varstop - varstart);
6769   s += varstop - varstart;
6770   *s = '\0';
6771   n->incr = buf;
6772
6773   if (flag_mri)
6774     {
6775       while (! is_end_of_line[(unsigned char) *input_line_pointer])
6776         ++input_line_pointer;
6777     }
6778
6779   demand_empty_rest_of_line ();
6780 }
6781
6782 /* Handle the MRI ENDF pseudo-op.  */
6783
6784 static void
6785 s_mri_endf (int ignore ATTRIBUTE_UNUSED)
6786 {
6787   if (mri_control_stack == NULL
6788       || mri_control_stack->type != mri_for)
6789     {
6790       as_bad (_("endf without for"));
6791       ignore_rest_of_line ();
6792       return;
6793     }
6794
6795   colon (mri_control_stack->next);
6796
6797   mri_assemble (mri_control_stack->incr);
6798
6799   sprintf (mri_control_stack->incr, "bra %s", mri_control_stack->top);
6800   mri_assemble (mri_control_stack->incr);
6801
6802   free (mri_control_stack->incr);
6803
6804   colon (mri_control_stack->bottom);
6805
6806   pop_mri_control ();
6807
6808   if (flag_mri)
6809     {
6810       while (! is_end_of_line[(unsigned char) *input_line_pointer])
6811         ++input_line_pointer;
6812     }
6813
6814   demand_empty_rest_of_line ();
6815 }
6816
6817 /* Handle the MRI REPEAT pseudo-op.  */
6818
6819 static void
6820 s_mri_repeat (int ignore ATTRIBUTE_UNUSED)
6821 {
6822   struct mri_control_info *n;
6823
6824   n = push_mri_control (mri_repeat);
6825   colon (n->top);
6826   if (flag_mri)
6827     {
6828       while (! is_end_of_line[(unsigned char) *input_line_pointer])
6829         ++input_line_pointer;
6830     }
6831   demand_empty_rest_of_line ();
6832 }
6833
6834 /* Handle the MRI UNTIL pseudo-op.  */
6835
6836 static void
6837 s_mri_until (int qual)
6838 {
6839   char *s;
6840
6841   if (mri_control_stack == NULL
6842       || mri_control_stack->type != mri_repeat)
6843     {
6844       as_bad (_("until without repeat"));
6845       ignore_rest_of_line ();
6846       return;
6847     }
6848
6849   colon (mri_control_stack->next);
6850
6851   for (s = input_line_pointer; ! is_end_of_line[(unsigned char) *s]; s++)
6852     ;
6853
6854   parse_mri_control_expression (s, qual, (const char *) NULL,
6855                                 mri_control_stack->top, '\0');
6856
6857   colon (mri_control_stack->bottom);
6858
6859   input_line_pointer = s;
6860
6861   pop_mri_control ();
6862
6863   if (flag_mri)
6864     {
6865       while (! is_end_of_line[(unsigned char) *input_line_pointer])
6866         ++input_line_pointer;
6867     }
6868
6869   demand_empty_rest_of_line ();
6870 }
6871
6872 /* Handle the MRI WHILE pseudo-op.  */
6873
6874 static void
6875 s_mri_while (int qual)
6876 {
6877   char *s;
6878
6879   struct mri_control_info *n;
6880
6881   s = input_line_pointer;
6882   /* We only accept '*' as introduction of comments if preceded by white space
6883      or at first column of a line (I think this can't actually happen here?)
6884      This is important when assembling:
6885        while d0 <ne> 12(a0,d0*2) do
6886        while d0 <ne> #CONST*20   do.  */
6887   while (! (is_end_of_line[(unsigned char) *s]
6888             || (flag_mri
6889                 && *s == '*'
6890                 && (s == input_line_pointer
6891                     || *(s-1) == ' '
6892                     || *(s-1) == '\t'))))
6893     s++;
6894   --s;
6895   while (*s == ' ' || *s == '\t')
6896     --s;
6897   if (s - input_line_pointer > 1
6898       && s[-1] == '.')
6899     s -= 2;
6900   if (s - input_line_pointer < 2
6901       || strncasecmp (s - 1, "DO", 2) != 0)
6902     {
6903       as_bad (_("missing do"));
6904       ignore_rest_of_line ();
6905       return;
6906     }
6907
6908   n = push_mri_control (mri_while);
6909
6910   colon (n->next);
6911
6912   parse_mri_control_expression (s - 1, qual, (const char *) NULL, n->bottom,
6913                                 s[1] == '.' ? s[2] : '\0');
6914
6915   input_line_pointer = s + 1;
6916   if (*input_line_pointer == '.')
6917     input_line_pointer += 2;
6918
6919   if (flag_mri)
6920     {
6921       while (! is_end_of_line[(unsigned char) *input_line_pointer])
6922         ++input_line_pointer;
6923     }
6924
6925   demand_empty_rest_of_line ();
6926 }
6927
6928 /* Handle the MRI ENDW pseudo-op.  */
6929
6930 static void
6931 s_mri_endw (int ignore ATTRIBUTE_UNUSED)
6932 {
6933   char *buf;
6934
6935   if (mri_control_stack == NULL
6936       || mri_control_stack->type != mri_while)
6937     {
6938       as_bad (_("endw without while"));
6939       ignore_rest_of_line ();
6940       return;
6941     }
6942
6943   buf = (char *) xmalloc (20 + strlen (mri_control_stack->next));
6944   sprintf (buf, "bra %s", mri_control_stack->next);
6945   mri_assemble (buf);
6946   free (buf);
6947
6948   colon (mri_control_stack->bottom);
6949
6950   pop_mri_control ();
6951
6952   if (flag_mri)
6953     {
6954       while (! is_end_of_line[(unsigned char) *input_line_pointer])
6955         ++input_line_pointer;
6956     }
6957
6958   demand_empty_rest_of_line ();
6959 }
6960 \f
6961 /* Parse a .cpu directive.  */
6962
6963 static void
6964 s_m68k_cpu (int ignored ATTRIBUTE_UNUSED)
6965 {
6966   char saved_char;
6967   char *name;
6968
6969   if (initialized)
6970     {
6971       as_bad (_("already assembled instructions"));
6972       ignore_rest_of_line ();
6973       return;
6974     }
6975
6976   name = input_line_pointer;
6977   while (*input_line_pointer && !ISSPACE(*input_line_pointer))
6978     input_line_pointer++;
6979   saved_char = *input_line_pointer;
6980   *input_line_pointer = 0;
6981
6982   m68k_set_cpu (name, 1, 0);
6983
6984   *input_line_pointer = saved_char;
6985   demand_empty_rest_of_line ();
6986   return;
6987 }
6988
6989 /* Parse a .arch directive.  */
6990
6991 static void
6992 s_m68k_arch (int ignored ATTRIBUTE_UNUSED)
6993 {
6994   char saved_char;
6995   char *name;
6996
6997   if (initialized)
6998     {
6999       as_bad (_("already assembled instructions"));
7000       ignore_rest_of_line ();
7001       return;
7002     }
7003
7004   name = input_line_pointer;
7005   while (*input_line_pointer && *input_line_pointer != ','
7006          && !ISSPACE (*input_line_pointer))
7007     input_line_pointer++;
7008   saved_char = *input_line_pointer;
7009   *input_line_pointer = 0;
7010
7011   if (m68k_set_arch (name, 1, 0))
7012     {
7013       /* Scan extensions. */
7014       do
7015         {
7016           *input_line_pointer++ = saved_char;
7017           if (!*input_line_pointer || ISSPACE (*input_line_pointer))
7018             break;
7019           name = input_line_pointer;
7020           while (*input_line_pointer && *input_line_pointer != ','
7021                  && !ISSPACE (*input_line_pointer))
7022             input_line_pointer++;
7023           saved_char = *input_line_pointer;
7024           *input_line_pointer = 0;
7025         }
7026       while (m68k_set_extension (name, 1, 0));
7027     }
7028
7029   *input_line_pointer = saved_char;
7030   demand_empty_rest_of_line ();
7031   return;
7032 }
7033 \f
7034 /* Lookup a cpu name in TABLE and return the slot found.  Return NULL
7035    if none is found, the caller is responsible for emitting an error
7036    message.  If ALLOW_M is non-zero, we allow an initial 'm' on the
7037    cpu name, if it begins with a '6' (possibly skipping an intervening
7038    'c'.  We also allow a 'c' in the same place.  if NEGATED is
7039    non-zero, we accept a leading 'no-' and *NEGATED is set to true, if
7040    the option is indeed negated.  */
7041
7042 static const struct m68k_cpu *
7043 m68k_lookup_cpu (const char *arg, const struct m68k_cpu *table,
7044                  int allow_m, int *negated)
7045 {
7046   /* allow negated value? */
7047   if (negated)
7048     {
7049       *negated = 0;
7050
7051       if (arg[0] == 'n' && arg[1] == 'o' && arg[2] == '-')
7052         {
7053           arg += 3;
7054           *negated = 1;
7055         }
7056     }
7057
7058   /* Remove 'm' or 'mc' prefix from 68k variants.  */
7059   if (allow_m)
7060     {
7061       if (arg[0] == 'm')
7062         {
7063           if (arg[1] == '6')
7064             arg += 1;
7065           else if (arg[1] == 'c'  && arg[2] == '6')
7066             arg += 2;
7067         }
7068     }
7069   else if (arg[0] == 'c' && arg[1] == '6')
7070     arg += 1;
7071
7072   for (; table->name; table++)
7073     if (!strcmp (arg, table->name))
7074       return table;
7075   return 0;
7076 }
7077
7078 /* Set the cpu, issuing errors if it is unrecognized, or invalid */
7079
7080 static int
7081 m68k_set_cpu (char const *name, int allow_m, int silent)
7082 {
7083   const struct m68k_cpu *cpu;
7084
7085   cpu = m68k_lookup_cpu (name, m68k_cpus, allow_m, NULL);
7086
7087   if (!cpu)
7088     {
7089       if (!silent)
7090         as_bad (_("cpu `%s' unrecognized"), name);
7091       return 0;
7092     }
7093
7094   if (selected_cpu && selected_cpu != cpu)
7095     {
7096       as_bad (_("already selected `%s' processor"),
7097               selected_cpu->name);
7098       return 0;
7099     }
7100   selected_cpu = cpu;
7101   return 1;
7102 }
7103
7104 /* Set the architecture, issuing errors if it is unrecognized, or invalid */
7105
7106 static int
7107 m68k_set_arch (char const *name, int allow_m, int silent)
7108 {
7109   const struct m68k_cpu *arch;
7110
7111   arch = m68k_lookup_cpu (name, m68k_archs, allow_m, NULL);
7112
7113   if (!arch)
7114     {
7115       if (!silent)
7116         as_bad (_("architecture `%s' unrecognized"), name);
7117       return 0;
7118     }
7119
7120   if (selected_arch && selected_arch != arch)
7121     {
7122       as_bad (_("already selected `%s' architecture"),
7123               selected_arch->name);
7124       return 0;
7125     }
7126
7127   selected_arch = arch;
7128   return 1;
7129 }
7130
7131 /* Set the architecture extension, issuing errors if it is
7132    unrecognized, or invalid */
7133
7134 static int
7135 m68k_set_extension (char const *name, int allow_m, int silent)
7136 {
7137   int negated;
7138   const struct m68k_cpu *ext;
7139
7140   ext = m68k_lookup_cpu (name, m68k_extensions, allow_m, &negated);
7141
7142   if (!ext)
7143     {
7144       if (!silent)
7145         as_bad (_("extension `%s' unrecognized"), name);
7146       return 0;
7147     }
7148
7149   if (negated)
7150     not_current_architecture |= ext->arch;
7151   else
7152     current_architecture |= ext->arch;
7153   return 1;
7154 }
7155
7156 /* md_parse_option
7157    Invocation line includes a switch not recognized by the base assembler.
7158  */
7159
7160 #ifdef OBJ_ELF
7161 const char *md_shortopts = "lSA:m:kQ:V";
7162 #else
7163 const char *md_shortopts = "lSA:m:k";
7164 #endif
7165
7166 struct option md_longopts[] = {
7167 #define OPTION_PIC (OPTION_MD_BASE)
7168   {"pic", no_argument, NULL, OPTION_PIC},
7169 #define OPTION_REGISTER_PREFIX_OPTIONAL (OPTION_MD_BASE + 1)
7170   {"register-prefix-optional", no_argument, NULL,
7171      OPTION_REGISTER_PREFIX_OPTIONAL},
7172 #define OPTION_BITWISE_OR (OPTION_MD_BASE + 2)
7173   {"bitwise-or", no_argument, NULL, OPTION_BITWISE_OR},
7174 #define OPTION_BASE_SIZE_DEFAULT_16 (OPTION_MD_BASE + 3)
7175   {"base-size-default-16", no_argument, NULL, OPTION_BASE_SIZE_DEFAULT_16},
7176 #define OPTION_BASE_SIZE_DEFAULT_32 (OPTION_MD_BASE + 4)
7177   {"base-size-default-32", no_argument, NULL, OPTION_BASE_SIZE_DEFAULT_32},
7178 #define OPTION_DISP_SIZE_DEFAULT_16 (OPTION_MD_BASE + 5)
7179   {"disp-size-default-16", no_argument, NULL, OPTION_DISP_SIZE_DEFAULT_16},
7180 #define OPTION_DISP_SIZE_DEFAULT_32 (OPTION_MD_BASE + 6)
7181   {"disp-size-default-32", no_argument, NULL, OPTION_DISP_SIZE_DEFAULT_32},
7182 #define OPTION_PCREL (OPTION_MD_BASE + 7)
7183   {"pcrel", no_argument, NULL, OPTION_PCREL},
7184   {NULL, no_argument, NULL, 0}
7185 };
7186 size_t md_longopts_size = sizeof (md_longopts);
7187
7188 int
7189 md_parse_option (int c, char *arg)
7190 {
7191   switch (c)
7192     {
7193     case 'l':                   /* -l means keep external to 2 bit offset
7194                                    rather than 16 bit one.  */
7195       flag_short_refs = 1;
7196       break;
7197
7198     case 'S':                   /* -S means that jbsr's always turn into
7199                                    jsr's.  */
7200       flag_long_jumps = 1;
7201       break;
7202
7203     case OPTION_PCREL:          /* --pcrel means never turn PC-relative
7204                                    branches into absolute jumps.  */
7205       flag_keep_pcrel = 1;
7206       break;
7207
7208     case OPTION_PIC:
7209     case 'k':
7210       flag_want_pic = 1;
7211       break;                    /* -pic, Position Independent Code.  */
7212
7213     case OPTION_REGISTER_PREFIX_OPTIONAL:
7214       flag_reg_prefix_optional = 1;
7215       reg_prefix_optional_seen = 1;
7216       break;
7217
7218       /* -V: SVR4 argument to print version ID.  */
7219     case 'V':
7220       print_version_id ();
7221       break;
7222
7223       /* -Qy, -Qn: SVR4 arguments controlling whether a .comment section
7224          should be emitted or not.  FIXME: Not implemented.  */
7225     case 'Q':
7226       break;
7227
7228     case OPTION_BITWISE_OR:
7229       {
7230         char *n, *t;
7231         const char *s;
7232
7233         n = (char *) xmalloc (strlen (m68k_comment_chars) + 1);
7234         t = n;
7235         for (s = m68k_comment_chars; *s != '\0'; s++)
7236           if (*s != '|')
7237             *t++ = *s;
7238         *t = '\0';
7239         m68k_comment_chars = n;
7240       }
7241       break;
7242
7243     case OPTION_BASE_SIZE_DEFAULT_16:
7244       m68k_index_width_default = SIZE_WORD;
7245       break;
7246
7247     case OPTION_BASE_SIZE_DEFAULT_32:
7248       m68k_index_width_default = SIZE_LONG;
7249       break;
7250
7251     case OPTION_DISP_SIZE_DEFAULT_16:
7252       m68k_rel32 = 0;
7253       m68k_rel32_from_cmdline = 1;
7254       break;
7255
7256     case OPTION_DISP_SIZE_DEFAULT_32:
7257       m68k_rel32 = 1;
7258       m68k_rel32_from_cmdline = 1;
7259       break;
7260
7261     case 'A':
7262 #if WARN_DEPRECATED
7263       as_tsktsk (_ ("option `-A%s' is deprecated: use `-%s'",
7264                     arg, arg));
7265 #endif
7266       /* Intentional fall-through.  */
7267     case 'm':
7268       if (!strncmp (arg, "arch=", 5))
7269         m68k_set_arch (arg + 5, 1, 0);
7270       else if (!strncmp (arg, "cpu=", 4))
7271         m68k_set_cpu (arg + 4, 1, 0);
7272       else if (m68k_set_extension (arg, 0, 1))
7273         ;
7274       else if (m68k_set_cpu (arg, 0, 1))
7275         ;
7276       else
7277         return 0;
7278       break;
7279
7280     default:
7281       return 0;
7282     }
7283
7284   return 1;
7285 }
7286
7287 /* Setup tables from the selected arch and/or cpu */
7288
7289 static void
7290 m68k_init_arch (void)
7291 {
7292   unsigned arch_of_chip = 0;
7293
7294   if (not_current_architecture & current_architecture)
7295     {
7296       as_bad (_("architecture features both enabled and disabled"));
7297       not_current_architecture &= ~current_architecture;
7298     }
7299   if (selected_arch)
7300     {
7301       arch_of_chip = selected_arch->arch;
7302       current_chip = selected_arch->chip;
7303       if (selected_cpu && (arch_of_chip & ~selected_cpu->arch))
7304         {
7305           as_bad (_("selected processor is not from selected architecture"));
7306           arch_of_chip = selected_cpu->arch;
7307         }
7308     }
7309   else
7310     arch_of_chip = selected_cpu->arch;
7311   if (selected_cpu)
7312     current_chip = selected_cpu->chip;
7313
7314   current_architecture |= arch_of_chip;
7315   current_architecture &= ~not_current_architecture;
7316   if ((current_architecture & m68k_mask)
7317       && (current_architecture & ~m68k_mask))
7318     {
7319       as_bad (_ ("m68k and cf features both selected"));
7320       if (arch_of_chip & m68k_mask)
7321         current_architecture &= m68k_mask;
7322       else
7323         current_architecture &= ~m68k_mask;
7324     }
7325
7326   /* Permit m68881 specification with all cpus; those that can't work
7327      with a coprocessor could be doing emulation.  */
7328   if (current_architecture & m68851)
7329     {
7330       if (current_architecture & m68040)
7331         as_warn (_("68040 and 68851 specified; mmu instructions may assemble incorrectly"));
7332     }
7333   /* What other incompatibilities could we check for?  */
7334
7335   /* Note which set of "movec" control registers is available.  */
7336   select_control_regs ();
7337
7338   if (cpu_of_arch (current_architecture) < m68020
7339       || arch_coldfire_p (current_architecture))
7340     md_relax_table[TAB (PCINDEX, BYTE)].rlx_more = 0;
7341
7342   initialized = 1;
7343 }
7344
7345 void
7346 md_show_usage (FILE *stream)
7347 {
7348   const char *default_cpu = TARGET_CPU;
7349   int i;
7350   unsigned int default_arch;
7351
7352   /* Get the canonical name for the default target CPU.  */
7353   if (*default_cpu == 'm')
7354     default_cpu++;
7355   for (i = 0; m68k_cpus[i].name; i++)
7356     {
7357       if (strcasecmp (default_cpu, m68k_cpus[i].name) == 0)
7358         {
7359           default_arch = m68k_cpus[i].arch;
7360           for (i = 0; m68k_cpus[i].name; i++)
7361             {
7362               if (m68k_cpus[i].arch == default_arch
7363                   && !m68k_cpus[i].alias)
7364                 {
7365                   default_cpu = m68k_cpus[i].name;
7366                   break;
7367                 }
7368             }
7369         }
7370     }
7371
7372   fprintf (stream, _("\
7373 -march=<arch>           set architecture\n\
7374 -mcpu=<cpu>             set cpu [default %s]\n\
7375 "), default_cpu);
7376   for (i = 0; m68k_extensions[i].name; i++)
7377     fprintf (stream, _("\
7378 -m[no-]%-16s enable/disable %s architecture extension\n\
7379 "), m68k_extensions[i].name, m68k_extensions[i].alias ? "ColdFire" : "m68k");
7380
7381   fprintf (stream, _("\
7382 -l                      use 1 word for refs to undefined symbols [default 2]\n\
7383 -pic, -k                generate position independent code\n\
7384 -S                      turn jbsr into jsr\n\
7385 --pcrel                 never turn PC-relative branches into absolute jumps\n\
7386 --register-prefix-optional\n\
7387                         recognize register names without prefix character\n\
7388 --bitwise-or            do not treat `|' as a comment character\n\
7389 --base-size-default-16  base reg without size is 16 bits\n\
7390 --base-size-default-32  base reg without size is 32 bits (default)\n\
7391 --disp-size-default-16  displacement with unknown size is 16 bits\n\
7392 --disp-size-default-32  displacement with unknown size is 32 bits (default)\n\
7393 "));
7394
7395   fprintf (stream, _("Architecture variants are: "));
7396   for (i = 0; m68k_archs[i].name; i++)
7397     {
7398       if (i)
7399         fprintf (stream, " | ");
7400       fprintf (stream, m68k_archs[i].name);
7401     }
7402   fprintf (stream, "\n");
7403
7404   fprintf (stream, _("Processor variants are: "));
7405   for (i = 0; m68k_cpus[i].name; i++)
7406     {
7407       if (i)
7408         fprintf (stream, " | ");
7409       fprintf (stream, m68k_cpus[i].name);
7410     }
7411   fprintf (stream, _("\n"));
7412 }
7413 \f
7414 #ifdef TEST2
7415
7416 /* TEST2:  Test md_assemble() */
7417 /* Warning, this routine probably doesn't work anymore.  */
7418 int
7419 main (void)
7420 {
7421   struct m68k_it the_ins;
7422   char buf[120];
7423   char *cp;
7424   int n;
7425
7426   m68k_ip_begin ();
7427   for (;;)
7428     {
7429       if (!gets (buf) || !*buf)
7430         break;
7431       if (buf[0] == '|' || buf[1] == '.')
7432         continue;
7433       for (cp = buf; *cp; cp++)
7434         if (*cp == '\t')
7435           *cp = ' ';
7436       if (is_label (buf))
7437         continue;
7438       memset (&the_ins, '\0', sizeof (the_ins));
7439       m68k_ip (&the_ins, buf);
7440       if (the_ins.error)
7441         {
7442           printf (_("Error %s in %s\n"), the_ins.error, buf);
7443         }
7444       else
7445         {
7446           printf (_("Opcode(%d.%s): "), the_ins.numo, the_ins.args);
7447           for (n = 0; n < the_ins.numo; n++)
7448             printf (" 0x%x", the_ins.opcode[n] & 0xffff);
7449           printf ("    ");
7450           print_the_insn (&the_ins.opcode[0], stdout);
7451           (void) putchar ('\n');
7452         }
7453       for (n = 0; n < strlen (the_ins.args) / 2; n++)
7454         {
7455           if (the_ins.operands[n].error)
7456             {
7457               printf ("op%d Error %s in %s\n", n, the_ins.operands[n].error, buf);
7458               continue;
7459             }
7460           printf ("mode %d, reg %d, ", the_ins.operands[n].mode,
7461                   the_ins.operands[n].reg);
7462           if (the_ins.operands[n].b_const)
7463             printf ("Constant: '%.*s', ",
7464                     1 + the_ins.operands[n].e_const - the_ins.operands[n].b_const,
7465                     the_ins.operands[n].b_const);
7466           printf ("ireg %d, isiz %d, imul %d, ", the_ins.operands[n].ireg,
7467                   the_ins.operands[n].isiz, the_ins.operands[n].imul);
7468           if (the_ins.operands[n].b_iadd)
7469             printf ("Iadd: '%.*s',",
7470                     1 + the_ins.operands[n].e_iadd - the_ins.operands[n].b_iadd,
7471                     the_ins.operands[n].b_iadd);
7472           putchar ('\n');
7473         }
7474     }
7475   m68k_ip_end ();
7476   return 0;
7477 }
7478
7479 int
7480 is_label (char *str)
7481 {
7482   while (*str == ' ')
7483     str++;
7484   while (*str && *str != ' ')
7485     str++;
7486   if (str[-1] == ':' || str[1] == '=')
7487     return 1;
7488   return 0;
7489 }
7490
7491 #endif
7492
7493 /* Possible states for relaxation:
7494
7495    0 0  branch offset   byte    (bra, etc)
7496    0 1                  word
7497    0 2                  long
7498
7499    1 0  indexed offsets byte    a0@(32,d4:w:1) etc
7500    1 1                  word
7501    1 2                  long
7502
7503    2 0  two-offset index word-word a0@(32,d4)@(45) etc
7504    2 1                  word-long
7505    2 2                  long-word
7506    2 3                  long-long
7507
7508    */
7509
7510 /* We have no need to default values of symbols.  */
7511
7512 symbolS *
7513 md_undefined_symbol (char *name ATTRIBUTE_UNUSED)
7514 {
7515   return 0;
7516 }
7517
7518 /* Round up a section size to the appropriate boundary.  */
7519 valueT
7520 md_section_align (segT segment ATTRIBUTE_UNUSED, valueT size)
7521 {
7522 #ifdef OBJ_AOUT
7523   /* For a.out, force the section size to be aligned.  If we don't do
7524      this, BFD will align it for us, but it will not write out the
7525      final bytes of the section.  This may be a bug in BFD, but it is
7526      easier to fix it here since that is how the other a.out targets
7527      work.  */
7528   int align;
7529
7530   align = bfd_get_section_alignment (stdoutput, segment);
7531   size = ((size + (1 << align) - 1) & ((valueT) -1 << align));
7532 #endif
7533
7534   return size;
7535 }
7536
7537 /* Exactly what point is a PC-relative offset relative TO?
7538    On the 68k, it is relative to the address of the first extension
7539    word.  The difference between the addresses of the offset and the
7540    first extension word is stored in fx_pcrel_adjust.  */
7541 long
7542 md_pcrel_from (fixS *fixP)
7543 {
7544   int adjust;
7545
7546   /* Because fx_pcrel_adjust is a char, and may be unsigned, we explicitly
7547      sign extend the value here.  */
7548   adjust = ((fixP->fx_pcrel_adjust & 0xff) ^ 0x80) - 0x80;
7549   if (adjust == 64)
7550     adjust = -1;
7551   return fixP->fx_where + fixP->fx_frag->fr_address - adjust;
7552 }
7553
7554 #ifdef OBJ_ELF
7555 void
7556 m68k_elf_final_processing (void)
7557 {
7558   unsigned flags = 0;
7559
7560   if (arch_coldfire_fpu (current_architecture))
7561     flags |= EF_M68K_CFV4E;
7562   /* Set file-specific flags if this is a cpu32 processor.  */
7563   if (cpu_of_arch (current_architecture) & cpu32)
7564     flags |= EF_M68K_CPU32;
7565   else if ((cpu_of_arch (current_architecture) & m68000up)
7566            && !(cpu_of_arch (current_architecture) & m68020up))
7567     flags |= EF_M68K_M68000;
7568
7569   if (current_architecture & mcfisa_a)
7570     {
7571       /* Set coldfire specific elf flags */
7572       if (current_architecture & mcfisa_b)
7573         flags |= EF_M68K_ISA_B;
7574       else if (current_architecture & mcfisa_aa)
7575         flags |= EF_M68K_ISA_A_PLUS;
7576       else
7577         flags |= EF_M68K_ISA_A;
7578
7579       if (current_architecture & mcfhwdiv)
7580         flags |= EF_M68K_HW_DIV;
7581
7582       if (current_architecture & mcfusp)
7583         flags |= EF_M68K_USP;
7584
7585       if (current_architecture & cfloat)
7586         flags |= EF_M68K_FLOAT;
7587
7588       if (current_architecture & mcfmac)
7589         flags |= EF_M68K_MAC;
7590       else if (current_architecture & mcfemac)
7591         flags |= EF_M68K_EMAC;
7592     }
7593   elf_elfheader (stdoutput)->e_flags |= flags;
7594 }
7595 #endif
7596
7597 int
7598 tc_m68k_regname_to_dw2regnum (const char *regname)
7599 {
7600   unsigned int regnum;
7601   static const char *const regnames[] =
7602     {
7603       "d0", "d1", "d2", "d3", "d4", "d5", "d6", "d7",
7604       "a0", "a1", "a2", "a3", "a4", "a5", "a6", "sp",
7605       "fp0", "fp1", "fp2", "fp3", "fp4", "fp5", "fp6", "fp7",
7606       "pc"
7607     };
7608
7609   for (regnum = 0; regnum < ARRAY_SIZE (regnames); regnum++)
7610     if (strcmp (regname, regnames[regnum]) == 0)
7611       return regnum;
7612
7613   return -1;
7614 }
7615
7616 void
7617 tc_m68k_frame_initial_instructions (void)
7618 {
7619   static int sp_regno = -1;
7620
7621   if (sp_regno < 0)
7622     sp_regno = tc_m68k_regname_to_dw2regnum ("sp");
7623
7624   cfi_add_CFA_def_cfa (sp_regno, -DWARF2_CIE_DATA_ALIGNMENT);
7625   cfi_add_CFA_offset (DWARF2_DEFAULT_RETURN_COLUMN, DWARF2_CIE_DATA_ALIGNMENT);
7626 }