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