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 m68000:
3954       control_regs = m68000_control_regs;
3955       break;
3956     case m68010:
3957       control_regs = m68010_control_regs;
3958       break;
3959     case m68020:
3960     case m68030:
3961       control_regs = m68020_control_regs;
3962       break;
3963     case m68040:
3964       control_regs = m68040_control_regs;
3965       break;
3966     case m68060:
3967       control_regs = m68060_control_regs;
3968       break;
3969     case cpu32:
3970       control_regs = cpu32_control_regs;
3971       break;
3972     case mcf5200:
3973     case mcf5206e:
3974     case mcf5307:
3975     case mcf5407:
3976       control_regs = mcf_control_regs;
3977       break;
3978     default:
3979       abort ();
3980     }
3981 }
3982
3983 void
3984 m68k_init_after_args ()
3985 {
3986   if (cpu_of_arch (current_architecture) == 0)
3987     {
3988       int i;
3989       const char *default_cpu = TARGET_CPU;
3990
3991       if (*default_cpu == 'm')
3992         default_cpu++;
3993       for (i = 0; i < n_archs; i++)
3994         if (strcasecmp (default_cpu, archs[i].name) == 0)
3995           break;
3996       if (i == n_archs)
3997         {
3998           as_bad (_("unrecognized default cpu `%s' ???"), TARGET_CPU);
3999           current_architecture |= m68020;
4000         }
4001       else
4002         current_architecture |= archs[i].arch;
4003     }
4004   /* Permit m68881 specification with all cpus; those that can't work
4005      with a coprocessor could be doing emulation.  */
4006   if (current_architecture & m68851)
4007     {
4008       if (current_architecture & m68040)
4009         {
4010           as_warn (_("68040 and 68851 specified; mmu instructions may assemble incorrectly"));
4011         }
4012     }
4013   /* What other incompatibilities could we check for?  */
4014
4015   /* Toss in some default assumptions about coprocessors.  */
4016   if (!no_68881
4017       && (cpu_of_arch (current_architecture)
4018           /* Can CPU32 have a 68881 coprocessor??  */
4019           & (m68020 | m68030 | cpu32)))
4020     {
4021       current_architecture |= m68881;
4022     }
4023   if (!no_68851
4024       && (cpu_of_arch (current_architecture) & m68020up) != 0
4025       && (cpu_of_arch (current_architecture) & m68040up) == 0)
4026     {
4027       current_architecture |= m68851;
4028     }
4029   if (no_68881 && (current_architecture & m68881))
4030     as_bad (_("options for 68881 and no-68881 both given"));
4031   if (no_68851 && (current_architecture & m68851))
4032     as_bad (_("options for 68851 and no-68851 both given"));
4033
4034 #ifdef OBJ_AOUT
4035   /* Work out the magic number.  This isn't very general.  */
4036   if (current_architecture & m68000)
4037     m68k_aout_machtype = 0;
4038   else if (current_architecture & m68010)
4039     m68k_aout_machtype = 1;
4040   else if (current_architecture & m68020)
4041     m68k_aout_machtype = 2;
4042   else
4043     m68k_aout_machtype = 2;
4044 #endif
4045
4046   /* Note which set of "movec" control registers is available.  */
4047   select_control_regs ();
4048
4049   if (cpu_of_arch (current_architecture) < m68020
4050       || arch_coldfire_p (current_architecture))
4051     md_relax_table[TAB (PCINDEX, BYTE)].rlx_more = 0;
4052 }
4053 \f
4054 /* This is called when a label is defined.  */
4055
4056 void
4057 m68k_frob_label (sym)
4058      symbolS *sym;
4059 {
4060   struct label_line *n;
4061
4062   n = (struct label_line *) xmalloc (sizeof *n);
4063   n->next = labels;
4064   n->label = sym;
4065   as_where (&n->file, &n->line);
4066   n->text = 0;
4067   labels = n;
4068   current_label = n;
4069 }
4070
4071 /* This is called when a value that is not an instruction is emitted.  */
4072
4073 void
4074 m68k_flush_pending_output ()
4075 {
4076   current_label = NULL;
4077 }
4078
4079 /* This is called at the end of the assembly, when the final value of
4080    the label is known.  We warn if this is a text symbol aligned at an
4081    odd location.  */
4082
4083 void
4084 m68k_frob_symbol (sym)
4085      symbolS *sym;
4086 {
4087   if (S_GET_SEGMENT (sym) == reg_section
4088       && (int) S_GET_VALUE (sym) < 0)
4089     {
4090       S_SET_SEGMENT (sym, absolute_section);
4091       S_SET_VALUE (sym, ~(int)S_GET_VALUE (sym));
4092     }
4093   else if ((S_GET_VALUE (sym) & 1) != 0)
4094     {
4095       struct label_line *l;
4096
4097       for (l = labels; l != NULL; l = l->next)
4098         {
4099           if (l->label == sym)
4100             {
4101               if (l->text)
4102                 as_warn_where (l->file, l->line,
4103                                _("text label `%s' aligned to odd boundary"),
4104                                S_GET_NAME (sym));
4105               break;
4106             }
4107         }
4108     }
4109 }
4110 \f
4111 /* This is called if we go in or out of MRI mode because of the .mri
4112    pseudo-op.  */
4113
4114 void
4115 m68k_mri_mode_change (on)
4116      int on;
4117 {
4118   if (on)
4119     {
4120       if (! flag_reg_prefix_optional)
4121         {
4122           flag_reg_prefix_optional = 1;
4123 #ifdef REGISTER_PREFIX
4124           init_regtable ();
4125 #endif
4126         }
4127       m68k_abspcadd = 1;
4128       if (! m68k_rel32_from_cmdline)
4129         m68k_rel32 = 0;
4130     }
4131   else
4132     {
4133       if (! reg_prefix_optional_seen)
4134         {
4135 #ifdef REGISTER_PREFIX_OPTIONAL
4136           flag_reg_prefix_optional = REGISTER_PREFIX_OPTIONAL;
4137 #else
4138           flag_reg_prefix_optional = 0;
4139 #endif
4140 #ifdef REGISTER_PREFIX
4141           init_regtable ();
4142 #endif
4143         }
4144       m68k_abspcadd = 0;
4145       if (! m68k_rel32_from_cmdline)
4146         m68k_rel32 = 1;
4147     }
4148 }
4149
4150 /* Equal to MAX_PRECISION in atof-ieee.c */
4151 #define MAX_LITTLENUMS 6
4152
4153 /* Turn a string in input_line_pointer into a floating point constant
4154    of type TYPE, and store the appropriate bytes in *LITP.  The number
4155    of LITTLENUMS emitted is stored in *SIZEP.  An error message is
4156    returned, or NULL on OK.  */
4157
4158 char *
4159 md_atof (type, litP, sizeP)
4160      char type;
4161      char *litP;
4162      int *sizeP;
4163 {
4164   int prec;
4165   LITTLENUM_TYPE words[MAX_LITTLENUMS];
4166   LITTLENUM_TYPE *wordP;
4167   char *t;
4168
4169   switch (type)
4170     {
4171     case 'f':
4172     case 'F':
4173     case 's':
4174     case 'S':
4175       prec = 2;
4176       break;
4177
4178     case 'd':
4179     case 'D':
4180     case 'r':
4181     case 'R':
4182       prec = 4;
4183       break;
4184
4185     case 'x':
4186     case 'X':
4187       prec = 6;
4188       break;
4189
4190     case 'p':
4191     case 'P':
4192       prec = 6;
4193       break;
4194
4195     default:
4196       *sizeP = 0;
4197       return _("Bad call to MD_ATOF()");
4198     }
4199   t = atof_ieee (input_line_pointer, type, words);
4200   if (t)
4201     input_line_pointer = t;
4202
4203   *sizeP = prec * sizeof (LITTLENUM_TYPE);
4204   for (wordP = words; prec--;)
4205     {
4206       md_number_to_chars (litP, (long) (*wordP++), sizeof (LITTLENUM_TYPE));
4207       litP += sizeof (LITTLENUM_TYPE);
4208     }
4209   return 0;
4210 }
4211
4212 void
4213 md_number_to_chars (buf, val, n)
4214      char *buf;
4215      valueT val;
4216      int n;
4217 {
4218   number_to_chars_bigendian (buf, val, n);
4219 }
4220
4221 void
4222 md_apply_fix3 (fixP, valP, seg)
4223      fixS *fixP;
4224      valueT *valP;
4225      segT seg ATTRIBUTE_UNUSED;
4226 {
4227   offsetT val = *valP;
4228   addressT upper_limit;
4229   offsetT lower_limit;
4230
4231   /* This is unnecessary but it convinces the native rs6000 compiler
4232      to generate the code we want.  */
4233   char *buf = fixP->fx_frag->fr_literal;
4234   buf += fixP->fx_where;
4235   /* end ibm compiler workaround */
4236
4237   val = ((val & 0xffffffff) ^ 0x80000000) - 0x80000000;
4238
4239   if (fixP->fx_addsy == NULL && fixP->fx_pcrel == 0)
4240     fixP->fx_done = 1;
4241
4242 #ifdef OBJ_ELF
4243   if (fixP->fx_addsy)
4244     {
4245       memset (buf, 0, fixP->fx_size);
4246       fixP->fx_addnumber = val; /* Remember value for emit_reloc */
4247
4248       if (fixP->fx_r_type == BFD_RELOC_VTABLE_INHERIT
4249           && !S_IS_DEFINED (fixP->fx_addsy)
4250           && !S_IS_WEAK (fixP->fx_addsy))
4251         S_SET_WEAK (fixP->fx_addsy);
4252       return;
4253     }
4254 #endif
4255
4256 #ifdef BFD_ASSEMBLER
4257   if (fixP->fx_r_type == BFD_RELOC_VTABLE_INHERIT
4258       || fixP->fx_r_type == BFD_RELOC_VTABLE_ENTRY)
4259     return;
4260 #endif
4261
4262   switch (fixP->fx_size)
4263     {
4264       /* The cast to offsetT below are necessary to make code
4265          correct for machines where ints are smaller than offsetT.  */
4266     case 1:
4267       *buf++ = val;
4268       upper_limit = 0x7f;
4269       lower_limit = - (offsetT) 0x80;
4270       break;
4271     case 2:
4272       *buf++ = (val >> 8);
4273       *buf++ = val;
4274       upper_limit = 0x7fff;
4275       lower_limit = - (offsetT) 0x8000;
4276       break;
4277     case 4:
4278       *buf++ = (val >> 24);
4279       *buf++ = (val >> 16);
4280       *buf++ = (val >> 8);
4281       *buf++ = val;
4282       upper_limit = 0x7fffffff;
4283       lower_limit = - (offsetT) 0x7fffffff - 1; /* avoid constant overflow */
4284       break;
4285     default:
4286       BAD_CASE (fixP->fx_size);
4287     }
4288
4289   /* Fix up a negative reloc.  */
4290   if (fixP->fx_addsy == NULL && fixP->fx_subsy != NULL)
4291     {
4292       fixP->fx_addsy = fixP->fx_subsy;
4293       fixP->fx_subsy = NULL;
4294       fixP->fx_tcbit = 1;
4295     }
4296
4297   /* For non-pc-relative values, it's conceivable we might get something
4298      like "0xff" for a byte field.  So extend the upper part of the range
4299      to accept such numbers.  We arbitrarily disallow "-0xff" or "0xff+0xff",
4300      so that we can do any range checking at all.  */
4301   if (! fixP->fx_pcrel && ! fixP->fx_signed)
4302     upper_limit = upper_limit * 2 + 1;
4303
4304   if ((addressT) val > upper_limit
4305       && (val > 0 || val < lower_limit))
4306     as_bad_where (fixP->fx_file, fixP->fx_line, _("value out of range"));
4307
4308   /* A one byte PC-relative reloc means a short branch.  We can't use
4309      a short branch with a value of 0 or -1, because those indicate
4310      different opcodes (branches with longer offsets).  fixup_segment
4311      in write.c may have clobbered fx_pcrel, so we need to examine the
4312      reloc type.  */
4313   if ((fixP->fx_pcrel
4314 #ifdef BFD_ASSEMBLER
4315        || fixP->fx_r_type == BFD_RELOC_8_PCREL
4316 #endif
4317        )
4318       && fixP->fx_size == 1
4319       && (fixP->fx_addsy == NULL
4320           || S_IS_DEFINED (fixP->fx_addsy))
4321       && (val == 0 || val == -1))
4322     as_bad_where (fixP->fx_file, fixP->fx_line, _("invalid byte branch offset"));
4323 }
4324
4325 /* *fragP has been relaxed to its final size, and now needs to have
4326    the bytes inside it modified to conform to the new size  There is UGLY
4327    MAGIC here. ..
4328    */
4329 static void
4330 md_convert_frag_1 (fragP)
4331      register fragS *fragP;
4332 {
4333   long disp;
4334   fixS *fixP;
4335
4336   /* Address in object code of the displacement.  */
4337   register int object_address = fragP->fr_fix + fragP->fr_address;
4338
4339   /* Address in gas core of the place to store the displacement.  */
4340   /* This convinces the native rs6000 compiler to generate the code we
4341      want.  */
4342   register char *buffer_address = fragP->fr_literal;
4343   buffer_address += fragP->fr_fix;
4344   /* end ibm compiler workaround */
4345
4346   /* The displacement of the address, from current location.  */
4347   disp = fragP->fr_symbol ? S_GET_VALUE (fragP->fr_symbol) : 0;
4348   disp = (disp + fragP->fr_offset) - object_address;
4349
4350   switch (fragP->fr_subtype)
4351     {
4352     case TAB (BRANCHBWL, BYTE):
4353     case TAB (BRABSJUNC, BYTE):
4354     case TAB (BRABSJCOND, BYTE):
4355     case TAB (BRANCHBW, BYTE):
4356       know (issbyte (disp));
4357       if (disp == 0)
4358         as_bad_where (fragP->fr_file, fragP->fr_line,
4359                       _("short branch with zero offset: use :w"));
4360       fixP = fix_new (fragP, fragP->fr_fix - 1, 1, fragP->fr_symbol,
4361                       fragP->fr_offset, 1, RELAX_RELOC_PC8);
4362       fixP->fx_pcrel_adjust = -1;
4363       break;
4364     case TAB (BRANCHBWL, SHORT):
4365     case TAB (BRABSJUNC, SHORT):
4366     case TAB (BRABSJCOND, SHORT):
4367     case TAB (BRANCHBW, SHORT):
4368       fragP->fr_opcode[1] = 0x00;
4369       fix_new (fragP, fragP->fr_fix, 2, fragP->fr_symbol, fragP->fr_offset,
4370                1, RELAX_RELOC_PC16);
4371       fragP->fr_fix += 2;
4372       break;
4373     case TAB (BRANCHBWL, LONG):
4374       fragP->fr_opcode[1] = (char) 0xFF;
4375       fix_new (fragP, fragP->fr_fix, 4, fragP->fr_symbol, fragP->fr_offset,
4376                1, RELAX_RELOC_PC32);
4377       fragP->fr_fix += 4;
4378       break;
4379     case TAB (BRABSJUNC, LONG):
4380       if (fragP->fr_opcode[0] == 0x61)          /* jbsr */
4381         {
4382           fragP->fr_opcode[0] = 0x4E;
4383           fragP->fr_opcode[1] = (char) 0xB9; /* JSR with ABSL LONG operand */
4384           fix_new (fragP, fragP->fr_fix, 4, fragP->fr_symbol, fragP->fr_offset,
4385                    0, RELAX_RELOC_ABS32);
4386           fragP->fr_fix += 4;
4387         }
4388       else if (fragP->fr_opcode[0] == 0x60)     /* jbra */
4389         {
4390           fragP->fr_opcode[0] = 0x4E;
4391           fragP->fr_opcode[1] = (char) 0xF9; /* JMP with ABSL LONG operand */
4392           fix_new (fragP, fragP->fr_fix, 4, fragP->fr_symbol, fragP->fr_offset,
4393                    0, RELAX_RELOC_ABS32);
4394           fragP->fr_fix += 4;
4395         }
4396       else
4397         {
4398           /* This cannot happen, because jbsr and jbra are the only two
4399              unconditional branches.  */
4400           abort ();
4401         }
4402       break;
4403     case TAB (BRABSJCOND, LONG):
4404       /* Only Bcc 68000 instructions can come here.  */
4405       /* Change bcc into b!cc/jmp absl long.  */
4406
4407       fragP->fr_opcode[0] ^= 0x01;      /* invert bcc */
4408       fragP->fr_opcode[1] = 0x6;/* branch offset = 6 */
4409
4410       /* JF: these used to be fr_opcode[2,3], but they may be in a
4411            different frag, in which case refering to them is a no-no.
4412            Only fr_opcode[0,1] are guaranteed to work.  */
4413       *buffer_address++ = 0x4e; /* put in jmp long (0x4ef9) */
4414       *buffer_address++ = (char) 0xf9;
4415       fragP->fr_fix += 2;       /* account for jmp instruction */
4416       fix_new (fragP, fragP->fr_fix, 4, fragP->fr_symbol,
4417                fragP->fr_offset, 0, RELAX_RELOC_ABS32);
4418       fragP->fr_fix += 4;
4419       break;
4420     case TAB (FBRANCH, SHORT):
4421       know ((fragP->fr_opcode[1] & 0x40) == 0);
4422       fix_new (fragP, fragP->fr_fix, 2, fragP->fr_symbol, fragP->fr_offset,
4423                1, RELAX_RELOC_PC16);
4424       fragP->fr_fix += 2;
4425       break;
4426     case TAB (FBRANCH, LONG):
4427       fragP->fr_opcode[1] |= 0x40;      /* Turn on LONG bit */
4428       fix_new (fragP, fragP->fr_fix, 4, fragP->fr_symbol, fragP->fr_offset,
4429                1, RELAX_RELOC_PC32);
4430       fragP->fr_fix += 4;
4431       break;
4432     case TAB (DBCCLBR, SHORT):
4433     case TAB (DBCCABSJ, SHORT):
4434       fix_new (fragP, fragP->fr_fix, 2, fragP->fr_symbol, fragP->fr_offset,
4435                1, RELAX_RELOC_PC16);
4436       fragP->fr_fix += 2;
4437       break;
4438     case TAB (DBCCLBR, LONG):
4439       /* only DBcc instructions can come here */
4440       /* Change dbcc into dbcc/bral.  */
4441
4442       /* JF: these used to be fr_opcode[2-7], but that's wrong */
4443       *buffer_address++ = 0x00; /* branch offset = 4 */
4444       *buffer_address++ = 0x04;
4445       *buffer_address++ = 0x60; /* put in bra pc+6 */
4446       *buffer_address++ = 0x06;
4447       *buffer_address++ = 0x60;     /* Put in bral (0x60ff).  */
4448       *buffer_address++ = (char) 0xff;
4449
4450       fragP->fr_fix += 6;       /* account for bra/jmp instructions */
4451       fix_new (fragP, fragP->fr_fix, 4, fragP->fr_symbol, fragP->fr_offset, 1,
4452                RELAX_RELOC_PC32);
4453       fragP->fr_fix += 4;
4454       break;
4455     case TAB (DBCCABSJ, LONG):
4456       /* only DBcc instructions can come here */
4457       /* Change dbcc into dbcc/jmp.  */
4458
4459       /* JF: these used to be fr_opcode[2-7], but that's wrong */
4460       *buffer_address++ = 0x00; /* branch offset = 4 */
4461       *buffer_address++ = 0x04;
4462       *buffer_address++ = 0x60; /* put in bra pc+6 */
4463       *buffer_address++ = 0x06;
4464       *buffer_address++ = 0x4e;     /* Put in jmp long (0x4ef9).  */
4465       *buffer_address++ = (char) 0xf9;
4466
4467       fragP->fr_fix += 6;       /* account for bra/jmp instructions */
4468       fix_new (fragP, fragP->fr_fix, 4, fragP->fr_symbol, fragP->fr_offset, 0,
4469                RELAX_RELOC_ABS32);
4470       fragP->fr_fix += 4;
4471       break;
4472     case TAB (PCREL1632, SHORT):
4473       fragP->fr_opcode[1] &= ~0x3F;
4474       fragP->fr_opcode[1] |= 0x3A; /* 072 - mode 7.2 */
4475       fix_new (fragP, (int) (fragP->fr_fix), 2, fragP->fr_symbol,
4476                fragP->fr_offset, 1, RELAX_RELOC_PC16);
4477       fragP->fr_fix += 2;
4478       break;
4479     case TAB (PCREL1632, LONG):
4480       /* Already set to mode 7.3; this indicates: PC indirect with
4481          suppressed index, 32-bit displacement.  */
4482       *buffer_address++ = 0x01;
4483       *buffer_address++ = 0x70;
4484       fragP->fr_fix += 2;
4485       fixP = fix_new (fragP, (int) (fragP->fr_fix), 4, fragP->fr_symbol,
4486                       fragP->fr_offset, 1, RELAX_RELOC_PC32);
4487       fixP->fx_pcrel_adjust = 2;
4488       fragP->fr_fix += 4;
4489       break;
4490     case TAB (PCINDEX, BYTE):
4491       assert (fragP->fr_fix >= 2);
4492       buffer_address[-2] &= ~1;
4493       fixP = fix_new (fragP, fragP->fr_fix - 1, 1, fragP->fr_symbol,
4494                       fragP->fr_offset, 1, RELAX_RELOC_PC8);
4495       fixP->fx_pcrel_adjust = 1;
4496       break;
4497     case TAB (PCINDEX, SHORT):
4498       assert (fragP->fr_fix >= 2);
4499       buffer_address[-2] |= 0x1;
4500       buffer_address[-1] = 0x20;
4501       fixP = fix_new (fragP, (int) (fragP->fr_fix), 2, fragP->fr_symbol,
4502                       fragP->fr_offset, 1, RELAX_RELOC_PC16);
4503       fixP->fx_pcrel_adjust = 2;
4504       fragP->fr_fix += 2;
4505       break;
4506     case TAB (PCINDEX, LONG):
4507       assert (fragP->fr_fix >= 2);
4508       buffer_address[-2] |= 0x1;
4509       buffer_address[-1] = 0x30;
4510       fixP = fix_new (fragP, (int) (fragP->fr_fix), 4, fragP->fr_symbol,
4511                       fragP->fr_offset, 1, RELAX_RELOC_PC32);
4512       fixP->fx_pcrel_adjust = 2;
4513       fragP->fr_fix += 4;
4514       break;
4515     case TAB (ABSTOPCREL, SHORT):
4516       fix_new (fragP, fragP->fr_fix, 2, fragP->fr_symbol, fragP->fr_offset,
4517                1, RELAX_RELOC_PC16);
4518       fragP->fr_fix += 2;
4519       break;
4520     case TAB (ABSTOPCREL, LONG):
4521       /* The thing to do here is force it to ABSOLUTE LONG, since
4522          ABSTOPCREL is really trying to shorten an ABSOLUTE address anyway */
4523       if ((fragP->fr_opcode[1] & 0x3F) != 0x3A)
4524         abort ();
4525       fragP->fr_opcode[1] &= ~0x3F;
4526       fragP->fr_opcode[1] |= 0x39;      /* Mode 7.1 */
4527       fix_new (fragP, fragP->fr_fix, 4, fragP->fr_symbol, fragP->fr_offset,
4528                0, RELAX_RELOC_ABS32);
4529       fragP->fr_fix += 4;
4530       break;
4531     }
4532 }
4533
4534 #ifndef BFD_ASSEMBLER
4535
4536 void
4537 md_convert_frag (headers, sec, fragP)
4538      object_headers *headers ATTRIBUTE_UNUSED;
4539      segT sec ATTRIBUTE_UNUSED;
4540      fragS *fragP;
4541 {
4542   md_convert_frag_1 (fragP);
4543 }
4544
4545 #else
4546
4547 void
4548 md_convert_frag (abfd, sec, fragP)
4549      bfd *abfd ATTRIBUTE_UNUSED;
4550      segT sec ATTRIBUTE_UNUSED;
4551      fragS *fragP;
4552 {
4553   md_convert_frag_1 (fragP);
4554 }
4555 #endif
4556
4557 /* Force truly undefined symbols to their maximum size, and generally set up
4558    the frag list to be relaxed
4559    */
4560 int
4561 md_estimate_size_before_relax (fragP, segment)
4562      register fragS *fragP;
4563      segT segment;
4564 {
4565   /* Handle SZ_UNDEF first, it can be changed to BYTE or SHORT.  */
4566   switch (fragP->fr_subtype)
4567     {
4568     case TAB (BRANCHBWL, SZ_UNDEF):
4569     case TAB (BRABSJUNC, SZ_UNDEF):
4570     case TAB (BRABSJCOND, SZ_UNDEF):
4571       {
4572         if (S_GET_SEGMENT (fragP->fr_symbol) == segment
4573             && relaxable_symbol (fragP->fr_symbol))
4574           {
4575             fragP->fr_subtype = TAB (TABTYPE (fragP->fr_subtype), BYTE);
4576           }
4577         else if (flag_short_refs)
4578           {
4579             /* Symbol is undefined and we want short ref.  */
4580             fragP->fr_subtype = TAB (TABTYPE (fragP->fr_subtype), SHORT);
4581           }
4582         else
4583           {
4584             /* Symbol is still undefined.  Make it LONG.  */
4585             fragP->fr_subtype = TAB (TABTYPE (fragP->fr_subtype), LONG);
4586           }
4587         break;
4588       }
4589
4590     case TAB (BRANCHBW, SZ_UNDEF):
4591       {
4592         if (S_GET_SEGMENT (fragP->fr_symbol) == segment
4593             && relaxable_symbol (fragP->fr_symbol))
4594           {
4595             fragP->fr_subtype = TAB (TABTYPE (fragP->fr_subtype), BYTE);
4596           }
4597         else
4598           {
4599             /* Symbol is undefined and we don't have long branches.  */
4600             fragP->fr_subtype = TAB (TABTYPE (fragP->fr_subtype), SHORT);
4601           }
4602         break;
4603       }
4604
4605     case TAB (FBRANCH, SZ_UNDEF):
4606     case TAB (DBCCLBR, SZ_UNDEF):
4607     case TAB (DBCCABSJ, SZ_UNDEF):
4608     case TAB (PCREL1632, SZ_UNDEF):
4609       {
4610         if ((S_GET_SEGMENT (fragP->fr_symbol) == segment
4611              && relaxable_symbol (fragP->fr_symbol))
4612             || flag_short_refs)
4613           {
4614             fragP->fr_subtype = TAB (TABTYPE (fragP->fr_subtype), SHORT);
4615           }
4616         else
4617           {
4618             fragP->fr_subtype = TAB (TABTYPE (fragP->fr_subtype), LONG);
4619           }
4620         break;
4621       }
4622
4623     case TAB (PCINDEX, SZ_UNDEF):
4624       if ((S_GET_SEGMENT (fragP->fr_symbol) == segment
4625            && relaxable_symbol (fragP->fr_symbol)))
4626         {
4627           fragP->fr_subtype = TAB (PCINDEX, BYTE);
4628         }
4629       else
4630         {
4631           fragP->fr_subtype = TAB (PCINDEX, LONG);
4632         }
4633       break;
4634
4635     case TAB (ABSTOPCREL, SZ_UNDEF):
4636       {
4637         if ((S_GET_SEGMENT (fragP->fr_symbol) == segment
4638              && relaxable_symbol (fragP->fr_symbol)))
4639           {
4640             fragP->fr_subtype = TAB (ABSTOPCREL, SHORT);
4641           }
4642         else
4643           {
4644             fragP->fr_subtype = TAB (ABSTOPCREL, LONG);
4645           }
4646         break;
4647       }
4648
4649     default:
4650       break;
4651     }
4652
4653   /* Now that SZ_UNDEF are taken care of, check others.  */
4654   switch (fragP->fr_subtype)
4655     {
4656     case TAB (BRANCHBWL, BYTE):
4657     case TAB (BRABSJUNC, BYTE):
4658     case TAB (BRABSJCOND, BYTE):
4659     case TAB (BRANCHBW, BYTE):
4660       /* We can't do a short jump to the next instruction, so in that
4661          case we force word mode.  If the symbol is at the start of a
4662          frag, and it is the next frag with any data in it (usually
4663          this is just the next frag, but assembler listings may
4664          introduce empty frags), we must use word mode.  */
4665       if (fragP->fr_symbol)
4666         {
4667           fragS *sym_frag;
4668
4669           sym_frag = symbol_get_frag (fragP->fr_symbol);
4670           if (S_GET_VALUE (fragP->fr_symbol) == sym_frag->fr_address)
4671             {
4672               fragS *l;
4673
4674               for (l = fragP->fr_next; l && l != sym_frag; l = l->fr_next)
4675                 if (l->fr_fix != 0)
4676                   break;
4677               if (l == sym_frag)
4678                 fragP->fr_subtype = TAB (TABTYPE (fragP->fr_subtype), SHORT);
4679             }
4680         }
4681       break;
4682     default:
4683       break;
4684     }
4685   return md_relax_table[fragP->fr_subtype].rlx_length;
4686 }
4687
4688 #if defined(OBJ_AOUT) | defined(OBJ_BOUT)
4689 /* the bit-field entries in the relocation_info struct plays hell
4690    with the byte-order problems of cross-assembly.  So as a hack,
4691    I added this mach. dependent ri twiddler.  Ugly, but it gets
4692    you there. -KWK */
4693 /* on m68k: first 4 bytes are normal unsigned long, next three bytes
4694    are symbolnum, most sig. byte first.  Last byte is broken up with
4695    bit 7 as pcrel, bits 6 & 5 as length, bit 4 as pcrel, and the lower
4696    nibble as nuthin. (on Sun 3 at least) */
4697 /* Translate the internal relocation information into target-specific
4698    format.  */
4699 #ifdef comment
4700 void
4701 md_ri_to_chars (the_bytes, ri)
4702      char *the_bytes;
4703      struct reloc_info_generic *ri;
4704 {
4705   /* this is easy */
4706   md_number_to_chars (the_bytes, ri->r_address, 4);
4707   /* now the fun stuff */
4708   the_bytes[4] = (ri->r_symbolnum >> 16) & 0x0ff;
4709   the_bytes[5] = (ri->r_symbolnum >> 8) & 0x0ff;
4710   the_bytes[6] = ri->r_symbolnum & 0x0ff;
4711   the_bytes[7] = (((ri->r_pcrel << 7) & 0x80) | ((ri->r_length << 5) & 0x60) |
4712                   ((ri->r_extern << 4) & 0x10));
4713 }
4714
4715 #endif /* comment */
4716
4717 #ifndef BFD_ASSEMBLER
4718 void
4719 tc_aout_fix_to_chars (where, fixP, segment_address_in_file)
4720      char *where;
4721      fixS *fixP;
4722      relax_addressT segment_address_in_file;
4723 {
4724   /*
4725    * In: length of relocation (or of address) in chars: 1, 2 or 4.
4726    * Out: GNU LD relocation length code: 0, 1, or 2.
4727    */
4728
4729   static const unsigned char nbytes_r_length[] = {42, 0, 1, 42, 2};
4730   long r_symbolnum;
4731
4732   know (fixP->fx_addsy != NULL);
4733
4734   md_number_to_chars (where,
4735        fixP->fx_frag->fr_address + fixP->fx_where - segment_address_in_file,
4736                       4);
4737
4738   r_symbolnum = (S_IS_DEFINED (fixP->fx_addsy)
4739                  ? S_GET_TYPE (fixP->fx_addsy)
4740                  : fixP->fx_addsy->sy_number);
4741
4742   where[4] = (r_symbolnum >> 16) & 0x0ff;
4743   where[5] = (r_symbolnum >> 8) & 0x0ff;
4744   where[6] = r_symbolnum & 0x0ff;
4745   where[7] = (((fixP->fx_pcrel << 7) & 0x80) | ((nbytes_r_length[fixP->fx_size] << 5) & 0x60) |
4746               (((!S_IS_DEFINED (fixP->fx_addsy)) << 4) & 0x10));
4747 }
4748 #endif
4749
4750 #endif /* OBJ_AOUT or OBJ_BOUT */
4751
4752 #ifndef WORKING_DOT_WORD
4753 const int md_short_jump_size = 4;
4754 const int md_long_jump_size = 6;
4755
4756 void
4757 md_create_short_jump (ptr, from_addr, to_addr, frag, to_symbol)
4758      char *ptr;
4759      addressT from_addr, to_addr;
4760      fragS *frag ATTRIBUTE_UNUSED;
4761      symbolS *to_symbol ATTRIBUTE_UNUSED;
4762 {
4763   valueT offset;
4764
4765   offset = to_addr - (from_addr + 2);
4766
4767   md_number_to_chars (ptr, (valueT) 0x6000, 2);
4768   md_number_to_chars (ptr + 2, (valueT) offset, 2);
4769 }
4770
4771 void
4772 md_create_long_jump (ptr, from_addr, to_addr, frag, to_symbol)
4773      char *ptr;
4774      addressT from_addr, to_addr;
4775      fragS *frag;
4776      symbolS *to_symbol;
4777 {
4778   valueT offset;
4779
4780   if (!HAVE_LONG_BRANCH(current_architecture))
4781     {
4782       offset = to_addr - S_GET_VALUE (to_symbol);
4783       md_number_to_chars (ptr, (valueT) 0x4EF9, 2);
4784       md_number_to_chars (ptr + 2, (valueT) offset, 4);
4785       fix_new (frag, (ptr + 2) - frag->fr_literal, 4, to_symbol, (offsetT) 0,
4786                0, NO_RELOC);
4787     }
4788   else
4789     {
4790       offset = to_addr - (from_addr + 2);
4791       md_number_to_chars (ptr, (valueT) 0x60ff, 2);
4792       md_number_to_chars (ptr + 2, (valueT) offset, 4);
4793     }
4794 }
4795
4796 #endif
4797
4798 /* Different values of OK tell what its OK to return.  Things that
4799    aren't OK are an error (what a shock, no?)
4800
4801    0:  Everything is OK
4802    10:  Absolute 1:8    only
4803    20:  Absolute 0:7    only
4804    30:  absolute 0:15   only
4805    40:  Absolute 0:31   only
4806    50:  absolute 0:127  only
4807    55:  absolute -64:63    only
4808    60:  absolute -128:127       only
4809    70:  absolute 0:4095 only
4810    80:  No bignums
4811
4812    */
4813
4814 static int
4815 get_num (exp, ok)
4816      struct m68k_exp *exp;
4817      int ok;
4818 {
4819   if (exp->exp.X_op == O_absent)
4820     {
4821       /* Do the same thing the VAX asm does */
4822       op (exp) = O_constant;
4823       adds (exp) = 0;
4824       subs (exp) = 0;
4825       offs (exp) = 0;
4826       if (ok == 10)
4827         {
4828           as_warn (_("expression out of range: defaulting to 1"));
4829           offs (exp) = 1;
4830         }
4831     }
4832   else if (exp->exp.X_op == O_constant)
4833     {
4834       switch (ok)
4835         {
4836         case 10:
4837           if (offs (exp) < 1 || offs (exp) > 8)
4838             {
4839               as_warn (_("expression out of range: defaulting to 1"));
4840               offs (exp) = 1;
4841             }
4842           break;
4843         case 20:
4844           if (offs (exp) < 0 || offs (exp) > 7)
4845             goto outrange;
4846           break;
4847         case 30:
4848           if (offs (exp) < 0 || offs (exp) > 15)
4849             goto outrange;
4850           break;
4851         case 40:
4852           if (offs (exp) < 0 || offs (exp) > 32)
4853             goto outrange;
4854           break;
4855         case 50:
4856           if (offs (exp) < 0 || offs (exp) > 127)
4857             goto outrange;
4858           break;
4859         case 55:
4860           if (offs (exp) < -64 || offs (exp) > 63)
4861             goto outrange;
4862           break;
4863         case 60:
4864           if (offs (exp) < -128 || offs (exp) > 127)
4865             goto outrange;
4866           break;
4867         case 70:
4868           if (offs (exp) < 0 || offs (exp) > 4095)
4869             {
4870             outrange:
4871               as_warn (_("expression out of range: defaulting to 0"));
4872               offs (exp) = 0;
4873             }
4874           break;
4875         default:
4876           break;
4877         }
4878     }
4879   else if (exp->exp.X_op == O_big)
4880     {
4881       if (offs (exp) <= 0       /* flonum */
4882           && (ok == 80          /* no bignums */
4883               || (ok > 10       /* small-int ranges including 0 ok */
4884                   /* If we have a flonum zero, a zero integer should
4885                      do as well (e.g., in moveq).  */
4886                   && generic_floating_point_number.exponent == 0
4887                   && generic_floating_point_number.low[0] == 0)))
4888         {
4889           /* HACK! Turn it into a long */
4890           LITTLENUM_TYPE words[6];
4891
4892           gen_to_words (words, 2, 8L);  /* These numbers are magic! */
4893           op (exp) = O_constant;
4894           adds (exp) = 0;
4895           subs (exp) = 0;
4896           offs (exp) = words[1] | (words[0] << 16);
4897         }
4898       else if (ok != 0)
4899         {
4900           op (exp) = O_constant;
4901           adds (exp) = 0;
4902           subs (exp) = 0;
4903           offs (exp) = (ok == 10) ? 1 : 0;
4904           as_warn (_("Can't deal with expression; defaulting to %ld"),
4905                    offs (exp));
4906         }
4907     }
4908   else
4909     {
4910       if (ok >= 10 && ok <= 70)
4911         {
4912           op (exp) = O_constant;
4913           adds (exp) = 0;
4914           subs (exp) = 0;
4915           offs (exp) = (ok == 10) ? 1 : 0;
4916           as_warn (_("Can't deal with expression; defaulting to %ld"),
4917                    offs (exp));
4918         }
4919     }
4920
4921   if (exp->size != SIZE_UNSPEC)
4922     {
4923       switch (exp->size)
4924         {
4925         case SIZE_UNSPEC:
4926         case SIZE_LONG:
4927           break;
4928         case SIZE_BYTE:
4929           if (!isbyte (offs (exp)))
4930             as_warn (_("expression doesn't fit in BYTE"));
4931           break;
4932         case SIZE_WORD:
4933           if (!isword (offs (exp)))
4934             as_warn (_("expression doesn't fit in WORD"));
4935           break;
4936         }
4937     }
4938
4939   return offs (exp);
4940 }
4941
4942 /* These are the back-ends for the various machine dependent pseudo-ops.  */
4943
4944 static void
4945 s_data1 (ignore)
4946      int ignore ATTRIBUTE_UNUSED;
4947 {
4948   subseg_set (data_section, 1);
4949   demand_empty_rest_of_line ();
4950 }
4951
4952 static void
4953 s_data2 (ignore)
4954      int ignore ATTRIBUTE_UNUSED;
4955 {
4956   subseg_set (data_section, 2);
4957   demand_empty_rest_of_line ();
4958 }
4959
4960 static void
4961 s_bss (ignore)
4962      int ignore ATTRIBUTE_UNUSED;
4963 {
4964   /* We don't support putting frags in the BSS segment, we fake it
4965      by marking in_bss, then looking at s_skip for clues.  */
4966
4967   subseg_set (bss_section, 0);
4968   demand_empty_rest_of_line ();
4969 }
4970
4971 static void
4972 s_even (ignore)
4973      int ignore ATTRIBUTE_UNUSED;
4974 {
4975   register int temp;
4976   register long temp_fill;
4977
4978   temp = 1;                     /* JF should be 2? */
4979   temp_fill = get_absolute_expression ();
4980   if (!need_pass_2)             /* Never make frag if expect extra pass.  */
4981     frag_align (temp, (int) temp_fill, 0);
4982   demand_empty_rest_of_line ();
4983   record_alignment (now_seg, temp);
4984 }
4985
4986 static void
4987 s_proc (ignore)
4988      int ignore ATTRIBUTE_UNUSED;
4989 {
4990   demand_empty_rest_of_line ();
4991 }
4992 \f
4993 /* Pseudo-ops handled for MRI compatibility.  */
4994
4995 /* This function returns non-zero if the argument is a conditional
4996    pseudo-op.  This is called when checking whether a pending
4997    alignment is needed.  */
4998
4999 int
5000 m68k_conditional_pseudoop (pop)
5001      pseudo_typeS *pop;
5002 {
5003   return (pop->poc_handler == s_mri_if
5004           || pop->poc_handler == s_mri_else);
5005 }
5006
5007 /* Handle an MRI style chip specification.  */
5008
5009 static void
5010 mri_chip ()
5011 {
5012   char *s;
5013   char c;
5014   int i;
5015
5016   s = input_line_pointer;
5017   /* We can't use get_symbol_end since the processor names are not proper
5018      symbols.  */
5019   while (is_part_of_name (c = *input_line_pointer++))
5020     ;
5021   *--input_line_pointer = 0;
5022   for (i = 0; i < n_archs; i++)
5023     if (strcasecmp (s, archs[i].name) == 0)
5024       break;
5025   if (i >= n_archs)
5026     {
5027       as_bad (_("%s: unrecognized processor name"), s);
5028       *input_line_pointer = c;
5029       ignore_rest_of_line ();
5030       return;
5031     }
5032   *input_line_pointer = c;
5033
5034   if (*input_line_pointer == '/')
5035     current_architecture = 0;
5036   else
5037     current_architecture &= m68881 | m68851;
5038   current_architecture |= archs[i].arch;
5039
5040   while (*input_line_pointer == '/')
5041     {
5042       ++input_line_pointer;
5043       s = input_line_pointer;
5044       /* We can't use get_symbol_end since the processor names are not
5045          proper symbols.  */
5046       while (is_part_of_name (c = *input_line_pointer++))
5047         ;
5048       *--input_line_pointer = 0;
5049       if (strcmp (s, "68881") == 0)
5050         current_architecture |= m68881;
5051       else if (strcmp (s, "68851") == 0)
5052         current_architecture |= m68851;
5053       *input_line_pointer = c;
5054     }
5055
5056   /* Update info about available control registers.  */
5057   select_control_regs ();
5058 }
5059
5060 /* The MRI CHIP pseudo-op.  */
5061
5062 static void
5063 s_chip (ignore)
5064      int ignore ATTRIBUTE_UNUSED;
5065 {
5066   char *stop = NULL;
5067   char stopc;
5068
5069   if (flag_mri)
5070     stop = mri_comment_field (&stopc);
5071   mri_chip ();
5072   if (flag_mri)
5073     mri_comment_end (stop, stopc);
5074   demand_empty_rest_of_line ();
5075 }
5076
5077 /* The MRI FOPT pseudo-op.  */
5078
5079 static void
5080 s_fopt (ignore)
5081      int ignore ATTRIBUTE_UNUSED;
5082 {
5083   SKIP_WHITESPACE ();
5084
5085   if (strncasecmp (input_line_pointer, "ID=", 3) == 0)
5086     {
5087       int temp;
5088
5089       input_line_pointer += 3;
5090       temp = get_absolute_expression ();
5091       if (temp < 0 || temp > 7)
5092         as_bad (_("bad coprocessor id"));
5093       else
5094         m68k_float_copnum = COP0 + temp;
5095     }
5096   else
5097     {
5098       as_bad (_("unrecognized fopt option"));
5099       ignore_rest_of_line ();
5100       return;
5101     }
5102
5103   demand_empty_rest_of_line ();
5104 }
5105
5106 /* The structure used to handle the MRI OPT pseudo-op.  */
5107
5108 struct opt_action
5109 {
5110   /* The name of the option.  */
5111   const char *name;
5112
5113   /* If this is not NULL, just call this function.  The first argument
5114      is the ARG field of this structure, the second argument is
5115      whether the option was negated.  */
5116   void (*pfn) PARAMS ((int arg, int on));
5117
5118   /* If this is not NULL, and the PFN field is NULL, set the variable
5119      this points to.  Set it to the ARG field if the option was not
5120      negated, and the NOTARG field otherwise.  */
5121   int *pvar;
5122
5123   /* The value to pass to PFN or to assign to *PVAR.  */
5124   int arg;
5125
5126   /* The value to assign to *PVAR if the option is negated.  If PFN is
5127      NULL, and PVAR is not NULL, and ARG and NOTARG are the same, then
5128      the option may not be negated.  */
5129   int notarg;
5130 };
5131
5132 /* The table used to handle the MRI OPT pseudo-op.  */
5133
5134 static void skip_to_comma PARAMS ((int, int));
5135 static void opt_nest PARAMS ((int, int));
5136 static void opt_chip PARAMS ((int, int));
5137 static void opt_list PARAMS ((int, int));
5138 static void opt_list_symbols PARAMS ((int, int));
5139
5140 static const struct opt_action opt_table[] =
5141 {
5142   { "abspcadd", 0, &m68k_abspcadd, 1, 0 },
5143
5144   /* We do relaxing, so there is little use for these options.  */
5145   { "b", 0, 0, 0, 0 },
5146   { "brs", 0, 0, 0, 0 },
5147   { "brb", 0, 0, 0, 0 },
5148   { "brl", 0, 0, 0, 0 },
5149   { "brw", 0, 0, 0, 0 },
5150
5151   { "c", 0, 0, 0, 0 },
5152   { "cex", 0, 0, 0, 0 },
5153   { "case", 0, &symbols_case_sensitive, 1, 0 },
5154   { "cl", 0, 0, 0, 0 },
5155   { "cre", 0, 0, 0, 0 },
5156   { "d", 0, &flag_keep_locals, 1, 0 },
5157   { "e", 0, 0, 0, 0 },
5158   { "f", 0, &flag_short_refs, 1, 0 },
5159   { "frs", 0, &flag_short_refs, 1, 0 },
5160   { "frl", 0, &flag_short_refs, 0, 1 },
5161   { "g", 0, 0, 0, 0 },
5162   { "i", 0, 0, 0, 0 },
5163   { "m", 0, 0, 0, 0 },
5164   { "mex", 0, 0, 0, 0 },
5165   { "mc", 0, 0, 0, 0 },
5166   { "md", 0, 0, 0, 0 },
5167   { "nest", opt_nest, 0, 0, 0 },
5168   { "next", skip_to_comma, 0, 0, 0 },
5169   { "o", 0, 0, 0, 0 },
5170   { "old", 0, 0, 0, 0 },
5171   { "op", skip_to_comma, 0, 0, 0 },
5172   { "pco", 0, 0, 0, 0 },
5173   { "p", opt_chip, 0, 0, 0 },
5174   { "pcr", 0, 0, 0, 0 },
5175   { "pcs", 0, 0, 0, 0 },
5176   { "r", 0, 0, 0, 0 },
5177   { "quick", 0, &m68k_quick, 1, 0 },
5178   { "rel32", 0, &m68k_rel32, 1, 0 },
5179   { "s", opt_list, 0, 0, 0 },
5180   { "t", opt_list_symbols, 0, 0, 0 },
5181   { "w", 0, &flag_no_warnings, 0, 1 },
5182   { "x", 0, 0, 0, 0 }
5183 };
5184
5185 #define OPTCOUNT ((int) (sizeof opt_table / sizeof opt_table[0]))
5186
5187 /* The MRI OPT pseudo-op.  */
5188
5189 static void
5190 s_opt (ignore)
5191      int ignore ATTRIBUTE_UNUSED;
5192 {
5193   do
5194     {
5195       int t;
5196       char *s;
5197       char c;
5198       int i;
5199       const struct opt_action *o;
5200
5201       SKIP_WHITESPACE ();
5202
5203       t = 1;
5204       if (*input_line_pointer == '-')
5205         {
5206           ++input_line_pointer;
5207           t = 0;
5208         }
5209       else if (strncasecmp (input_line_pointer, "NO", 2) == 0)
5210         {
5211           input_line_pointer += 2;
5212           t = 0;
5213         }
5214
5215       s = input_line_pointer;
5216       c = get_symbol_end ();
5217
5218       for (i = 0, o = opt_table; i < OPTCOUNT; i++, o++)
5219         {
5220           if (strcasecmp (s, o->name) == 0)
5221             {
5222               if (o->pfn)
5223                 {
5224                   /* Restore input_line_pointer now in case the option
5225                      takes arguments.  */
5226                   *input_line_pointer = c;
5227                   (*o->pfn) (o->arg, t);
5228                 }
5229               else if (o->pvar != NULL)
5230                 {
5231                   if (! t && o->arg == o->notarg)
5232                     as_bad (_("option `%s' may not be negated"), s);
5233                   *input_line_pointer = c;
5234                   *o->pvar = t ? o->arg : o->notarg;
5235                 }
5236               else
5237                 *input_line_pointer = c;
5238               break;
5239             }
5240         }
5241       if (i >= OPTCOUNT)
5242         {
5243           as_bad (_("option `%s' not recognized"), s);
5244           *input_line_pointer = c;
5245         }
5246     }
5247   while (*input_line_pointer++ == ',');
5248
5249   /* Move back to terminating character.  */
5250   --input_line_pointer;
5251   demand_empty_rest_of_line ();
5252 }
5253
5254 /* Skip ahead to a comma.  This is used for OPT options which we do
5255    not suppor tand which take arguments.  */
5256
5257 static void
5258 skip_to_comma (arg, on)
5259      int arg ATTRIBUTE_UNUSED;
5260      int on ATTRIBUTE_UNUSED;
5261 {
5262   while (*input_line_pointer != ','
5263          && ! is_end_of_line[(unsigned char) *input_line_pointer])
5264     ++input_line_pointer;
5265 }
5266
5267 /* Handle the OPT NEST=depth option.  */
5268
5269 static void
5270 opt_nest (arg, on)
5271      int arg ATTRIBUTE_UNUSED;
5272      int on ATTRIBUTE_UNUSED;
5273 {
5274   if (*input_line_pointer != '=')
5275     {
5276       as_bad (_("bad format of OPT NEST=depth"));
5277       return;
5278     }
5279
5280   ++input_line_pointer;
5281   max_macro_nest = get_absolute_expression ();
5282 }
5283
5284 /* Handle the OPT P=chip option.  */
5285
5286 static void
5287 opt_chip (arg, on)
5288      int arg ATTRIBUTE_UNUSED;
5289      int on ATTRIBUTE_UNUSED;
5290 {
5291   if (*input_line_pointer != '=')
5292     {
5293       /* This is just OPT P, which we do not support.  */
5294       return;
5295     }
5296
5297   ++input_line_pointer;
5298   mri_chip ();
5299 }
5300
5301 /* Handle the OPT S option.  */
5302
5303 static void
5304 opt_list (arg, on)
5305      int arg ATTRIBUTE_UNUSED;
5306      int on;
5307 {
5308   listing_list (on);
5309 }
5310
5311 /* Handle the OPT T option.  */
5312
5313 static void
5314 opt_list_symbols (arg, on)
5315      int arg ATTRIBUTE_UNUSED;
5316      int on;
5317 {
5318   if (on)
5319     listing |= LISTING_SYMBOLS;
5320   else
5321     listing &= ~LISTING_SYMBOLS;
5322 }
5323
5324 /* Handle the MRI REG pseudo-op.  */
5325
5326 static void
5327 s_reg (ignore)
5328      int ignore ATTRIBUTE_UNUSED;
5329 {
5330   char *s;
5331   int c;
5332   struct m68k_op rop;
5333   int mask;
5334   char *stop = NULL;
5335   char stopc;
5336
5337   if (line_label == NULL)
5338     {
5339       as_bad (_("missing label"));
5340       ignore_rest_of_line ();
5341       return;
5342     }
5343
5344   if (flag_mri)
5345     stop = mri_comment_field (&stopc);
5346
5347   SKIP_WHITESPACE ();
5348
5349   s = input_line_pointer;
5350   while (ISALNUM (*input_line_pointer)
5351 #ifdef REGISTER_PREFIX
5352          || *input_line_pointer == REGISTER_PREFIX
5353 #endif
5354          || *input_line_pointer == '/'
5355          || *input_line_pointer == '-')
5356     ++input_line_pointer;
5357   c = *input_line_pointer;
5358   *input_line_pointer = '\0';
5359
5360   if (m68k_ip_op (s, &rop) != 0)
5361     {
5362       if (rop.error == NULL)
5363         as_bad (_("bad register list"));
5364       else
5365         as_bad (_("bad register list: %s"), rop.error);
5366       *input_line_pointer = c;
5367       ignore_rest_of_line ();
5368       return;
5369     }
5370
5371   *input_line_pointer = c;
5372
5373   if (rop.mode == REGLST)
5374     mask = rop.mask;
5375   else if (rop.mode == DREG)
5376     mask = 1 << (rop.reg - DATA0);
5377   else if (rop.mode == AREG)
5378     mask = 1 << (rop.reg - ADDR0 + 8);
5379   else if (rop.mode == FPREG)
5380     mask = 1 << (rop.reg - FP0 + 16);
5381   else if (rop.mode == CONTROL
5382            && rop.reg == FPI)
5383     mask = 1 << 24;
5384   else if (rop.mode == CONTROL
5385            && rop.reg == FPS)
5386     mask = 1 << 25;
5387   else if (rop.mode == CONTROL
5388            && rop.reg == FPC)
5389     mask = 1 << 26;
5390   else
5391     {
5392       as_bad (_("bad register list"));
5393       ignore_rest_of_line ();
5394       return;
5395     }
5396
5397   S_SET_SEGMENT (line_label, reg_section);
5398   S_SET_VALUE (line_label, ~mask);
5399   symbol_set_frag (line_label, &zero_address_frag);
5400
5401   if (flag_mri)
5402     mri_comment_end (stop, stopc);
5403
5404   demand_empty_rest_of_line ();
5405 }
5406
5407 /* This structure is used for the MRI SAVE and RESTORE pseudo-ops.  */
5408
5409 struct save_opts
5410 {
5411   struct save_opts *next;
5412   int abspcadd;
5413   int symbols_case_sensitive;
5414   int keep_locals;
5415   int short_refs;
5416   int architecture;
5417   int quick;
5418   int rel32;
5419   int listing;
5420   int no_warnings;
5421   /* FIXME: We don't save OPT S.  */
5422 };
5423
5424 /* This variable holds the stack of saved options.  */
5425
5426 static struct save_opts *save_stack;
5427
5428 /* The MRI SAVE pseudo-op.  */
5429
5430 static void
5431 s_save (ignore)
5432      int ignore ATTRIBUTE_UNUSED;
5433 {
5434   struct save_opts *s;
5435
5436   s = (struct save_opts *) xmalloc (sizeof (struct save_opts));
5437   s->abspcadd = m68k_abspcadd;
5438   s->symbols_case_sensitive = symbols_case_sensitive;
5439   s->keep_locals = flag_keep_locals;
5440   s->short_refs = flag_short_refs;
5441   s->architecture = current_architecture;
5442   s->quick = m68k_quick;
5443   s->rel32 = m68k_rel32;
5444   s->listing = listing;
5445   s->no_warnings = flag_no_warnings;
5446
5447   s->next = save_stack;
5448   save_stack = s;
5449
5450   demand_empty_rest_of_line ();
5451 }
5452
5453 /* The MRI RESTORE pseudo-op.  */
5454
5455 static void
5456 s_restore (ignore)
5457      int ignore ATTRIBUTE_UNUSED;
5458 {
5459   struct save_opts *s;
5460
5461   if (save_stack == NULL)
5462     {
5463       as_bad (_("restore without save"));
5464       ignore_rest_of_line ();
5465       return;
5466     }
5467
5468   s = save_stack;
5469   save_stack = s->next;
5470
5471   m68k_abspcadd = s->abspcadd;
5472   symbols_case_sensitive = s->symbols_case_sensitive;
5473   flag_keep_locals = s->keep_locals;
5474   flag_short_refs = s->short_refs;
5475   current_architecture = s->architecture;
5476   m68k_quick = s->quick;
5477   m68k_rel32 = s->rel32;
5478   listing = s->listing;
5479   flag_no_warnings = s->no_warnings;
5480
5481   free (s);
5482
5483   demand_empty_rest_of_line ();
5484 }
5485
5486 /* Types of MRI structured control directives.  */
5487
5488 enum mri_control_type
5489 {
5490   mri_for,
5491   mri_if,
5492   mri_repeat,
5493   mri_while
5494 };
5495
5496 /* This structure is used to stack the MRI structured control
5497    directives.  */
5498
5499 struct mri_control_info
5500 {
5501   /* The directive within which this one is enclosed.  */
5502   struct mri_control_info *outer;
5503
5504   /* The type of directive.  */
5505   enum mri_control_type type;
5506
5507   /* Whether an ELSE has been in an IF.  */
5508   int else_seen;
5509
5510   /* The add or sub statement at the end of a FOR.  */
5511   char *incr;
5512
5513   /* The label of the top of a FOR or REPEAT loop.  */
5514   char *top;
5515
5516   /* The label to jump to for the next iteration, or the else
5517      expression of a conditional.  */
5518   char *next;
5519
5520   /* The label to jump to to break out of the loop, or the label past
5521      the end of a conditional.  */
5522   char *bottom;
5523 };
5524
5525 /* The stack of MRI structured control directives.  */
5526
5527 static struct mri_control_info *mri_control_stack;
5528
5529 /* The current MRI structured control directive index number, used to
5530    generate label names.  */
5531
5532 static int mri_control_index;
5533
5534 /* Some function prototypes.  */
5535
5536 static void mri_assemble PARAMS ((char *));
5537 static char *mri_control_label PARAMS ((void));
5538 static struct mri_control_info *push_mri_control
5539   PARAMS ((enum mri_control_type));
5540 static void pop_mri_control PARAMS ((void));
5541 static int parse_mri_condition PARAMS ((int *));
5542 static int parse_mri_control_operand
5543   PARAMS ((int *, char **, char **, char **, char **));
5544 static int swap_mri_condition PARAMS ((int));
5545 static int reverse_mri_condition PARAMS ((int));
5546 static void build_mri_control_operand
5547   PARAMS ((int, int, char *, char *, char *, char *, const char *,
5548            const char *, int));
5549 static void parse_mri_control_expression
5550   PARAMS ((char *, int, const char *, const char *, int));
5551
5552 /* Assemble an instruction for an MRI structured control directive.  */
5553
5554 static void
5555 mri_assemble (str)
5556      char *str;
5557 {
5558   char *s;
5559
5560   /* md_assemble expects the opcode to be in lower case.  */
5561   for (s = str; *s != ' ' && *s != '\0'; s++)
5562     *s = TOLOWER (*s);
5563
5564   md_assemble (str);
5565 }
5566
5567 /* Generate a new MRI label structured control directive label name.  */
5568
5569 static char *
5570 mri_control_label ()
5571 {
5572   char *n;
5573
5574   n = (char *) xmalloc (20);
5575   sprintf (n, "%smc%d", FAKE_LABEL_NAME, mri_control_index);
5576   ++mri_control_index;
5577   return n;
5578 }
5579
5580 /* Create a new MRI structured control directive.  */
5581
5582 static struct mri_control_info *
5583 push_mri_control (type)
5584      enum mri_control_type type;
5585 {
5586   struct mri_control_info *n;
5587
5588   n = (struct mri_control_info *) xmalloc (sizeof (struct mri_control_info));
5589
5590   n->type = type;
5591   n->else_seen = 0;
5592   if (type == mri_if || type == mri_while)
5593     n->top = NULL;
5594   else
5595     n->top = mri_control_label ();
5596   n->next = mri_control_label ();
5597   n->bottom = mri_control_label ();
5598
5599   n->outer = mri_control_stack;
5600   mri_control_stack = n;
5601
5602   return n;
5603 }
5604
5605 /* Pop off the stack of MRI structured control directives.  */
5606
5607 static void
5608 pop_mri_control ()
5609 {
5610   struct mri_control_info *n;
5611
5612   n = mri_control_stack;
5613   mri_control_stack = n->outer;
5614   if (n->top != NULL)
5615     free (n->top);
5616   free (n->next);
5617   free (n->bottom);
5618   free (n);
5619 }
5620
5621 /* Recognize a condition code in an MRI structured control expression.  */
5622
5623 static int
5624 parse_mri_condition (pcc)
5625      int *pcc;
5626 {
5627   char c1, c2;
5628
5629   know (*input_line_pointer == '<');
5630
5631   ++input_line_pointer;
5632   c1 = *input_line_pointer++;
5633   c2 = *input_line_pointer++;
5634
5635   if (*input_line_pointer != '>')
5636     {
5637       as_bad (_("syntax error in structured control directive"));
5638       return 0;
5639     }
5640
5641   ++input_line_pointer;
5642   SKIP_WHITESPACE ();
5643
5644   c1 = TOLOWER (c1);
5645   c2 = TOLOWER (c2);
5646
5647   *pcc = (c1 << 8) | c2;
5648
5649   return 1;
5650 }
5651
5652 /* Parse a single operand in an MRI structured control expression.  */
5653
5654 static int
5655 parse_mri_control_operand (pcc, leftstart, leftstop, rightstart, rightstop)
5656      int *pcc;
5657      char **leftstart;
5658      char **leftstop;
5659      char **rightstart;
5660      char **rightstop;
5661 {
5662   char *s;
5663
5664   SKIP_WHITESPACE ();
5665
5666   *pcc = -1;
5667   *leftstart = NULL;
5668   *leftstop = NULL;
5669   *rightstart = NULL;
5670   *rightstop = NULL;
5671
5672   if (*input_line_pointer == '<')
5673     {
5674       /* It's just a condition code.  */
5675       return parse_mri_condition (pcc);
5676     }
5677
5678   /* Look ahead for the condition code.  */
5679   for (s = input_line_pointer; *s != '\0'; ++s)
5680     {
5681       if (*s == '<' && s[1] != '\0' && s[2] != '\0' && s[3] == '>')
5682         break;
5683     }
5684   if (*s == '\0')
5685     {
5686       as_bad (_("missing condition code in structured control directive"));
5687       return 0;
5688     }
5689
5690   *leftstart = input_line_pointer;
5691   *leftstop = s;
5692   if (*leftstop > *leftstart
5693       && ((*leftstop)[-1] == ' ' || (*leftstop)[-1] == '\t'))
5694     --*leftstop;
5695
5696   input_line_pointer = s;
5697   if (! parse_mri_condition (pcc))
5698     return 0;
5699
5700   /* Look ahead for AND or OR or end of line.  */
5701   for (s = input_line_pointer; *s != '\0'; ++s)
5702     {
5703       /* We must make sure we don't misinterpret AND/OR at the end of labels!
5704          if d0 <eq> #FOOAND and d1 <ne> #BAROR then
5705                         ^^^                 ^^ */
5706       if ((s == input_line_pointer
5707            || *(s-1) == ' '
5708            || *(s-1) == '\t')
5709           && ((strncasecmp (s, "AND", 3) == 0
5710                && (s[3] == '.' || ! is_part_of_name (s[3])))
5711               || (strncasecmp (s, "OR", 2) == 0
5712                   && (s[2] == '.' || ! is_part_of_name (s[2])))))
5713         break;
5714     }
5715
5716   *rightstart = input_line_pointer;
5717   *rightstop = s;
5718   if (*rightstop > *rightstart
5719       && ((*rightstop)[-1] == ' ' || (*rightstop)[-1] == '\t'))
5720     --*rightstop;
5721
5722   input_line_pointer = s;
5723
5724   return 1;
5725 }
5726
5727 #define MCC(b1, b2) (((b1) << 8) | (b2))
5728
5729 /* Swap the sense of a condition.  This changes the condition so that
5730    it generates the same result when the operands are swapped.  */
5731
5732 static int
5733 swap_mri_condition (cc)
5734      int cc;
5735 {
5736   switch (cc)
5737     {
5738     case MCC ('h', 'i'): return MCC ('c', 's');
5739     case MCC ('l', 's'): return MCC ('c', 'c');
5740     /* <HS> is an alias for <CC> */
5741     case MCC ('h', 's'):
5742     case MCC ('c', 'c'): return MCC ('l', 's');
5743     /* <LO> is an alias for <CS> */
5744     case MCC ('l', 'o'):
5745     case MCC ('c', 's'): return MCC ('h', 'i');
5746     case MCC ('p', 'l'): return MCC ('m', 'i');
5747     case MCC ('m', 'i'): return MCC ('p', 'l');
5748     case MCC ('g', 'e'): return MCC ('l', 'e');
5749     case MCC ('l', 't'): return MCC ('g', 't');
5750     case MCC ('g', 't'): return MCC ('l', 't');
5751     case MCC ('l', 'e'): return MCC ('g', 'e');
5752     /* issue a warning for conditions we can not swap */
5753     case MCC ('n', 'e'): return MCC ('n', 'e'); // no problem here
5754     case MCC ('e', 'q'): return MCC ('e', 'q'); // also no problem
5755     case MCC ('v', 'c'):
5756     case MCC ('v', 's'):
5757     default :
5758            as_warn (_("Condition <%c%c> in structured control directive can not be encoded correctly"),
5759                          (char) (cc >> 8), (char) (cc));
5760       break;
5761     }
5762   return cc;
5763 }
5764
5765 /* Reverse the sense of a condition.  */
5766
5767 static int
5768 reverse_mri_condition (cc)
5769      int cc;
5770 {
5771   switch (cc)
5772     {
5773     case MCC ('h', 'i'): return MCC ('l', 's');
5774     case MCC ('l', 's'): return MCC ('h', 'i');
5775     /* <HS> is an alias for <CC> */
5776     case MCC ('h', 's'): return MCC ('l', 'o');
5777     case MCC ('c', 'c'): return MCC ('c', 's');
5778     /* <LO> is an alias for <CS> */
5779     case MCC ('l', 'o'): return MCC ('h', 's');
5780     case MCC ('c', 's'): return MCC ('c', 'c');
5781     case MCC ('n', 'e'): return MCC ('e', 'q');
5782     case MCC ('e', 'q'): return MCC ('n', 'e');
5783     case MCC ('v', 'c'): return MCC ('v', 's');
5784     case MCC ('v', 's'): return MCC ('v', 'c');
5785     case MCC ('p', 'l'): return MCC ('m', 'i');
5786     case MCC ('m', 'i'): return MCC ('p', 'l');
5787     case MCC ('g', 'e'): return MCC ('l', 't');
5788     case MCC ('l', 't'): return MCC ('g', 'e');
5789     case MCC ('g', 't'): return MCC ('l', 'e');
5790     case MCC ('l', 'e'): return MCC ('g', 't');
5791     }
5792   return cc;
5793 }
5794
5795 /* Build an MRI structured control expression.  This generates test
5796    and branch instructions.  It goes to TRUELAB if the condition is
5797    true, and to FALSELAB if the condition is false.  Exactly one of
5798    TRUELAB and FALSELAB will be NULL, meaning to fall through.  QUAL
5799    is the size qualifier for the expression.  EXTENT is the size to
5800    use for the branch.  */
5801
5802 static void
5803 build_mri_control_operand (qual, cc, leftstart, leftstop, rightstart,
5804                            rightstop, truelab, falselab, extent)
5805      int qual;
5806      int cc;
5807      char *leftstart;
5808      char *leftstop;
5809      char *rightstart;
5810      char *rightstop;
5811      const char *truelab;
5812      const char *falselab;
5813      int extent;
5814 {
5815   char *buf;
5816   char *s;
5817
5818   if (leftstart != NULL)
5819     {
5820       struct m68k_op leftop, rightop;
5821       char c;
5822
5823       /* Swap the compare operands, if necessary, to produce a legal
5824          m68k compare instruction.  Comparing a register operand with
5825          a non-register operand requires the register to be on the
5826          right (cmp, cmpa).  Comparing an immediate value with
5827          anything requires the immediate value to be on the left
5828          (cmpi).  */
5829
5830       c = *leftstop;
5831       *leftstop = '\0';
5832       (void) m68k_ip_op (leftstart, &leftop);
5833       *leftstop = c;
5834
5835       c = *rightstop;
5836       *rightstop = '\0';
5837       (void) m68k_ip_op (rightstart, &rightop);
5838       *rightstop = c;
5839
5840       if (rightop.mode == IMMED
5841           || ((leftop.mode == DREG || leftop.mode == AREG)
5842               && (rightop.mode != DREG && rightop.mode != AREG)))
5843         {
5844           char *temp;
5845
5846      /* Correct conditional handling:
5847         if #1 <lt> d0 then  ;means if (1 < d0)
5848            ...
5849         endi
5850
5851         should assemble to:
5852
5853          cmp #1,d0        if we do *not* swap the operands
5854          bgt true         we need the swapped condition!
5855          ble false
5856         true:
5857          ...
5858         false:
5859      */
5860           temp = leftstart;
5861           leftstart = rightstart;
5862           rightstart = temp;
5863           temp = leftstop;
5864           leftstop = rightstop;
5865           rightstop = temp;
5866         }
5867       else
5868         {
5869           cc = swap_mri_condition (cc);
5870         }
5871     }
5872
5873   if (truelab == NULL)
5874     {
5875       cc = reverse_mri_condition (cc);
5876       truelab = falselab;
5877     }
5878
5879   if (leftstart != NULL)
5880     {
5881       buf = (char *) xmalloc (20
5882                               + (leftstop - leftstart)
5883                               + (rightstop - rightstart));
5884       s = buf;
5885       *s++ = 'c';
5886       *s++ = 'm';
5887       *s++ = 'p';
5888       if (qual != '\0')
5889         *s++ = TOLOWER (qual);
5890       *s++ = ' ';
5891       memcpy (s, leftstart, leftstop - leftstart);
5892       s += leftstop - leftstart;
5893       *s++ = ',';
5894       memcpy (s, rightstart, rightstop - rightstart);
5895       s += rightstop - rightstart;
5896       *s = '\0';
5897       mri_assemble (buf);
5898       free (buf);
5899     }
5900
5901   buf = (char *) xmalloc (20 + strlen (truelab));
5902   s = buf;
5903   *s++ = 'b';
5904   *s++ = cc >> 8;
5905   *s++ = cc & 0xff;
5906   if (extent != '\0')
5907     *s++ = TOLOWER (extent);
5908   *s++ = ' ';
5909   strcpy (s, truelab);
5910   mri_assemble (buf);
5911   free (buf);
5912 }
5913
5914 /* Parse an MRI structured control expression.  This generates test
5915    and branch instructions.  STOP is where the expression ends.  It
5916    goes to TRUELAB if the condition is true, and to FALSELAB if the
5917    condition is false.  Exactly one of TRUELAB and FALSELAB will be
5918    NULL, meaning to fall through.  QUAL is the size qualifier for the
5919    expression.  EXTENT is the size to use for the branch.  */
5920
5921 static void
5922 parse_mri_control_expression (stop, qual, truelab, falselab, extent)
5923      char *stop;
5924      int qual;
5925      const char *truelab;
5926      const char *falselab;
5927      int extent;
5928 {
5929   int c;
5930   int cc;
5931   char *leftstart;
5932   char *leftstop;
5933   char *rightstart;
5934   char *rightstop;
5935
5936   c = *stop;
5937   *stop = '\0';
5938
5939   if (! parse_mri_control_operand (&cc, &leftstart, &leftstop,
5940                                    &rightstart, &rightstop))
5941     {
5942       *stop = c;
5943       return;
5944     }
5945
5946   if (strncasecmp (input_line_pointer, "AND", 3) == 0)
5947     {
5948       const char *flab;
5949
5950       if (falselab != NULL)
5951         flab = falselab;
5952       else
5953         flab = mri_control_label ();
5954
5955       build_mri_control_operand (qual, cc, leftstart, leftstop, rightstart,
5956                                  rightstop, (const char *) NULL, flab, extent);
5957
5958       input_line_pointer += 3;
5959       if (*input_line_pointer != '.'
5960           || input_line_pointer[1] == '\0')
5961         qual = '\0';
5962       else
5963         {
5964           qual = input_line_pointer[1];
5965           input_line_pointer += 2;
5966         }
5967
5968       if (! parse_mri_control_operand (&cc, &leftstart, &leftstop,
5969                                        &rightstart, &rightstop))
5970         {
5971           *stop = c;
5972           return;
5973         }
5974
5975       build_mri_control_operand (qual, cc, leftstart, leftstop, rightstart,
5976                                  rightstop, truelab, falselab, extent);
5977
5978       if (falselab == NULL)
5979         colon (flab);
5980     }
5981   else if (strncasecmp (input_line_pointer, "OR", 2) == 0)
5982     {
5983       const char *tlab;
5984
5985       if (truelab != NULL)
5986         tlab = truelab;
5987       else
5988         tlab = mri_control_label ();
5989
5990       build_mri_control_operand (qual, cc, leftstart, leftstop, rightstart,
5991                                  rightstop, tlab, (const char *) NULL, extent);
5992
5993       input_line_pointer += 2;
5994       if (*input_line_pointer != '.'
5995           || input_line_pointer[1] == '\0')
5996         qual = '\0';
5997       else
5998         {
5999           qual = input_line_pointer[1];
6000           input_line_pointer += 2;
6001         }
6002
6003       if (! parse_mri_control_operand (&cc, &leftstart, &leftstop,
6004                                        &rightstart, &rightstop))
6005         {
6006           *stop = c;
6007           return;
6008         }
6009
6010       build_mri_control_operand (qual, cc, leftstart, leftstop, rightstart,
6011                                  rightstop, truelab, falselab, extent);
6012
6013       if (truelab == NULL)
6014         colon (tlab);
6015     }
6016   else
6017     {
6018       build_mri_control_operand (qual, cc, leftstart, leftstop, rightstart,
6019                                  rightstop, truelab, falselab, extent);
6020     }
6021
6022   *stop = c;
6023   if (input_line_pointer != stop)
6024     as_bad (_("syntax error in structured control directive"));
6025 }
6026
6027 /* Handle the MRI IF pseudo-op.  This may be a structured control
6028    directive, or it may be a regular assembler conditional, depending
6029    on its operands.  */
6030
6031 static void
6032 s_mri_if (qual)
6033      int qual;
6034 {
6035   char *s;
6036   int c;
6037   struct mri_control_info *n;
6038
6039   /* A structured control directive must end with THEN with an
6040      optional qualifier.  */
6041   s = input_line_pointer;
6042   /* We only accept '*' as introduction of comments if preceded by white space
6043      or at first column of a line (I think this can't actually happen here?)
6044      This is important when assembling:
6045        if d0 <ne> 12(a0,d0*2) then
6046        if d0 <ne> #CONST*20   then */
6047   while ( ! (    is_end_of_line[(unsigned char) *s]
6048               || (     flag_mri
6049                    && *s == '*'
6050                    && (    s == input_line_pointer
6051                         || *(s-1) == ' '
6052                         || *(s-1) == '\t'))))
6053     ++s;
6054   --s;
6055   while (s > input_line_pointer && (*s == ' ' || *s == '\t'))
6056     --s;
6057
6058   if (s - input_line_pointer > 1
6059       && s[-1] == '.')
6060     s -= 2;
6061
6062   if (s - input_line_pointer < 3
6063       || strncasecmp (s - 3, "THEN", 4) != 0)
6064     {
6065       if (qual != '\0')
6066         {
6067           as_bad (_("missing then"));
6068           ignore_rest_of_line ();
6069           return;
6070         }
6071
6072       /* It's a conditional.  */
6073       s_if (O_ne);
6074       return;
6075     }
6076
6077   /* Since this might be a conditional if, this pseudo-op will be
6078      called even if we are supported to be ignoring input.  Double
6079      check now.  Clobber *input_line_pointer so that ignore_input
6080      thinks that this is not a special pseudo-op.  */
6081   c = *input_line_pointer;
6082   *input_line_pointer = 0;
6083   if (ignore_input ())
6084     {
6085       *input_line_pointer = c;
6086       while (! is_end_of_line[(unsigned char) *input_line_pointer])
6087         ++input_line_pointer;
6088       demand_empty_rest_of_line ();
6089       return;
6090     }
6091   *input_line_pointer = c;
6092
6093   n = push_mri_control (mri_if);
6094
6095   parse_mri_control_expression (s - 3, qual, (const char *) NULL,
6096                                 n->next, s[1] == '.' ? s[2] : '\0');
6097
6098   if (s[1] == '.')
6099     input_line_pointer = s + 3;
6100   else
6101     input_line_pointer = s + 1;
6102
6103   if (flag_mri)
6104     {
6105       while (! is_end_of_line[(unsigned char) *input_line_pointer])
6106         ++input_line_pointer;
6107     }
6108
6109   demand_empty_rest_of_line ();
6110 }
6111
6112 /* Handle the MRI else pseudo-op.  If we are currently doing an MRI
6113    structured IF, associate the ELSE with the IF.  Otherwise, assume
6114    it is a conditional else.  */
6115
6116 static void
6117 s_mri_else (qual)
6118      int qual;
6119 {
6120   int c;
6121   char *buf;
6122   char q[2];
6123
6124   if (qual == '\0'
6125       && (mri_control_stack == NULL
6126           || mri_control_stack->type != mri_if
6127           || mri_control_stack->else_seen))
6128     {
6129       s_else (0);
6130       return;
6131     }
6132
6133   c = *input_line_pointer;
6134   *input_line_pointer = 0;
6135   if (ignore_input ())
6136     {
6137       *input_line_pointer = c;
6138       while (! is_end_of_line[(unsigned char) *input_line_pointer])
6139         ++input_line_pointer;
6140       demand_empty_rest_of_line ();
6141       return;
6142     }
6143   *input_line_pointer = c;
6144
6145   if (mri_control_stack == NULL
6146       || mri_control_stack->type != mri_if
6147       || mri_control_stack->else_seen)
6148     {
6149       as_bad (_("else without matching if"));
6150       ignore_rest_of_line ();
6151       return;
6152     }
6153
6154   mri_control_stack->else_seen = 1;
6155
6156   buf = (char *) xmalloc (20 + strlen (mri_control_stack->bottom));
6157   q[0] = TOLOWER (qual);
6158   q[1] = '\0';
6159   sprintf (buf, "bra%s %s", q, mri_control_stack->bottom);
6160   mri_assemble (buf);
6161   free (buf);
6162
6163   colon (mri_control_stack->next);
6164
6165   if (flag_mri)
6166     {
6167       while (! is_end_of_line[(unsigned char) *input_line_pointer])
6168         ++input_line_pointer;
6169     }
6170
6171   demand_empty_rest_of_line ();
6172 }
6173
6174 /* Handle the MRI ENDI pseudo-op.  */
6175
6176 static void
6177 s_mri_endi (ignore)
6178      int ignore ATTRIBUTE_UNUSED;
6179 {
6180   if (mri_control_stack == NULL
6181       || mri_control_stack->type != mri_if)
6182     {
6183       as_bad (_("endi without matching if"));
6184       ignore_rest_of_line ();
6185       return;
6186     }
6187
6188   /* ignore_input will not return true for ENDI, so we don't need to
6189      worry about checking it again here.  */
6190
6191   if (! mri_control_stack->else_seen)
6192     colon (mri_control_stack->next);
6193   colon (mri_control_stack->bottom);
6194
6195   pop_mri_control ();
6196
6197   if (flag_mri)
6198     {
6199       while (! is_end_of_line[(unsigned char) *input_line_pointer])
6200         ++input_line_pointer;
6201     }
6202
6203   demand_empty_rest_of_line ();
6204 }
6205
6206 /* Handle the MRI BREAK pseudo-op.  */
6207
6208 static void
6209 s_mri_break (extent)
6210      int extent;
6211 {
6212   struct mri_control_info *n;
6213   char *buf;
6214   char ex[2];
6215
6216   n = mri_control_stack;
6217   while (n != NULL
6218          && n->type != mri_for
6219          && n->type != mri_repeat
6220          && n->type != mri_while)
6221     n = n->outer;
6222   if (n == NULL)
6223     {
6224       as_bad (_("break outside of structured loop"));
6225       ignore_rest_of_line ();
6226       return;
6227     }
6228
6229   buf = (char *) xmalloc (20 + strlen (n->bottom));
6230   ex[0] = TOLOWER (extent);
6231   ex[1] = '\0';
6232   sprintf (buf, "bra%s %s", ex, n->bottom);
6233   mri_assemble (buf);
6234   free (buf);
6235
6236   if (flag_mri)
6237     {
6238       while (! is_end_of_line[(unsigned char) *input_line_pointer])
6239         ++input_line_pointer;
6240     }
6241
6242   demand_empty_rest_of_line ();
6243 }
6244
6245 /* Handle the MRI NEXT pseudo-op.  */
6246
6247 static void
6248 s_mri_next (extent)
6249      int extent;
6250 {
6251   struct mri_control_info *n;
6252   char *buf;
6253   char ex[2];
6254
6255   n = mri_control_stack;
6256   while (n != NULL
6257          && n->type != mri_for
6258          && n->type != mri_repeat
6259          && n->type != mri_while)
6260     n = n->outer;
6261   if (n == NULL)
6262     {
6263       as_bad (_("next outside of structured loop"));
6264       ignore_rest_of_line ();
6265       return;
6266     }
6267
6268   buf = (char *) xmalloc (20 + strlen (n->next));
6269   ex[0] = TOLOWER (extent);
6270   ex[1] = '\0';
6271   sprintf (buf, "bra%s %s", ex, n->next);
6272   mri_assemble (buf);
6273   free (buf);
6274
6275   if (flag_mri)
6276     {
6277       while (! is_end_of_line[(unsigned char) *input_line_pointer])
6278         ++input_line_pointer;
6279     }
6280
6281   demand_empty_rest_of_line ();
6282 }
6283
6284 /* Handle the MRI FOR pseudo-op.  */
6285
6286 static void
6287 s_mri_for (qual)
6288      int qual;
6289 {
6290   const char *varstart, *varstop;
6291   const char *initstart, *initstop;
6292   const char *endstart, *endstop;
6293   const char *bystart, *bystop;
6294   int up;
6295   int by;
6296   int extent;
6297   struct mri_control_info *n;
6298   char *buf;
6299   char *s;
6300   char ex[2];
6301
6302   /* The syntax is
6303        FOR.q var = init { TO | DOWNTO } end [ BY by ] DO.e
6304      */
6305
6306   SKIP_WHITESPACE ();
6307   varstart = input_line_pointer;
6308
6309   /* Look for the '='.  */
6310   while (! is_end_of_line[(unsigned char) *input_line_pointer]
6311          && *input_line_pointer != '=')
6312     ++input_line_pointer;
6313   if (*input_line_pointer != '=')
6314     {
6315       as_bad (_("missing ="));
6316       ignore_rest_of_line ();
6317       return;
6318     }
6319
6320   varstop = input_line_pointer;
6321   if (varstop > varstart
6322       && (varstop[-1] == ' ' || varstop[-1] == '\t'))
6323     --varstop;
6324
6325   ++input_line_pointer;
6326
6327   initstart = input_line_pointer;
6328
6329   /* Look for TO or DOWNTO.  */
6330   up = 1;
6331   initstop = NULL;
6332   while (! is_end_of_line[(unsigned char) *input_line_pointer])
6333     {
6334       if (strncasecmp (input_line_pointer, "TO", 2) == 0
6335           && ! is_part_of_name (input_line_pointer[2]))
6336         {
6337           initstop = input_line_pointer;
6338           input_line_pointer += 2;
6339           break;
6340         }
6341       if (strncasecmp (input_line_pointer, "DOWNTO", 6) == 0
6342           && ! is_part_of_name (input_line_pointer[6]))
6343         {
6344           initstop = input_line_pointer;
6345           up = 0;
6346           input_line_pointer += 6;
6347           break;
6348         }
6349       ++input_line_pointer;
6350     }
6351   if (initstop == NULL)
6352     {
6353       as_bad (_("missing to or downto"));
6354       ignore_rest_of_line ();
6355       return;
6356     }
6357   if (initstop > initstart
6358       && (initstop[-1] == ' ' || initstop[-1] == '\t'))
6359     --initstop;
6360
6361   SKIP_WHITESPACE ();
6362   endstart = input_line_pointer;
6363
6364   /* Look for BY or DO.  */
6365   by = 0;
6366   endstop = NULL;
6367   while (! is_end_of_line[(unsigned char) *input_line_pointer])
6368     {
6369       if (strncasecmp (input_line_pointer, "BY", 2) == 0
6370           && ! is_part_of_name (input_line_pointer[2]))
6371         {
6372           endstop = input_line_pointer;
6373           by = 1;
6374           input_line_pointer += 2;
6375           break;
6376         }
6377       if (strncasecmp (input_line_pointer, "DO", 2) == 0
6378           && (input_line_pointer[2] == '.'
6379               || ! is_part_of_name (input_line_pointer[2])))
6380         {
6381           endstop = input_line_pointer;
6382           input_line_pointer += 2;
6383           break;
6384         }
6385       ++input_line_pointer;
6386     }
6387   if (endstop == NULL)
6388     {
6389       as_bad (_("missing do"));
6390       ignore_rest_of_line ();
6391       return;
6392     }
6393   if (endstop > endstart
6394       && (endstop[-1] == ' ' || endstop[-1] == '\t'))
6395     --endstop;
6396
6397   if (! by)
6398     {
6399       bystart = "#1";
6400       bystop = bystart + 2;
6401     }
6402   else
6403     {
6404       SKIP_WHITESPACE ();
6405       bystart = input_line_pointer;
6406
6407       /* Look for DO.  */
6408       bystop = NULL;
6409       while (! is_end_of_line[(unsigned char) *input_line_pointer])
6410         {
6411           if (strncasecmp (input_line_pointer, "DO", 2) == 0
6412               && (input_line_pointer[2] == '.'
6413                   || ! is_part_of_name (input_line_pointer[2])))
6414             {
6415               bystop = input_line_pointer;
6416               input_line_pointer += 2;
6417               break;
6418             }
6419           ++input_line_pointer;
6420         }
6421       if (bystop == NULL)
6422         {
6423           as_bad (_("missing do"));
6424           ignore_rest_of_line ();
6425           return;
6426         }
6427       if (bystop > bystart
6428           && (bystop[-1] == ' ' || bystop[-1] == '\t'))
6429         --bystop;
6430     }
6431
6432   if (*input_line_pointer != '.')
6433     extent = '\0';
6434   else
6435     {
6436       extent = input_line_pointer[1];
6437       input_line_pointer += 2;
6438     }
6439
6440   /* We have fully parsed the FOR operands.  Now build the loop.  */
6441
6442   n = push_mri_control (mri_for);
6443
6444   buf = (char *) xmalloc (50 + (input_line_pointer - varstart));
6445
6446   /* move init,var */
6447   s = buf;
6448   *s++ = 'm';
6449   *s++ = 'o';
6450   *s++ = 'v';
6451   *s++ = 'e';
6452   if (qual != '\0')
6453     *s++ = TOLOWER (qual);
6454   *s++ = ' ';
6455   memcpy (s, initstart, initstop - initstart);
6456   s += initstop - initstart;
6457   *s++ = ',';
6458   memcpy (s, varstart, varstop - varstart);
6459   s += varstop - varstart;
6460   *s = '\0';
6461   mri_assemble (buf);
6462
6463   colon (n->top);
6464
6465   /* cmp end,var */
6466   s = buf;
6467   *s++ = 'c';
6468   *s++ = 'm';
6469   *s++ = 'p';
6470   if (qual != '\0')
6471     *s++ = TOLOWER (qual);
6472   *s++ = ' ';
6473   memcpy (s, endstart, endstop - endstart);
6474   s += endstop - endstart;
6475   *s++ = ',';
6476   memcpy (s, varstart, varstop - varstart);
6477   s += varstop - varstart;
6478   *s = '\0';
6479   mri_assemble (buf);
6480
6481   /* bcc bottom */
6482   ex[0] = TOLOWER (extent);
6483   ex[1] = '\0';
6484   if (up)
6485     sprintf (buf, "blt%s %s", ex, n->bottom);
6486   else
6487     sprintf (buf, "bgt%s %s", ex, n->bottom);
6488   mri_assemble (buf);
6489
6490   /* Put together the add or sub instruction used by ENDF.  */
6491   s = buf;
6492   if (up)
6493     strcpy (s, "add");
6494   else
6495     strcpy (s, "sub");
6496   s += 3;
6497   if (qual != '\0')
6498     *s++ = TOLOWER (qual);
6499   *s++ = ' ';
6500   memcpy (s, bystart, bystop - bystart);
6501   s += bystop - bystart;
6502   *s++ = ',';
6503   memcpy (s, varstart, varstop - varstart);
6504   s += varstop - varstart;
6505   *s = '\0';
6506   n->incr = buf;
6507
6508   if (flag_mri)
6509     {
6510       while (! is_end_of_line[(unsigned char) *input_line_pointer])
6511         ++input_line_pointer;
6512     }
6513
6514   demand_empty_rest_of_line ();
6515 }
6516
6517 /* Handle the MRI ENDF pseudo-op.  */
6518
6519 static void
6520 s_mri_endf (ignore)
6521      int ignore ATTRIBUTE_UNUSED;
6522 {
6523   if (mri_control_stack == NULL
6524       || mri_control_stack->type != mri_for)
6525     {
6526       as_bad (_("endf without for"));
6527       ignore_rest_of_line ();
6528       return;
6529     }
6530
6531   colon (mri_control_stack->next);
6532
6533   mri_assemble (mri_control_stack->incr);
6534
6535   sprintf (mri_control_stack->incr, "bra %s", mri_control_stack->top);
6536   mri_assemble (mri_control_stack->incr);
6537
6538   free (mri_control_stack->incr);
6539
6540   colon (mri_control_stack->bottom);
6541
6542   pop_mri_control ();
6543
6544   if (flag_mri)
6545     {
6546       while (! is_end_of_line[(unsigned char) *input_line_pointer])
6547         ++input_line_pointer;
6548     }
6549
6550   demand_empty_rest_of_line ();
6551 }
6552
6553 /* Handle the MRI REPEAT pseudo-op.  */
6554
6555 static void
6556 s_mri_repeat (ignore)
6557      int ignore ATTRIBUTE_UNUSED;
6558 {
6559   struct mri_control_info *n;
6560
6561   n = push_mri_control (mri_repeat);
6562   colon (n->top);
6563   if (flag_mri)
6564     {
6565       while (! is_end_of_line[(unsigned char) *input_line_pointer])
6566         ++input_line_pointer;
6567     }
6568   demand_empty_rest_of_line ();
6569 }
6570
6571 /* Handle the MRI UNTIL pseudo-op.  */
6572
6573 static void
6574 s_mri_until (qual)
6575      int qual;
6576 {
6577   char *s;
6578
6579   if (mri_control_stack == NULL
6580       || mri_control_stack->type != mri_repeat)
6581     {
6582       as_bad (_("until without repeat"));
6583       ignore_rest_of_line ();
6584       return;
6585     }
6586
6587   colon (mri_control_stack->next);
6588
6589   for (s = input_line_pointer; ! is_end_of_line[(unsigned char) *s]; s++)
6590     ;
6591
6592   parse_mri_control_expression (s, qual, (const char *) NULL,
6593                                 mri_control_stack->top, '\0');
6594
6595   colon (mri_control_stack->bottom);
6596
6597   input_line_pointer = s;
6598
6599   pop_mri_control ();
6600
6601   if (flag_mri)
6602     {
6603       while (! is_end_of_line[(unsigned char) *input_line_pointer])
6604         ++input_line_pointer;
6605     }
6606
6607   demand_empty_rest_of_line ();
6608 }
6609
6610 /* Handle the MRI WHILE pseudo-op.  */
6611
6612 static void
6613 s_mri_while (qual)
6614      int qual;
6615 {
6616   char *s;
6617
6618   struct mri_control_info *n;
6619
6620   s = input_line_pointer;
6621   /* We only accept '*' as introduction of comments if preceded by white space
6622      or at first column of a line (I think this can't actually happen here?)
6623      This is important when assembling:
6624        while d0 <ne> 12(a0,d0*2) do
6625        while d0 <ne> #CONST*20   do */
6626   while (! (is_end_of_line[(unsigned char) *s]
6627             || (flag_mri
6628                 && *s == '*'
6629                 && (s == input_line_pointer
6630                     || *(s-1) == ' '
6631                     || *(s-1) == '\t'))))
6632     s++;
6633   --s;
6634   while (*s == ' ' || *s == '\t')
6635     --s;
6636   if (s - input_line_pointer > 1
6637       && s[-1] == '.')
6638     s -= 2;
6639   if (s - input_line_pointer < 2
6640       || strncasecmp (s - 1, "DO", 2) != 0)
6641     {
6642       as_bad (_("missing do"));
6643       ignore_rest_of_line ();
6644       return;
6645     }
6646
6647   n = push_mri_control (mri_while);
6648
6649   colon (n->next);
6650
6651   parse_mri_control_expression (s - 1, qual, (const char *) NULL, n->bottom,
6652                                 s[1] == '.' ? s[2] : '\0');
6653
6654   input_line_pointer = s + 1;
6655   if (*input_line_pointer == '.')
6656     input_line_pointer += 2;
6657
6658   if (flag_mri)
6659     {
6660       while (! is_end_of_line[(unsigned char) *input_line_pointer])
6661         ++input_line_pointer;
6662     }
6663
6664   demand_empty_rest_of_line ();
6665 }
6666
6667 /* Handle the MRI ENDW pseudo-op.  */
6668
6669 static void
6670 s_mri_endw (ignore)
6671      int ignore ATTRIBUTE_UNUSED;
6672 {
6673   char *buf;
6674
6675   if (mri_control_stack == NULL
6676       || mri_control_stack->type != mri_while)
6677     {
6678       as_bad (_("endw without while"));
6679       ignore_rest_of_line ();
6680       return;
6681     }
6682
6683   buf = (char *) xmalloc (20 + strlen (mri_control_stack->next));
6684   sprintf (buf, "bra %s", mri_control_stack->next);
6685   mri_assemble (buf);
6686   free (buf);
6687
6688   colon (mri_control_stack->bottom);
6689
6690   pop_mri_control ();
6691
6692   if (flag_mri)
6693     {
6694       while (! is_end_of_line[(unsigned char) *input_line_pointer])
6695         ++input_line_pointer;
6696     }
6697
6698   demand_empty_rest_of_line ();
6699 }
6700 \f
6701 /*
6702  * md_parse_option
6703  *      Invocation line includes a switch not recognized by the base assembler.
6704  *      See if it's a processor-specific option.  These are:
6705  *
6706  *      -[A]m[c]68000, -[A]m[c]68008, -[A]m[c]68010, -[A]m[c]68020, -[A]m[c]68030, -[A]m[c]68040
6707  *      -[A]m[c]68881, -[A]m[c]68882, -[A]m[c]68851
6708  *              Select the architecture.  Instructions or features not
6709  *              supported by the selected architecture cause fatal
6710  *              errors.  More than one may be specified.  The default is
6711  *              -m68020 -m68851 -m68881.  Note that -m68008 is a synonym
6712  *              for -m68000, and -m68882 is a synonym for -m68881.
6713  *      -[A]m[c]no-68851, -[A]m[c]no-68881
6714  *              Don't accept 688?1 instructions.  (The "c" is kind of silly,
6715  *              so don't use or document it, but that's the way the parsing
6716  *              works).
6717  *
6718  *      -pic    Indicates PIC.
6719  *      -k      Indicates PIC.  (Sun 3 only.)
6720  *      --pcrel Never turn PC-relative branches into absolute jumps.
6721  *
6722  *      --bitwise-or
6723  *              Permit `|' to be used in expressions.
6724  *
6725  */
6726
6727 #ifdef OBJ_ELF
6728 const char *md_shortopts = "lSA:m:kQ:V";
6729 #else
6730 const char *md_shortopts = "lSA:m:k";
6731 #endif
6732
6733 struct option md_longopts[] = {
6734 #define OPTION_PIC (OPTION_MD_BASE)
6735   {"pic", no_argument, NULL, OPTION_PIC},
6736 #define OPTION_REGISTER_PREFIX_OPTIONAL (OPTION_MD_BASE + 1)
6737   {"register-prefix-optional", no_argument, NULL,
6738      OPTION_REGISTER_PREFIX_OPTIONAL},
6739 #define OPTION_BITWISE_OR (OPTION_MD_BASE + 2)
6740   {"bitwise-or", no_argument, NULL, OPTION_BITWISE_OR},
6741 #define OPTION_BASE_SIZE_DEFAULT_16 (OPTION_MD_BASE + 3)
6742   {"base-size-default-16", no_argument, NULL, OPTION_BASE_SIZE_DEFAULT_16},
6743 #define OPTION_BASE_SIZE_DEFAULT_32 (OPTION_MD_BASE + 4)
6744   {"base-size-default-32", no_argument, NULL, OPTION_BASE_SIZE_DEFAULT_32},
6745 #define OPTION_DISP_SIZE_DEFAULT_16 (OPTION_MD_BASE + 5)
6746   {"disp-size-default-16", no_argument, NULL, OPTION_DISP_SIZE_DEFAULT_16},
6747 #define OPTION_DISP_SIZE_DEFAULT_32 (OPTION_MD_BASE + 6)
6748   {"disp-size-default-32", no_argument, NULL, OPTION_DISP_SIZE_DEFAULT_32},
6749 #define OPTION_PCREL (OPTION_MD_BASE + 7)
6750   {"pcrel", no_argument, NULL, OPTION_PCREL},
6751   {NULL, no_argument, NULL, 0}
6752 };
6753 size_t md_longopts_size = sizeof (md_longopts);
6754
6755 int
6756 md_parse_option (c, arg)
6757      int c;
6758      char *arg;
6759 {
6760   switch (c)
6761     {
6762     case 'l':                   /* -l means keep external to 2 bit offset
6763                                    rather than 16 bit one */
6764       flag_short_refs = 1;
6765       break;
6766
6767     case 'S':                   /* -S means that jbsr's always turn into
6768                                    jsr's.  */
6769       flag_long_jumps = 1;
6770       break;
6771
6772     case OPTION_PCREL:          /* --pcrel means never turn PC-relative
6773                                    branches into absolute jumps.  */
6774       flag_keep_pcrel = 1;
6775       break;
6776
6777     case 'A':
6778       if (*arg == 'm')
6779         arg++;
6780       /* intentional fall-through */
6781     case 'm':
6782
6783       if (arg[0] == 'n' && arg[1] == 'o' && arg[2] == '-')
6784         {
6785           int i;
6786           unsigned long arch;
6787           const char *oarg = arg;
6788
6789           arg += 3;
6790           if (*arg == 'm')
6791             {
6792               arg++;
6793               if (arg[0] == 'c' && arg[1] == '6')
6794                 arg++;
6795             }
6796           for (i = 0; i < n_archs; i++)
6797             if (!strcmp (arg, archs[i].name))
6798               break;
6799           if (i == n_archs)
6800             {
6801             unknown:
6802               as_bad (_("unrecognized option `%s'"), oarg);
6803               return 0;
6804             }
6805           arch = archs[i].arch;
6806           if (arch == m68881)
6807             no_68881 = 1;
6808           else if (arch == m68851)
6809             no_68851 = 1;
6810           else
6811             goto unknown;
6812         }
6813       else
6814         {
6815           int i;
6816
6817           if (arg[0] == 'c' && arg[1] == '6')
6818             arg++;
6819
6820           for (i = 0; i < n_archs; i++)
6821             if (!strcmp (arg, archs[i].name))
6822               {
6823                 unsigned long arch = archs[i].arch;
6824                 if (cpu_of_arch (arch))
6825                   /* It's a cpu spec.  */
6826                   {
6827                     current_architecture &= ~m68000up;
6828                     current_architecture |= arch;
6829                   }
6830                 else if (arch == m68881)
6831                   {
6832                     current_architecture |= m68881;
6833                     no_68881 = 0;
6834                   }
6835                 else if (arch == m68851)
6836                   {
6837                     current_architecture |= m68851;
6838                     no_68851 = 0;
6839                   }
6840                 else
6841                   /* ??? */
6842                   abort ();
6843                 break;
6844               }
6845           if (i == n_archs)
6846             {
6847               as_bad (_("unrecognized architecture specification `%s'"), arg);
6848               return 0;
6849             }
6850         }
6851       break;
6852
6853     case OPTION_PIC:
6854     case 'k':
6855       flag_want_pic = 1;
6856       break;                    /* -pic, Position Independent Code */
6857
6858     case OPTION_REGISTER_PREFIX_OPTIONAL:
6859       flag_reg_prefix_optional = 1;
6860       reg_prefix_optional_seen = 1;
6861       break;
6862
6863       /* -V: SVR4 argument to print version ID.  */
6864     case 'V':
6865       print_version_id ();
6866       break;
6867
6868       /* -Qy, -Qn: SVR4 arguments controlling whether a .comment section
6869          should be emitted or not.  FIXME: Not implemented.  */
6870     case 'Q':
6871       break;
6872
6873     case OPTION_BITWISE_OR:
6874       {
6875         char *n, *t;
6876         const char *s;
6877
6878         n = (char *) xmalloc (strlen (m68k_comment_chars) + 1);
6879         t = n;
6880         for (s = m68k_comment_chars; *s != '\0'; s++)
6881           if (*s != '|')
6882             *t++ = *s;
6883         *t = '\0';
6884         m68k_comment_chars = n;
6885       }
6886       break;
6887
6888     case OPTION_BASE_SIZE_DEFAULT_16:
6889       m68k_index_width_default = SIZE_WORD;
6890       break;
6891
6892     case OPTION_BASE_SIZE_DEFAULT_32:
6893       m68k_index_width_default = SIZE_LONG;
6894       break;
6895
6896     case OPTION_DISP_SIZE_DEFAULT_16:
6897       m68k_rel32 = 0;
6898       m68k_rel32_from_cmdline = 1;
6899       break;
6900
6901     case OPTION_DISP_SIZE_DEFAULT_32:
6902       m68k_rel32 = 1;
6903       m68k_rel32_from_cmdline = 1;
6904       break;
6905
6906     default:
6907       return 0;
6908     }
6909
6910   return 1;
6911 }
6912
6913 void
6914 md_show_usage (stream)
6915      FILE *stream;
6916 {
6917   const char *default_cpu = TARGET_CPU;
6918   int default_arch, i;
6919
6920   /* Get the canonical name for the default target CPU.  */
6921   if (*default_cpu == 'm')
6922     default_cpu++;
6923   for (i = 0; i < n_archs; i++)
6924     {
6925       if (strcasecmp (default_cpu, archs[i].name) == 0)
6926         {
6927           default_arch = archs[i].arch;
6928           for (i = 0; i < n_archs; i++)
6929             {
6930               if (archs[i].arch == default_arch
6931                   && !archs[i].alias)
6932                 {
6933                   default_cpu = archs[i].name;
6934                   break;
6935                 }
6936             }
6937         }
6938     }
6939
6940   fprintf (stream, _("\
6941 680X0 options:\n\
6942 -l                      use 1 word for refs to undefined symbols [default 2]\n\
6943 -m68000 | -m68008 | -m68010 | -m68020 | -m68030 | -m68040 | -m68060 |\n\
6944 -m68302 | -m68331 | -m68332 | -m68333 | -m68340 | -m68360 | -mcpu32 |\n\
6945 -m5200  | -m5202  | -m5204  | -m5206  | -m5206e | -m5307  | -m5407\n\
6946                         specify variant of 680X0 architecture [default %s]\n\
6947 -m68881 | -m68882 | -mno-68881 | -mno-68882\n\
6948                         target has/lacks floating-point coprocessor\n\
6949                         [default yes for 68020, 68030, and cpu32]\n"),
6950           default_cpu);
6951   fprintf (stream, _("\
6952 -m68851 | -mno-68851\n\
6953                         target has/lacks memory-management unit coprocessor\n\
6954                         [default yes for 68020 and up]\n\
6955 -pic, -k                generate position independent code\n\
6956 -S                      turn jbsr into jsr\n\
6957 --pcrel                 never turn PC-relative branches into absolute jumps\n\
6958 --register-prefix-optional\n\
6959                         recognize register names without prefix character\n\
6960 --bitwise-or            do not treat `|' as a comment character\n"));
6961   fprintf (stream, _("\
6962 --base-size-default-16  base reg without size is 16 bits\n\
6963 --base-size-default-32  base reg without size is 32 bits (default)\n\
6964 --disp-size-default-16  displacement with unknown size is 16 bits\n\
6965 --disp-size-default-32  displacement with unknown size is 32 bits (default)\n"));
6966 }
6967 \f
6968 #ifdef TEST2
6969
6970 /* TEST2:  Test md_assemble() */
6971 /* Warning, this routine probably doesn't work anymore */
6972
6973 main ()
6974 {
6975   struct m68k_it the_ins;
6976   char buf[120];
6977   char *cp;
6978   int n;
6979
6980   m68k_ip_begin ();
6981   for (;;)
6982     {
6983       if (!gets (buf) || !*buf)
6984         break;
6985       if (buf[0] == '|' || buf[1] == '.')
6986         continue;
6987       for (cp = buf; *cp; cp++)
6988         if (*cp == '\t')
6989           *cp = ' ';
6990       if (is_label (buf))
6991         continue;
6992       memset (&the_ins, '\0', sizeof (the_ins));
6993       m68k_ip (&the_ins, buf);
6994       if (the_ins.error)
6995         {
6996           printf (_("Error %s in %s\n"), the_ins.error, buf);
6997         }
6998       else
6999         {
7000           printf (_("Opcode(%d.%s): "), the_ins.numo, the_ins.args);
7001           for (n = 0; n < the_ins.numo; n++)
7002             printf (" 0x%x", the_ins.opcode[n] & 0xffff);
7003           printf ("    ");
7004           print_the_insn (&the_ins.opcode[0], stdout);
7005           (void) putchar ('\n');
7006         }
7007       for (n = 0; n < strlen (the_ins.args) / 2; n++)
7008         {
7009           if (the_ins.operands[n].error)
7010             {
7011               printf ("op%d Error %s in %s\n", n, the_ins.operands[n].error, buf);
7012               continue;
7013             }
7014           printf ("mode %d, reg %d, ", the_ins.operands[n].mode, the_ins.operands[n].reg);
7015           if (the_ins.operands[n].b_const)
7016             printf ("Constant: '%.*s', ", 1 + the_ins.operands[n].e_const - the_ins.operands[n].b_const, the_ins.operands[n].b_const);
7017           printf ("ireg %d, isiz %d, imul %d, ", the_ins.operands[n].ireg, the_ins.operands[n].isiz, the_ins.operands[n].imul);
7018           if (the_ins.operands[n].b_iadd)
7019             printf ("Iadd: '%.*s',", 1 + the_ins.operands[n].e_iadd - the_ins.operands[n].b_iadd, the_ins.operands[n].b_iadd);
7020           (void) putchar ('\n');
7021         }
7022     }
7023   m68k_ip_end ();
7024   return 0;
7025 }
7026
7027 is_label (str)
7028      char *str;
7029 {
7030   while (*str == ' ')
7031     str++;
7032   while (*str && *str != ' ')
7033     str++;
7034   if (str[-1] == ':' || str[1] == '=')
7035     return 1;
7036   return 0;
7037 }
7038
7039 #endif
7040
7041 /* Possible states for relaxation:
7042
7043    0 0  branch offset   byte    (bra, etc)
7044    0 1                  word
7045    0 2                  long
7046
7047    1 0  indexed offsets byte    a0@(32,d4:w:1) etc
7048    1 1                  word
7049    1 2                  long
7050
7051    2 0  two-offset index word-word a0@(32,d4)@(45) etc
7052    2 1                  word-long
7053    2 2                  long-word
7054    2 3                  long-long
7055
7056    */
7057
7058 /* We have no need to default values of symbols.  */
7059
7060 symbolS *
7061 md_undefined_symbol (name)
7062      char *name ATTRIBUTE_UNUSED;
7063 {
7064   return 0;
7065 }
7066
7067 /* Round up a section size to the appropriate boundary.  */
7068 valueT
7069 md_section_align (segment, size)
7070      segT segment ATTRIBUTE_UNUSED;
7071      valueT size;
7072 {
7073 #ifdef OBJ_AOUT
7074 #ifdef BFD_ASSEMBLER
7075   /* For a.out, force the section size to be aligned.  If we don't do
7076      this, BFD will align it for us, but it will not write out the
7077      final bytes of the section.  This may be a bug in BFD, but it is
7078      easier to fix it here since that is how the other a.out targets
7079      work.  */
7080   int align;
7081
7082   align = bfd_get_section_alignment (stdoutput, segment);
7083   size = ((size + (1 << align) - 1) & ((valueT) -1 << align));
7084 #endif
7085 #endif
7086
7087   return size;
7088 }
7089
7090 /* Exactly what point is a PC-relative offset relative TO?
7091    On the 68k, it is relative to the address of the first extension
7092    word.  The difference between the addresses of the offset and the
7093    first extension word is stored in fx_pcrel_adjust.  */
7094 long
7095 md_pcrel_from (fixP)
7096      fixS *fixP;
7097 {
7098   int adjust;
7099
7100   /* Because fx_pcrel_adjust is a char, and may be unsigned, we explicitly
7101      sign extend the value here.  */
7102   adjust = ((fixP->fx_pcrel_adjust & 0xff) ^ 0x80) - 0x80;
7103   if (adjust == 64)
7104     adjust = -1;
7105   return fixP->fx_where + fixP->fx_frag->fr_address - adjust;
7106 }
7107
7108 #ifndef BFD_ASSEMBLER
7109 #ifdef OBJ_COFF
7110
7111 void
7112 tc_coff_symbol_emit_hook (ignore)
7113      symbolS *ignore ATTRIBUTE_UNUSED;
7114 {
7115 }
7116
7117 int
7118 tc_coff_sizemachdep (frag)
7119      fragS *frag;
7120 {
7121   switch (frag->fr_subtype & 0x3)
7122     {
7123     case BYTE:
7124       return 1;
7125     case SHORT:
7126       return 2;
7127     case LONG:
7128       return 4;
7129     default:
7130       abort ();
7131       return 0;
7132     }
7133 }
7134
7135 #endif
7136 #endif
7137 #ifdef OBJ_ELF
7138 void
7139 m68k_elf_final_processing ()
7140 {
7141   /* Set file-specific flags if this is a cpu32 processor */
7142   if (cpu_of_arch (current_architecture) & cpu32)
7143     elf_elfheader (stdoutput)->e_flags |= EF_CPU32;
7144   else if ((cpu_of_arch (current_architecture) & m68000up)
7145            && !(cpu_of_arch (current_architecture) & m68020up))
7146     elf_elfheader (stdoutput)->e_flags |= EF_M68000;
7147 }
7148 #endif