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