home *** CD-ROM | disk | FTP | other *** search
/ Fresh Fish 8 / FreshFishVol8-CD1.bin / gnu / src / amiga / binutils-2.5.2-src.lha / binutils-2.5.2 / gas / config / tc-m68k.c < prev    next >
Encoding:
C/C++ Source or Header  |  1994-11-21  |  117.8 KB  |  5,267 lines
  1. /* tc-m68k.c  All the m68020 specific stuff in one convenient, huge,
  2.    slow to compile, easy to find file.
  3.  
  4.    Copyright (C) 1987, 1991, 1992, 1993 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
  20.    the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.  */
  21.  
  22. #include <ctype.h>
  23. #define  NO_RELOC 0
  24. #include "as.h"
  25.  
  26. /* need TARGET_CPU */
  27. #include "config.h"
  28.  
  29. #include "obstack.h"
  30.  
  31. /* The opcode table is too big for gcc, which (currently) requires
  32.    exponential space at compile time for initialized arrays.  */
  33. #ifdef __GNUC__
  34. #define DO_BREAK_UP_BIG_DECL
  35. #define BREAK_UP_BIG_DECL    }; struct m68k_opcode m68k_opcodes_2[] = {
  36. #define AND_OTHER_PART        sizeof (m68k_opcodes_2)
  37. #endif
  38.  
  39. /* Note that this file includes real declarations and thus can only be
  40.    included by one source file per executable.  */
  41. #include "opcode/m68k.h"
  42.  
  43. /* This array holds the chars that always start a comment.  If the
  44.    pre-processor is disabled, these aren't very useful */
  45. CONST char comment_chars[] = "|";
  46.  
  47. /* This array holds the chars that only start a comment at the beginning of
  48.    a line.  If the line seems to have the form '# 123 filename'
  49.    .line and .file directives will appear in the pre-processed output */
  50. /* Note that input_file.c hand checks for '#' at the beginning of the
  51.    first line of the input file.  This is because the compiler outputs
  52.    #NO_APP at the beginning of its output. */
  53. /* Also note that comments like this one will always work. */
  54. CONST char line_comment_chars[] = "#";
  55.  
  56. CONST char line_separator_chars[] = "";
  57.  
  58. /* Chars that can be used to separate mant from exp in floating point nums */
  59. CONST char EXP_CHARS[] = "eE";
  60.  
  61. /* Chars that mean this number is a floating point constant, as
  62.    in "0f12.456" or "0d1.2345e12".  */
  63.  
  64. CONST char FLT_CHARS[] = "rRsSfFdDxXeEpP";
  65.  
  66. /* Also be aware that MAXIMUM_NUMBER_OF_CHARS_FOR_FLOAT may have to be
  67.    changed in read.c .  Ideally it shouldn't have to know about it at all,
  68.    but nothing is ideal around here.  */
  69.  
  70. const int md_reloc_size = 8;    /* Size of relocation record */
  71.  
  72. /* Are we trying to generate PIC code?  If so, absolute references
  73.    ought to be made into linkage table references or pc-relative
  74.    references.  */
  75. int flag_want_pic;
  76.  
  77. static int flag_short_refs;    /* -l option */
  78. static int flag_long_jumps;    /* -S option */
  79.  
  80. #ifdef REGISTER_PREFIX_OPTIONAL
  81. int flag_reg_prefix_optional = REGISTER_PREFIX_OPTIONAL;
  82. #else
  83. int flag_reg_prefix_optional;
  84. #endif
  85.  
  86. /* Its an arbitrary name:  This means I don't approve of it */
  87. /* See flames below */
  88. static struct obstack robyn;
  89.  
  90. #define TAB(x,y)    (((x)<<2)+(y))
  91. #define TABTYPE(xy)     ((xy) >> 2)
  92. #define BYTE        0
  93. #define SHORT        1
  94. #define LONG        2
  95. #define SZ_UNDEF    3
  96. #undef BRANCH
  97. #define ABRANCH        1
  98. #define FBRANCH        2
  99. #define PCREL        3
  100. #define BCC68000        4
  101. #define DBCC            5
  102. #define PCLEA        6
  103.  
  104. struct m68k_incant
  105.   {
  106.     char *m_operands;
  107.     unsigned long m_opcode;
  108.     short m_opnum;
  109.     short m_codenum;
  110.     int m_arch;
  111.     struct m68k_incant *m_next;
  112.   };
  113.  
  114. #define getone(x)    ((((x)->m_opcode)>>16)&0xffff)
  115. #define gettwo(x)    (((x)->m_opcode)&0xffff)
  116.  
  117. /* Operands we can parse:  (And associated modes)
  118.  
  119.    numb:    8 bit num
  120.    numw:    16 bit num
  121.    numl:    32 bit num
  122.    dreg:    data reg 0-7
  123.    reg:    address or data register
  124.    areg:    address register
  125.    apc:    address register, PC, ZPC or empty string
  126.    num:    16 or 32 bit num
  127.    num2:    like num
  128.    sz:    w or l        if omitted, l assumed
  129.    scale:    1 2 4 or 8    if omitted, 1 assumed
  130.  
  131.    7.4 IMMED #num                --> NUM
  132.    0.? DREG  dreg                --> dreg
  133.    1.? AREG  areg                --> areg
  134.    2.? AINDR areg@                --> *(areg)
  135.    3.? AINC  areg@+            --> *(areg++)
  136.    4.? ADEC  areg@-            --> *(--areg)
  137.    5.? AOFF  apc@(numw)            --> *(apc+numw)    -- empty string and ZPC not allowed here
  138.    6.? AINDX apc@(num,reg:sz:scale)    --> *(apc+num+reg*scale)
  139.    6.? AINDX apc@(reg:sz:scale)        --> same, with num=0
  140.    6.? APODX apc@(num)@(num2,reg:sz:scale)    --> *(*(apc+num)+num2+reg*scale)
  141.    6.? APODX apc@(num)@(reg:sz:scale)    --> same, with num2=0
  142.    6.? AMIND apc@(num)@(num2)        --> *(*(apc+num)+num2) (previous mode without an index reg)
  143.    6.? APRDX apc@(num,reg:sz:scale)@(num2)    --> *(*(apc+num+reg*scale)+num2)
  144.    6.? APRDX apc@(reg:sz:scale)@(num2)    --> same, with num=0
  145.    7.0 ABSL  num:sz            --> *(num)
  146.    num                --> *(num) (sz L assumed)
  147.    *** MSCR  otherreg            --> Magic
  148.    With -l option
  149.    5.? AOFF  apc@(num)            --> *(apc+num) -- empty string and ZPC not allowed here still
  150.    ?.? DINDR dreg@            --> (dreg) -- cas2 only
  151.  
  152.    examples:
  153.    #foo    #0x35    #12
  154.    d2
  155.    a4
  156.    a3@
  157.    a5@+
  158.    a6@-
  159.    a2@(12)    pc@(14)
  160.    a1@(5,d2:w:1)    @(45,d6:l:4)
  161.    pc@(a2)        @(d4)
  162.    etc . . .
  163.  
  164.  
  165.    #name@(numw)    -->turn into PC rel mode
  166.    apc@(num8,reg:sz:scale)        --> *(apc+num8+reg*scale)
  167.  
  168.    */
  169.  
  170. enum operand_type
  171.   {
  172.     IMMED = 1,
  173.     DREG,
  174.     AREG,
  175.     AINDR,
  176.     ADEC,
  177.     AINC,
  178.     AOFF,
  179.     AINDX,
  180.     APODX,
  181.     AMIND,
  182.     APRDX,
  183.     ABSL,
  184.     MSCR,
  185.     REGLST,
  186.     DINDR
  187.   };
  188.  
  189.  
  190. struct m68k_exp
  191.   {
  192.     char *e_beg;
  193.     char *e_end;
  194.     segT e_seg;
  195.     expressionS e_exp;
  196.     short e_siz;        /* 0== default 1==short/byte 2==word 3==long */
  197.   };
  198.  
  199. /* DATA and ADDR have to be contiguous, so that reg-DATA gives
  200.    0-7==data reg, 8-15==addr reg for operands that take both types.
  201.  
  202.    We don't use forms like "ADDR0 = ADDR" here because this file is
  203.    likely to be used on an Apollo, and the broken Apollo compiler
  204.    gives an `undefined variable' error if we do that, according to
  205.    troy@cbme.unsw.edu.au.  */
  206.  
  207. #define DATA DATA0
  208. #define ADDR ADDR0
  209. #define SP ADDR7
  210. #define FPREG FP0
  211. #define COPNUM  COP0
  212. #define BAD BAD0
  213. #define BAC BAC0
  214.  
  215. enum _register
  216.   {
  217.     DATA0 = 1,            /*   1- 8 == data registers 0-7 */
  218.     DATA1,
  219.     DATA2,
  220.     DATA3,
  221.     DATA4,
  222.     DATA5,
  223.     DATA6,
  224.     DATA7,
  225.  
  226.     ADDR0,
  227.     ADDR1,
  228.     ADDR2,
  229.     ADDR3,
  230.     ADDR4,
  231.     ADDR5,
  232.     ADDR6,
  233.     ADDR7,
  234.  
  235.     /* Note that COP0==processor #1 -- COP0+7==#8, which stores as 000 */
  236.     /* I think. . .  */
  237.  
  238.     FP0,            /* Eight FP registers */
  239.     FP1,
  240.     FP2,
  241.     FP3,
  242.     FP4,
  243.     FP5,
  244.     FP6,
  245.     FP7,
  246.  
  247.     COP0,            /* Co-processor #1-#8 */
  248.     COP1,
  249.     COP2,
  250.     COP3,
  251.     COP4,
  252.     COP5,
  253.     COP6,
  254.     COP7,
  255.  
  256.     PC,                /* Program counter */
  257.     ZPC,            /* Hack for Program space, but 0 addressing */
  258.     SR,                /* Status Reg */
  259.     CCR,            /* Condition code Reg */
  260.  
  261.     /* These have to be grouped together for the movec instruction to work. */
  262.     USP,            /*  User Stack Pointer */
  263.     ISP,            /*  Interrupt stack pointer */
  264.     SFC,
  265.     DFC,
  266.     CACR,
  267.     VBR,
  268.     CAAR,
  269.     MSP,
  270.     ITT0,
  271.     ITT1,
  272.     DTT0,
  273.     DTT1,
  274.     MMUSR,
  275.     TC,
  276.     SRP,
  277.     URP,
  278.     BUSCR,            /* 68060 added these */
  279.     PCR,
  280. #define last_movec_reg PCR
  281.     /* end of movec ordering constraints */
  282.  
  283.     FPI,
  284.     FPS,
  285.     FPC,
  286.  
  287.     DRP,            /* 68851 or 68030 MMU regs */
  288.     CRP,
  289.     CAL,
  290.     VAL,
  291.     SCC,
  292.     AC,
  293.     BAD0,
  294.     BAD1,
  295.     BAD2,
  296.     BAD3,
  297.     BAD4,
  298.     BAD5,
  299.     BAD6,
  300.     BAD7,
  301.     BAC0,
  302.     BAC1,
  303.     BAC2,
  304.     BAC3,
  305.     BAC4,
  306.     BAC5,
  307.     BAC6,
  308.     BAC7,
  309.     PSR,            /* aka MMUSR on 68030 (but not MMUSR on 68040)
  310.                    and ACUSR on 68ec030 */
  311.     PCSR,
  312.  
  313.     IC,                /* instruction cache token */
  314.     DC,                /* data cache token */
  315.     NC,                /* no cache token */
  316.     BC,                /* both caches token */
  317.  
  318.     TT0,            /* 68030 access control unit regs */
  319.     TT1,
  320.   };
  321.  
  322. static const enum _register m68000_control_regs[] = { 0 };
  323. static const enum _register m68010_control_regs[] = {
  324.   SFC, DFC, USP, VBR,
  325.   0
  326. };
  327. static const enum _register m68020_control_regs[] = {
  328.   SFC, DFC, USP, VBR, CACR, CAAR, MSP, ISP,
  329.   0
  330. };
  331. static const enum _register m68040_control_regs[] = {
  332.   SFC, DFC, CACR, TC, ITT0, ITT1, DTT0, DTT1,
  333.   USP, VBR, MSP, ISP, MMUSR, URP, SRP,
  334.   0
  335. };
  336. static const enum _register m68060_control_regs[] = {
  337.   SFC, DFC, CACR, TC, ITT0, ITT1, DTT0, DTT1, BUSCR,
  338.   USP, VBR, URP, SRP, PCR,
  339.   0
  340. };
  341.  
  342. static const enum _register *control_regs;
  343.  
  344. /* Internal form of an operand.  */
  345. struct m68k_op
  346.   {
  347.     char *error;        /* Couldn't parse it */
  348.     enum operand_type mode;    /* What mode this instruction is in.  */
  349.     enum _register reg;        /* Base register */
  350.     struct m68k_exp *con1;
  351.     int ireg;            /* Index register */
  352.     int isiz;            /* 0==unspec  1==byte(?)  2==short  3==long  */
  353.     int imul;            /* Multipy ireg by this (1,2,4,or 8) */
  354.     struct m68k_exp *con2;
  355.   };
  356.  
  357. /* internal form of a 68020 instruction */
  358. struct m68k_it
  359.   {
  360.     char *error;
  361.     char *args;            /* list of opcode info */
  362.     int numargs;
  363.  
  364.     int numo;            /* Number of shorts in opcode */
  365.     short opcode[11];
  366.  
  367.     struct m68k_op operands[6];
  368.  
  369.     int nexp;            /* number of exprs in use */
  370.     struct m68k_exp exprs[4];
  371.  
  372.     int nfrag;            /* Number of frags we have to produce */
  373.     struct
  374.       {
  375.     int fragoff;        /* Where in the current opcode[] the frag ends */
  376.     symbolS *fadd;
  377.     long foff;
  378.     int fragty;
  379.       }
  380.     fragb[4];
  381.  
  382.     int nrel;            /* Num of reloc strucs in use */
  383.     struct
  384.       {
  385.     int n;
  386.     expressionS exp;
  387.     char wid;
  388.     char pcrel;
  389.       }
  390.     reloc[5];            /* Five is enough??? */
  391.   };
  392.  
  393. #define cpu_of_arch(x)        ((x) & m68000up)
  394. #define float_of_arch(x)    ((x) & mfloat)
  395. #define mmu_of_arch(x)        ((x) & mmmu)
  396.  
  397. static struct m68k_it the_ins;    /* the instruction being assembled */
  398.  
  399. #define seg(exp)    ((exp)->e_seg)
  400. #define op(exp)        ((exp)->e_exp.X_op)
  401. #define adds(exp)    ((exp)->e_exp.X_add_symbol)
  402. #define subs(exp)    ((exp)->e_exp.X_op_symbol)
  403. #define offs(exp)    ((exp)->e_exp.X_add_number)
  404.  
  405. /* Macros for adding things to the m68k_it struct */
  406.  
  407. #define addword(w)    the_ins.opcode[the_ins.numo++]=(w)
  408.  
  409. /* Like addword, but goes BEFORE general operands */
  410. static void
  411. insop (w, opcode)
  412.      int w;
  413.      struct m68k_incant *opcode;
  414. {
  415.   int z;
  416.   for(z=the_ins.numo;z>opcode->m_codenum;--z)
  417.     the_ins.opcode[z]=the_ins.opcode[z-1];
  418.   for(z=0;z<the_ins.nrel;z++)
  419.     the_ins.reloc[z].n+=2;
  420.   the_ins.opcode[opcode->m_codenum]=w;
  421.   the_ins.numo++;
  422. }
  423.  
  424. static struct m68k_exp *
  425. add_exp (beg, end)
  426.      char *beg;
  427.      char *end;
  428. {
  429.   the_ins.exprs[the_ins.nexp].e_beg=beg;
  430.   the_ins.exprs[the_ins.nexp].e_end=end;
  431.   return &the_ins.exprs[the_ins.nexp++];
  432. }
  433.  
  434.  
  435. /* The numo+1 kludge is so we can hit the low order byte of the prev word.
  436.    Blecch.  */
  437. static void
  438. add_fix (width, exp, pc_rel)
  439.      char width;
  440.      struct m68k_exp *exp;
  441.      int pc_rel;
  442. {
  443.   the_ins.reloc[the_ins.nrel].n = (((width)=='B')
  444.                    ? (the_ins.numo*2-1)
  445.                    : (((width)=='b')
  446.                       ? ((the_ins.numo-1)*2)
  447.                       : (the_ins.numo*2)));
  448.   the_ins.reloc[the_ins.nrel].exp = exp->e_exp;
  449.   the_ins.reloc[the_ins.nrel].wid = width;
  450.   the_ins.reloc[the_ins.nrel++].pcrel = pc_rel;
  451. }
  452.  
  453. static void
  454. add_frag(add,off,type)
  455.      symbolS *add;
  456.      long off;
  457.      int type;
  458. {
  459.   the_ins.fragb[the_ins.nfrag].fragoff=the_ins.numo;
  460.   the_ins.fragb[the_ins.nfrag].fadd=add;
  461.   the_ins.fragb[the_ins.nfrag].foff=off;
  462.   the_ins.fragb[the_ins.nfrag++].fragty=type;
  463. }
  464.  
  465. #define isvar(exp) \
  466.   ((exp) && op (exp) != O_constant && op (exp) != O_big)
  467.  
  468. static char *crack_operand PARAMS ((char *str, struct m68k_op *opP));
  469. static int get_num PARAMS ((struct m68k_exp *exp, int ok));
  470. static int get_regs PARAMS ((int i, char *str, struct m68k_op *opP));
  471. static int reverse_16_bits PARAMS ((int in));
  472. static int reverse_8_bits PARAMS ((int in));
  473. static int try_index PARAMS ((char **s, struct m68k_op *opP));
  474. static void install_gen_operand PARAMS ((int mode, int val));
  475. static void install_operand PARAMS ((int mode, int val));
  476. static void s_bss PARAMS ((int));
  477. static void s_data1 PARAMS ((int));
  478. static void s_data2 PARAMS ((int));
  479. static void s_even PARAMS ((int));
  480. static void s_proc PARAMS ((int));
  481.  
  482. static int current_architecture;
  483.  
  484. /* BCC68000 is for patching in an extra jmp instruction for long offsets
  485.    on the 68000.  The 68000 doesn't support long branches with branchs */
  486.  
  487. /* This table desribes how you change sizes for the various types of variable
  488.    size expressions.  This version only supports two kinds. */
  489.  
  490. /* Note that calls to frag_var need to specify the maximum expansion
  491.    needed; this is currently 10 bytes for DBCC.  */
  492.  
  493. /* The fields are:
  494.    How far Forward this mode will reach:
  495.    How far Backward this mode will reach:
  496.    How many bytes this mode will add to the size of the frag
  497.    Which mode to go to if the offset won't fit in this one
  498.    */
  499. CONST relax_typeS md_relax_table[] =
  500. {
  501.   {1, 1, 0, 0},            /* First entries aren't used */
  502.   {1, 1, 0, 0},            /* For no good reason except */
  503.   {1, 1, 0, 0},            /* that the VAX doesn't either */
  504.   {1, 1, 0, 0},
  505.  
  506.   {(127), (-128), 0, TAB (ABRANCH, SHORT)},
  507.   {(32767), (-32768), 2, TAB (ABRANCH, LONG)},
  508.   {0, 0, 4, 0},
  509.   {1, 1, 0, 0},
  510.  
  511.   {1, 1, 0, 0},            /* FBRANCH doesn't come BYTE */
  512.   {(32767), (-32768), 2, TAB (FBRANCH, LONG)},
  513.   {0, 0, 4, 0},
  514.   {1, 1, 0, 0},
  515.  
  516.   {1, 1, 0, 0},            /* PCREL doesn't come BYTE */
  517.   {(32767), (-32768), 2, TAB (PCREL, LONG)},
  518.   {0, 0, 4, 0},
  519.   {1, 1, 0, 0},
  520.  
  521.   {(127), (-128), 0, TAB (BCC68000, SHORT)},
  522.   {(32767), (-32768), 2, TAB (BCC68000, LONG)},
  523.   {0, 0, 6, 0},            /* jmp long space */
  524.   {1, 1, 0, 0},
  525.  
  526.   {1, 1, 0, 0},            /* DBCC doesn't come BYTE */
  527.   {(32767), (-32768), 2, TAB (DBCC, LONG)},
  528.   {0, 0, 10, 0},        /* bra/jmp long space */
  529.   {1, 1, 0, 0},
  530.  
  531.   {1, 1, 0, 0},            /* PCLEA doesn't come BYTE */
  532.   {32767, -32768, 2, TAB (PCLEA, LONG)},
  533.   {0, 0, 6, 0},
  534.   {1, 1, 0, 0},
  535.  
  536. };
  537.  
  538. /* These are the machine dependent pseudo-ops.  These are included so
  539.    the assembler can work on the output from the SUN C compiler, which
  540.    generates these.
  541.    */
  542.  
  543. /* This table describes all the machine specific pseudo-ops the assembler
  544.    has to support.  The fields are:
  545.    pseudo-op name without dot
  546.    function to call to execute this pseudo-op
  547.    Integer arg to pass to the function
  548.    */
  549. CONST pseudo_typeS md_pseudo_table[] =
  550. {
  551.   {"data1", s_data1, 0},
  552.   {"data2", s_data2, 0},
  553.   {"bss", s_bss, 0},
  554.   {"even", s_even, 0},
  555.   {"skip", s_space, 0},
  556.   {"proc", s_proc, 0},
  557. #ifndef amigados
  558. #ifdef TE_SUN3
  559.   {"align", s_align_bytes, 0},
  560. #endif
  561. #endif
  562.   {0, 0, 0}
  563. };
  564.  
  565.  
  566. /* The mote pseudo ops are put into the opcode table, since they
  567.    don't start with a . they look like opcodes to gas.
  568.    */
  569. extern void obj_coff_section ();
  570.  
  571. CONST pseudo_typeS mote_pseudo_table[] =
  572. {
  573.  
  574.   {"dc.l", cons, 4},
  575.   {"dc", cons, 2},
  576.   {"dc.w", cons, 2},
  577.   {"dc.b", cons, 1},
  578.  
  579.   {"ds.l", s_space, 4},
  580.   {"ds", s_space, 2},
  581.   {"ds.w", s_space, 2},
  582.   {"ds.b", s_space, 1},
  583.  
  584.   {"xdef", s_globl, 0},
  585.   {"align", s_align_ptwo, 0},
  586. #ifdef M68KCOFF
  587.   {"sect", obj_coff_section, 0},
  588.   {"section", obj_coff_section, 0},
  589. #endif
  590.   {0, 0, 0}
  591. };
  592.  
  593. #define issbyte(x)    ((x)>=-128 && (x)<=127)
  594. #define isubyte(x)    ((x)>=0 && (x)<=255)
  595. #define issword(x)    ((x)>=-32768 && (x)<=32767)
  596. #define isuword(x)    ((x)>=0 && (x)<=65535)
  597.  
  598. #define isbyte(x)    ((x)>= -255 && (x)<=255)
  599. #define isword(x)    ((x)>=-32768 && (x)<=65535)
  600. #define islong(x)    (1)
  601.  
  602. extern char *input_line_pointer;
  603.  
  604. enum
  605.   {
  606.     FAIL = 0,
  607.     OK = 1,
  608.   };
  609.  
  610. /* JF these tables here are for speed at the expense of size */
  611. /* You can replace them with the #if 0 versions if you really
  612.    need space and don't mind it running a bit slower */
  613.  
  614. static char mklower_table[256];
  615. #define mklower(c) (mklower_table[(unsigned char)(c)])
  616. static char notend_table[256];
  617. static char alt_notend_table[256];
  618. #define notend(s) ( !(notend_table[(unsigned char)(*s)] || (*s==':' &&\
  619.                                 alt_notend_table[(unsigned char)(s[1])])))
  620.  
  621. #if 0
  622. #define mklower(c)    (isupper(c) ? tolower(c) : c)
  623. #endif
  624.  
  625.  
  626. /* JF modified this to handle cases where the first part of a symbol name
  627.    looks like a register */
  628.  
  629. /*
  630.  * m68k_reg_parse() := if it looks like a register, return it's token &
  631.  * advance the pointer.
  632.  */
  633.  
  634. enum _register
  635. m68k_reg_parse (ccp)
  636.      register char **ccp;
  637. {
  638.   char *start = *ccp;
  639.   char c;
  640.   char *p;
  641.   symbolS *symbolP;
  642.  
  643.   if (flag_reg_prefix_optional)
  644.     {
  645.       if (*start == REGISTER_PREFIX)
  646.     start++;
  647.       p = start;
  648.     }
  649.   else
  650.     {
  651.       if (*start != REGISTER_PREFIX)
  652.     return FAIL;
  653.       p = start + 1;
  654.     }
  655.  
  656.   if (!isalpha (*p) || !is_name_beginner (*p))
  657.     return FAIL;
  658.  
  659.   c = *p++;
  660.   while (isalpha (c) || isdigit (c) || c == '_')
  661.     {
  662.       c = *p++;
  663.     }
  664.  
  665.   *--p = 0;
  666.   symbolP = symbol_find (start);
  667.   *p = c;
  668.  
  669.   if (symbolP && S_GET_SEGMENT (symbolP) == reg_section)
  670.     {
  671.       *ccp = p;
  672.       return S_GET_VALUE (symbolP);
  673.     }
  674.  
  675.   return FAIL;
  676. }
  677.  
  678. #define SKIP_WHITE()    { str++; if(*str==' ') str++;}
  679. #define SKIP_W()    { ss++; if(*ss==' ') ss++;}
  680.  
  681. /* Parse an index specification using Motorola syntax.  */
  682.  
  683. static int
  684. try_moto_index (s, opP)
  685.      char **s;
  686.      struct m68k_op *opP;
  687. {
  688.   register int i;
  689.   char *ss;
  690.  
  691.   ss = *s;
  692.   /* SKIP_W(); */
  693.   if (*ss == ' ')
  694.     ss++;
  695.   i = m68k_reg_parse (&ss);
  696.   if (!(i >= DATA + 0 && i <= ADDR + 7))
  697.     {                /* if i is not DATA or ADDR reg */
  698.       opP->error = "Invalid index register";
  699.       *s = ss;
  700.       return FAIL;
  701.     }
  702.   opP->ireg = i;
  703.   /* SKIP_W(); */
  704.   if (*ss == ')')
  705.     {
  706.       opP->isiz = 0;
  707.       opP->imul = 1;
  708.       SKIP_W ();
  709.       *s = ss;
  710.       return OK;
  711.     }
  712.   if (*ss != '.')
  713.     {
  714.       opP->error = "Missing . in index register";
  715.       *s = ss;
  716.       return FAIL;
  717.     }
  718.   SKIP_W ();
  719.   if (mklower (*ss) == 'w')
  720.     opP->isiz = 2;
  721.   else if (mklower (*ss) == 'l')
  722.     opP->isiz = 3;
  723.   else
  724.     {
  725.       opP->error = "Size spec not .W or .L";
  726.       *s = ss;
  727.       return FAIL;
  728.     }
  729.   SKIP_W ();
  730.   if (*ss == '.' || *ss == '*')
  731.     {
  732.       SKIP_W ();
  733.       switch (*ss)
  734.     {
  735.     case '1':
  736.     case '2':
  737.     case '4':
  738.     case '8':
  739.       opP->imul = *ss - '0';
  740.       break;
  741.     default:
  742.       opP->error = "index multiplier not 1, 2, 4 or 8";
  743.       *s = ss;
  744.       return FAIL;
  745.     }
  746.       SKIP_W ();
  747.     }
  748.   else
  749.     opP->imul = 1;
  750.   if (*ss != ')')
  751.     {
  752.       opP->error = "Missing )";
  753.       *s = ss;
  754.       return FAIL;
  755.     }
  756.   SKIP_W ();
  757.   *s = ss;
  758.   return OK;
  759. }
  760.  
  761. /*
  762.  *
  763.  * try_index := data_or_address_register + ')' + SKIP_W
  764.  *    | data_or_address_register + ':' + SKIP_W + size_spec + SKIP_W + multiplier + ')' + SKIP_W
  765.  *
  766.  * multiplier := <empty>
  767.  *    | ':' + multiplier_number
  768.  *    ;
  769.  *
  770.  * multiplier_number := '1' | '2' | '4' | '8' ;
  771.  *
  772.  * size_spec := 'l' | 'L' | 'w' | 'W' ;
  773.  *
  774.  * SKIP_W := <empty> | ' ' ;
  775.  *
  776.  */
  777.  
  778. static int
  779. try_index (s, opP)
  780.      char **s;
  781.      struct m68k_op *opP;
  782. {
  783.   register int i;
  784.   char *ss;
  785.  
  786.   ss = *s;
  787.   /* SKIP_W(); */
  788.   i = m68k_reg_parse (&ss);
  789.   if (!(i >= DATA + 0 && i <= ADDR + 7))
  790.     {                /* if i is not DATA or ADDR reg */
  791.       *s = ss;
  792.       return FAIL;
  793.     }
  794.   opP->ireg = i;
  795.   /* SKIP_W(); */
  796.   if (*ss == ')')
  797.     {
  798.       opP->isiz = 0;
  799.       opP->imul = 1;
  800.       SKIP_W ();
  801.       *s = ss;
  802.       return OK;
  803.     }
  804.   if (*ss != ':')
  805.     {
  806.       opP->error = "Missing : in index register";
  807.       *s = ss;
  808.       return FAIL;
  809.     }
  810.   SKIP_W ();
  811.   switch (*ss)
  812.     {
  813.     case 'w':
  814.     case 'W':
  815.       opP->isiz = 2;
  816.       break;
  817.     case 'l':
  818.     case 'L':
  819.       opP->isiz = 3;
  820.       break;
  821.     default:
  822.       opP->error = "Index register size spec not :w or :l";
  823.       *s = ss;
  824.       return FAIL;
  825.     }
  826.   SKIP_W ();
  827.   if (*ss == ':')
  828.     {
  829.       SKIP_W ();
  830.       switch (*ss)
  831.     {
  832.     case '1':
  833.     case '2':
  834.     case '4':
  835.     case '8':
  836.       if (cpu_of_arch (current_architecture) < m68020)
  837.         {
  838.           opP->error = "no index scaling in pre-68020's";
  839.           *s = ss;
  840.           return FAIL;
  841.         }
  842.       opP->imul = *ss - '0';
  843.       break;
  844.     default:
  845.       opP->error = "index multiplier not 1, 2, 4 or 8";
  846.       *s = ss;
  847.       return FAIL;
  848.     }
  849.       SKIP_W ();
  850.     }
  851.   else
  852.     opP->imul = 1;
  853.   if (*ss != ')')
  854.     {
  855.       opP->error = "Missing )";
  856.       *s = ss;
  857.       return FAIL;
  858.     }
  859.   SKIP_W ();
  860.   *s = ss;
  861.   return OK;
  862. }                /* try_index() */
  863.  
  864. /* Ian Taylor expanded this function to accept both MIT and Motorola
  865.    syntax.  I removed the old comment, since it was wrong.  The syntax
  866.    this accepted even before my changes was complex and undocumented.
  867.    I mainly added a large case when the operand string does not
  868.    contain an '@', since the Motorola syntax does not use the '@'
  869.    character.  */
  870.  
  871. int
  872. m68k_ip_op (str, opP)
  873.      char *str;
  874.      register struct m68k_op *opP;
  875. {
  876.   char *strend;
  877.   long i;
  878.   char *parse_index ();
  879.   int needp;
  880.  
  881.   if (*str == ' ')
  882.     {
  883.       str++;
  884.     }                /* Find the beginning of the string */
  885.  
  886.   if (!*str)
  887.     {
  888.       opP->error = "Missing operand";
  889.       return FAIL;
  890.     }                /* Out of gas */
  891.  
  892.   for (strend = str; *strend; strend++)
  893.     ;
  894.   --strend;
  895.  
  896.   if (*str == '#' || *str == '&')
  897.     {
  898.       str++;
  899.       opP->con1 = add_exp (str, strend);
  900.       opP->mode = IMMED;
  901.       return OK;
  902.     }                /* Guess what:  A constant.  Shar and enjoy */
  903.  
  904.   i = m68k_reg_parse (&str);
  905.  
  906.   if (i != FAIL)
  907.     {
  908.       if (*str == '/' || *str == '-')
  909.     {
  910.       /* "Rm-Rn/Ro-Rp"  Register list for MOVEM instruction */
  911.       opP->mode = REGLST;
  912.       return get_regs (i, str, opP);
  913.     }
  914.       if (*str == '\0')
  915.     {
  916.       opP->reg = i;
  917.       /* "Rn"  Register Direct mode */
  918.       if (i >= DATA + 0 && i <= DATA + 7)
  919.         opP->mode = DREG;
  920.       else if (i >= ADDR + 0 && i <= ADDR + 7)
  921.         opP->mode = AREG;
  922.       else
  923.         opP->mode = MSCR;
  924.       return OK;
  925.     }
  926.     }
  927.  
  928.   if (*str != '@')
  929.     {
  930.       char *stmp;
  931.  
  932.       if ((stmp = strchr (str, '@')) != 0)
  933.     {
  934.       opP->con1 = add_exp (str, stmp - 1);
  935.       if (stmp == strend)
  936.         {
  937.           opP->mode = AINDX;
  938.           return (OK);
  939.         }
  940.  
  941.       if ((current_architecture & m68020up) == 0)
  942.         {
  943.           return (FAIL);
  944.         }            /* if target is not a '20 or better */
  945.  
  946.       stmp++;
  947.       if (*stmp++ != '(' || *strend-- != ')')
  948.         {
  949.           opP->error = "Malformed operand";
  950.           return (FAIL);
  951.         }
  952.       i = try_index (&stmp, opP);
  953.       opP->con2 = add_exp (stmp, strend);
  954.  
  955.       if (i == FAIL)
  956.         {
  957.           opP->mode = AMIND;
  958.         }
  959.       else
  960.         {
  961.           opP->mode = APODX;
  962.         }
  963.       return (OK);
  964.     }            /* if there's an '@' */
  965.  
  966. #ifndef MIT_SYNTAX_ONLY
  967.       /* The operand has no '@'.  Try to parse it using
  968.      Motorola syntax.  */
  969.       /* Logic of the parsing switch(*str):
  970.            case            opP->mode =
  971.            ----            -----------
  972.            #anything        IMMED    1
  973.            REG                AREG or DREG or MSCR    3 or 2 or 13
  974.            REG- or REG/            REGLST    14
  975.            (REG)        AINDR    4
  976.            (REG)+            AINC       6
  977.            (REG,INDX)            AINDX    8
  978.            (EXPR,REG)            AOFF       7
  979.            (EXPR,REG,INDX)      AINDX    8
  980.            -(REG)              ADEC       5
  981.            EXP2(REG)        AOFF       7
  982.            EXP2(REG,INDX)    AINDX    8
  983.            EXP2            ABSL       12
  984.  
  985.            REG  means truth(m68k_reg_parse(&str))
  986.            INDX means truth(try_moto_index(&str,opP))
  987.            EXPR means not REG
  988.            EXP2 means not REG and not '(' and not '-('
  989.            */
  990.  
  991.       if (*str == '(')
  992.     {
  993.       str++;
  994.       i = m68k_reg_parse (&str);
  995.       if ((i < ADDR + 0 || i > ADDR + 7)
  996.           && (i < DATA + 0 || i > DATA + 7
  997.           || *str != ')' || str[1] != '0')
  998.           && i != PC && i != ZPC && i != FAIL)
  999.         {
  1000.           /* Can't indirect off non address regs */
  1001.           opP->error = "Invalid indirect register";
  1002.           return FAIL;
  1003.         }
  1004.       if (i != FAIL)
  1005.         {
  1006.           opP->reg = i;
  1007.           if (*str == ')')
  1008.         {
  1009.           str++;
  1010.           if (*str == '\0')
  1011.             {
  1012.               /* "(An)"  Address Register Indirect mode
  1013.                      or "(Dn)" for cas2.  */
  1014.               if (i >= DATA + 0 && i <= DATA + 7)
  1015.             opP->mode = DINDR;
  1016.               else
  1017.             opP->mode = AINDR;
  1018.               return OK;
  1019.             }
  1020.           if (*str == '+')
  1021.             {
  1022.               if (str[1] == '\0')
  1023.             {
  1024.               /* "(An)+" Register Indirect w Postincrement */
  1025.               opP->mode = AINC;
  1026.               return OK;
  1027.             }
  1028.             }
  1029.           opP->error = "Junk after indirect";
  1030.           return FAIL;
  1031.         }
  1032.           if (*str == ',')
  1033.         {
  1034.           str++;
  1035.           i = try_moto_index (&str, opP);
  1036.           if (i == FAIL)
  1037.             return FAIL;
  1038.           /* "(An,Rn)"  Register Indirect with Index mode*/
  1039.           opP->mode = AINDX;
  1040.           return OK;
  1041.         }
  1042.           else
  1043.         {
  1044.           opP->error = "Bad indirect syntax";
  1045.           return FAIL;
  1046.         }
  1047.         }
  1048.       else
  1049.         {
  1050.           /* "(EXPR,..." , a displacement */
  1051.           char *stmp;
  1052.  
  1053.           if ((stmp = strchr (str, ',')) != NULL)
  1054.         {
  1055.           opP->con1 = add_exp (str, stmp - 1);
  1056.           str = stmp;
  1057.           SKIP_WHITE ();
  1058.           i = m68k_reg_parse (&str);
  1059.           if ((i < ADDR + 0 || i > ADDR + 7) && i != PC && i != ZPC)
  1060.             {
  1061.               /* Can't indirect off non address regs */
  1062.               opP->error = "Invalid indirect register";
  1063.               return FAIL;
  1064.             }
  1065.           if (i != FAIL)
  1066.             {
  1067.               opP->reg = i;
  1068.               if (*str == ')')
  1069.             {
  1070.               /* "(d,An)"  Register Indirect w Displacement */
  1071.               opP->mode = AOFF;
  1072.               return OK;
  1073.             }
  1074.               if (*str == ',')
  1075.             {
  1076.               str++;
  1077.               i = try_moto_index (&str, opP);
  1078.               if (i == FAIL)
  1079.                 return FAIL;
  1080.               /* "(d,An,Rn)"  Register Indirect with Index */
  1081.               opP->mode = AINDX;
  1082.               return OK;
  1083.             }
  1084.               else
  1085.             {
  1086.               opP->error = "Bad indirect syntax";
  1087.               return FAIL;
  1088.             }
  1089.             }
  1090.           else
  1091.             {
  1092.               opP->error = "Invalid register";
  1093.               return FAIL;
  1094.             }
  1095.         }
  1096.           else
  1097.         {
  1098.           opP->mode = ABSL;
  1099.           opP->con1 = add_exp (str - 1, strend);
  1100.           return OK;
  1101.         }
  1102.         }
  1103.     }
  1104.  
  1105.       if (*str == '-')
  1106.     {
  1107.       if (str[1] == '(')
  1108.         {
  1109.           str = str + 2;
  1110.           i = m68k_reg_parse (&str);
  1111.           if ((i < ADDR + 0 || i > ADDR + 7) && i != PC && i != ZPC && i != FAIL)
  1112.         {
  1113.           /* Can't indirect off non address regs */
  1114.           opP->error = "Invalid indirect register";
  1115.           return FAIL;
  1116.         }
  1117.           if (i != FAIL)
  1118.         {
  1119.           opP->reg = i;
  1120.           if (*str == ')')
  1121.             {
  1122.               str++;
  1123.               if (*str == '\0')
  1124.             {
  1125.               /* "-(An)" Register Indirect with Predecrement */
  1126.               opP->mode = ADEC;
  1127.               return OK;
  1128.             }
  1129.               opP->error = "Junk after indirect";
  1130.               return FAIL;
  1131.             }
  1132.           opP->error = "Bad indirect syntax";
  1133.           return FAIL;
  1134.         }
  1135.           opP->mode = ABSL;
  1136.           opP->con1 = add_exp (str - 2, strend);
  1137.           return OK;
  1138.         }
  1139.       /* if '-' but not "-(', do nothing */
  1140.     }
  1141.  
  1142.       /* whether *str=='-' or not */
  1143.       {
  1144.     /* "EXP2" or "EXP2(REG..." */
  1145.     char *stmp;
  1146.     if ((stmp = strchr (str, '(')) != NULL)
  1147.       {
  1148.         char *ostr = str;
  1149.  
  1150.         opP->con1 = add_exp (str, stmp - 1);
  1151.         str = stmp + 1;
  1152.         i = m68k_reg_parse (&str);
  1153.         if ((i < ADDR + 0 || i > ADDR + 7) && i != PC
  1154.         && i != ZPC && i != FAIL)
  1155.           {
  1156.         /* Can't indirect off non address regs */
  1157.         opP->error = "Invalid indirect register";
  1158.         return FAIL;
  1159.           }
  1160.         if (i != FAIL)
  1161.           {
  1162.         opP->reg = i;
  1163.         if (*str == ')')
  1164.           {
  1165.             /* "d(An)"  Register Indirect w Displacement */
  1166.             opP->mode = AOFF;
  1167.             return OK;
  1168.           }
  1169.         if (*str == ',')
  1170.           {
  1171.             str++;
  1172.             i = try_moto_index (&str, opP);
  1173.             if (i == FAIL)
  1174.               return FAIL;
  1175.             /* "d(An,Rn)"  Register Indirect with Index */
  1176.             opP->mode = AINDX;
  1177.             return OK;
  1178.           }
  1179.         else
  1180.           {
  1181.             opP->error = "Bad indirect syntax";
  1182.             return FAIL;
  1183.           }
  1184.           }
  1185.         else
  1186.           {
  1187.         opP->mode = ABSL;
  1188.         opP->con1 = add_exp (ostr, strend);
  1189.         return OK;
  1190.           }
  1191.       }
  1192.     else
  1193.       {
  1194.         /* "EXP2"  Absolute */
  1195.         opP->mode = ABSL;
  1196.         opP->isiz = 0;
  1197.         if (strend[-1] == '.' || strend[-1] == ':')
  1198.           {
  1199.         /* mode ==foo.[wl] */
  1200.         switch (*strend)
  1201.           {
  1202.           case 'w':
  1203.           case 'W':
  1204.             opP->isiz = 2;
  1205.             break;
  1206.           case 'l':
  1207.           case 'L':
  1208.             opP->isiz = 3;
  1209.             break;
  1210.           }
  1211.           }
  1212.         opP->con1 = add_exp (str, strend);
  1213.         return OK;
  1214.       }
  1215.       }
  1216.       /*NOTREACHED*/
  1217. #else /* defined (MIT_SYNTAX_ONLY) */
  1218.       opP->mode = ABSL;
  1219.       opP->con1 = add_exp (str, strend);
  1220.       return OK;
  1221. #endif /* defined (MIT_SYNTAX_ONLY) */
  1222.     }
  1223.  
  1224.   opP->reg = i;
  1225.  
  1226.   /* Can't indirect off non address regs, but Dx@ is OK for cas2 */
  1227.   if ((i < ADDR + 0 || i > ADDR + 7) && i != PC && i != ZPC && i != FAIL
  1228.       && (str[1] != '\0' || i < DATA + 0 || i > DATA + 7))
  1229.     {
  1230.       opP->error = "Invalid indirect register";
  1231.       return FAIL;
  1232.     }
  1233.   know (*str == '@');
  1234.  
  1235.   str++;
  1236.   switch (*str)
  1237.     {
  1238.     case '\0':
  1239.       if (i < DATA + 0 || i > DATA + 7)
  1240.     opP->mode = AINDR;
  1241.       else
  1242.     opP->mode = DINDR;
  1243.       return OK;
  1244.     case '-':
  1245.       opP->mode = ADEC;
  1246.       return OK;
  1247.     case '+':
  1248.       opP->mode = AINC;
  1249.       return OK;
  1250.     case '(':
  1251.       str++;
  1252.       break;
  1253.     default:
  1254.       opP->error = "Junk after indirect";
  1255.       return FAIL;
  1256.     }
  1257.   /* Some kind of indexing involved.  Lets find out how bad it is */
  1258.   i = try_index (&str, opP);
  1259.   /* Didn't start with an index reg, maybe its offset or offset,reg */
  1260.   if (i == FAIL)
  1261.     {
  1262.       char *beg_str;
  1263.  
  1264.       beg_str = str;
  1265.       for (i = 1; i;)
  1266.     {
  1267.       switch (*str++)
  1268.         {
  1269.         case '\0':
  1270.           opP->error = "Missing )";
  1271.           return FAIL;
  1272.         case ',':
  1273.           i = 0;
  1274.           break;
  1275.         case '(':
  1276.           i++;
  1277.           break;
  1278.         case ')':
  1279.           --i;
  1280.           break;
  1281.         }
  1282.     }
  1283. #if 0
  1284.       if (str[-3]==':')
  1285.     {
  1286.       int siz;
  1287.  
  1288.       switch (str[-2])
  1289.         {
  1290.         case 'b':
  1291.         case 'B':
  1292.           siz=1;
  1293.           break;
  1294.         case 'w':
  1295.         case 'W':
  1296.           siz=2;
  1297.           break;
  1298.         case 'l':
  1299.         case 'L':
  1300.           siz=3;
  1301.           break;
  1302.         default:
  1303.           opP->error="Specified size isn't :w or :l";
  1304.           return FAIL;
  1305.         }
  1306.       opP->con1=add_exp(beg_str,str-4);
  1307.       opP->con1->e_siz=siz;
  1308.     }
  1309.       else
  1310. #endif
  1311.     opP->con1 = add_exp (beg_str, str - 2);
  1312.       /* Should be offset,reg */
  1313.       if (str[-1] == ',')
  1314.     {
  1315.       i = try_index (&str, opP);
  1316.       if (i == FAIL)
  1317.         {
  1318.           opP->error = "Malformed index reg";
  1319.           return FAIL;
  1320.         }
  1321.     }
  1322.     }
  1323.   /* We've now got offset)   offset,reg)   or    reg) */
  1324.  
  1325.   if (*str == '\0')
  1326.     {
  1327.       /* Th-the-thats all folks */
  1328.       if (opP->reg == FAIL)
  1329.     opP->mode = AINDX;    /* Other form of indirect */
  1330.       else if (opP->ireg == FAIL)
  1331.     opP->mode = AOFF;
  1332.       else
  1333.     opP->mode = AINDX;
  1334.       return (OK);
  1335.     }
  1336.   /* Next thing had better be another @ */
  1337.   if (*str == '@')
  1338.     {
  1339.       if (str[1] == '(')
  1340.     {
  1341.       needp = 1;
  1342.       str += 2;
  1343.     }
  1344.       else
  1345.     {
  1346.       needp = 0;
  1347.       str++;
  1348.     }
  1349.     }
  1350.  
  1351.   if ((current_architecture & m68020up) == 0)
  1352.     {
  1353.       return (FAIL);
  1354.     }                /* if target is not a '20 or better */
  1355.  
  1356.  
  1357.   if (opP->ireg != FAIL)
  1358.     {
  1359.       opP->mode = APRDX;
  1360.  
  1361.       i = try_index (&str, opP);
  1362.       if (i != FAIL)
  1363.     {
  1364.       opP->error = "Two index registers!  not allowed!";
  1365.       return (FAIL);
  1366.     }
  1367.     }
  1368.   else
  1369.     {
  1370.       i = try_index (&str, opP);
  1371.     }
  1372.  
  1373.   if (i == FAIL)
  1374.     {
  1375.       char *beg_str;
  1376.  
  1377.       beg_str = str;
  1378.  
  1379.       for (i = 1; i;)
  1380.     {
  1381.       switch (*str++)
  1382.         {
  1383.         case '\0':
  1384.           if (needp)
  1385.         opP->error = "Missing )";
  1386.           return (FAIL);
  1387.           break;
  1388.         case ',':
  1389.           i = 0;
  1390.           break;
  1391.         case '(':
  1392.           i++;
  1393.           break;
  1394.         case ')':
  1395.           --i;
  1396.           break;
  1397.         }
  1398.     }
  1399.  
  1400.       opP->con2 = add_exp (beg_str, str - 2);
  1401.  
  1402.       if (str[-1] == ',')
  1403.     {
  1404.       if (opP->ireg != FAIL)
  1405.         {
  1406.           opP->error = "Can't have two index regs";
  1407.           return (FAIL);
  1408.         }
  1409.  
  1410.       i = try_index (&str, opP);
  1411.  
  1412.       if (i == FAIL)
  1413.         {
  1414.           opP->error = "malformed index reg";
  1415.           return (FAIL);
  1416.         }
  1417.  
  1418.       opP->mode = APODX;
  1419.     }
  1420.       else if (opP->ireg != FAIL)
  1421.     {
  1422.       opP->mode = APRDX;
  1423.     }
  1424.       else
  1425.     {
  1426.       opP->mode = AMIND;
  1427.     }
  1428.     }
  1429.   else
  1430.     {
  1431.       opP->mode = APODX;
  1432.     }
  1433.  
  1434.   if (*str != '\0')
  1435.     {
  1436.       opP->error = "Junk after indirect";
  1437.       return FAIL;
  1438.     }
  1439.   return (OK);
  1440. }                /* m68k_ip_op() */
  1441.  
  1442.  
  1443. #if defined (M68KCOFF) && !defined (BFD_ASSEMBLER)
  1444.  
  1445. #ifdef NO_PCREL_RELOCS
  1446.  
  1447. int
  1448. make_pcrel_absolute(fixP, add_number)
  1449.     fixS *fixP;
  1450.     long *add_number;
  1451. {
  1452.   register unsigned char *opcode = fixP->fx_frag->fr_opcode;
  1453.  
  1454.   /* rewrite the PC relative instructions to absolute address ones.
  1455.    * these are rumoured to be faster, and the apollo linker refuses
  1456.    * to deal with the PC relative relocations.
  1457.    */
  1458.   if (opcode[0] == 0x60 && opcode[1] == 0xff) /* BRA -> JMP */
  1459.     {
  1460.       opcode[0] = 0x4e;
  1461.       opcode[1] = 0xf9;
  1462.     }
  1463.   else if (opcode[0] == 0x61 && opcode[1] == 0xff) /* BSR -> JSR */
  1464.     {
  1465.       opcode[0] = 0x4e;
  1466.       opcode[1] = 0xb9;
  1467.     }
  1468.   else
  1469.     as_fatal ("Unknown PC relative instruction");
  1470.   *add_number -= 4;
  1471.   return 0;
  1472. }
  1473.  
  1474. #endif /* NO_PCREL_RELOCS */
  1475.  
  1476. short
  1477. tc_coff_fix2rtype (fixP)
  1478.      fixS *fixP;
  1479. {
  1480. #ifdef NO_PCREL_RELOCS
  1481.   know (fixP->fx_pcrel == 0);
  1482.   return (fixP->fx_size == 1 ? R_RELBYTE
  1483.       : fixP->fx_size == 2 ? R_DIR16
  1484.       : R_DIR32);
  1485. #else
  1486.   return (fixP->fx_pcrel ?
  1487.       (fixP->fx_size == 1 ? R_PCRBYTE :
  1488.        fixP->fx_size == 2 ? R_PCRWORD :
  1489.        R_PCRLONG) :
  1490.       (fixP->fx_size == 1 ? R_RELBYTE :
  1491.        fixP->fx_size == 2 ? R_RELWORD :
  1492.        R_RELLONG));
  1493. #endif
  1494. }
  1495.  
  1496. #endif
  1497.  
  1498. #ifdef BFD_ASSEMBLER
  1499.  
  1500. arelent *
  1501. tc_gen_reloc (section, fixp)
  1502.      asection *section;
  1503.      fixS *fixp;
  1504. {
  1505.   arelent *reloc;
  1506.   bfd_reloc_code_real_type code;
  1507.  
  1508. #define F(SZ,PCREL)        (((SZ) << 1) + (PCREL))
  1509.   switch (F (fixp->fx_size, fixp->fx_pcrel))
  1510.     {
  1511. #define MAP(SZ,PCREL,TYPE)    case F(SZ,PCREL): code = (TYPE); break
  1512.       MAP (1, 0, BFD_RELOC_8);
  1513.       MAP (2, 0, BFD_RELOC_16);
  1514.       MAP (4, 0, BFD_RELOC_32);
  1515.       MAP (1, 1, BFD_RELOC_8_PCREL);
  1516.       MAP (2, 1, BFD_RELOC_16_PCREL);
  1517.       MAP (4, 1, BFD_RELOC_32_PCREL);
  1518.     default:
  1519.       abort ();
  1520.     }
  1521.  
  1522.   reloc = (arelent *) bfd_alloc_by_size_t (stdoutput, sizeof (arelent));
  1523.   assert (reloc != 0);
  1524.   reloc->sym_ptr_ptr = &fixp->fx_addsy->bsym;
  1525.   reloc->address = fixp->fx_frag->fr_address + fixp->fx_where;
  1526.   if (fixp->fx_pcrel)
  1527.     reloc->addend = fixp->fx_addnumber;
  1528.   else
  1529.     reloc->addend = 0;
  1530.  
  1531.   reloc->howto = bfd_reloc_type_lookup (stdoutput, code);
  1532.   assert (reloc->howto != 0);
  1533.  
  1534.   return reloc;
  1535. }
  1536.  
  1537. #endif /* BFD_ASSEMBLER */
  1538.  
  1539. #ifdef TEST1            /* TEST1 tests m68k_ip_op(), which parses operands */
  1540. main ()
  1541. {
  1542.   char buf[128];
  1543.   struct m68k_op thark;
  1544.  
  1545.   for (;;)
  1546.     {
  1547.       if (!gets (buf))
  1548.     break;
  1549.       memset (&thark, '\0', sizeof (thark));
  1550.       if (!m68k_ip_op (buf, &thark))
  1551.     printf ("FAIL:");
  1552.       if (thark.error)
  1553.     printf ("op1 error %s in %s\n", thark.error, buf);
  1554.       printf ("mode %d, reg %d, ", thark.mode, thark.reg);
  1555.       if (thark.b_const)
  1556.     printf ("Constant: '%.*s',", 1 + thark.e_const - thark.b_const, thark.b_const);
  1557.       printf ("ireg %d, isiz %d, imul %d ", thark.ireg, thark.isiz, thark.imul);
  1558.       if (thark.b_iadd)
  1559.     printf ("Iadd: '%.*s'", 1 + thark.e_iadd - thark.b_iadd, thark.b_iadd);
  1560.       printf ("\n");
  1561.     }
  1562.   exit (EXIT_SUCCESS);
  1563. }
  1564.  
  1565. #endif
  1566.  
  1567.  
  1568. /* Handle of the OPCODE hash table.  NULL means any use before
  1569.    m68k_ip_begin() will crash.  */
  1570. static struct hash_control *op_hash;
  1571.  
  1572.  
  1573. /*
  1574.  *        m 6 8 k _ i p ( )
  1575.  *
  1576.  * This converts a string into a 68k instruction.
  1577.  * The string must be a bare single instruction in sun format
  1578.  * with RMS-style 68020 indirects
  1579.  *  (example:  )
  1580.  *
  1581.  * It provides some error messages: at most one fatal error message (which
  1582.  * stops the scan) and at most one warning message for each operand.
  1583.  * The 68k instruction is returned in exploded form, since we have no
  1584.  * knowledge of how you parse (or evaluate) your expressions.
  1585.  * We do however strip off and decode addressing modes and operation
  1586.  * mnemonic.
  1587.  *
  1588.  * This function's value is a string. If it is not "" then an internal
  1589.  * logic error was found: read this code to assign meaning to the string.
  1590.  * No argument string should generate such an error string:
  1591.  * it means a bug in our code, not in the user's text.
  1592.  *
  1593.  * You MUST have called m68k_ip_begin() once and m86_ip_end() never before using
  1594.  * this function.
  1595.  */
  1596.  
  1597. /* JF this function no longer returns a useful value.  Sorry */
  1598. void
  1599. m68k_ip (instring)
  1600.      char *instring;
  1601. {
  1602.   register char *p;
  1603.   register struct m68k_op *opP;
  1604.   register struct m68k_incant *opcode;
  1605.   register char *s;
  1606.   register int tmpreg = 0, baseo = 0, outro = 0, nextword;
  1607.   char *pdot, *pdotmove;
  1608.   int siz1, siz2;
  1609.   char c;
  1610.   int losing;
  1611.   int opsfound;
  1612.   char *crack_operand ();
  1613.   LITTLENUM_TYPE words[6];
  1614.   LITTLENUM_TYPE *wordp;
  1615.   unsigned long ok_arch = 0;
  1616.  
  1617.   if (*instring == ' ')
  1618.     instring++;            /* skip leading whitespace */
  1619.  
  1620.   /* Scan up to end of operation-code, which MUST end in end-of-string
  1621.      or exactly 1 space. */
  1622.   pdot = 0;
  1623.   for (p = instring; *p != '\0'; p++)
  1624.     {
  1625.       if (*p == ' ')
  1626.     break;
  1627.       if (*p == '.')
  1628.     pdot = p;
  1629.     }
  1630.  
  1631.   if (p == instring)
  1632.     {
  1633.       the_ins.error = "No operator";
  1634.       the_ins.opcode[0] = 0;
  1635.       /* the_ins.numo=1; */
  1636.       return;
  1637.     }
  1638.  
  1639.   /* p now points to the end of the opcode name, probably whitespace.
  1640.      make sure the name is null terminated by clobbering the whitespace,
  1641.      look it up in the hash table, then fix it back.
  1642.      Remove a dot, first, since the opcode tables have none.  */
  1643.   if (pdot != NULL)
  1644.     {
  1645.       for (pdotmove = pdot; pdotmove < p; pdotmove++)
  1646.     *pdotmove = pdotmove[1];
  1647.       p--;
  1648.     }
  1649.  
  1650.   c = *p;
  1651.   *p = '\0';
  1652.   opcode = (struct m68k_incant *) hash_find (op_hash, instring);
  1653.   *p = c;
  1654.  
  1655.   if (pdot != NULL)
  1656.     {
  1657.       for (pdotmove = p; pdotmove > pdot; pdotmove--)
  1658.     *pdotmove = pdotmove[-1];
  1659.       *pdot = '.';
  1660.       ++p;
  1661.     }
  1662.  
  1663.   if (opcode == NULL)
  1664.     {
  1665.       the_ins.error = "Unknown operator";
  1666.       the_ins.opcode[0] = 0;
  1667.       /* the_ins.numo=1; */
  1668.       return;
  1669.     }
  1670.  
  1671.   /* found a legitimate opcode, start matching operands */
  1672.   while (*p == ' ')
  1673.     ++p;
  1674.  
  1675.  
  1676.   if (opcode->m_operands == 0)
  1677.     {
  1678.       char *old = input_line_pointer;
  1679.       *old = '\n';
  1680.       input_line_pointer = p;
  1681.       /* Ahh - it's a motorola style psuedo op */
  1682.       mote_pseudo_table[opcode->m_opnum].poc_handler
  1683.     (mote_pseudo_table[opcode->m_opnum].poc_val);
  1684.       input_line_pointer = old;
  1685.       *old = 0;
  1686.  
  1687.       return;
  1688.     }
  1689.  
  1690.   for (opP = &the_ins.operands[0]; *p; opP++)
  1691.     {
  1692.  
  1693.       p = crack_operand (p, opP);
  1694.  
  1695.       if (opP->error)
  1696.     {
  1697.       the_ins.error = opP->error;
  1698.       return;
  1699.     }
  1700.     }
  1701.  
  1702.   opsfound = opP - &the_ins.operands[0];
  1703.  
  1704.   /* This ugly hack is to support the floating pt opcodes in their standard form */
  1705.   /* Essentially, we fake a first enty of type COP#1 */
  1706.   if (opcode->m_operands[0] == 'I')
  1707.     {
  1708.       int n;
  1709.  
  1710.       for (n = opsfound; n > 0; --n)
  1711.     the_ins.operands[n] = the_ins.operands[n - 1];
  1712.  
  1713.       memset ((char *) (&the_ins.operands[0]), '\0', sizeof (the_ins.operands[0]));
  1714.       the_ins.operands[0].mode = MSCR;
  1715.       the_ins.operands[0].reg = COPNUM;    /* COP #1 */
  1716.       opsfound++;
  1717.     }
  1718.  
  1719.   /* We've got the operands.  Find an opcode that'll accept them */
  1720.   for (losing = 0;;)
  1721.     {
  1722.       /* If we didn't get the right number of ops, or we have no
  1723.      common model with this pattern then reject this pattern. */
  1724.  
  1725.       if (opsfound != opcode->m_opnum
  1726.       || ((opcode->m_arch & current_architecture) == 0))
  1727.     {
  1728.       ++losing;
  1729.       ok_arch |= opcode->m_arch;
  1730.     }
  1731.       else
  1732.     {
  1733.       for (s = opcode->m_operands, opP = &the_ins.operands[0]; *s && !losing; s += 2, opP++)
  1734.         {
  1735.           /* Warning: this switch is huge! */
  1736.           /* I've tried to organize the cases into this order:
  1737.          non-alpha first, then alpha by letter.  Lower-case
  1738.          goes directly before uppercase counterpart.  */
  1739.           /* Code with multiple case ...: gets sorted by the lowest
  1740.          case ... it belongs to.  I hope this makes sense.  */
  1741.           switch (*s)
  1742.         {
  1743.         case '!':
  1744.           if (opP->mode == MSCR || opP->mode == IMMED
  1745.               || opP->mode == DREG || opP->mode == AREG
  1746.               || opP->mode == AINC || opP->mode == ADEC
  1747.               || opP->mode == REGLST)
  1748.             losing++;
  1749.           break;
  1750.  
  1751.         case '`':
  1752.           switch (opP->mode)
  1753.             {
  1754.             case MSCR:
  1755.             case IMMED:
  1756.             case DREG:
  1757.             case AREG:
  1758.             case AINC:
  1759.             case REGLST:
  1760.             case AINDR:
  1761.               losing++;
  1762.               break;
  1763.             default:
  1764.               break;
  1765.             }
  1766.           break;
  1767.  
  1768.         case '#':
  1769.           if (opP->mode != IMMED)
  1770.             losing++;
  1771.           else
  1772.             {
  1773.               long t;
  1774.  
  1775.               t = get_num (opP->con1, 80);
  1776.               if (s[1] == 'b' && !isbyte (t))
  1777.             losing++;
  1778.               else if (s[1] == 'w' && !isword (t))
  1779.             losing++;
  1780.             }
  1781.           break;
  1782.  
  1783.         case '^':
  1784.         case 'T':
  1785.           if (opP->mode != IMMED)
  1786.             losing++;
  1787.           break;
  1788.  
  1789.         case '$':
  1790.           if (opP->mode == MSCR || opP->mode == AREG ||
  1791.               opP->mode == IMMED || opP->reg == PC || opP->reg == ZPC || opP->mode == REGLST)
  1792.             losing++;
  1793.           break;
  1794.  
  1795.         case '%':
  1796.           if (opP->mode == MSCR || opP->reg == PC ||
  1797.               opP->reg == ZPC || opP->mode == REGLST)
  1798.             losing++;
  1799.           break;
  1800.  
  1801.  
  1802.         case '&':
  1803.           if (opP->mode == MSCR || opP->mode == DREG ||
  1804.               opP->mode == AREG || opP->mode == IMMED || opP->reg == PC || opP->reg == ZPC ||
  1805.               opP->mode == AINC || opP->mode == ADEC || opP->mode == REGLST)
  1806.             losing++;
  1807.           break;
  1808.  
  1809.         case '*':
  1810.           if (opP->mode == MSCR || opP->mode == REGLST)
  1811.             losing++;
  1812.           break;
  1813.  
  1814.         case '+':
  1815.           if (opP->mode != AINC)
  1816.             losing++;
  1817.           break;
  1818.  
  1819.         case '-':
  1820.           if (opP->mode != ADEC)
  1821.             losing++;
  1822.           break;
  1823.  
  1824.         case '/':
  1825.           if (opP->mode == MSCR || opP->mode == AREG ||
  1826.               opP->mode == AINC || opP->mode == ADEC || opP->mode == IMMED || opP->mode == REGLST)
  1827.             losing++;
  1828.           break;
  1829.  
  1830.         case ';':
  1831.           if (opP->mode == MSCR || opP->mode == AREG || opP->mode == REGLST)
  1832.             losing++;
  1833.           break;
  1834.  
  1835.         case '?':
  1836.           if (opP->mode == MSCR || opP->mode == AREG ||
  1837.               opP->mode == AINC || opP->mode == ADEC || opP->mode == IMMED || opP->reg == PC ||
  1838.               opP->reg == ZPC || opP->mode == REGLST)
  1839.             losing++;
  1840.           break;
  1841.  
  1842.         case '@':
  1843.           if (opP->mode == MSCR || opP->mode == AREG ||
  1844.               opP->mode == IMMED || opP->mode == REGLST)
  1845.             losing++;
  1846.           break;
  1847.  
  1848.         case '~':    /* For now! (JF FOO is this right?) */
  1849.           if (opP->mode == MSCR || opP->mode == DREG ||
  1850.               opP->mode == AREG || opP->mode == IMMED || opP->reg == PC || opP->reg == ZPC || opP->mode == REGLST)
  1851.             losing++;
  1852.           break;
  1853.  
  1854.         case '3':
  1855.           if (opP->mode != MSCR || (opP->reg != TT0 && opP->reg != TT1))
  1856.             losing++;
  1857.           break;
  1858.  
  1859.         case 'A':
  1860.           if (opP->mode != AREG)
  1861.             losing++;
  1862.           break;
  1863.         case 'a':
  1864.           if (opP->mode != AINDR)
  1865.             {
  1866.               ++losing;
  1867.             }        /* if not address register indirect */
  1868.           break;
  1869.         case 'B':    /* FOO */
  1870.           if (opP->mode != ABSL || (flag_long_jumps && instring[0] == 'j'
  1871.                         && instring[1] == 'b'
  1872.                         && instring[2] == 's'
  1873.                         && instring[3] == 'r'))
  1874.             losing++;
  1875.           break;
  1876.  
  1877.         case 'C':
  1878.           if (opP->mode != MSCR || opP->reg != CCR)
  1879.             losing++;
  1880.           break;
  1881.  
  1882.         case 'd':    /* FOO This mode is a KLUDGE!! */
  1883.           if (opP->mode != AOFF && (opP->mode != ABSL ||
  1884.           opP->con1->e_beg[0] != '(' || opP->con1->e_end[0] != ')'))
  1885.             losing++;
  1886.           break;
  1887.  
  1888.         case 'D':
  1889.           if (opP->mode != DREG)
  1890.             losing++;
  1891.           break;
  1892.  
  1893.         case 'F':
  1894.           if (opP->mode != MSCR || opP->reg < (FPREG + 0) || opP->reg > (FPREG + 7))
  1895.             losing++;
  1896.           break;
  1897.  
  1898.         case 'I':
  1899.           if (opP->mode != MSCR || opP->reg < COPNUM ||
  1900.               opP->reg >= COPNUM + 7)
  1901.             losing++;
  1902.           break;
  1903.  
  1904.         case 'J':
  1905.           if (opP->mode != MSCR
  1906.               || opP->reg < USP
  1907.               || opP->reg > last_movec_reg)
  1908.             losing++;
  1909.           else
  1910.             {
  1911.               const enum _register *rp;
  1912.               for (rp = control_regs; *rp; rp++)
  1913.             if (*rp == opP->reg)
  1914.               break;
  1915.               if (*rp == 0)
  1916.             losing++;
  1917.             }
  1918.           break;
  1919.  
  1920.         case 'k':
  1921.           if (opP->mode != IMMED)
  1922.             losing++;
  1923.           break;
  1924.  
  1925.         case 'l':
  1926.         case 'L':
  1927.           if (opP->mode == DREG || opP->mode == AREG || opP->mode == FPREG)
  1928.             {
  1929.               if (s[1] == '8')
  1930.             losing++;
  1931.               else
  1932.             {
  1933.               opP->mode = REGLST;
  1934.               opP->reg = 1 << (opP->reg - DATA);
  1935.             }
  1936.             }
  1937.           else if (opP->mode != REGLST)
  1938.             {
  1939.               losing++;
  1940.             }
  1941.           else if (s[1] == '8' && opP->reg & 0x0FFffFF)
  1942.             losing++;
  1943.           else if (s[1] == '3' && opP->reg & 0x7000000)
  1944.             losing++;
  1945.           break;
  1946.  
  1947.         case 'M':
  1948.           if (opP->mode != IMMED)
  1949.             losing++;
  1950.           else
  1951.             {
  1952.               long t;
  1953.  
  1954.               t = get_num (opP->con1, 0);
  1955.               if (!issbyte (t)
  1956.               || isvar (opP->con1))
  1957.             losing++;
  1958.             }
  1959.           break;
  1960.  
  1961.         case 'O':
  1962.           if (opP->mode != DREG && opP->mode != IMMED)
  1963.             losing++;
  1964.           break;
  1965.  
  1966.         case 'Q':
  1967.           if (opP->mode != IMMED)
  1968.             losing++;
  1969.           else
  1970.             {
  1971.               long t;
  1972.  
  1973.               t = get_num (opP->con1, 80);
  1974.               if (t < 1 || t > 8 || isvar (opP->con1))
  1975.             losing++;
  1976.             }
  1977.           break;
  1978.  
  1979.         case 'R':
  1980.           if (opP->mode != DREG && opP->mode != AREG)
  1981.             losing++;
  1982.           break;
  1983.  
  1984.         case 'r':
  1985.           if (opP->mode != AINDR && opP->mode != DINDR)
  1986.             losing++;
  1987.           break;
  1988.  
  1989.         case 's':
  1990.           if (opP->mode != MSCR || !(opP->reg == FPI || opP->reg == FPS || opP->reg == FPC))
  1991.             losing++;
  1992.           break;
  1993.  
  1994.         case 'S':
  1995.           if (opP->mode != MSCR || opP->reg != SR)
  1996.             losing++;
  1997.           break;
  1998.  
  1999.         case 't':
  2000.           if (opP->mode != IMMED)
  2001.             losing++;
  2002.           else
  2003.             {
  2004.               long t = get_num (opP->con1, 80);
  2005.               if (t < 0 || t > 7 || isvar (opP->con1))
  2006.             losing++;
  2007.             }
  2008.           break;
  2009.  
  2010.         case 'U':
  2011.           if (opP->mode != MSCR || opP->reg != USP)
  2012.             losing++;
  2013.           break;
  2014.  
  2015.           /* JF these are out of order.  We could put them
  2016.              in order if we were willing to put up with
  2017.              bunches of #ifdef m68851s in the code.
  2018.  
  2019.              Don't forget that you need these operands
  2020.              to use 68030 MMU instructions.  */
  2021. #ifndef NO_68851
  2022.           /* Memory addressing mode used by pflushr */
  2023.         case '|':
  2024.           if (opP->mode == MSCR || opP->mode == DREG ||
  2025.               opP->mode == AREG || opP->mode == REGLST)
  2026.             losing++;
  2027.           break;
  2028.  
  2029.         case 'f':
  2030.           if (opP->mode != MSCR || (opP->reg != SFC && opP->reg != DFC))
  2031.             losing++;
  2032.           break;
  2033.  
  2034.         case 'P':
  2035.           if (opP->mode != MSCR
  2036.               || (opP->reg != TC && opP->reg != CAL
  2037.            && opP->reg != VAL && opP->reg != SCC && opP->reg != AC))
  2038.             losing++;
  2039.           break;
  2040.  
  2041.         case 'V':
  2042.           if (opP->reg != VAL)
  2043.             losing++;
  2044.           break;
  2045.  
  2046.         case 'W':
  2047.           if (opP->mode != MSCR
  2048.               || (opP->reg != DRP && opP->reg != SRP
  2049.               && opP->reg != CRP))
  2050.             losing++;
  2051.           break;
  2052.  
  2053.         case 'X':
  2054.           if (opP->mode != MSCR ||
  2055.               (!(opP->reg >= BAD && opP->reg <= BAD + 7) &&
  2056.                !(opP->reg >= BAC && opP->reg <= BAC + 7)))
  2057.             losing++;
  2058.           break;
  2059.  
  2060.         case 'Y':
  2061.           if (opP->reg != PSR)
  2062.             losing++;
  2063.           break;
  2064.  
  2065.         case 'Z':
  2066.           if (opP->reg != PCSR)
  2067.             losing++;
  2068.           break;
  2069. #endif
  2070.         case 'c':
  2071.           if (opP->reg != NC
  2072.               && opP->reg != IC
  2073.               && opP->reg != DC
  2074.               && opP->reg != BC)
  2075.             {
  2076.               losing++;
  2077.             }        /* not a cache specifier. */
  2078.           break;
  2079.  
  2080.         case '_':
  2081.           if (opP->mode != ABSL)
  2082.             {
  2083.               ++losing;
  2084.             }        /* not absolute */
  2085.           break;
  2086.  
  2087.         default:
  2088.           as_fatal ("Internal error:  Operand mode %c unknown in line %d of file \"%s\"",
  2089.                 *s, __LINE__, __FILE__);
  2090.         }        /* switch on type of operand */
  2091.  
  2092.           if (losing)
  2093.         break;
  2094.         }            /* for each operand */
  2095.     }            /* if immediately wrong */
  2096.  
  2097.       if (!losing)
  2098.     {
  2099.       break;
  2100.     }            /* got it. */
  2101.  
  2102.       opcode = opcode->m_next;
  2103.  
  2104.       if (!opcode)
  2105.     {
  2106.       if (ok_arch
  2107.           && !(ok_arch & current_architecture))
  2108.         {
  2109.           char buf[200], *cp;
  2110.           int len;
  2111.           strcpy (buf, "invalid instruction for this architecture; needs ");
  2112.           cp = buf + strlen (buf);
  2113.           switch (ok_arch)
  2114.         {
  2115.         case mfloat:
  2116.           strcpy (cp, "fpu (68040, 68060 or 68881/68882)");
  2117.           break;
  2118.         case mmmu:
  2119.           strcpy (cp, "mmu (68030 or 68851)");
  2120.           break;
  2121.         case m68020up:
  2122.           strcpy (cp, "68020 or higher");
  2123.           break;
  2124.         case m68000up:
  2125.           strcpy (cp, "68000 or higher");
  2126.           break;
  2127.         case m68010up:
  2128.           strcpy (cp, "68010 or higher");
  2129.           break;
  2130.         default:
  2131.           {
  2132.             int got_one = 0, idx;
  2133.             static const struct
  2134.               {
  2135.             int arch;
  2136.             const char *name;
  2137.               }
  2138.             archs[] =
  2139.             {
  2140.               { m68000, "68000" },
  2141.               { m68010, "68010" },
  2142.               { m68020, "68020" },
  2143.               { m68030, "68030" },
  2144.               { m68040, "68040" },
  2145.               { m68060, "68060" },
  2146.               { cpu32,  "cpu32" },
  2147.               { m68881, "68881" },
  2148.               { m68851, "68851" }
  2149.             };
  2150.             for (idx = 0; idx < sizeof (archs) / sizeof (archs[0]); idx++)
  2151.               {
  2152.             if (archs[idx].arch & ok_arch)
  2153.               {
  2154.                 if (got_one)
  2155.                   {
  2156.                 strcpy (cp, " or ");
  2157.                 cp += strlen (cp);
  2158.                   }
  2159.                 got_one = 1;
  2160.                 strcpy (cp, archs[idx].name);
  2161.                 cp += strlen (cp);
  2162.               }
  2163.               }
  2164.           }
  2165.         }
  2166.           len = cp - buf + 1;
  2167.           cp = malloc (len);
  2168.           strcpy (cp, buf);
  2169.           the_ins.error = cp;
  2170.         }
  2171.       else
  2172.         the_ins.error = "operands mismatch";
  2173.       return;
  2174.     }            /* Fell off the end */
  2175.  
  2176.       losing = 0;
  2177.     }
  2178.  
  2179.   /* now assemble it */
  2180.  
  2181.   the_ins.args = opcode->m_operands;
  2182.   the_ins.numargs = opcode->m_opnum;
  2183.   the_ins.numo = opcode->m_codenum;
  2184.   the_ins.opcode[0] = getone (opcode);
  2185.   the_ins.opcode[1] = gettwo (opcode);
  2186.  
  2187.   for (s = the_ins.args, opP = &the_ins.operands[0]; *s; s += 2, opP++)
  2188.     {
  2189.       /* This switch is a doozy.
  2190.        Watch the first step; its a big one! */
  2191.       switch (s[0])
  2192.     {
  2193.  
  2194.     case '*':
  2195.     case '~':
  2196.     case '%':
  2197.     case ';':
  2198.     case '@':
  2199.     case '!':
  2200.     case '&':
  2201.     case '$':
  2202.     case '?':
  2203.     case '/':
  2204.     case '`':
  2205. #ifndef NO_68851
  2206.     case '|':
  2207. #endif
  2208.       switch (opP->mode)
  2209.         {
  2210.         case IMMED:
  2211.           tmpreg = 0x3c;    /* 7.4 */
  2212.           if (strchr ("bwl", s[1]))
  2213.         nextword = get_num (opP->con1, 80);
  2214.           else
  2215.         nextword = get_num (opP->con1, 0);
  2216.           if (isvar (opP->con1))
  2217.         add_fix (s[1], opP->con1, 0);
  2218.           switch (s[1])
  2219.         {
  2220.         case 'b':
  2221.           if (!isbyte (nextword))
  2222.             opP->error = "operand out of range";
  2223.           addword (nextword);
  2224.           baseo = 0;
  2225.           break;
  2226.         case 'w':
  2227.           if (!isword (nextword))
  2228.             opP->error = "operand out of range";
  2229.           addword (nextword);
  2230.           baseo = 0;
  2231.           break;
  2232.         case 'l':
  2233.           addword (nextword >> 16);
  2234.           addword (nextword);
  2235.           baseo = 0;
  2236.           break;
  2237.  
  2238.         case 'f':
  2239.           baseo = 2;
  2240.           outro = 8;
  2241.           break;
  2242.         case 'F':
  2243.           baseo = 4;
  2244.           outro = 11;
  2245.           break;
  2246.         case 'x':
  2247.           baseo = 6;
  2248.           outro = 15;
  2249.           break;
  2250.         case 'p':
  2251.           baseo = 6;
  2252.           outro = -1;
  2253.           break;
  2254.         default:
  2255.           as_fatal ("Internal error:  Can't decode %c%c in line %d of file \"%s\"",
  2256.                 *s, s[1], __LINE__, __FILE__);
  2257.         }
  2258.           if (!baseo)
  2259.         break;
  2260.  
  2261.           /* We gotta put out some float */
  2262.           if (op (opP->con1) != O_big)
  2263.         {
  2264.           valueT val;
  2265.           int gencnt;
  2266.  
  2267.           /* Can other cases happen here?  */
  2268.           if (op (opP->con1) != O_constant)
  2269.             abort ();
  2270.  
  2271.           val = (valueT) offs (opP->con1);
  2272.           gencnt = 0;
  2273.           do
  2274.             {
  2275.               generic_bignum[gencnt] = (LITTLENUM_TYPE) val;
  2276.               val >>= LITTLENUM_NUMBER_OF_BITS;
  2277.               ++gencnt;
  2278.             }
  2279.           while (val != 0);
  2280.           offs (opP->con1) = gencnt;
  2281.         }
  2282.           if (offs (opP->con1) > 0)
  2283.         {
  2284.           if (offs (opP->con1) > baseo)
  2285.             {
  2286.               as_warn ("Bignum too big for %c format; truncated", s[1]);
  2287.               offs (opP->con1) = baseo;
  2288.             }
  2289.           baseo -= offs (opP->con1);
  2290.           while (baseo--)
  2291.             addword (0);
  2292.           for (wordp = generic_bignum + offs (opP->con1) - 1; offs (opP->con1)--; --wordp)
  2293.             addword (*wordp);
  2294.           break;
  2295.         }
  2296.           gen_to_words (words, baseo, (long) outro);
  2297.           for (wordp = words; baseo--; wordp++)
  2298.         addword (*wordp);
  2299.           break;
  2300.         case DREG:
  2301.           tmpreg = opP->reg - DATA;    /* 0.dreg */
  2302.           break;
  2303.         case AREG:
  2304.           tmpreg = 0x08 + opP->reg - ADDR;    /* 1.areg */
  2305.           break;
  2306.         case AINDR:
  2307.           tmpreg = 0x10 + opP->reg - ADDR;    /* 2.areg */
  2308.           break;
  2309.         case ADEC:
  2310.           tmpreg = 0x20 + opP->reg - ADDR;    /* 4.areg */
  2311.           break;
  2312.         case AINC:
  2313.           tmpreg = 0x18 + opP->reg - ADDR;    /* 3.areg */
  2314.           break;
  2315.         case AOFF:
  2316.  
  2317.           nextword = get_num (opP->con1, 80);
  2318.           /* Force into index mode.  Hope this works */
  2319.  
  2320.           /* We do the first bit for 32-bit displacements, and the
  2321.          second bit for 16 bit ones.  It is possible that we
  2322.          should make the default be WORD instead of LONG, but
  2323.          I think that'd break GCC, so we put up with a little
  2324.          inefficiency for the sake of working output.  */
  2325.  
  2326.           if (!issword (nextword)
  2327.           || (isvar (opP->con1)
  2328.               && ((opP->con1->e_siz == 0
  2329.                && flag_short_refs == 0)
  2330.               || opP->con1->e_siz == 3)))
  2331.         {
  2332.  
  2333.           if (opP->reg == PC)
  2334.             tmpreg = 0x3B;    /* 7.3 */
  2335.           else
  2336.             tmpreg = 0x30 + opP->reg - ADDR;    /* 6.areg */
  2337.           if (isvar (opP->con1))
  2338.             {
  2339.               if (opP->reg == PC)
  2340.             {
  2341.               addword (0x0170);
  2342.               opP->con1->e_exp.X_add_number += 6;
  2343.               add_fix ('l', opP->con1, 1);
  2344.               addword (0), addword (0);
  2345.               break;
  2346.             }
  2347.               else
  2348.             {
  2349.               addword (0x0170);
  2350.               add_fix ('l', opP->con1, 0);
  2351.             }
  2352.             }
  2353.           else
  2354.             addword (0x0170);
  2355.           addword (nextword >> 16);
  2356.         }
  2357.           else
  2358.         {
  2359.           if (opP->reg == PC)
  2360.             tmpreg = 0x3A;    /* 7.2 */
  2361.           else
  2362.             tmpreg = 0x28 + opP->reg - ADDR;    /* 5.areg */
  2363.  
  2364.           if (isvar (opP->con1))
  2365.             {
  2366.               if (opP->reg == PC)
  2367.             {
  2368.               opP->con1->e_exp.X_add_number += 2;
  2369.               add_fix ('w', opP->con1, 1);
  2370.             }
  2371.               else
  2372.             add_fix ('w', opP->con1, 0);
  2373.             }
  2374.         }
  2375.           addword (nextword);
  2376.           break;
  2377.  
  2378.         case APODX:
  2379.         case AMIND:
  2380.         case APRDX:
  2381.           know (current_architecture & m68020up);
  2382.           /* intentional fall-through */
  2383.         case AINDX:
  2384.           nextword = 0;
  2385.           baseo = get_num (opP->con1, 80);
  2386.           outro = get_num (opP->con2, 80);
  2387.           /* Figure out the `addressing mode'.
  2388.          Also turn on the BASE_DISABLE bit, if needed.  */
  2389.           if (opP->reg == PC || opP->reg == ZPC)
  2390.         {
  2391.           tmpreg = 0x3b;/* 7.3 */
  2392.           if (opP->reg == ZPC)
  2393.             nextword |= 0x80;
  2394.         }
  2395.           else if (opP->reg == FAIL)
  2396.         {
  2397.           nextword |= 0x80;
  2398.           tmpreg = 0x30;/* 6.garbage */
  2399.         }
  2400.           else
  2401.         tmpreg = 0x30 + opP->reg - ADDR;    /* 6.areg */
  2402.  
  2403.           siz1 = (opP->con1) ? opP->con1->e_siz : 0;
  2404.           siz2 = (opP->con2) ? opP->con2->e_siz : 0;
  2405.  
  2406.           /* Index register stuff */
  2407.           if (opP->ireg >= DATA + 0 && opP->ireg <= ADDR + 7)
  2408.         {
  2409.           nextword |= (opP->ireg - DATA) << 12;
  2410.  
  2411.           if (opP->isiz == 0 || opP->isiz == 3)
  2412.             nextword |= 0x800;
  2413.           switch (opP->imul)
  2414.             {
  2415.             case 1:
  2416.               break;
  2417.             case 2:
  2418.               nextword |= 0x200;
  2419.               break;
  2420.             case 4:
  2421.               nextword |= 0x400;
  2422.               break;
  2423.             case 8:
  2424.               nextword |= 0x600;
  2425.               break;
  2426.             default:
  2427.               as_fatal ("failed sanity check.");
  2428.             }
  2429.           /* IF its simple,
  2430.              GET US OUT OF HERE! */
  2431.  
  2432.           /* Must be INDEX, with an index
  2433.              register.  Address register
  2434.              cannot be ZERO-PC, and either
  2435.              :b was forced, or we know
  2436.              it will fit */
  2437.           if (opP->mode == AINDX
  2438.               && opP->reg != FAIL
  2439.               && opP->reg != ZPC
  2440.               && (siz1 == 1
  2441.               || (issbyte (baseo)
  2442.                   && !isvar (opP->con1))))
  2443.             {
  2444.               nextword += baseo & 0xff;
  2445.               addword (nextword);
  2446.               if (isvar (opP->con1))
  2447.             add_fix ('B', opP->con1, 0);
  2448.               break;
  2449.             }
  2450.         }
  2451.           else
  2452.         nextword |= 0x40;    /* No index reg */
  2453.  
  2454.           /* It isn't simple.  */
  2455.           nextword |= 0x100;
  2456.           /* If the guy specified a width, we assume that it is
  2457.          wide enough.  Maybe it isn't.  If so, we lose.  */
  2458.           switch (siz1)
  2459.         {
  2460.         case 0:
  2461.           if (isvar (opP->con1) || !issword (baseo))
  2462.             {
  2463.               siz1 = 3;
  2464.               nextword |= 0x30;
  2465.             }
  2466.           else if (baseo == 0)
  2467.             nextword |= 0x10;
  2468.           else
  2469.             {
  2470.               nextword |= 0x20;
  2471.               siz1 = 2;
  2472.             }
  2473.           break;
  2474.         case 1:
  2475.           as_warn ("Byte dispacement won't work.  Defaulting to :w");
  2476.         case 2:
  2477.           nextword |= 0x20;
  2478.           break;
  2479.         case 3:
  2480.           nextword |= 0x30;
  2481.           break;
  2482.         }
  2483.  
  2484.           /* Figure out innner displacement stuff */
  2485.           if (opP->mode != AINDX)
  2486.         {
  2487.           switch (siz2)
  2488.             {
  2489.             case 0:
  2490.               if (isvar (opP->con2) || !issword (outro))
  2491.             {
  2492.               siz2 = 3;
  2493.               nextword |= 0x3;
  2494.             }
  2495.               else if (outro == 0)
  2496.             nextword |= 0x1;
  2497.               else
  2498.             {
  2499.               nextword |= 0x2;
  2500.               siz2 = 2;
  2501.             }
  2502.               break;
  2503.             case 1:
  2504.               as_warn ("Byte dispacement won't work.  Defaulting to :w");
  2505.             case 2:
  2506.               nextword |= 0x2;
  2507.               break;
  2508.             case 3:
  2509.               nextword |= 0x3;
  2510.               break;
  2511.             }
  2512.           if (opP->mode == APODX)
  2513.             nextword |= 0x04;
  2514.           else if (opP->mode == AMIND)
  2515.             nextword |= 0x40;
  2516.         }
  2517.           addword (nextword);
  2518.  
  2519.           if (isvar (opP->con1))
  2520.         {
  2521.           if (opP->reg == PC || opP->reg == ZPC)
  2522.             {
  2523.               opP->con1->e_exp.X_add_number += 6;
  2524.               add_fix (siz1 == 3 ? 'l' : 'w', opP->con1, 1);
  2525.             }
  2526.           else
  2527.             add_fix (siz1 == 3 ? 'l' : 'w', opP->con1, 0);
  2528.         }
  2529.           if (siz1 == 3)
  2530.         addword (baseo >> 16);
  2531.           if (siz1)
  2532.         addword (baseo);
  2533.  
  2534.           if (isvar (opP->con2))
  2535.         {
  2536.           if (opP->reg == PC || opP->reg == ZPC)
  2537.             {
  2538.               opP->con1->e_exp.X_add_number += 6;
  2539.               add_fix (siz2 == 3 ? 'l' : 'w', opP->con2, 1);
  2540.             }
  2541.           else
  2542.             add_fix (siz2 == 3 ? 'l' : 'w', opP->con2, 0);
  2543.         }
  2544.           if (siz2 == 3)
  2545.         addword (outro >> 16);
  2546.           if (siz2)
  2547.         addword (outro);
  2548.  
  2549.           break;
  2550.  
  2551.         case ABSL:
  2552.           nextword = get_num (opP->con1, 80);
  2553.           switch (opP->con1->e_siz)
  2554.         {
  2555.         default:
  2556.           as_warn ("Unknown size for absolute reference");
  2557.         case 0:
  2558.           if (!isvar (opP->con1) && issword (offs (opP->con1)))
  2559.             {
  2560.               tmpreg = 0x38;    /* 7.0 */
  2561.               addword (nextword);
  2562.               break;
  2563.             }
  2564.           /* Don't generate pc relative code on 68010 and
  2565.              68000.  */
  2566.           if (isvar (opP->con1)
  2567.               && !subs (opP->con1)
  2568.               && seg (opP->con1) == text_section
  2569.               && now_seg == text_section
  2570.               && cpu_of_arch (current_architecture) >= m68020
  2571.               && !flag_long_jumps
  2572.               && !strchr ("~%&$?", s[0]))
  2573.             {
  2574.               tmpreg = 0x3A;    /* 7.2 */
  2575.               add_frag (adds (opP->con1),
  2576.                 offs (opP->con1),
  2577.                 TAB (PCREL, SZ_UNDEF));
  2578.               break;
  2579.             }
  2580.         case 3:    /* Fall through into long */
  2581.           if (isvar (opP->con1))
  2582.             add_fix ('l', opP->con1, 0);
  2583.  
  2584.           tmpreg = 0x39;/* 7.1 mode */
  2585.           addword (nextword >> 16);
  2586.           addword (nextword);
  2587.           break;
  2588.  
  2589.         case 2:    /* Word */
  2590.           if (isvar (opP->con1))
  2591.             add_fix ('w', opP->con1, 0);
  2592.  
  2593.           tmpreg = 0x38;/* 7.0 mode */
  2594.           addword (nextword);
  2595.           break;
  2596.         }
  2597.           break;
  2598.         case DINDR:
  2599.           as_bad ("invalid indirect register");
  2600.           break;
  2601.         case MSCR:
  2602.         default:
  2603.           as_bad ("unknown/incorrect operand");
  2604.           /* abort(); */
  2605.         }
  2606.       install_gen_operand (s[1], tmpreg);
  2607.       break;
  2608.  
  2609.     case '#':
  2610.     case '^':
  2611.       switch (s[1])
  2612.         {            /* JF: I hate floating point! */
  2613.         case 'j':
  2614.           tmpreg = 70;
  2615.           break;
  2616.         case '8':
  2617.           tmpreg = 20;
  2618.           break;
  2619.         case 'C':
  2620.           tmpreg = 50;
  2621.           break;
  2622.         case '3':
  2623.         default:
  2624.           tmpreg = 80;
  2625.           break;
  2626.         }
  2627.       tmpreg = get_num (opP->con1, tmpreg);
  2628.       if (isvar (opP->con1))
  2629.         add_fix (s[1], opP->con1, 0);
  2630.       switch (s[1])
  2631.         {
  2632.         case 'b':        /* Danger:  These do no check for
  2633.                    certain types of overflow.
  2634.                    user beware! */
  2635.           if (!isbyte (tmpreg))
  2636.         opP->error = "out of range";
  2637.           insop (tmpreg, opcode);
  2638.           if (isvar (opP->con1))
  2639.         the_ins.reloc[the_ins.nrel - 1].n = (opcode->m_codenum) * 2;
  2640.           break;
  2641.         case 'w':
  2642.           if (!isword (tmpreg))
  2643.         opP->error = "out of range";
  2644.           insop (tmpreg, opcode);
  2645.           if (isvar (opP->con1))
  2646.         the_ins.reloc[the_ins.nrel - 1].n = (opcode->m_codenum) * 2;
  2647.           break;
  2648.         case 'l':
  2649.           /* Because of the way insop works, we put these two out
  2650.          backwards.  */
  2651.           insop (tmpreg, opcode);
  2652.           insop (tmpreg >> 16, opcode);
  2653.           if (isvar (opP->con1))
  2654.         the_ins.reloc[the_ins.nrel - 1].n = (opcode->m_codenum) * 2;
  2655.           break;
  2656.         case '3':
  2657.           tmpreg &= 0xFF;
  2658.         case '8':
  2659.         case 'C':
  2660.           install_operand (s[1], tmpreg);
  2661.           break;
  2662.         default:
  2663.           as_fatal ("Internal error:  Unknown mode #%c in line %d of file \"%s\"", s[1], __LINE__, __FILE__);
  2664.         }
  2665.       break;
  2666.  
  2667.     case '+':
  2668.     case '-':
  2669.     case 'A':
  2670.     case 'a':
  2671.       install_operand (s[1], opP->reg - ADDR);
  2672.       break;
  2673.  
  2674.     case 'B':
  2675.       tmpreg = get_num (opP->con1, 80);
  2676.       switch (s[1])
  2677.         {
  2678.         case 'B':
  2679.           /* Needs no offsetting */
  2680.           add_fix ('B', opP->con1, 1);
  2681.           break;
  2682.         case 'W':
  2683.           /* Offset the displacement to be relative to byte disp location */
  2684.           opP->con1->e_exp.X_add_number += 2;
  2685.           add_fix ('w', opP->con1, 1);
  2686.           addword (0);
  2687.           break;
  2688.         case 'L':
  2689.         long_branch:
  2690.           if (cpu_of_arch (current_architecture) < m68020)    /* 68000 or 010 */
  2691.         as_warn ("Can't use long branches on 68000/68010");
  2692.           the_ins.opcode[the_ins.numo - 1] |= 0xff;
  2693.           /* Offset the displacement to be relative to byte disp location */
  2694.           opP->con1->e_exp.X_add_number += 4;
  2695.           add_fix ('l', opP->con1, 1);
  2696.           addword (0);
  2697.           addword (0);
  2698.           break;
  2699.         case 'g':
  2700.           if (subs (opP->con1))    /* We can't relax it */
  2701.         goto long_branch;
  2702.  
  2703.           /* This could either be a symbol, or an
  2704.          absolute address.  No matter, the
  2705.          frag hacking will finger it out.
  2706.          Not quite: it can't switch from
  2707.          BRANCH to BCC68000 for the case
  2708.          where opnd is absolute (it needs
  2709.          to use the 68000 hack since no
  2710.          conditional abs jumps).  */
  2711.           if (((cpu_of_arch (current_architecture) < m68020) || (0 == adds (opP->con1)))
  2712.           && (the_ins.opcode[0] >= 0x6200)
  2713.           && (the_ins.opcode[0] <= 0x6f00))
  2714.         {
  2715.           add_frag (adds (opP->con1), offs (opP->con1), TAB (BCC68000, SZ_UNDEF));
  2716.         }
  2717.           else
  2718.         {
  2719.           add_frag (adds (opP->con1), offs (opP->con1), TAB (ABRANCH, SZ_UNDEF));
  2720.         }
  2721.           break;
  2722.         case 'w':
  2723.           if (isvar (opP->con1))
  2724.         {
  2725. #if 1
  2726.           /* check for DBcc instruction */
  2727.           if ((the_ins.opcode[0] & 0xf0f8) == 0x50c8)
  2728.             {
  2729.               /* size varies if patch */
  2730.               /* needed for long form */
  2731.               add_frag (adds (opP->con1), offs (opP->con1), TAB (DBCC, SZ_UNDEF));
  2732.               break;
  2733.             }
  2734. #endif
  2735.           /* Don't ask! */
  2736.           opP->con1->e_exp.X_add_number += 2;
  2737.           add_fix ('w', opP->con1, 1);
  2738.         }
  2739.           addword (0);
  2740.           break;
  2741.         case 'C':        /* Fixed size LONG coproc branches */
  2742.           the_ins.opcode[the_ins.numo - 1] |= 0x40;
  2743.           /* Offset the displacement to be relative to byte disp location */
  2744.           /* Coproc branches don't have a byte disp option, but they are
  2745.        compatible with the ordinary branches, which do... */
  2746.           opP->con1->e_exp.X_add_number += 4;
  2747.           add_fix ('l', opP->con1, 1);
  2748.           addword (0);
  2749.           addword (0);
  2750.           break;
  2751.         case 'c':        /* Var size Coprocesssor branches */
  2752.           if (subs (opP->con1))
  2753.         {
  2754.           add_fix ('l', opP->con1, 1);
  2755.           add_frag ((symbolS *) 0, (long) 0, TAB (FBRANCH, LONG));
  2756.         }
  2757.           else if (adds (opP->con1))
  2758.         {
  2759.           add_frag (adds (opP->con1), offs (opP->con1), TAB (FBRANCH, SZ_UNDEF));
  2760.         }
  2761.           else
  2762.         {
  2763.           /* add_frag((symbolS *)0,offs(opP->con1),TAB(FBRANCH,SHORT)); */
  2764.           the_ins.opcode[the_ins.numo - 1] |= 0x40;
  2765.           add_fix ('l', opP->con1, 1);
  2766.           addword (0);
  2767.           addword (4);
  2768.         }
  2769.           break;
  2770.         default:
  2771.           as_fatal ("Internal error:  operand type B%c unknown in line %d of file \"%s\"",
  2772.             s[1], __LINE__, __FILE__);
  2773.         }
  2774.       break;
  2775.  
  2776.     case 'C':        /* Ignore it */
  2777.       break;
  2778.  
  2779.     case 'd':        /* JF this is a kludge */
  2780.       if (opP->mode == AOFF)
  2781.         {
  2782.           install_operand ('s', opP->reg - ADDR);
  2783.         }
  2784.       else
  2785.         {
  2786.           char *tmpP;
  2787.  
  2788.           tmpP = opP->con1->e_end - 2;
  2789.           opP->con1->e_beg++;
  2790.           opP->con1->e_end -= 4;    /* point to the , */
  2791.           baseo = m68k_reg_parse (&tmpP);
  2792.           if (baseo < ADDR + 0 || baseo > ADDR + 7)
  2793.         {
  2794.           as_bad ("Unknown address reg, using A0");
  2795.           baseo = 0;
  2796.         }
  2797.           else
  2798.         baseo -= ADDR;
  2799.           install_operand ('s', baseo);
  2800.         }
  2801.       tmpreg = get_num (opP->con1, 80);
  2802.       if (!issword (tmpreg))
  2803.         {
  2804.           as_warn ("Expression out of range, using 0");
  2805.           tmpreg = 0;
  2806.         }
  2807.       addword (tmpreg);
  2808.       break;
  2809.  
  2810.     case 'D':
  2811.       install_operand (s[1], opP->reg - DATA);
  2812.       break;
  2813.  
  2814.     case 'F':
  2815.       install_operand (s[1], opP->reg - FPREG);
  2816.       break;
  2817.  
  2818.     case 'I':
  2819.       tmpreg = 1 + opP->reg - COPNUM;
  2820.       if (tmpreg == 8)
  2821.         tmpreg = 0;
  2822.       install_operand (s[1], tmpreg);
  2823.       break;
  2824.  
  2825.     case 'J':        /* JF foo */
  2826.       switch (opP->reg)
  2827.         {
  2828.         case SFC:
  2829.           tmpreg = 0x000;
  2830.           break;
  2831.         case DFC:
  2832.           tmpreg = 0x001;
  2833.           break;
  2834.         case CACR:
  2835.           tmpreg = 0x002;
  2836.           break;
  2837.         case TC:
  2838.           tmpreg = 0x003;
  2839.           break;
  2840.         case ITT0:
  2841.           tmpreg = 0x004;
  2842.           break;
  2843.         case ITT1:
  2844.           tmpreg = 0x005;
  2845.           break;
  2846.         case DTT0:
  2847.           tmpreg = 0x006;
  2848.           break;
  2849.         case DTT1:
  2850.           tmpreg = 0x007;
  2851.           break;
  2852.  
  2853.         case USP:
  2854.           tmpreg = 0x800;
  2855.           break;
  2856.         case VBR:
  2857.           tmpreg = 0x801;
  2858.           break;
  2859.         case CAAR:
  2860.           tmpreg = 0x802;
  2861.           break;
  2862.         case MSP:
  2863.           tmpreg = 0x803;
  2864.           break;
  2865.         case ISP:
  2866.           tmpreg = 0x804;
  2867.           break;
  2868.         case MMUSR:
  2869.           tmpreg = 0x805;
  2870.           break;
  2871.         case URP:
  2872.           tmpreg = 0x806;
  2873.           break;
  2874.         case SRP:
  2875.           tmpreg = 0x807;
  2876.           break;
  2877.         default:
  2878.           as_fatal ("failed sanity check.");
  2879.         }
  2880.       install_operand (s[1], tmpreg);
  2881.       break;
  2882.  
  2883.     case 'k':
  2884.       tmpreg = get_num (opP->con1, 55);
  2885.       install_operand (s[1], tmpreg & 0x7f);
  2886.       break;
  2887.  
  2888.     case 'l':
  2889.       tmpreg = opP->reg;
  2890.       if (s[1] == 'w')
  2891.         {
  2892.           if (tmpreg & 0x7FF0000)
  2893.         as_bad ("Floating point register in register list");
  2894.           insop (reverse_16_bits (tmpreg), opcode);
  2895.         }
  2896.       else
  2897.         {
  2898.           if (tmpreg & 0x700FFFF)
  2899.         as_bad ("Wrong register in floating-point reglist");
  2900.           install_operand (s[1], reverse_8_bits (tmpreg >> 16));
  2901.         }
  2902.       break;
  2903.  
  2904.     case 'L':
  2905.       tmpreg = opP->reg;
  2906.       if (s[1] == 'w')
  2907.         {
  2908.           if (tmpreg & 0x7FF0000)
  2909.         as_bad ("Floating point register in register list");
  2910.           insop (tmpreg, opcode);
  2911.         }
  2912.       else if (s[1] == '8')
  2913.         {
  2914.           if (tmpreg & 0x0FFFFFF)
  2915.         as_bad ("incorrect register in reglist");
  2916.           install_operand (s[1], tmpreg >> 24);
  2917.         }
  2918.       else
  2919.         {
  2920.           if (tmpreg & 0x700FFFF)
  2921.         as_bad ("wrong register in floating-point reglist");
  2922.           else
  2923.         install_operand (s[1], tmpreg >> 16);
  2924.         }
  2925.       break;
  2926.  
  2927.     case 'M':
  2928.       install_operand (s[1], get_num (opP->con1, 60));
  2929.       break;
  2930.  
  2931.     case 'O':
  2932.       tmpreg = (opP->mode == DREG)
  2933.         ? 0x20 + opP->reg - DATA
  2934.         : (get_num (opP->con1, 40) & 0x1F);
  2935.       install_operand (s[1], tmpreg);
  2936.       break;
  2937.  
  2938.     case 'Q':
  2939.       tmpreg = get_num (opP->con1, 10);
  2940.       if (tmpreg == 8)
  2941.         tmpreg = 0;
  2942.       install_operand (s[1], tmpreg);
  2943.       break;
  2944.  
  2945.     case 'R':
  2946.     case 'r':
  2947.       /* This depends on the fact that ADDR registers are
  2948.      eight more than their corresponding DATA regs, so
  2949.      the result will have the ADDR_REG bit set */
  2950.       install_operand (s[1], opP->reg - DATA);
  2951.       break;
  2952.  
  2953.     case 's':
  2954.       if (opP->reg == FPI)
  2955.         tmpreg = 0x1;
  2956.       else if (opP->reg == FPS)
  2957.         tmpreg = 0x2;
  2958.       else if (opP->reg == FPC)
  2959.         tmpreg = 0x4;
  2960.       else
  2961.         as_fatal ("failed sanity check.");
  2962.       install_operand (s[1], tmpreg);
  2963.       break;
  2964.  
  2965.     case 'S':        /* Ignore it */
  2966.       break;
  2967.  
  2968.     case 'T':
  2969.       install_operand (s[1], get_num (opP->con1, 30));
  2970.       break;
  2971.  
  2972.     case 'U':        /* Ignore it */
  2973.       break;
  2974.  
  2975.     case 'c':
  2976.       switch (opP->reg)
  2977.         {
  2978.         case NC:
  2979.           tmpreg = 0;
  2980.           break;
  2981.         case DC:
  2982.           tmpreg = 1;
  2983.           break;
  2984.         case IC:
  2985.           tmpreg = 2;
  2986.           break;
  2987.         case BC:
  2988.           tmpreg = 3;
  2989.           break;
  2990.         default:
  2991.           as_fatal ("failed sanity check");
  2992.         }            /* switch on cache token */
  2993.       install_operand (s[1], tmpreg);
  2994.       break;
  2995. #ifndef NO_68851
  2996.       /* JF: These are out of order, I fear. */
  2997.     case 'f':
  2998.       switch (opP->reg)
  2999.         {
  3000.         case SFC:
  3001.           tmpreg = 0;
  3002.           break;
  3003.         case DFC:
  3004.           tmpreg = 1;
  3005.           break;
  3006.         default:
  3007.           as_fatal ("failed sanity check.");
  3008.         }
  3009.       install_operand (s[1], tmpreg);
  3010.       break;
  3011.  
  3012.     case 'P':
  3013.       switch (opP->reg)
  3014.         {
  3015.         case TC:
  3016.           tmpreg = 0;
  3017.           break;
  3018.         case CAL:
  3019.           tmpreg = 4;
  3020.           break;
  3021.         case VAL:
  3022.           tmpreg = 5;
  3023.           break;
  3024.         case SCC:
  3025.           tmpreg = 6;
  3026.           break;
  3027.         case AC:
  3028.           tmpreg = 7;
  3029.           break;
  3030.         default:
  3031.           as_fatal ("failed sanity check.");
  3032.         }
  3033.       install_operand (s[1], tmpreg);
  3034.       break;
  3035.  
  3036.     case 'V':
  3037.       if (opP->reg == VAL)
  3038.         break;
  3039.       as_fatal ("failed sanity check.");
  3040.  
  3041.     case 'W':
  3042.       switch (opP->reg)
  3043.         {
  3044.  
  3045.         case DRP:
  3046.           tmpreg = 1;
  3047.           break;
  3048.         case SRP:
  3049.           tmpreg = 2;
  3050.           break;
  3051.         case CRP:
  3052.           tmpreg = 3;
  3053.           break;
  3054.         default:
  3055.           as_fatal ("failed sanity check.");
  3056.         }
  3057.       install_operand (s[1], tmpreg);
  3058.       break;
  3059.  
  3060.     case 'X':
  3061.       switch (opP->reg)
  3062.         {
  3063.         case BAD:
  3064.         case BAD + 1:
  3065.         case BAD + 2:
  3066.         case BAD + 3:
  3067.         case BAD + 4:
  3068.         case BAD + 5:
  3069.         case BAD + 6:
  3070.         case BAD + 7:
  3071.           tmpreg = (4 << 10) | ((opP->reg - BAD) << 2);
  3072.           break;
  3073.  
  3074.         case BAC:
  3075.         case BAC + 1:
  3076.         case BAC + 2:
  3077.         case BAC + 3:
  3078.         case BAC + 4:
  3079.         case BAC + 5:
  3080.         case BAC + 6:
  3081.         case BAC + 7:
  3082.           tmpreg = (5 << 10) | ((opP->reg - BAC) << 2);
  3083.           break;
  3084.  
  3085.         default:
  3086.           as_fatal ("failed sanity check.");
  3087.         }
  3088.       install_operand (s[1], tmpreg);
  3089.       break;
  3090.     case 'Y':
  3091.       know (opP->reg == PSR);
  3092.       break;
  3093.     case 'Z':
  3094.       know (opP->reg == PCSR);
  3095.       break;
  3096. #endif /* m68851 */
  3097.     case '3':
  3098.       switch (opP->reg)
  3099.         {
  3100.         case TT0:
  3101.           tmpreg = 2;
  3102.           break;
  3103.         case TT1:
  3104.           tmpreg = 3;
  3105.           break;
  3106.         default:
  3107.           as_fatal ("failed sanity check");
  3108.         }
  3109.       install_operand (s[1], tmpreg);
  3110.       break;
  3111.     case 't':
  3112.       tmpreg = get_num (opP->con1, 20);
  3113.       install_operand (s[1], tmpreg);
  3114.       break;
  3115.     case '_':        /* used only for move16 absolute 32-bit address */
  3116.       tmpreg = get_num (opP->con1, 80);
  3117.       addword (tmpreg >> 16);
  3118.       addword (tmpreg & 0xFFFF);
  3119.       break;
  3120.     default:
  3121.       as_fatal ("Internal error:  Operand type %c unknown in line %d of file \"%s\"",
  3122.             s[0], __LINE__, __FILE__);
  3123.     }
  3124.     }
  3125.  
  3126.   /* By the time whe get here (FINALLY) the_ins contains the complete
  3127.      instruction, ready to be emitted. . . */
  3128. }                /* m68k_ip() */
  3129.  
  3130. /*
  3131.  * get_regs := '/' + ?
  3132.  *    | '-' + <register>
  3133.  *    | '-' + <register> + ?
  3134.  *    | <empty>
  3135.  *    ;
  3136.  *
  3137.  
  3138.  * The idea here must be to scan in a set of registers but I don't
  3139.  * understand it.  Looks awfully sloppy to me but I don't have any doc on
  3140.  * this format so...
  3141.  
  3142.  *
  3143.  *
  3144.  */
  3145.  
  3146. static int
  3147. get_regs (i, str, opP)
  3148.      int i;
  3149.      struct m68k_op *opP;
  3150.      char *str;
  3151. {
  3152.   /*                 26, 25, 24, 23-16,  15-8, 0-7 */
  3153.   /* Low order 24 bits encoded fpc,fps,fpi,fp7-fp0,a7-a0,d7-d0 */
  3154.   unsigned long cur_regs = 0;
  3155.   int reg1, reg2;
  3156.  
  3157. #define ADD_REG(x)    {     if(x==FPI) cur_regs|=(1<<24);\
  3158. else if(x==FPS) cur_regs|=(1<<25);\
  3159. else if(x==FPC) cur_regs|=(1<<26);\
  3160. else cur_regs|=(1<<(x-1));  }
  3161.  
  3162.   reg1 = i;
  3163.   for (;;)
  3164.     {
  3165.       if (*str == '/')
  3166.     {
  3167.       ADD_REG (reg1);
  3168.       str++;
  3169.     }
  3170.       else if (*str == '-')
  3171.     {
  3172.       str++;
  3173.       reg2 = m68k_reg_parse (&str);
  3174.       if (reg2 < DATA || reg2 >= FPREG + 8 || reg1 == FPI || reg1 == FPS || reg1 == FPC)
  3175.         {
  3176.           opP->error = "unknown register in register list";
  3177.           return FAIL;
  3178.         }
  3179.       while (reg1 <= reg2)
  3180.         {
  3181.           ADD_REG (reg1);
  3182.           reg1++;
  3183.         }
  3184.       if (*str == '\0')
  3185.         break;
  3186.     }
  3187.       else if (*str == '\0')
  3188.     {
  3189.       ADD_REG (reg1);
  3190.       break;
  3191.     }
  3192.       else
  3193.     {
  3194.       opP->error = "unknow character in register list";
  3195.       return FAIL;
  3196.     }
  3197.       /* DJA -- Bug Fix.  Did't handle d1-d2/a1 until the following instruction was added */
  3198.       if (*str == '/')
  3199.     str++;
  3200.       reg1 = m68k_reg_parse (&str);
  3201.       if ((reg1 < DATA || reg1 >= FPREG + 8) && !(reg1 == FPI || reg1 == FPS || reg1 == FPC))
  3202.     {
  3203.       opP->error = "unknown register in register list";
  3204.       return FAIL;
  3205.     }
  3206.     }
  3207.   opP->reg = cur_regs;
  3208.   return OK;
  3209. }                /* get_regs() */
  3210.  
  3211. static int
  3212. reverse_16_bits (in)
  3213.      int in;
  3214. {
  3215.   int out = 0;
  3216.   int n;
  3217.  
  3218.   static int mask[16] =
  3219.   {
  3220.     0x0001, 0x0002, 0x0004, 0x0008, 0x0010, 0x0020, 0x0040, 0x0080,
  3221.     0x0100, 0x0200, 0x0400, 0x0800, 0x1000, 0x2000, 0x4000, 0x8000
  3222.   };
  3223.   for (n = 0; n < 16; n++)
  3224.     {
  3225.       if (in & mask[n])
  3226.     out |= mask[15 - n];
  3227.     }
  3228.   return out;
  3229. }                /* reverse_16_bits() */
  3230.  
  3231. static int
  3232. reverse_8_bits (in)
  3233.      int in;
  3234. {
  3235.   int out = 0;
  3236.   int n;
  3237.  
  3238.   static int mask[8] =
  3239.   {
  3240.     0x0001, 0x0002, 0x0004, 0x0008, 0x0010, 0x0020, 0x0040, 0x0080,
  3241.   };
  3242.  
  3243.   for (n = 0; n < 8; n++)
  3244.     {
  3245.       if (in & mask[n])
  3246.     out |= mask[7 - n];
  3247.     }
  3248.   return out;
  3249. }                /* reverse_8_bits() */
  3250.  
  3251. static void
  3252. install_operand (mode, val)
  3253.      int mode;
  3254.      int val;
  3255. {
  3256.   switch (mode)
  3257.     {
  3258.     case 's':
  3259.       the_ins.opcode[0] |= val & 0xFF;    /* JF FF is for M kludge */
  3260.       break;
  3261.     case 'd':
  3262.       the_ins.opcode[0] |= val << 9;
  3263.       break;
  3264.     case '1':
  3265.       the_ins.opcode[1] |= val << 12;
  3266.       break;
  3267.     case '2':
  3268.       the_ins.opcode[1] |= val << 6;
  3269.       break;
  3270.     case '3':
  3271.       the_ins.opcode[1] |= val;
  3272.       break;
  3273.     case '4':
  3274.       the_ins.opcode[2] |= val << 12;
  3275.       break;
  3276.     case '5':
  3277.       the_ins.opcode[2] |= val << 6;
  3278.       break;
  3279.     case '6':
  3280.       /* DANGER!  This is a hack to force cas2l and cas2w cmds to be
  3281.      three words long! */
  3282.       the_ins.numo++;
  3283.       the_ins.opcode[2] |= val;
  3284.       break;
  3285.     case '7':
  3286.       the_ins.opcode[1] |= val << 7;
  3287.       break;
  3288.     case '8':
  3289.       the_ins.opcode[1] |= val << 10;
  3290.       break;
  3291. #ifndef NO_68851
  3292.     case '9':
  3293.       the_ins.opcode[1] |= val << 5;
  3294.       break;
  3295. #endif
  3296.  
  3297.     case 't':
  3298.       the_ins.opcode[1] |= (val << 10) | (val << 7);
  3299.       break;
  3300.     case 'D':
  3301.       the_ins.opcode[1] |= (val << 12) | val;
  3302.       break;
  3303.     case 'g':
  3304.       the_ins.opcode[0] |= val = 0xff;
  3305.       break;
  3306.     case 'i':
  3307.       the_ins.opcode[0] |= val << 9;
  3308.       break;
  3309.     case 'C':
  3310.       the_ins.opcode[1] |= val;
  3311.       break;
  3312.     case 'j':
  3313.       the_ins.opcode[1] |= val;
  3314.       the_ins.numo++;        /* What a hack */
  3315.       break;
  3316.     case 'k':
  3317.       the_ins.opcode[1] |= val << 4;
  3318.       break;
  3319.     case 'b':
  3320.     case 'w':
  3321.     case 'l':
  3322.       break;
  3323.     case 'e':
  3324.       the_ins.opcode[0] |= (val << 6);
  3325.       break;
  3326.     case 'L':
  3327.       the_ins.opcode[1] = (val >> 16);
  3328.       the_ins.opcode[2] = val & 0xffff;
  3329.       break;
  3330.     case 'c':
  3331.     default:
  3332.       as_fatal ("failed sanity check.");
  3333.     }
  3334. }                /* install_operand() */
  3335.  
  3336. static void
  3337. install_gen_operand (mode, val)
  3338.      int mode;
  3339.      int val;
  3340. {
  3341.   switch (mode)
  3342.     {
  3343.     case 's':
  3344.       the_ins.opcode[0] |= val;
  3345.       break;
  3346.     case 'd':
  3347.       /* This is a kludge!!! */
  3348.       the_ins.opcode[0] |= (val & 0x07) << 9 | (val & 0x38) << 3;
  3349.       break;
  3350.     case 'b':
  3351.     case 'w':
  3352.     case 'l':
  3353.     case 'f':
  3354.     case 'F':
  3355.     case 'x':
  3356.     case 'p':
  3357.       the_ins.opcode[0] |= val;
  3358.       break;
  3359.       /* more stuff goes here */
  3360.     default:
  3361.       as_fatal ("failed sanity check.");
  3362.     }
  3363. }                /* install_gen_operand() */
  3364.  
  3365. /*
  3366.  * verify that we have some number of paren pairs, do m68k_ip_op(), and
  3367.  * then deal with the bitfield hack.
  3368.  */
  3369.  
  3370. static char *
  3371. crack_operand (str, opP)
  3372.      register char *str;
  3373.      register struct m68k_op *opP;
  3374. {
  3375.   register int parens;
  3376.   register int c;
  3377.   register char *beg_str;
  3378.  
  3379.   if (!str)
  3380.     {
  3381.       return str;
  3382.     }
  3383.   beg_str = str;
  3384.   for (parens = 0; *str && (parens > 0 || notend (str)); str++)
  3385.     {
  3386.       if (*str == '(')
  3387.     parens++;
  3388.       else if (*str == ')')
  3389.     {
  3390.       if (!parens)
  3391.         {            /* ERROR */
  3392.           opP->error = "Extra )";
  3393.           return str;
  3394.         }
  3395.       --parens;
  3396.     }
  3397.     }
  3398.   if (!*str && parens)
  3399.     {                /* ERROR */
  3400.       opP->error = "Missing )";
  3401.       return str;
  3402.     }
  3403.   c = *str;
  3404.   *str = '\0';
  3405.   if (m68k_ip_op (beg_str, opP) == FAIL)
  3406.     {
  3407.       *str = c;
  3408.       return str;
  3409.     }
  3410.   *str = c;
  3411.   if (c == '}')
  3412.     c = *++str;            /* JF bitfield hack */
  3413.   if (c)
  3414.     {
  3415.       c = *++str;
  3416.       if (!c)
  3417.     as_bad ("Missing operand");
  3418.     }
  3419.   return str;
  3420. }
  3421.  
  3422. /* See the comment up above where the #define notend(... is */
  3423. #if 0
  3424. notend (s)
  3425.      char *s;
  3426. {
  3427.   if (*s == ',')
  3428.     return 0;
  3429.   if (*s == '{' || *s == '}')
  3430.     return 0;
  3431.   if (*s != ':')
  3432.     return 1;
  3433.   /* This kludge here is for the division cmd, which is a kludge */
  3434.   if (index ("aAdD#", s[1]))
  3435.     return 0;
  3436.   return 1;
  3437. }
  3438.  
  3439. #endif
  3440.  
  3441. /* This is the guts of the machine-dependent assembler.  STR points to a
  3442.    machine dependent instruction.  This function is supposed to emit
  3443.    the frags/bytes it assembles to.
  3444.    */
  3445.  
  3446. void
  3447. insert_reg (regname, regnum)
  3448.      char *regname;
  3449.      int regnum;
  3450. {
  3451.   char buf[100];
  3452.   int i;
  3453.  
  3454. #ifdef REGISTER_PREFIX
  3455.   if (!flag_reg_prefix_optional)
  3456.     {
  3457.       buf[0] = REGISTER_PREFIX;
  3458.       strcpy (buf + 1, regname);
  3459.       regname = buf;
  3460.     }
  3461. #endif
  3462.  
  3463.   symbol_table_insert (symbol_new (regname, reg_section, regnum,
  3464.                    &zero_address_frag));
  3465.  
  3466.   for (i = 0; regname[i]; i++)
  3467.     buf[i] = islower (regname[i]) ? toupper (regname[i]) : regname[i];
  3468.   buf[i] = '\0';
  3469.  
  3470.   symbol_table_insert (symbol_new (buf, reg_section, regnum,
  3471.                    &zero_address_frag));
  3472. }
  3473.  
  3474. struct init_entry
  3475.   {
  3476.     const char *name;
  3477.     int number;
  3478.   };
  3479.  
  3480. static const struct init_entry init_table[] =
  3481. {
  3482.   { "d0", DATA0 },
  3483.   { "d1", DATA1 },
  3484.   { "d2", DATA2 },
  3485.   { "d3", DATA3 },
  3486.   { "d4", DATA4 },
  3487.   { "d5", DATA5 },
  3488.   { "d6", DATA6 },
  3489.   { "d7", DATA7 },
  3490.   { "a0", ADDR0 },
  3491.   { "a1", ADDR1 },
  3492.   { "a2", ADDR2 },
  3493.   { "a3", ADDR3 },
  3494.   { "a4", ADDR4 },
  3495.   { "a5", ADDR5 },
  3496.   { "a6", ADDR6 },
  3497.   { "fp", ADDR6 },
  3498.   { "a7", ADDR7 },
  3499.   { "sp", ADDR7 },
  3500.   { "fp0", FP0 },
  3501.   { "fp1", FP1 },
  3502.   { "fp2", FP2 },
  3503.   { "fp3", FP3 },
  3504.   { "fp4", FP4 },
  3505.   { "fp5", FP5 },
  3506.   { "fp6", FP6 },
  3507.   { "fp7", FP7 },
  3508.   { "fpi", FPI },
  3509.   { "fpiar", FPI },
  3510.   { "fpc", FPI },
  3511.   { "fps", FPS },
  3512.   { "fpsr", FPS },
  3513.   { "fpc", FPC },
  3514.   { "fpcr", FPC },
  3515.  
  3516.   { "cop0", COP0 },
  3517.   { "cop1", COP1 },
  3518.   { "cop2", COP2 },
  3519.   { "cop3", COP3 },
  3520.   { "cop4", COP4 },
  3521.   { "cop5", COP5 },
  3522.   { "cop6", COP6 },
  3523.   { "cop7", COP7 },
  3524.   { "pc", PC },
  3525.   { "zpc", ZPC },
  3526.   { "sr", SR },
  3527.  
  3528.   { "ccr", CCR },
  3529.   { "cc", CCR },
  3530.  
  3531.   { "usp", USP },
  3532.   { "isp", ISP },
  3533.   { "sfc", SFC },
  3534.   { "dfc", DFC },
  3535.   { "cacr", CACR },
  3536.   { "caar", CAAR },
  3537.  
  3538.   { "vbr", VBR },
  3539.  
  3540.   { "msp", MSP },
  3541.   { "itt0", ITT0 },
  3542.   { "itt1", ITT1 },
  3543.   { "dtt0", DTT0 },
  3544.   { "dtt1", DTT1 },
  3545.   { "mmusr", MMUSR },
  3546.   { "tc", TC },
  3547.   { "srp", SRP },
  3548.   { "urp", URP },
  3549.  
  3550.   { "ac", AC },
  3551.   { "bc", BC },
  3552.   { "cal", CAL },
  3553.   { "crp", CRP },
  3554.   { "drp", DRP },
  3555.   { "pcsr", PCSR },
  3556.   { "psr", PSR },
  3557.   { "scc", SCC },
  3558.   { "val", VAL },
  3559.   { "bad0", BAD0 },
  3560.   { "bad1", BAD1 },
  3561.   { "bad2", BAD2 },
  3562.   { "bad3", BAD3 },
  3563.   { "bad4", BAD4 },
  3564.   { "bad5", BAD5 },
  3565.   { "bad6", BAD6 },
  3566.   { "bad7", BAD7 },
  3567.   { "bac0", BAC0 },
  3568.   { "bac1", BAC1 },
  3569.   { "bac2", BAC2 },
  3570.   { "bac3", BAC3 },
  3571.   { "bac4", BAC4 },
  3572.   { "bac5", BAC5 },
  3573.   { "bac6", BAC6 },
  3574.   { "bac7", BAC7 },
  3575.  
  3576.   { "ic", IC },
  3577.   { "dc", DC },
  3578.   { "nc", NC },
  3579.  
  3580.   { "tt0", TT0 },
  3581.   { "tt1", TT1 },
  3582.   /* 68ec030 versions of same */
  3583.   { "ac0", TT0 },
  3584.   { "ac1", TT1 },
  3585.   /* 68ec030 access control unit, identical to 030 MMU status reg */
  3586.   { "acusr", PSR },
  3587.  
  3588.   { 0, 0 }
  3589. };
  3590.  
  3591. void
  3592. init_regtable ()
  3593. {
  3594.   int i;
  3595.   for (i = 0; init_table[i].name; i++)
  3596.     insert_reg (init_table[i].name, init_table[i].number);
  3597. }
  3598.  
  3599. static int no_68851, no_68881;
  3600.  
  3601. #ifdef OBJ_AOUT
  3602. /* a.out machine type.  Default to 68020.  */
  3603. int m68k_aout_machtype = 2;
  3604. #endif
  3605.  
  3606. void
  3607. md_assemble (str)
  3608.      char *str;
  3609. {
  3610.   char *er;
  3611.   short *fromP;
  3612.   char *toP = NULL;
  3613.   int m, n = 0;
  3614.   char *to_beg_P;
  3615.   int shorts_this_frag;
  3616.  
  3617.   memset ((char *) (&the_ins), '\0', sizeof (the_ins));
  3618.   m68k_ip (str);
  3619.   er = the_ins.error;
  3620.   if (!er)
  3621.     {
  3622.       for (n = the_ins.numargs; n; --n)
  3623.     if (the_ins.operands[n].error)
  3624.       {
  3625.         er = the_ins.operands[n].error;
  3626.         break;
  3627.       }
  3628.     }
  3629.   if (er)
  3630.     {
  3631.       as_bad ("%s -- statement `%s' ignored", er, str);
  3632.       return;
  3633.     }
  3634.  
  3635.   if (the_ins.nfrag == 0)
  3636.     {
  3637.       /* No frag hacking involved; just put it out */
  3638.       toP = frag_more (2 * the_ins.numo);
  3639.       fromP = &the_ins.opcode[0];
  3640.       for (m = the_ins.numo; m; --m)
  3641.     {
  3642.       md_number_to_chars (toP, (long) (*fromP), 2);
  3643.       toP += 2;
  3644.       fromP++;
  3645.     }
  3646.       /* put out symbol-dependent info */
  3647.       for (m = 0; m < the_ins.nrel; m++)
  3648.     {
  3649.       switch (the_ins.reloc[m].wid)
  3650.         {
  3651.         case 'B':
  3652.           n = 1;
  3653.           break;
  3654.         case 'b':
  3655.           n = 1;
  3656.           break;
  3657.         case '3':
  3658.           n = 2;
  3659.           break;
  3660.         case 'w':
  3661.           n = 2;
  3662.           break;
  3663.         case 'l':
  3664.           n = 4;
  3665.           break;
  3666.         default:
  3667.           as_fatal ("Don't know how to figure width of %c in md_assemble()",
  3668.             the_ins.reloc[m].wid);
  3669.         }
  3670.  
  3671.       fix_new_exp (frag_now,
  3672.                ((toP - frag_now->fr_literal)
  3673.             - the_ins.numo * 2 + the_ins.reloc[m].n),
  3674.                n,
  3675.                &the_ins.reloc[m].exp,
  3676.                the_ins.reloc[m].pcrel,
  3677.                NO_RELOC);
  3678.     }
  3679.       return;
  3680.     }
  3681.  
  3682.   /* There's some frag hacking */
  3683.   for (n = 0, fromP = &the_ins.opcode[0]; n < the_ins.nfrag; n++)
  3684.     {
  3685.       int wid;
  3686.  
  3687.       if (n == 0)
  3688.     wid = 2 * the_ins.fragb[n].fragoff;
  3689.       else
  3690.     wid = 2 * (the_ins.numo - the_ins.fragb[n - 1].fragoff);
  3691.       toP = frag_more (wid);
  3692.       to_beg_P = toP;
  3693.       shorts_this_frag = 0;
  3694.       for (m = wid / 2; m; --m)
  3695.     {
  3696.       md_number_to_chars (toP, (long) (*fromP), 2);
  3697.       toP += 2;
  3698.       fromP++;
  3699.       shorts_this_frag++;
  3700.     }
  3701.       for (m = 0; m < the_ins.nrel; m++)
  3702.     {
  3703.       if ((the_ins.reloc[m].n) >= 2 * shorts_this_frag)
  3704.         {
  3705.           the_ins.reloc[m].n -= 2 * shorts_this_frag;
  3706.           break;
  3707.         }
  3708.       wid = the_ins.reloc[m].wid;
  3709.       if (wid == 0)
  3710.         continue;
  3711.       the_ins.reloc[m].wid = 0;
  3712.       wid = (wid == 'b') ? 1 : (wid == 'w') ? 2 : (wid == 'l') ? 4 : 4000;
  3713.  
  3714.       fix_new_exp (frag_now,
  3715.                ((toP - frag_now->fr_literal)
  3716.             - the_ins.numo * 2 + the_ins.reloc[m].n),
  3717.                wid,
  3718.                &the_ins.reloc[m].exp,
  3719.                the_ins.reloc[m].pcrel,
  3720.                NO_RELOC);
  3721.     }
  3722.       (void) frag_var (rs_machine_dependent, 10, 0,
  3723.                (relax_substateT) (the_ins.fragb[n].fragty),
  3724.                the_ins.fragb[n].fadd, the_ins.fragb[n].foff, to_beg_P);
  3725.     }
  3726.   n = (the_ins.numo - the_ins.fragb[n - 1].fragoff);
  3727.   shorts_this_frag = 0;
  3728.   if (n)
  3729.     {
  3730.       toP = frag_more (n * sizeof (short));
  3731.       while (n--)
  3732.     {
  3733.       md_number_to_chars (toP, (long) (*fromP), 2);
  3734.       toP += 2;
  3735.       fromP++;
  3736.       shorts_this_frag++;
  3737.     }
  3738.     }
  3739.   for (m = 0; m < the_ins.nrel; m++)
  3740.     {
  3741.       int wid;
  3742.  
  3743.       wid = the_ins.reloc[m].wid;
  3744.       if (wid == 0)
  3745.     continue;
  3746.       the_ins.reloc[m].wid = 0;
  3747.       wid = (wid == 'b') ? 1 : (wid == 'w') ? 2 : (wid == 'l') ? 4 : 4000;
  3748.  
  3749.       fix_new_exp (frag_now,
  3750.            ((the_ins.reloc[m].n + toP - frag_now->fr_literal)
  3751.             - shorts_this_frag * 2),
  3752.            wid,
  3753.            &the_ins.reloc[m].exp,
  3754.            the_ins.reloc[m].pcrel,
  3755.            NO_RELOC);
  3756.     }
  3757. }
  3758.  
  3759. /* See BREAK_UP_BIG_DECL definition, above.  */
  3760. static struct m68k_opcode *
  3761. opcode_ptr (i)
  3762.      int i;
  3763. {
  3764. #ifdef DO_BREAK_UP_BIG_DECL
  3765.   int lim1 = sizeof (m68k_opcodes) / sizeof (m68k_opcodes[0]);
  3766.   if (i >= lim1)
  3767.     return m68k_opcodes_2 + (i - lim1);
  3768. #endif
  3769.   return m68k_opcodes + i;
  3770. }
  3771.  
  3772. void
  3773. md_begin ()
  3774. {
  3775.   /*
  3776.    * md_begin -- set up hash tables with 68000 instructions.
  3777.    * similar to what the vax assembler does.  ---phr
  3778.    */
  3779.   /* RMS claims the thing to do is take the m68k-opcode.h table, and make
  3780.      a copy of it at runtime, adding in the information we want but isn't
  3781.      there.  I think it'd be better to have an awk script hack the table
  3782.      at compile time.  Or even just xstr the table and use it as-is.  But
  3783.      my lord ghod hath spoken, so we do it this way.  Excuse the ugly var
  3784.      names.  */
  3785.  
  3786.   register CONST struct m68k_opcode *ins;
  3787.   register struct m68k_incant *hack, *slak;
  3788.   register const char *retval = 0;    /* empty string, or error msg text */
  3789.   register unsigned int i;
  3790.   register char c;
  3791.  
  3792.   op_hash = hash_new ();
  3793.  
  3794.   obstack_begin (&robyn, 4000);
  3795.   for (i = 0; i < numopcodes; i++)
  3796.     {
  3797.       hack = slak = (struct m68k_incant *) obstack_alloc (&robyn, sizeof (struct m68k_incant));
  3798.       do
  3799.     {
  3800.       ins = opcode_ptr (i);
  3801.       /* We *could* ignore insns that don't match our arch here
  3802.          but just leaving them out of the hash. */
  3803.       slak->m_operands = ins->args;
  3804.       slak->m_opnum = strlen (slak->m_operands) / 2;
  3805.       slak->m_arch = ins->arch;
  3806.       slak->m_opcode = ins->opcode;
  3807.       /* This is kludgey */
  3808.       slak->m_codenum = ((ins->match) & 0xffffL) ? 2 : 1;
  3809.       if (i + 1 != numopcodes
  3810.           && !strcmp (ins->name, opcode_ptr (i + 1)->name))
  3811.         {
  3812.           slak->m_next = (struct m68k_incant *) obstack_alloc (&robyn, sizeof (struct m68k_incant));
  3813.           i++;
  3814.         }
  3815.       else
  3816.         slak->m_next = 0;
  3817.       slak = slak->m_next;
  3818.     }
  3819.       while (slak);
  3820.  
  3821.       retval = hash_insert (op_hash, ins->name, (char *) hack);
  3822.       if (retval)
  3823.     as_bad ("Internal Error:  Can't hash %s: %s", ins->name, retval);
  3824.     }
  3825.  
  3826.   for (i = 0; i < sizeof (mklower_table); i++)
  3827.     mklower_table[i] = (isupper (c = (char) i)) ? tolower (c) : c;
  3828.  
  3829.   for (i = 0; i < sizeof (notend_table); i++)
  3830.     {
  3831.       notend_table[i] = 0;
  3832.       alt_notend_table[i] = 0;
  3833.     }
  3834.   notend_table[','] = 1;
  3835.   notend_table['{'] = 1;
  3836.   notend_table['}'] = 1;
  3837.   alt_notend_table['a'] = 1;
  3838.   alt_notend_table['A'] = 1;
  3839.   alt_notend_table['d'] = 1;
  3840.   alt_notend_table['D'] = 1;
  3841.   alt_notend_table['#'] = 1;
  3842.   alt_notend_table['f'] = 1;
  3843.   alt_notend_table['F'] = 1;
  3844. #ifdef REGISTER_PREFIX
  3845.   alt_notend_table[REGISTER_PREFIX] = 1;
  3846. #endif
  3847.  
  3848. #ifndef MIT_SYNTAX_ONLY
  3849.   /* Insert pseudo ops, these have to go into the opcode table since
  3850.      gas expects pseudo ops to start with a dot */
  3851.   {
  3852.     int n = 0;
  3853.     while (mote_pseudo_table[n].poc_name)
  3854.       {
  3855.     hack = (struct m68k_incant *)
  3856.       obstack_alloc (&robyn, sizeof (struct m68k_incant));
  3857.     hash_insert (op_hash,
  3858.              mote_pseudo_table[n].poc_name, (char *) hack);
  3859.     hack->m_operands = 0;
  3860.     hack->m_opnum = n;
  3861.     n++;
  3862.       }
  3863.   }
  3864. #endif
  3865.  
  3866.   init_regtable ();
  3867. }
  3868.  
  3869. void
  3870. m68k_init_after_args ()
  3871. {
  3872.   if (cpu_of_arch (current_architecture) == 0)
  3873.     {
  3874.       int cpu_type;
  3875.  
  3876.       if (strcmp (TARGET_CPU, "m68000") == 0
  3877.       || strcmp (TARGET_CPU, "m68302") == 0)
  3878.     cpu_type = m68000;
  3879.       else if (strcmp (TARGET_CPU, "m68010") == 0)
  3880.     cpu_type = m68010;
  3881.       else if (strcmp (TARGET_CPU, "m68020") == 0
  3882.            || strcmp (TARGET_CPU, "m68k") == 0)
  3883.     cpu_type = m68020;
  3884.       else if (strcmp (TARGET_CPU, "m68030") == 0)
  3885.     cpu_type = m68030;
  3886.       else if (strcmp (TARGET_CPU, "m68040") == 0)
  3887.     cpu_type = m68040;
  3888.       else if (strcmp (TARGET_CPU, "m68060") == 0)
  3889.     cpu_type = m68060;
  3890.       else if (strcmp (TARGET_CPU, "cpu32") == 0
  3891.            || strcmp (TARGET_CPU, "m68331") == 0
  3892.            || strcmp (TARGET_CPU, "m68332") == 0
  3893.            || strcmp (TARGET_CPU, "m68333") == 0
  3894.            || strcmp (TARGET_CPU, "m68340") == 0)
  3895.     cpu_type = cpu32;
  3896.       else
  3897.     cpu_type = m68020;
  3898.  
  3899.       current_architecture |= cpu_type;
  3900.     }
  3901. #if 0                /* Could be doing emulation.  */
  3902.   if (current_architecture & m68881)
  3903.     {
  3904.       if (current_architecture & m68000)
  3905.     as_bad ("incompatible processors 68000 and 68881/2 specified");
  3906.       if (current_architecture & m68010)
  3907.     as_bad ("incompatible processors 68010 and 68881/2 specified");
  3908.       if (current_architecture & m68040)
  3909.     as_bad ("incompatible processors 68040 and 68881/2 specified");
  3910.     }
  3911. #endif
  3912.   if (current_architecture & m68851)
  3913.     {
  3914.       if (current_architecture & m68040)
  3915.     {
  3916.       as_warn ("68040 and 68851 specified; mmu instructions may assemble incorrectly");
  3917.     }
  3918.     }
  3919.   /* What other incompatibilities could we check for?  */
  3920.  
  3921.   /* Toss in some default assumptions about coprocessors.  */
  3922.   if (!no_68881
  3923.       && (cpu_of_arch (current_architecture)
  3924.       /* Can CPU32 have a 68881 coprocessor??  */
  3925.       & (m68020 | m68030 | cpu32)))
  3926.     {
  3927.       current_architecture |= m68881;
  3928.     }
  3929.   if (!no_68851
  3930.       && (cpu_of_arch (current_architecture) & m68020up) != 0
  3931.       && (cpu_of_arch (current_architecture) & m68040up) == 0)
  3932.     {
  3933.       current_architecture |= m68851;
  3934.     }
  3935.   if (no_68881 && (current_architecture & m68881))
  3936.     as_bad ("options for 68881 and no-68881 both given");
  3937.   if (no_68851 && (current_architecture & m68851))
  3938.     as_bad ("options for 68851 and no-68851 both given");
  3939.  
  3940. #ifdef OBJ_AOUT
  3941.   /* Work out the magic number.  This isn't very general.  */
  3942.   if (current_architecture & m68000)
  3943.     m68k_aout_machtype = 0;
  3944.   else if (current_architecture & m68010)
  3945.     m68k_aout_machtype = 1;
  3946.   else if (current_architecture & m68020)
  3947.     m68k_aout_machtype = 2;
  3948.   else
  3949.     m68k_aout_machtype = 2;
  3950. #endif
  3951.  
  3952.   /* Note which set of "movec" control registers is available.  */
  3953.   switch (cpu_of_arch (current_architecture))
  3954.     {
  3955.     case m68000:
  3956.       control_regs = m68000_control_regs;
  3957.       break;
  3958.     case m68010:
  3959.       control_regs = m68010_control_regs;
  3960.       break;
  3961.     case m68020:
  3962.     case m68030:
  3963.       control_regs = m68020_control_regs;
  3964.       break;
  3965.     case m68040:
  3966.       control_regs = m68040_control_regs;
  3967.       break;
  3968.     case m68060:
  3969.       control_regs = m68060_control_regs;
  3970.       break;
  3971.     default:
  3972.       abort ();
  3973.     }
  3974. }
  3975.  
  3976. #if 0
  3977. #define notend(s) ((*s == ',' || *s == '}' || *s == '{' \
  3978.             || (*s == ':' && strchr("aAdD#", s[1]))) \
  3979.            ? 0 : 1)
  3980. #endif
  3981.  
  3982. /* Equal to MAX_PRECISION in atof-ieee.c */
  3983. #define MAX_LITTLENUMS 6
  3984.  
  3985. /* Turn a string in input_line_pointer into a floating point constant of type
  3986.    type, and store the appropriate bytes in *litP.  The number of LITTLENUMS
  3987.    emitted is stored in *sizeP .  An error message is returned, or NULL on OK.
  3988.    */
  3989. char *
  3990. md_atof (type, litP, sizeP)
  3991.      char type;
  3992.      char *litP;
  3993.      int *sizeP;
  3994. {
  3995.   int prec;
  3996.   LITTLENUM_TYPE words[MAX_LITTLENUMS];
  3997.   LITTLENUM_TYPE *wordP;
  3998.   char *t;
  3999.   char *atof_ieee ();
  4000.  
  4001.   switch (type)
  4002.     {
  4003.     case 'f':
  4004.     case 'F':
  4005.     case 's':
  4006.     case 'S':
  4007.       prec = 2;
  4008.       break;
  4009.  
  4010.     case 'd':
  4011.     case 'D':
  4012.     case 'r':
  4013.     case 'R':
  4014.       prec = 4;
  4015.       break;
  4016.  
  4017.     case 'x':
  4018.     case 'X':
  4019.       prec = 6;
  4020.       break;
  4021.  
  4022.     case 'p':
  4023.     case 'P':
  4024.       prec = 6;
  4025.       break;
  4026.  
  4027.     default:
  4028.       *sizeP = 0;
  4029.       return "Bad call to MD_ATOF()";
  4030.     }
  4031.   t = atof_ieee (input_line_pointer, type, words);
  4032.   if (t)
  4033.     input_line_pointer = t;
  4034.  
  4035.   *sizeP = prec * sizeof (LITTLENUM_TYPE);
  4036.   for (wordP = words; prec--;)
  4037.     {
  4038.       md_number_to_chars (litP, (long) (*wordP++), sizeof (LITTLENUM_TYPE));
  4039.       litP += sizeof (LITTLENUM_TYPE);
  4040.     }
  4041.   return 0;
  4042. }
  4043.  
  4044. void
  4045. md_number_to_chars (buf, val, n)
  4046.      char *buf;
  4047.      valueT val;
  4048.      int n;
  4049. {
  4050.   number_to_chars_bigendian (buf, val, n);
  4051. }
  4052.  
  4053. static void
  4054. md_apply_fix_2 (fixP, val)
  4055.      fixS *fixP;
  4056.      long val;
  4057. {
  4058.   unsigned long upper_limit;
  4059.   long lower_limit;
  4060.  
  4061.   /* This is unnecessary but it convinces the native rs6000 compiler
  4062.      to generate the code we want.  */
  4063.   char *buf = fixP->fx_frag->fr_literal;
  4064.   buf += fixP->fx_where;
  4065.   /* end ibm compiler workaround */
  4066.  
  4067.   switch (fixP->fx_size)
  4068.     {
  4069.     case 1:
  4070.       *buf++ = val;
  4071.       upper_limit = 0x7f;
  4072.       lower_limit = -0x80;
  4073.       break;
  4074.     case 2:
  4075.       *buf++ = (val >> 8);
  4076.       *buf++ = val;
  4077.       upper_limit = 0x7fff;
  4078.       lower_limit = -0x8000;
  4079.       break;
  4080.     case 4:
  4081.       *buf++ = (val >> 24);
  4082.       *buf++ = (val >> 16);
  4083.       *buf++ = (val >> 8);
  4084.       *buf++ = val;
  4085.       upper_limit = 0x7fffffff;
  4086.       lower_limit = -0x80000000;
  4087.       break;
  4088.     default:
  4089.       BAD_CASE (fixP->fx_size);
  4090.     }
  4091.  
  4092.   /* For non-pc-relative values, it's conceivable we might get something
  4093.      like "0xff" for a byte field.  So extend the upper part of the range
  4094.      to accept such numbers.  We arbitrarily disallow "-0xff" or "0xff+0xff",
  4095.      so that we can do any range checking at all.  */
  4096.   if (!fixP->fx_pcrel)
  4097.     upper_limit = upper_limit * 2 + 1;
  4098.  
  4099.   if ((unsigned) val > upper_limit && (val > 0 || val < lower_limit))
  4100.     as_bad_where (fixP->fx_file, fixP->fx_line, "value out of range");
  4101.  
  4102.   /* A one byte PC-relative reloc means a short branch.  We can't use
  4103.      a short branch with a value of 0 or -1, because those indicate
  4104.      different opcodes (branches with longer offsets).  */
  4105.   if (fixP->fx_pcrel
  4106.       && fixP->fx_size == 1
  4107.       && (fixP->fx_addsy == NULL
  4108.       || S_IS_DEFINED (fixP->fx_addsy))
  4109.       && (val == 0 || val == -1))
  4110.     as_bad_where (fixP->fx_file, fixP->fx_line, "invalid byte branch offset");
  4111. }
  4112.  
  4113. #ifdef BFD_ASSEMBLER
  4114. int
  4115. md_apply_fix (fixP, valp)
  4116.      fixS *fixP;
  4117.      long *valp;
  4118. {
  4119.   md_apply_fix_2 (fixP, *valp);
  4120.   return 1;
  4121. }
  4122. #else
  4123. void md_apply_fix (fixP, val)
  4124.      fixS *fixP;
  4125.      long val;
  4126. {
  4127.   md_apply_fix_2 (fixP, val);
  4128. }
  4129. #endif
  4130.  
  4131. /* *fragP has been relaxed to its final size, and now needs to have
  4132.    the bytes inside it modified to conform to the new size  There is UGLY
  4133.    MAGIC here. ..
  4134.    */
  4135. void
  4136. md_convert_frag_1 (fragP)
  4137.      register fragS *fragP;
  4138. {
  4139.   long disp;
  4140.   long ext = 0;
  4141.  
  4142.   /* Address in object code of the displacement.  */
  4143.   register int object_address = fragP->fr_fix + fragP->fr_address;
  4144.  
  4145.   /* Address in gas core of the place to store the displacement.  */
  4146.   /* This convinces the native rs6000 compiler to generate the code we
  4147.      want. */
  4148.   register char *buffer_address = fragP->fr_literal;
  4149.   buffer_address += fragP->fr_fix;
  4150.   /* end ibm compiler workaround */
  4151.  
  4152.   /* The displacement of the address, from current location.  */
  4153.   disp = fragP->fr_symbol ? S_GET_VALUE (fragP->fr_symbol) : 0;
  4154.   disp = (disp + fragP->fr_offset) - object_address;
  4155.  
  4156.   switch (fragP->fr_subtype)
  4157.     {
  4158.     case TAB (BCC68000, BYTE):
  4159.     case TAB (ABRANCH, BYTE):
  4160.       know (issbyte (disp));
  4161.       if (disp == 0)
  4162.     as_bad ("short branch with zero offset: use :w");
  4163.       fragP->fr_opcode[1] = disp;
  4164.       ext = 0;
  4165.       break;
  4166.     case TAB (DBCC, SHORT):
  4167.       know (issword (disp));
  4168.       ext = 2;
  4169.       break;
  4170.     case TAB (BCC68000, SHORT):
  4171.     case TAB (ABRANCH, SHORT):
  4172.       know (issword (disp));
  4173.       fragP->fr_opcode[1] = 0x00;
  4174.       ext = 2;
  4175.       break;
  4176.     case TAB (ABRANCH, LONG):
  4177.       if (cpu_of_arch (current_architecture) < m68020)
  4178.     {
  4179.       if (fragP->fr_opcode[0] == 0x61)
  4180.         {
  4181.           fragP->fr_opcode[0] = 0x4E;
  4182.           fragP->fr_opcode[1] = (char) 0xB9; /* JBSR with ABSL LONG offset */
  4183.           subseg_change (text_section, 0); /* @@ */
  4184.  
  4185.           fix_new (fragP,
  4186.                fragP->fr_fix,
  4187.                4,
  4188.                fragP->fr_symbol,
  4189.                fragP->fr_offset,
  4190.                0,
  4191.                NO_RELOC);
  4192.  
  4193.           fragP->fr_fix += 4;
  4194.           ext = 0;
  4195.         }
  4196.       else if (fragP->fr_opcode[0] == 0x60)
  4197.         {
  4198.           fragP->fr_opcode[0] = 0x4E;
  4199.           fragP->fr_opcode[1] = (char) 0xF9; /* JMP  with ABSL LONG offset */
  4200.           subseg_change (text_section, 0); /* @@ */
  4201.           fix_new (fragP, fragP->fr_fix, 4, fragP->fr_symbol,
  4202.                fragP->fr_offset, 0, NO_RELOC);
  4203.           fragP->fr_fix += 4;
  4204.           ext = 0;
  4205.         }
  4206.       else
  4207.         {
  4208.           as_bad ("Long branch offset not supported.");
  4209.         }
  4210.     }
  4211.       else
  4212.     {
  4213.       fragP->fr_opcode[1] = (char) 0xff;
  4214.       ext = 4;
  4215.     }
  4216.       break;
  4217.     case TAB (BCC68000, LONG):
  4218.       /* only Bcc 68000 instructions can come here */
  4219.       /* change bcc into b!cc/jmp absl long */
  4220.       fragP->fr_opcode[0] ^= 0x01;    /* invert bcc */
  4221.       fragP->fr_opcode[1] = 0x6;/* branch offset = 6 */
  4222.  
  4223.       /* JF: these used to be fr_opcode[2,3], but they may be in a
  4224.        different frag, in which case refering to them is a no-no.
  4225.        Only fr_opcode[0,1] are guaranteed to work. */
  4226.       *buffer_address++ = 0x4e;    /* put in jmp long (0x4ef9) */
  4227.       *buffer_address++ = (char) 0xf9;
  4228.       fragP->fr_fix += 2;    /* account for jmp instruction */
  4229.       subseg_change (text_section, 0);
  4230.       fix_new (fragP, fragP->fr_fix, 4, fragP->fr_symbol,
  4231.            fragP->fr_offset, 0, NO_RELOC);
  4232.       fragP->fr_fix += 4;
  4233.       ext = 0;
  4234.       break;
  4235.     case TAB (DBCC, LONG):
  4236.       /* only DBcc 68000 instructions can come here */
  4237.       /* change dbcc into dbcc/jmp absl long */
  4238.       /* JF: these used to be fr_opcode[2-7], but that's wrong */
  4239.       *buffer_address++ = 0x00;    /* branch offset = 4 */
  4240.       *buffer_address++ = 0x04;
  4241.       *buffer_address++ = 0x60;    /* put in bra pc+6 */
  4242.       *buffer_address++ = 0x06;
  4243.       *buffer_address++ = 0x4e;    /* put in jmp long (0x4ef9) */
  4244.       *buffer_address++ = (char) 0xf9;
  4245.  
  4246.       fragP->fr_fix += 6;    /* account for bra/jmp instructions */
  4247.       subseg_change (text_section, 0);
  4248.       fix_new (fragP, fragP->fr_fix, 4, fragP->fr_symbol,
  4249.            fragP->fr_offset, 0, NO_RELOC);
  4250.       fragP->fr_fix += 4;
  4251.       ext = 0;
  4252.       break;
  4253.     case TAB (FBRANCH, SHORT):
  4254.       know ((fragP->fr_opcode[1] & 0x40) == 0);
  4255.       ext = 2;
  4256.       break;
  4257.     case TAB (FBRANCH, LONG):
  4258.       fragP->fr_opcode[1] |= 0x40;    /* Turn on LONG bit */
  4259.       ext = 4;
  4260.       break;
  4261.     case TAB (PCREL, SHORT):
  4262.       ext = 2;
  4263.       break;
  4264.     case TAB (PCREL, LONG):
  4265.       /* The thing to do here is force it to ABSOLUTE LONG, since
  4266.     PCREL is really trying to shorten an ABSOLUTE address anyway */
  4267.       /* JF FOO This code has not been tested */
  4268.       subseg_change (text_section, 0);
  4269.       fix_new (fragP, fragP->fr_fix, 4, fragP->fr_symbol, fragP->fr_offset,
  4270.            0, NO_RELOC);
  4271.       if ((fragP->fr_opcode[1] & 0x3F) != 0x3A)
  4272.     as_bad ("Internal error (long PC-relative operand) for insn 0x%04x at 0x%lx",
  4273.         (unsigned) fragP->fr_opcode[0],
  4274.         (unsigned long) fragP->fr_address);
  4275.       fragP->fr_opcode[1] &= ~0x3F;
  4276.       fragP->fr_opcode[1] |= 0x39;    /* Mode 7.1 */
  4277.       fragP->fr_fix += 4;
  4278.       ext = 0;
  4279.       break;
  4280.     case TAB (PCLEA, SHORT):
  4281.       subseg_change (text_section, 0);
  4282.       fix_new (fragP, (int) (fragP->fr_fix), 2, fragP->fr_symbol,
  4283.            fragP->fr_offset, 1, NO_RELOC);
  4284.       fragP->fr_opcode[1] &= ~0x3F;
  4285.       fragP->fr_opcode[1] |= 0x3A;
  4286.       ext = 2;
  4287.       break;
  4288.     case TAB (PCLEA, LONG):
  4289.       subseg_change (text_section, 0);
  4290.       fix_new (fragP, (int) (fragP->fr_fix) + 2, 4, fragP->fr_symbol,
  4291.            fragP->fr_offset + 2, 1, NO_RELOC);
  4292.       *buffer_address++ = 0x01;
  4293.       *buffer_address++ = 0x70;
  4294.       fragP->fr_fix += 2;
  4295.       ext = 4;
  4296.       break;
  4297.     }
  4298.  
  4299.   if (ext)
  4300.     {
  4301.       md_number_to_chars (buffer_address, (long) disp, (int) ext);
  4302.       fragP->fr_fix += ext;
  4303.     }
  4304. }
  4305.  
  4306. #ifndef BFD_ASSEMBLER
  4307.  
  4308. void
  4309. md_convert_frag (headers, fragP)
  4310.      object_headers *headers;
  4311.      fragS *fragP;
  4312. {
  4313.   md_convert_frag_1 (fragP);
  4314. }
  4315.  
  4316. #else
  4317.  
  4318. void
  4319. md_convert_frag (abfd, sec, fragP)
  4320.      bfd *abfd;
  4321.      asection sec;
  4322.      fragS *fragP;
  4323. {
  4324.   md_convert_frag_1 (fragP);
  4325. }
  4326. #endif
  4327.  
  4328. /* Force truly undefined symbols to their maximum size, and generally set up
  4329.    the frag list to be relaxed
  4330.    */
  4331. int
  4332. md_estimate_size_before_relax (fragP, segment)
  4333.      register fragS *fragP;
  4334.      segT segment;
  4335. {
  4336.   int old_fix;
  4337.   register char *buffer_address = fragP->fr_fix + fragP->fr_literal;
  4338.  
  4339.   old_fix = fragP->fr_fix;
  4340.  
  4341.   /* handle SZ_UNDEF first, it can be changed to BYTE or SHORT */
  4342.   switch (fragP->fr_subtype)
  4343.     {
  4344.  
  4345.     case TAB (ABRANCH, SZ_UNDEF):
  4346.       {
  4347.     if ((fragP->fr_symbol != NULL)    /* Not absolute */
  4348.         && S_GET_SEGMENT (fragP->fr_symbol) == segment)
  4349.       {
  4350.         fragP->fr_subtype = TAB (TABTYPE (fragP->fr_subtype), BYTE);
  4351.         break;
  4352.       }
  4353.     else if ((fragP->fr_symbol == 0) || (cpu_of_arch (current_architecture) < m68020))
  4354.       {
  4355.         /* On 68000, or for absolute value, switch to abs long */
  4356.         /* FIXME, we should check abs val, pick short or long */
  4357.         if (fragP->fr_opcode[0] == 0x61)
  4358.           {
  4359.         fragP->fr_opcode[0] = 0x4E;
  4360.         fragP->fr_opcode[1] = (char) 0xB9; /* JBSR with ABSL LONG offset */
  4361.         subseg_change (text_section, 0);
  4362.         fix_new (fragP, fragP->fr_fix, 4,
  4363.              fragP->fr_symbol, fragP->fr_offset, 0, NO_RELOC);
  4364.         fragP->fr_fix += 4;
  4365.         frag_wane (fragP);
  4366.           }
  4367.         else if (fragP->fr_opcode[0] == 0x60)
  4368.           {
  4369.         fragP->fr_opcode[0] = 0x4E;
  4370.         fragP->fr_opcode[1] = (char) 0xF9; /* JMP  with ABSL LONG offset */
  4371.         subseg_change (text_section, 0);
  4372.         fix_new (fragP, fragP->fr_fix, 4,
  4373.              fragP->fr_symbol, fragP->fr_offset, 0, NO_RELOC);
  4374.         fragP->fr_fix += 4;
  4375.         frag_wane (fragP);
  4376.           }
  4377.         else
  4378.           {
  4379.         as_warn ("Long branch offset to extern symbol not supported.");
  4380.           }
  4381.       }
  4382.     else
  4383.       {            /* Symbol is still undefined.  Make it simple */
  4384.         fix_new (fragP, (int) (fragP->fr_fix), 4, fragP->fr_symbol,
  4385.              fragP->fr_offset + 4, 1, NO_RELOC);
  4386.         fragP->fr_fix += 4;
  4387.         fragP->fr_opcode[1] = (char) 0xff;
  4388.         frag_wane (fragP);
  4389.         break;
  4390.       }
  4391.  
  4392.     break;
  4393.       }                /* case TAB(ABRANCH,SZ_UNDEF) */
  4394.  
  4395.     case TAB (FBRANCH, SZ_UNDEF):
  4396.       {
  4397.     if (S_GET_SEGMENT (fragP->fr_symbol) == segment || flag_short_refs)
  4398.       {
  4399.         fragP->fr_subtype = TAB (FBRANCH, SHORT);
  4400.         fragP->fr_var += 2;
  4401.       }
  4402.     else
  4403.       {
  4404.         fragP->fr_subtype = TAB (FBRANCH, LONG);
  4405.         fragP->fr_var += 4;
  4406.       }
  4407.     break;
  4408.       }                /* TAB(FBRANCH,SZ_UNDEF) */
  4409.  
  4410.     case TAB (PCREL, SZ_UNDEF):
  4411.       {
  4412.     if (S_GET_SEGMENT (fragP->fr_symbol) == segment || flag_short_refs)
  4413.       {
  4414.         fragP->fr_subtype = TAB (PCREL, SHORT);
  4415.         fragP->fr_var += 2;
  4416.       }
  4417.     else
  4418.       {
  4419.         fragP->fr_subtype = TAB (PCREL, LONG);
  4420.         fragP->fr_var += 4;
  4421.       }
  4422.     break;
  4423.       }                /* TAB(PCREL,SZ_UNDEF) */
  4424.  
  4425.     case TAB (BCC68000, SZ_UNDEF):
  4426.       {
  4427.     if ((fragP->fr_symbol != NULL)
  4428.         && S_GET_SEGMENT (fragP->fr_symbol) == segment)
  4429.       {
  4430.         fragP->fr_subtype = TAB (BCC68000, BYTE);
  4431.         break;
  4432.       }
  4433.     /* only Bcc 68000 instructions can come here */
  4434.     /* change bcc into b!cc/jmp absl long */
  4435.     fragP->fr_opcode[0] ^= 0x01;    /* invert bcc */
  4436.     if (flag_short_refs)
  4437.       {
  4438.         fragP->fr_opcode[1] = 0x04;    /* branch offset = 6 */
  4439.         /* JF: these were fr_opcode[2,3] */
  4440.         buffer_address[0] = 0x4e;    /* put in jmp long (0x4ef9) */
  4441.         buffer_address[1] = (char) 0xf8;
  4442.         fragP->fr_fix += 2;    /* account for jmp instruction */
  4443.         subseg_change (text_section, 0);
  4444.         fix_new (fragP, fragP->fr_fix, 2, fragP->fr_symbol,
  4445.              fragP->fr_offset, 0, NO_RELOC);
  4446.         fragP->fr_fix += 2;
  4447.       }
  4448.     else
  4449.       {
  4450.         fragP->fr_opcode[1] = 0x06;    /* branch offset = 6 */
  4451.         /* JF: these were fr_opcode[2,3] */
  4452.         buffer_address[0] = 0x4e;    /* put in jmp long (0x4ef9) */
  4453.         buffer_address[1] = (char) 0xf9;
  4454.         fragP->fr_fix += 2;    /* account for jmp instruction */
  4455.         subseg_change (text_section, 0);
  4456.         fix_new (fragP, fragP->fr_fix, 4, fragP->fr_symbol,
  4457.              fragP->fr_offset, 0, NO_RELOC);
  4458.         fragP->fr_fix += 4;
  4459.       }
  4460.     frag_wane (fragP);
  4461.     break;
  4462.       }                /* case TAB(BCC68000,SZ_UNDEF) */
  4463.  
  4464.     case TAB (DBCC, SZ_UNDEF):
  4465.       {
  4466.     if (fragP->fr_symbol != NULL && S_GET_SEGMENT (fragP->fr_symbol) == segment)
  4467.       {
  4468.         fragP->fr_subtype = TAB (DBCC, SHORT);
  4469.         fragP->fr_var += 2;
  4470.         break;
  4471.       }
  4472.     /* only DBcc 68000 instructions can come here */
  4473.     /* change dbcc into dbcc/jmp absl long */
  4474.     /* JF: these used to be fr_opcode[2-4], which is wrong. */
  4475.     buffer_address[0] = 0x00;    /* branch offset = 4 */
  4476.     buffer_address[1] = 0x04;
  4477.     buffer_address[2] = 0x60;    /* put in bra pc + ... */
  4478.  
  4479.     if (flag_short_refs)
  4480.       {
  4481.         /* JF: these were fr_opcode[5-7] */
  4482.         buffer_address[3] = 0x04;    /* plus 4 */
  4483.         buffer_address[4] = 0x4e;    /* Put in Jump Word */
  4484.         buffer_address[5] = (char) 0xf8;
  4485.         fragP->fr_fix += 6;    /* account for bra/jmp instruction */
  4486.         subseg_change (text_section, 0);
  4487.         fix_new (fragP, fragP->fr_fix, 2, fragP->fr_symbol,
  4488.              fragP->fr_offset, 0, NO_RELOC);
  4489.         fragP->fr_fix += 2;
  4490.       }
  4491.     else
  4492.       {
  4493.         /* JF: these were fr_opcode[5-7] */
  4494.         buffer_address[3] = 0x06;    /* Plus 6 */
  4495.         buffer_address[4] = 0x4e;    /* put in jmp long (0x4ef9) */
  4496.         buffer_address[5] = (char) 0xf9;
  4497.         fragP->fr_fix += 6;    /* account for bra/jmp instruction */
  4498.         subseg_change (text_section, 0);
  4499.         fix_new (fragP, fragP->fr_fix, 4, fragP->fr_symbol,
  4500.              fragP->fr_offset, 0, NO_RELOC);
  4501.         fragP->fr_fix += 4;
  4502.       }
  4503.  
  4504.     frag_wane (fragP);
  4505.     break;
  4506.       }                /* case TAB(DBCC,SZ_UNDEF) */
  4507.  
  4508.     case TAB (PCLEA, SZ_UNDEF):
  4509.       {
  4510.     if ((S_GET_SEGMENT (fragP->fr_symbol)) == segment || flag_short_refs)
  4511.       {
  4512.         fragP->fr_subtype = TAB (PCLEA, SHORT);
  4513.         fragP->fr_var += 2;
  4514.       }
  4515.     else
  4516.       {
  4517.         fragP->fr_subtype = TAB (PCLEA, LONG);
  4518.         fragP->fr_var += 6;
  4519.       }
  4520.     break;
  4521.       }                /* TAB(PCLEA,SZ_UNDEF) */
  4522.  
  4523.     default:
  4524.       break;
  4525.  
  4526.     }                /* switch on subtype looking for SZ_UNDEF's. */
  4527.  
  4528.   /* now that SZ_UNDEF are taken care of, check others */
  4529.   switch (fragP->fr_subtype)
  4530.     {
  4531.     case TAB (BCC68000, BYTE):
  4532.     case TAB (ABRANCH, BYTE):
  4533.       /* We can't do a short jump to the next instruction,
  4534.        so we force word mode.  */
  4535.       if (fragP->fr_symbol && S_GET_VALUE (fragP->fr_symbol) == 0 &&
  4536.       fragP->fr_symbol->sy_frag == fragP->fr_next)
  4537.     {
  4538.       fragP->fr_subtype = TAB (TABTYPE (fragP->fr_subtype), SHORT);
  4539.       fragP->fr_var += 2;
  4540.     }
  4541.       break;
  4542.     default:
  4543.       break;
  4544.     }
  4545.   return fragP->fr_var + fragP->fr_fix - old_fix;
  4546. }
  4547.  
  4548. #if defined(OBJ_AOUT) | defined(OBJ_BOUT)
  4549. /* the bit-field entries in the relocation_info struct plays hell
  4550.    with the byte-order problems of cross-assembly.  So as a hack,
  4551.    I added this mach. dependent ri twiddler.  Ugly, but it gets
  4552.    you there. -KWK */
  4553. /* on m68k: first 4 bytes are normal unsigned long, next three bytes
  4554.    are symbolnum, most sig. byte first.  Last byte is broken up with
  4555.    bit 7 as pcrel, bits 6 & 5 as length, bit 4 as pcrel, and the lower
  4556.    nibble as nuthin. (on Sun 3 at least) */
  4557. /* Translate the internal relocation information into target-specific
  4558.    format. */
  4559. #ifdef comment
  4560. void
  4561. md_ri_to_chars (the_bytes, ri)
  4562.      char *the_bytes;
  4563.      struct reloc_info_generic *ri;
  4564. {
  4565.   /* this is easy */
  4566.   md_number_to_chars (the_bytes, ri->r_address, 4);
  4567.   /* now the fun stuff */
  4568.   the_bytes[4] = (ri->r_symbolnum >> 16) & 0x0ff;
  4569.   the_bytes[5] = (ri->r_symbolnum >> 8) & 0x0ff;
  4570.   the_bytes[6] = ri->r_symbolnum & 0x0ff;
  4571.   the_bytes[7] = (((ri->r_pcrel << 7) & 0x80) | ((ri->r_length << 5) & 0x60) |
  4572.           ((ri->r_extern << 4) & 0x10));
  4573. }
  4574.  
  4575. #endif /* comment */
  4576.  
  4577. #ifndef BFD_ASSEMBLER
  4578. void
  4579. tc_aout_fix_to_chars (where, fixP, segment_address_in_file)
  4580.      char *where;
  4581.      fixS *fixP;
  4582.      relax_addressT segment_address_in_file;
  4583. {
  4584.   /*
  4585.    * In: length of relocation (or of address) in chars: 1, 2 or 4.
  4586.    * Out: GNU LD relocation length code: 0, 1, or 2.
  4587.    */
  4588.  
  4589.   static CONST unsigned char nbytes_r_length[] = {42, 0, 1, 42, 2};
  4590.   long r_symbolnum;
  4591.  
  4592.   know (fixP->fx_addsy != NULL);
  4593.  
  4594.   md_number_to_chars (where,
  4595.        fixP->fx_frag->fr_address + fixP->fx_where - segment_address_in_file,
  4596.               4);
  4597.  
  4598.   r_symbolnum = (S_IS_DEFINED (fixP->fx_addsy)
  4599.          ? S_GET_TYPE (fixP->fx_addsy)
  4600.          : fixP->fx_addsy->sy_number);
  4601.  
  4602.   where[4] = (r_symbolnum >> 16) & 0x0ff;
  4603.   where[5] = (r_symbolnum >> 8) & 0x0ff;
  4604.   where[6] = r_symbolnum & 0x0ff;
  4605.   where[7] = (((fixP->fx_pcrel << 7) & 0x80) | ((nbytes_r_length[fixP->fx_size] << 5) & 0x60) |
  4606.           (((!S_IS_DEFINED (fixP->fx_addsy)) << 4) & 0x10));
  4607. }
  4608. #endif
  4609.  
  4610. #endif /* OBJ_AOUT or OBJ_BOUT */
  4611.  
  4612. #ifndef WORKING_DOT_WORD
  4613. CONST int md_short_jump_size = 4;
  4614. CONST int md_long_jump_size = 6;
  4615.  
  4616. void
  4617. md_create_short_jump (ptr, from_addr, to_addr, frag, to_symbol)
  4618.      char *ptr;
  4619.      addressT from_addr, to_addr;
  4620.      fragS *frag;
  4621.      symbolS *to_symbol;
  4622. {
  4623.   valueT offset;
  4624.  
  4625.   offset = to_addr - (from_addr + 2);
  4626.  
  4627.   md_number_to_chars (ptr, (valueT) 0x6000, 2);
  4628.   md_number_to_chars (ptr + 2, (valueT) offset, 2);
  4629. }
  4630.  
  4631. void
  4632. md_create_long_jump (ptr, from_addr, to_addr, frag, to_symbol)
  4633.      char *ptr;
  4634.      addressT from_addr, to_addr;
  4635.      fragS *frag;
  4636.      symbolS *to_symbol;
  4637. {
  4638.   valueT offset;
  4639.  
  4640.   if (cpu_of_arch (current_architecture) < m68020)
  4641.     {
  4642.       offset = to_addr - S_GET_VALUE (to_symbol);
  4643.       md_number_to_chars (ptr, (valueT) 0x4EF9, 2);
  4644.       md_number_to_chars (ptr + 2, (valueT) offset, 4);
  4645.       fix_new (frag, (ptr + 2) - frag->fr_literal, 4, to_symbol, (offsetT) 0,
  4646.            0, NO_RELOC);
  4647.     }
  4648.   else
  4649.     {
  4650.       offset = to_addr - (from_addr + 2);
  4651.       md_number_to_chars (ptr, (valueT) 0x60ff, 2);
  4652.       md_number_to_chars (ptr + 2, (valueT) offset, 4);
  4653.     }
  4654. }
  4655.  
  4656. #endif
  4657. /* Different values of OK tell what its OK to return.  Things that aren't OK are an error (what a shock, no?)
  4658.  
  4659.    0:  Everything is OK
  4660.    10:  Absolute 1:8    only
  4661.    20:  Absolute 0:7    only
  4662.    30:  absolute 0:15    only
  4663.    40:  Absolute 0:31    only
  4664.    50:  absolute 0:127    only
  4665.    55:  absolute -64:63    only
  4666.    60:  absolute -128:127    only
  4667.    70:  absolute 0:4095    only
  4668.    80:  No bignums
  4669.  
  4670.    */
  4671.  
  4672. static int
  4673. get_num (exp, ok)
  4674.      struct m68k_exp *exp;
  4675.      int ok;
  4676. {
  4677. #ifdef TEST2
  4678.   long l = 0;
  4679.  
  4680.   if (!exp->e_beg)
  4681.     return 0;
  4682.   if (*exp->e_beg == '0')
  4683.     {
  4684.       if (exp->e_beg[1] == 'x')
  4685.     sscanf (exp->e_beg + 2, "%x", &l);
  4686.       else
  4687.     sscanf (exp->e_beg + 1, "%O", &l);
  4688.       return l;
  4689.     }
  4690.   return atol (exp->e_beg);
  4691. #else
  4692.   char *save_in;
  4693.   char c_save;
  4694.   segT section;
  4695.  
  4696.   if (!exp)
  4697.     {
  4698.       /* Can't do anything */
  4699.       return 0;
  4700.     }
  4701.   if (!exp->e_beg || !exp->e_end)
  4702.     {
  4703.       seg (exp) = absolute_section;
  4704.       adds (exp) = 0;
  4705.       subs (exp) = 0;
  4706.       offs (exp) = (ok == 10) ? 1 : 0;
  4707.       as_warn ("Null expression defaults to %ld", offs (exp));
  4708.       return 0;
  4709.     }
  4710.  
  4711.   exp->e_siz = 0;
  4712.   if ( /* ok!=80 && */ (exp->e_end[-1] == ':' || exp->e_end[-1] == '.')
  4713.       && (exp->e_end - exp->e_beg) >= 2)
  4714.     {
  4715.       switch (exp->e_end[0])
  4716.     {
  4717.     case 's':
  4718.     case 'S':
  4719.     case 'b':
  4720.     case 'B':
  4721.       exp->e_siz = 1;
  4722.       exp->e_end -= 2;
  4723.       break;
  4724.     case 'w':
  4725.     case 'W':
  4726.       exp->e_siz = 2;
  4727.       exp->e_end -= 2;
  4728.       break;
  4729.     case 'l':
  4730.     case 'L':
  4731.       exp->e_siz = 3;
  4732.       exp->e_end -= 2;
  4733.       break;
  4734.     default:
  4735.       if (exp->e_end[-1] == ':')
  4736.         as_bad ("Unknown size for expression \"%c\"", exp->e_end[0]);
  4737.       break;
  4738.     }
  4739.     }
  4740.   c_save = exp->e_end[1];
  4741.   exp->e_end[1] = '\0';
  4742.   save_in = input_line_pointer;
  4743.   input_line_pointer = exp->e_beg;
  4744.   section = expression (&exp->e_exp);
  4745.   seg (exp) = section;
  4746.   if (exp->e_exp.X_op == O_absent)
  4747.     {
  4748.       /* Do the same thing the VAX asm does */
  4749.       seg (exp) = absolute_section;
  4750.       op (exp) = O_constant;
  4751.       adds (exp) = 0;
  4752.       subs (exp) = 0;
  4753.       offs (exp) = 0;
  4754.       if (ok == 10)
  4755.     {
  4756.       as_warn ("expression out of range: defaulting to 1");
  4757.       offs (exp) = 1;
  4758.     }
  4759.     }
  4760.   else if (exp->e_exp.X_op == O_constant)
  4761.     {
  4762.       switch (ok)
  4763.     {
  4764.     case 10:
  4765.       if (offs (exp) < 1 || offs (exp) > 8)
  4766.         {
  4767.           as_warn ("expression out of range: defaulting to 1");
  4768.           offs (exp) = 1;
  4769.         }
  4770.       break;
  4771.     case 20:
  4772.       if (offs (exp) < 0 || offs (exp) > 7)
  4773.         goto outrange;
  4774.       break;
  4775.     case 30:
  4776.       if (offs (exp) < 0 || offs (exp) > 15)
  4777.         goto outrange;
  4778.       break;
  4779.     case 40:
  4780.       if (offs (exp) < 0 || offs (exp) > 32)
  4781.         goto outrange;
  4782.       break;
  4783.     case 50:
  4784.       if (offs (exp) < 0 || offs (exp) > 127)
  4785.         goto outrange;
  4786.       break;
  4787.     case 55:
  4788.       if (offs (exp) < -64 || offs (exp) > 63)
  4789.         goto outrange;
  4790.       break;
  4791.     case 60:
  4792.       if (offs (exp) < -128 || offs (exp) > 127)
  4793.         goto outrange;
  4794.       break;
  4795.     case 70:
  4796.       if (offs (exp) < 0 || offs (exp) > 4095)
  4797.         {
  4798.         outrange:
  4799.           as_warn ("expression out of range: defaulting to 0");
  4800.           offs (exp) = 0;
  4801.         }
  4802.       break;
  4803.     default:
  4804.       break;
  4805.     }
  4806.     }
  4807.   else if (exp->e_exp.X_op == O_big)
  4808.     {
  4809.       if (offs (exp) <= 0    /* flonum */
  4810.       && (ok == 80        /* no bignums */
  4811.           || (ok > 10    /* small-int ranges including 0 ok */
  4812.           /* If we have a flonum zero, a zero integer should
  4813.              do as well (e.g., in moveq).  */
  4814.           && generic_floating_point_number.exponent == 0
  4815.           && generic_floating_point_number.low[0] == 0)))
  4816.     {
  4817.       /* HACK! Turn it into a long */
  4818.       LITTLENUM_TYPE words[6];
  4819.  
  4820.       gen_to_words (words, 2, 8L);    /* These numbers are magic! */
  4821.       seg (exp) = absolute_section;
  4822.       op (exp) = O_constant;
  4823.       adds (exp) = 0;
  4824.       subs (exp) = 0;
  4825.       offs (exp) = words[1] | (words[0] << 16);
  4826.     }
  4827.       else if (ok != 0)
  4828.     {
  4829.       seg (exp) = absolute_section;
  4830.       op (exp) = O_constant;
  4831.       adds (exp) = 0;
  4832.       subs (exp) = 0;
  4833.       offs (exp) = (ok == 10) ? 1 : 0;
  4834.       as_warn ("Can't deal with expression \"%s\": defaulting to %ld", exp->e_beg, offs (exp));
  4835.     }
  4836.     }
  4837.   else
  4838.     {
  4839.       if (ok >= 10 && ok <= 70)
  4840.     {
  4841.       seg (exp) = absolute_section;
  4842.       op (exp) = O_constant;
  4843.       adds (exp) = 0;
  4844.       subs (exp) = 0;
  4845.       offs (exp) = (ok == 10) ? 1 : 0;
  4846.       as_warn ("Can't deal with expression \"%s\": defaulting to %ld", exp->e_beg, offs (exp));
  4847.     }
  4848.     }
  4849.  
  4850.   if (input_line_pointer != exp->e_end + 1)
  4851.     as_bad ("Ignoring junk after expression");
  4852.   exp->e_end[1] = c_save;
  4853.   input_line_pointer = save_in;
  4854.   if (exp->e_siz)
  4855.     {
  4856.       switch (exp->e_siz)
  4857.     {
  4858.     case 1:
  4859.       if (!isbyte (offs (exp)))
  4860.         as_warn ("expression doesn't fit in BYTE");
  4861.       break;
  4862.     case 2:
  4863.       if (!isword (offs (exp)))
  4864.         as_warn ("expression doesn't fit in WORD");
  4865.       break;
  4866.     }
  4867.     }
  4868.   return offs (exp);
  4869. #endif
  4870. }
  4871.  
  4872. /* These are the back-ends for the various machine dependent pseudo-ops.  */
  4873. void demand_empty_rest_of_line ();    /* Hate those extra verbose names */
  4874.  
  4875. static void
  4876. s_data1 (ignore)
  4877.      int ignore;
  4878. {
  4879.   subseg_set (data_section, 1);
  4880.   demand_empty_rest_of_line ();
  4881. }
  4882.  
  4883. static void
  4884. s_data2 (ignore)
  4885.      int ignore;
  4886. {
  4887.   subseg_set (data_section, 2);
  4888.   demand_empty_rest_of_line ();
  4889. }
  4890.  
  4891. static void
  4892. s_bss (ignore)
  4893.      int ignore;
  4894. {
  4895.   /* We don't support putting frags in the BSS segment, we fake it
  4896.      by marking in_bss, then looking at s_skip for clues.  */
  4897.  
  4898.   subseg_set (bss_section, 0);
  4899.   demand_empty_rest_of_line ();
  4900. }
  4901.  
  4902. static void
  4903. s_even (ignore)
  4904.      int ignore;
  4905. {
  4906.   register int temp;
  4907.   register long temp_fill;
  4908.  
  4909.   temp = 1;            /* JF should be 2? */
  4910.   temp_fill = get_absolute_expression ();
  4911.   if (!need_pass_2)        /* Never make frag if expect extra pass. */
  4912.     frag_align (temp, (int) temp_fill);
  4913.   demand_empty_rest_of_line ();
  4914. }
  4915.  
  4916. static void
  4917. s_proc (ignore)
  4918.      int ignore;
  4919. {
  4920.   demand_empty_rest_of_line ();
  4921. }
  4922.  
  4923. /* s_space is defined in read.c .skip is simply an alias to it. */
  4924.  
  4925.  
  4926. /*
  4927.  * md_parse_option
  4928.  *    Invocation line includes a switch not recognized by the base assembler.
  4929.  *    See if it's a processor-specific option.  These are:
  4930.  *
  4931.  *    -[A]m[c]68000, -[A]m[c]68008, -[A]m[c]68010, -[A]m[c]68020, -[A]m[c]68030, -[A]m[c]68040
  4932.  *    -[A]m[c]68881, -[A]m[c]68882, -[A]m[c]68851
  4933.  *        Select the architecture.  Instructions or features not
  4934.  *        supported by the selected architecture cause fatal
  4935.  *        errors.  More than one may be specified.  The default is
  4936.  *        -m68020 -m68851 -m68881.  Note that -m68008 is a synonym
  4937.  *        for -m68000, and -m68882 is a synonym for -m68881.
  4938.  *    -[A]m[c]no-68851, -[A]m[c]no-68881
  4939.  *        Don't accept 688?1 instructions.  (The "c" is kind of silly,
  4940.  *        so don't use or document it, but that's the way the parsing
  4941.  *        works).
  4942.  *
  4943.  *    -pic    Indicates PIC.
  4944.  *    -k    Indicates PIC.  (Sun 3 only.)
  4945.  *
  4946.  * MAYBE_FLOAT_TOO is defined below so that specifying a processor type
  4947.  * (e.g. m68020) also requests that float instructions be included.  This
  4948.  * is the default setup, mostly to avoid hassling users.  A better
  4949.  * rearrangement of this structure would be to add an option to DENY
  4950.  * floating point opcodes, for people who want to really know there's none
  4951.  * of that funny floaty stuff going on.  FIXME-later.
  4952.  */
  4953. #ifndef MAYBE_FLOAT_TOO
  4954. #define    MAYBE_FLOAT_TOO    /* m68881 */ 0    /* this is handled later */
  4955. #endif
  4956.  
  4957. CONST char *md_shortopts = "lSA:m:k";
  4958. struct option md_longopts[] = {
  4959. #define OPTION_PIC (OPTION_MD_BASE)
  4960.   {"pic", no_argument, NULL, OPTION_PIC},
  4961. #define OPTION_REGISTER_PREFIX_OPTIONAL (OPTION_MD_BASE + 1)
  4962.   {"register-prefix-optional", no_argument, NULL,
  4963.      OPTION_REGISTER_PREFIX_OPTIONAL},
  4964.   {NULL, no_argument, NULL, 0}
  4965. };
  4966. size_t md_longopts_size = sizeof(md_longopts);
  4967.  
  4968. int
  4969. md_parse_option (c, arg)
  4970.      int c;
  4971.      char *arg;
  4972. {
  4973.   switch (c)
  4974.     {
  4975.     case 'l':            /* -l means keep external to 2 bit offset
  4976.                    rather than 16 bit one */
  4977.       flag_short_refs = 1;
  4978.       break;
  4979.  
  4980.     case 'S':            /* -S means that jbsr's always turn into
  4981.                    jsr's.  */
  4982.       flag_long_jumps = 1;
  4983.       break;
  4984.  
  4985.     case 'A':
  4986.       if (*arg == 'm')
  4987.      arg++;
  4988.       /* intentional fall-through */
  4989.     case 'm':
  4990.       if (*arg == 'c')
  4991.      arg++;
  4992.  
  4993.       if (!strcmp (arg, "68000")
  4994.       || !strcmp (arg, "68008")
  4995.       || !strcmp (arg, "68302"))
  4996.     {
  4997.       current_architecture &=~ m68000up;
  4998.       current_architecture |= m68000;
  4999.     }
  5000.       else if (!strcmp (arg, "68010"))
  5001.     {
  5002.       current_architecture &=~ m68000up;
  5003.       current_architecture |= m68010;
  5004.     }
  5005.       else if (!strcmp (arg, "68020"))
  5006.     {
  5007.       current_architecture &=~ m68000up;
  5008.       current_architecture |= m68020 | MAYBE_FLOAT_TOO;
  5009.     }
  5010.       else if (!strcmp (arg, "68030"))
  5011.     {
  5012.       current_architecture &=~ m68000up;
  5013.       current_architecture |= m68030 | MAYBE_FLOAT_TOO;
  5014.     }
  5015.       else if (!strcmp (arg, "68040"))
  5016.     {
  5017.       current_architecture &=~ m68000up;
  5018.       current_architecture |= m68040 | MAYBE_FLOAT_TOO;
  5019.     }
  5020.       else if (!strcmp (arg, "68060"))
  5021.     {
  5022.       current_architecture &=~ m68000up;
  5023.       current_architecture |= m68060 | MAYBE_FLOAT_TOO;
  5024.     }
  5025. #ifndef NO_68881
  5026.       else if (!strcmp (arg, "68881"))
  5027.     {
  5028.       current_architecture |= m68881;
  5029.       no_68881 = 0;
  5030.     }
  5031.       else if (!strcmp (arg, "68882"))
  5032.     {
  5033.       current_architecture |= m68882;
  5034.       no_68881 = 0;
  5035.     }
  5036. #endif /* NO_68881 */
  5037.       /* Even if we aren't configured to support the processor,
  5038.      it should still be possible to assert that the user
  5039.      doesn't have it...  */
  5040.       else if (!strcmp (arg, "no-68881")
  5041.            || !strcmp (arg, "no-68882"))
  5042.     {
  5043.       no_68881 = 1;
  5044.     }
  5045. #ifndef NO_68851
  5046.       else if (!strcmp (arg, "68851"))
  5047.     {
  5048.       current_architecture |= m68851;
  5049.       no_68851 = 0;
  5050.     }
  5051. #endif /* NO_68851 */
  5052.       else if (!strcmp (arg, "no-68851"))
  5053.     {
  5054.       no_68851 = 1;
  5055.     }
  5056.       else if (!strcmp (arg, "pu32") /* "cpu32" minus 'c' */
  5057.            || !strcmp (arg, "68331")
  5058.            || !strcmp (arg, "68332")
  5059.            || !strcmp (arg, "68333")
  5060.            || !strcmp (arg, "68340"))
  5061.     {
  5062.       current_architecture &=~ m68000up;
  5063.       current_architecture |= cpu32;
  5064.     }
  5065.       else
  5066.     {
  5067.       as_bad ("invalid architecture %s", arg);
  5068.       return 0;
  5069.     }
  5070.       break;
  5071.  
  5072.     case OPTION_PIC:
  5073.     case 'k':
  5074.       flag_want_pic = 1;
  5075.       break;            /* -pic, Position Independent Code */
  5076.  
  5077.     case OPTION_REGISTER_PREFIX_OPTIONAL:
  5078.       flag_reg_prefix_optional = 1;
  5079.       break;
  5080.  
  5081.     default:
  5082.       return 0;
  5083.     }
  5084.  
  5085.   return 1;
  5086. }
  5087.  
  5088. void
  5089. md_show_usage (stream)
  5090.      FILE *stream;
  5091. {
  5092.   fprintf(stream, "\
  5093. 680X0 options:\n\
  5094. -l            use 1 word for refs to undefined symbols [default 2]\n\
  5095. -m68000 | -m68008 | -m68010 | -m68020 | -m68030 | -m68040\n\
  5096.  | -m68302 | -m68331 | -m68332 | -m68333 | -m68340 | -mcpu32\n\
  5097.             specify variant of 680X0 architecture [default 68020]\n\
  5098. -m68881 | -m68882 | -mno-68881 | -mno-68882\n\
  5099.             target has/lacks floating-point coprocessor\n\
  5100.             [default yes for 68020, 68030, and cpu32]\n\
  5101. -m68851 | -mno-68851\n\
  5102.             target has/lacks memory-management unit coprocessor\n\
  5103.             [default yes for 68020 and up]\n\
  5104. -pic, -k        generate position independent code\n\
  5105. -S            turn jbsr into jsr\n\
  5106. --register-prefix-optional\n\
  5107.             recognize register names without prefix character\n");
  5108. }
  5109.  
  5110. #ifdef TEST2
  5111.  
  5112. /* TEST2:  Test md_assemble() */
  5113. /* Warning, this routine probably doesn't work anymore */
  5114.  
  5115. main ()
  5116. {
  5117.   struct m68k_it the_ins;
  5118.   char buf[120];
  5119.   char *cp;
  5120.   int n;
  5121.  
  5122.   m68k_ip_begin ();
  5123.   for (;;)
  5124.     {
  5125.       if (!gets (buf) || !*buf)
  5126.     break;
  5127.       if (buf[0] == '|' || buf[1] == '.')
  5128.     continue;
  5129.       for (cp = buf; *cp; cp++)
  5130.     if (*cp == '\t')
  5131.       *cp = ' ';
  5132.       if (is_label (buf))
  5133.     continue;
  5134.       memset (&the_ins, '\0', sizeof (the_ins));
  5135.       m68k_ip (&the_ins, buf);
  5136.       if (the_ins.error)
  5137.     {
  5138.       printf ("Error %s in %s\n", the_ins.error, buf);
  5139.     }
  5140.       else
  5141.     {
  5142.       printf ("Opcode(%d.%s): ", the_ins.numo, the_ins.args);
  5143.       for (n = 0; n < the_ins.numo; n++)
  5144.         printf (" 0x%x", the_ins.opcode[n] & 0xffff);
  5145.       printf ("    ");
  5146.       print_the_insn (&the_ins.opcode[0], stdout);
  5147.       (void) putchar ('\n');
  5148.     }
  5149.       for (n = 0; n < strlen (the_ins.args) / 2; n++)
  5150.     {
  5151.       if (the_ins.operands[n].error)
  5152.         {
  5153.           printf ("op%d Error %s in %s\n", n, the_ins.operands[n].error, buf);
  5154.           continue;
  5155.         }
  5156.       printf ("mode %d, reg %d, ", the_ins.operands[n].mode, the_ins.operands[n].reg);
  5157.       if (the_ins.operands[n].b_const)
  5158.         printf ("Constant: '%.*s', ", 1 + the_ins.operands[n].e_const - the_ins.operands[n].b_const, the_ins.operands[n].b_const);
  5159.       printf ("ireg %d, isiz %d, imul %d, ", the_ins.operands[n].ireg, the_ins.operands[n].isiz, the_ins.operands[n].imul);
  5160.       if (the_ins.operands[n].b_iadd)
  5161.         printf ("Iadd: '%.*s',", 1 + the_ins.operands[n].e_iadd - the_ins.operands[n].b_iadd, the_ins.operands[n].b_iadd);
  5162.       (void) putchar ('\n');
  5163.     }
  5164.     }
  5165.   m68k_ip_end ();
  5166.   return 0;
  5167. }
  5168.  
  5169. is_label (str)
  5170.      char *str;
  5171. {
  5172.   while (*str == ' ')
  5173.     str++;
  5174.   while (*str && *str != ' ')
  5175.     str++;
  5176.   if (str[-1] == ':' || str[1] == '=')
  5177.     return 1;
  5178.   return 0;
  5179. }
  5180.  
  5181. #endif
  5182.  
  5183. /* Possible states for relaxation:
  5184.  
  5185.    0 0    branch offset    byte    (bra, etc)
  5186.    0 1            word
  5187.    0 2            long
  5188.  
  5189.    1 0    indexed offsets    byte    a0@(32,d4:w:1) etc
  5190.    1 1            word
  5191.    1 2            long
  5192.  
  5193.    2 0    two-offset index word-word a0@(32,d4)@(45) etc
  5194.    2 1            word-long
  5195.    2 2            long-word
  5196.    2 3            long-long
  5197.  
  5198.    */
  5199.  
  5200. /* We have no need to default values of symbols.  */
  5201.  
  5202. /* ARGSUSED */
  5203. symbolS *
  5204. md_undefined_symbol (name)
  5205.      char *name;
  5206. {
  5207.   return 0;
  5208. }
  5209.  
  5210. /* Parse an operand that is machine-specific.
  5211.    We just return without modifying the expression if we have nothing
  5212.    to do.  */
  5213.  
  5214. /* ARGSUSED */
  5215. void
  5216. md_operand (expressionP)
  5217.      expressionS *expressionP;
  5218. {
  5219. }
  5220.  
  5221. /* Round up a section size to the appropriate boundary.  */
  5222. valueT
  5223. md_section_align (segment, size)
  5224.      segT segment;
  5225.      valueT size;
  5226. {
  5227.   return size;            /* Byte alignment is fine */
  5228. }
  5229.  
  5230. /* Exactly what point is a PC-relative offset relative TO?
  5231.    On the 68k, they're relative to the address of the offset, plus
  5232.    its size. (??? Is this right?  FIXME-SOON!) */
  5233. long
  5234. md_pcrel_from (fixP)
  5235.      fixS *fixP;
  5236. {
  5237.   return (fixP->fx_size + fixP->fx_where + fixP->fx_frag->fr_address);
  5238. }
  5239.  
  5240. #ifndef BFD_ASSEMBLER
  5241. /*ARGSUSED*/
  5242. void
  5243. tc_coff_symbol_emit_hook (ignore)
  5244.      symbolS *ignore;
  5245. {
  5246. }
  5247.  
  5248. int
  5249. tc_coff_sizemachdep (frag)
  5250.      fragS *frag;
  5251. {
  5252.   switch (frag->fr_subtype & 0x3)
  5253.     {
  5254.     case BYTE:
  5255.       return 1;
  5256.     case SHORT:
  5257.       return 2;
  5258.     case LONG:
  5259.       return 4;
  5260.     default:
  5261.       abort ();
  5262.     }
  5263. }
  5264. #endif
  5265.  
  5266. /* end of tc-m68k.c */
  5267.