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