gas/config/tc-m68k.c

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