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