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