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