gas/config/tc-m68k.c

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