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