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