gas/config/tc-m68k.c

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