gas/config/tc-m68k.c

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