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