home *** CD-ROM | disk | FTP | other *** search
/ Club Amiga de Montreal - CAM / CAM_CD_1.iso / files / 529a.lha / A68k_v2.71 / Operands.c < prev    next >
Encoding:
C/C++ Source or Header  |  1991-07-02  |  17.5 KB  |  592 lines
  1. /*------------------------------------------------------------------*/
  2. /*                                    */
  3. /*            MC68000 Cross Assembler                */
  4. /*                                    */
  5. /*                Copyright 1985 by Brian R. Anderson            */
  6. /*                                    */
  7. /*                Operand processor - April 16, 1991            */
  8. /*                                    */
  9. /*   This program may be copied for personal, non-commercial use    */
  10. /*   only, provided that the above copyright notice is included        */
  11. /*   on all copies of the source code.  Copying for any other use   */
  12. /*   without the consent of the author is prohibited.            */
  13. /*                                    */
  14. /*------------------------------------------------------------------*/
  15. /*                                    */
  16. /*        Originally published (in Modula-2) in            */
  17. /*        Dr. Dobb's Journal, April, May, and June 1986.        */
  18. /*                                    */
  19. /*     AmigaDOS conversion copyright 1991 by Charlie Gibbs.        */
  20. /*                                    */
  21. /*------------------------------------------------------------------*/
  22.  
  23. #include "A68kdef.h"
  24. #include "A68kglb.h"
  25.  
  26.  
  27.  
  28. int GetArgs (name) char *name;
  29. /* Gets macro arguments and adds them to FNStack after adding "name".
  30.     Returns the number of arguments added to the stack.
  31.     Note that this might not be the full number of arguments
  32.     provided if the stack overflowed.                */
  33. {
  34.     register char *s, *t;
  35.     int narg, instring;
  36.     char currarg[MAXLINE];        /* Current argument */
  37.  
  38.     narg = strlen (name) + 1;
  39.     Heap2Space (narg);            /* Find space for name. */
  40.     strcpy (NextFNS, name);        /* Add name to stack. */
  41.     NextFNS += narg;            /* Bump pointer. */
  42.     if (NextFNS > High2)
  43.     High2 = NextFNS;        /* Update the high-water mark. */
  44.  
  45.     narg = 0;                /* Argument counter */
  46.  
  47.     s = Line + SrcLoc;            /* Now scan Line. */
  48.     while (!isspace(*s) && (*s != ';') && (*s != '\0')) {
  49.     t = currarg;
  50.     if (instring = (*s == '<'))    /* String delimiter */
  51.         s++;
  52.     while (1) {
  53.         if (*s == '\0')
  54.         break;            /* End of line */
  55.         if (instring) {
  56.         if (*s == '>') {
  57.             s++;
  58.             break;        /* End of string */
  59.         }
  60.         } else {
  61.         if ((*s == ',')        /* End of operand */
  62.         || isspace(*s)        /* End of all operands */
  63.         || (*s == ';'))        /* Start of comments */
  64.             break;
  65.         }
  66.         *t++ = *s++;        /* Get a character. */
  67.     }
  68.     *t++ = '\0';
  69.     Heap2Space (t - currarg);    /* Check for space. */
  70.     strcpy (NextFNS, currarg);    /* Store argument. */
  71.     NextFNS += t - currarg;        /* Next available space */
  72.     if (NextFNS > High2)
  73.         High2 = NextFNS;        /* High-water mark */
  74.     narg++;                /* Count arguments. */
  75.     if (*s == ',')
  76.         s++;            /* Skip over separator. */
  77.     }
  78.     return (narg);            /* Successful completion */
  79. }
  80.  
  81.  
  82.  
  83. void EffAdr (EA, Bad) register struct OpConfig *EA; int Bad;
  84. /* Adds effective address field to Op (BITSET representing opcode). */
  85. {
  86.     if ((1 << (EA->Mode - 1)) IN Bad) {
  87.     Error (EA->Loc, ModeErr);    /* Invalid mode */
  88.     return;
  89.     } else if (EA->Mode > 12)        /* Special modes */
  90.     return;
  91.     else if (EA->Mode < 8)        /* Register direct or indirect */
  92.     Op |= ((EA->Mode - 1) << 3) | EA->Rn;
  93.     else
  94.     Op |= 0x0038 | (EA->Mode - 8);    /* Absolute modes */
  95.     OperExt (EA);
  96. }
  97.  
  98.  
  99.  
  100. void OperExt (EA) register struct OpConfig *EA;
  101. /* Calculate operand Extension word, and check range of operands. */
  102. {
  103.     switch (EA->Mode) {
  104.     case AbsL:
  105.         break;    /* No range checking is needed. */
  106.     case AbsW:
  107.     case ARDisp:
  108.     case PCDisp:
  109.         if ((EA->Value < -32768) || (EA->Value > 32767))
  110.         Error (EA->Loc, SizeErr);
  111.         break;
  112.     case ARDisX:
  113.     case PCDisX:
  114.         if ((EA->Value < -128) || (EA->Value > 127))
  115.         Error (EA->Loc, SizeErr);
  116.         EA->Value &= 0x00FF;            /* Displacement */
  117.         EA->Value |= EA->Xn << 12;            /* Index reg. */
  118.         if (EA->X == Areg)     EA->Value |= 0x8000;    /* Addr. Reg. */
  119.         if (EA->Xsize == Long) EA->Value |= 0x0800;    /* Long reg.  */
  120.         break;
  121.     case Imm:
  122.         if (Size == Word) {
  123.         if ((EA->Value < -32768) || (EA->Value > 65535L))
  124.             Error (EA->Loc, SizeErr);
  125.         } else if (Size == Byte)
  126.         if ((EA->Value < -128) || (EA->Value > 255))
  127.             Error (EA->Loc, SizeErr);
  128.         break;
  129.     }
  130. }
  131.  
  132.  
  133.  
  134. void GetOperand (oper, op, pcconv)
  135. char *oper; register struct OpConfig *op; int pcconv;
  136. /* Finds mode and value for source or destination operand.
  137.     If PC-relative addressing is permitted, "pcconv" gives the
  138.     offset to the displacement word; otherwise "pcconv" is zero. */
  139. {
  140.     register char *s, *t;
  141.     register int  i;
  142.     char *opend;
  143.     char UCoper[MAXLINE], tempop[MAXLINE];
  144.     int  rloc;
  145.     long templong;
  146.  
  147.     op->Value  = op->Defn = 0;
  148.     op->Mode   = Null;
  149.     op->X      = X0;
  150.     op->Hunk   = ABSHUNK;
  151.     op->Single = FALSE;
  152.  
  153.     if (*oper == '\0')
  154.     return;                /* There is nothing to process. */
  155.  
  156.     s = oper;
  157.     t = UCoper;
  158.     while (*s) {
  159.     *t++ = toupper (*s);        /* Upper-case version */
  160.     s++;
  161.     }
  162.     *t = '\0';
  163.     opend = s - 1;            /* Last character of operand */
  164.  
  165.     if (*oper == '#') {            /* Immediate */
  166.     s = oper + 1;            /* The value starts here. */
  167.     if (*s == '~')
  168.         s++;            /* Skip over unary NOT. */
  169.     op->Value  = GetValue (s, (op->Loc)+1);
  170.     op->Mode   = Imm;
  171.     op->Hunk   = Hunk2;
  172.     op->Defn   = DefLine2;
  173.     op->Single = SingleFlag;
  174.     if (*(oper+1) == '~') {        /* Unary NOT of entire value */
  175.         if (Hunk2 != ABSHUNK) {
  176.         Error (op->Loc + 2, RelErr);
  177.         op->Hunk = ABSHUNK;    /* Must be absolute! */
  178.         }
  179.         op->Value = ~(op->Value);    /* Flip all bits. */
  180.         if (Size == Byte)
  181.         op->Value &= 0xFFL;    /* Trim to 8 bits. */
  182.         else if (Size == Word)
  183.         op->Value &= 0xFFFFL;    /* Trim to 16 bits. */
  184.     }
  185.     return;
  186.     }
  187.  
  188.     i = IsRegister (oper, opend-oper+1);
  189.     if (i >= 0) {
  190.     op->Mode = (i & 8) ? ARDir : DReg;    /* Register type */
  191.     op->Rn = i & 7;                /* Register number */
  192.     return;
  193.     } else if (i == -2) {
  194.     op->Mode = MultiM;            /* Equated register list */
  195.     op->Value = Sym->Val;
  196.     return;
  197.     } else if ((*oper == '(') && (*opend == ')')) {
  198.     i = IsRegister (oper+1, opend-oper-1);
  199.     if (i >= 8 && i <= 15) {
  200.         op->Mode = ARInd;        /* Address Register indirect */
  201.         op->Rn = i - 8;
  202.         return;
  203.     } else if (i != -1) {
  204.         Error (op->Loc, AddrErr);    /* Data register is invalid! */
  205.         return;
  206.     }    /* else may be parenthesized expression */
  207.     } else if ((*oper == '(')        /* Post-increment */
  208.     && (*opend == '+')
  209.     && (*(opend-1) == ')')) {
  210.     op->Mode = ARPost;
  211.     op->Rn = GetAReg (oper+1, opend-oper-2, op->Loc + 1);
  212.     return;
  213.     } else if ((*oper == '-')        /* Pre-decrement */
  214.     && (*opend == ')')
  215.     && (*(oper+1) == '(')) {
  216.     i = IsRegister (oper+2, opend-oper-2);
  217.     if (i >= 8 && i <= 15) {
  218.         op->Mode = ARPre;
  219.         op->Rn = i - 8;
  220.         return;
  221.     } else if (i > 0) {
  222.         Error (op->Loc, AddrErr);    /* Data register is invalid! */
  223.         return;
  224.     }    /* else parenthesized expression with leading minus? */
  225.     } else if (strcmp (UCoper, "SR") == 0) {
  226.     op->Mode = SR;                /* Status Register */
  227.     return;
  228.     } else if (strcmp (UCoper, "CCR") == 0) {
  229.     op->Mode = CCR;            /* Condition Code Register */
  230.     return;
  231.     } else if (strcmp (UCoper, "USP") == 0) {
  232.     op->Mode = USP;            /* User Stack Pointer */
  233.     return;
  234.     }
  235.  
  236.     /* Try to split off displacement (if present).
  237.     We'll assume we have a register expression if the operand
  238.     ends with a parenthesized expression not preceded by an
  239.     operator.  I know this code is a real kludge, but that's
  240.     the result of the bloody syntax.  Thanks, Motorola.    */
  241.  
  242.     s = opend;                /* Last character */
  243.     if (i = (*s == ')'))        /* Trailing parenthesis? */
  244.     while (*(--s) != '(')        /* Find left parenthesis. */
  245.         if (s <= oper)
  246.         break;
  247.     if (s <= oper)            /* Must not be at beginning. */
  248.     i = FALSE;
  249.     if (i) {
  250.     if (s == (oper+1)) {
  251.         if (*oper == '-')
  252.         i = FALSE;        /* Leading minus sign */
  253.     } else {
  254.         t = s - 1;
  255.         if (*t == '*') {        /* Location counter? */
  256.         t--;
  257.         if (!IsOperator (t) || (*t == ')'))
  258.             i = FALSE;        /* No, it's multiplication. */
  259.         } else if (IsOperator (t) && (*t != ')')) {
  260.         i = FALSE;        /* Preceded by an operator */
  261.         }
  262.     }
  263.     }
  264.  
  265.     if (i) {        /* Looks like a displacement mode */
  266.     *s = '\0';
  267.     op->Value = GetValue (oper, op->Loc);    /* Displacement */
  268.     op->Hunk  = Hunk2;            /* Hunk number */
  269.     op->Defn  = DefLine2;            /* Line where defined */
  270.     *s++ = '(';                /* Restore parenthesis. */
  271.  
  272.     rloc = op->Loc + s - oper;    /* The register starts here. */
  273.     s = GetField (s, tempop);    /* Get address register. */
  274.     if (*s == '\0')            /* If there's no index register, */
  275.         tempop[strlen(tempop)-1] = '\0';    /* chop off parenthesis. */
  276.  
  277.     if ((tempop[2] == '\0')
  278.     && (toupper (tempop[0]) == 'P')
  279.     && (toupper (tempop[1]) == 'C')) {
  280.         op->Mode = PCDisp;            /* Program Counter */
  281.         if (op->Hunk == CurrHunk) {
  282.         op->Value -= (AddrCnt+pcconv);    /* Adjust displacement. */
  283.         op->Hunk = ABSHUNK;
  284.         }
  285.     } else {
  286.         if ((op->Value == 0)    /* If displacement is zero   */
  287.         && (op->Hunk == ABSHUNK)    /*  and is absolute          */
  288.         && (op->Defn < LineCount)    /*  and is already defined   */
  289.         && !(OpM68R IN AdrModeA)    /*  and isn't for a MOVEP    */
  290.         && !NoOpt)            /*  and we can optimize      */
  291.         op->Mode = ARInd;    /*  forget the displacement. */
  292.         else
  293.         op->Mode = ARDisp;    /* Address reg. w/displacement */
  294.         op->Rn = GetAReg (tempop, strlen (tempop), rloc);
  295.     }
  296.     if (*s != '\0') {        /* Index register is present. */
  297.         if (op->Mode == PCDisp)
  298.         op->Mode = PCDisX;    /* Program Counter indexed */
  299.         else
  300.         op->Mode = ARDisX;    /* Address Register indexed */
  301.         if (*s != ',')
  302.         Error (op->Loc, AddrErr);    /* Bad separator */
  303.         s++;                /* Skip separator. */
  304.         rloc = op->Loc + s - oper;        /* Start of index */
  305.         s = GetField (s, tempop);        /* Get index register. */
  306.         t = tempop + strlen(tempop);
  307.         if (*s == '\0')
  308.         *(--t) = '\0';            /* Chop parenthesis. */
  309.         else
  310.         Error (rloc, AddrErr);        /* It better be there. */
  311.  
  312.         t -= 2;
  313.         if ((t < tempop) || (*t != '.')) {
  314.         op->Xsize = Word;    /* Size defaults to 16 bits. */
  315.         t += 3;
  316.         } else {
  317.         *t++ = '\0';            /* Chop off size code. */
  318.         switch (toupper (*t)) {
  319.         case 'W':            /* Word */
  320.             op->Xsize = Word;
  321.             break;
  322.         case 'L':            /* Long */
  323.             op->Xsize = Long;
  324.             break;
  325.         default:
  326.             Error (op->Loc+s-1-oper, SizeErr);    /* Invalid size */
  327.             op->Xsize = Word;        /* Make it word for now. */
  328.         }
  329.         }
  330.         i = IsRegister (tempop,t-tempop-1);    /* Get register. */
  331.         op->Xn = i & 7;            /* Index register number */
  332.         if ((i >= 0) && (i <= 7))
  333.         op->X = Dreg;            /* Data Register */
  334.         else if ((i >= 8) && (i <= 15))
  335.         op->X = Areg;            /* Address Register */
  336.         else
  337.         Error (rloc, AddrErr);        /* Invalid register */
  338.     }
  339.  
  340.     if ((op->Hunk >= 0) && (op->Hunk != ABSHUNK))
  341.         Error (op->Loc, RelErr);    /*  Relocatable displacement */
  342.     return;
  343.     }
  344.  
  345.     if ((i = GetMultReg (oper, op->Loc)) != 0) {
  346.     op->Value = (long) i;
  347.     op->Mode = MultiM;        /* Register list for MOVEM */
  348.     return;
  349.     }
  350.  
  351.     if ((*oper == '(')        /* Operands of the form (xxxx).W or (xxxx).L */
  352.     && (*(opend-2) == ')')
  353.     && (*(opend-1) == '.')
  354.     && ((toupper(*opend) == 'W') || (toupper(*opend) == 'L'))) {
  355.     *(opend-1) = '\0';    /* Temporarily cut off length specifier. */
  356.     op->Value  = GetValue (oper, op->Loc);    /* Get operand value. */
  357.     op->Hunk   = Hunk2;
  358.     op->Defn   = DefLine2;
  359.     op->Single = SingleFlag;
  360.     if (toupper(*opend) == 'W')
  361.         op->Mode = AbsW;    /* Absolute word */
  362.     else
  363.         op->Mode = AbsL;    /* Absolute long */
  364.     *(opend-1) = '.';    /* Restore original operand. */
  365.     return;
  366.     }
  367.  
  368.     op->Value  = GetValue (oper, op->Loc);    /* Plain old expression */
  369.     op->Hunk   = Hunk2;
  370.     op->Defn   = DefLine2;
  371.     op->Single = SingleFlag;
  372.     op->Mode   = AbsL;        /* Assume absolute long addressing. */
  373.  
  374.     if (NoOpt)
  375.     return;            /* Do no optimizing. */
  376.  
  377.     if (DefLine2 < LineCount) {        /* Backward reference */
  378.  
  379.     if (Hunk2 < 0) {
  380.         return;        /* External - leave as absolute long. */
  381.  
  382.     } else if (Hunk2 == CurrHunk) {    /* Reference to current hunk */
  383.         if (pcconv) {
  384.         templong = op->Value-(AddrCnt+pcconv);    /* PC disp. */
  385.         if ((templong >= -32768) && (templong <= 32767)) {
  386.             op->Mode = PCDisp;    /* Convert to PC relative mode. */
  387.             op->Value=templong;    /* Adjust displacement. */
  388.             op->Hunk = ABSHUNK;
  389.         }
  390.         }
  391.  
  392.     } else if (Hunk2 == ABSHUNK) {    /* Absolute value */
  393.         if ((op->Value >= -32768) && (op->Value <= 32767))
  394.         op->Mode = AbsW;    /* Absolute word */
  395.  
  396.     } else if ((SmallData != -1)
  397.     && (op->Value>=0) && (op->Value<=65535L)) {
  398.         op->Mode = ARDisp;        /* Make it a data reference     */
  399.         op->Rn = SmallData;        /*  through specified register. */
  400.         op->Value -= DataOffset;    /* Adjust displacement. */
  401.         op->Hunk = ABSHUNK;
  402.     }
  403.     return;            /* Could default to absolute long. */
  404.  
  405.     } else if (SmallData==-1) {    /* Fwd. reference - if not small data, */
  406.     return;            /*  leave as absolute long addressing. */
  407.  
  408.     } else if (Brnch IN AdrModeA) {
  409.     return;            /* Branches are handled elsewhere. */
  410.  
  411.     } else if (!Pass2) {    /* Forward reference, pass 1 */
  412.     op->Mode = ARDisp;    /* Assume displacement       */
  413.     op->Rn = SmallData;    /*  from specified register. */
  414.     op->Hunk = ABSHUNK;
  415.     return;
  416.  
  417.     } else {            /* On pass 2 we know what it is. */
  418.  
  419.     if (Hunk2 < 0) {
  420.         Error (op->Loc,FwdRef);    /* External - must be 32 bits. */
  421.         op->Mode = AbsW;        /* Force absolute word anyway. */
  422.  
  423.     } else if (Hunk2 == CurrHunk) {    /* It's in the current hunk. */
  424.         op->Mode = PCDisp;        /* Convert to PC relative mode. */
  425.         op->Value -= AddrCnt + pcconv;    /* Adjust displacement. */
  426.         op->Hunk = ABSHUNK;
  427.         if (!pcconv || (op->Value < -32768) || (op->Value > 32767))
  428.         Error (op->Loc,FwdRef);    /* It doesn't fit! */
  429.  
  430.     } else if (Hunk2 == ABSHUNK) {    /* It's absolute. */
  431.         op->Mode = AbsW;        /* It has to fit in a word. */
  432.         if ((op->Value < -32768) || (op->Value > 32767))
  433.         Error (op->Loc,FwdRef);    /* It doesn't fit! */
  434.  
  435.     } else {
  436.         op->Mode = ARDisp;        /* Assume data reference        */
  437.         op->Rn = SmallData;        /*  through specified register. */
  438.         op->Value -= DataOffset;    /* Adjust displacement. */
  439.         if ((op->Value < -32768) || (op->Value > 32767))
  440.         Error (op->Loc,FwdRef);    /* It doesn't fit! */
  441.     }
  442.     }
  443. }
  444.  
  445.  
  446.  
  447. int GetMultReg (oper, loc) char *oper; int loc;
  448. /* Builds a register mask for the MOVEM instruction.
  449.     Returns the mask in the low-order portion of its value if
  450.     "oper" is a valid multiple-register list; otherwise returns 0. */
  451. {
  452.     register char *s, *t;
  453.     register int  j;
  454.     int t1, t2;        /* Temporary variables for registers */
  455.     int range;        /* We're processing a range of registers. */
  456.     int multext;    /* The result is built here. */
  457.  
  458.     multext = 0;
  459.     range = FALSE;
  460.     s = oper;
  461.     if (IsOperator (s))
  462.     return (0);            /* Starts with an operator! */
  463.  
  464.     while (1) {
  465.     for (t = s; *t; t++) {
  466.         if ((*t == '-') || (*t == '/')) {
  467.         break;
  468.         }
  469.     }
  470.     if ((multext == 0) && (*t == '\0'))
  471.         return (0);            /* Reject single term. */
  472.     if ((t2 = IsRegister (s, (int)(t-s))) < 0)
  473.         return (0);            /* Not a recognizable register */
  474.  
  475.     if (!range) {
  476.         multext |= (1 << t2);    /* Single register */
  477.         t1 = t2;            /* Save number in case it's a range. */
  478.     } else {            /* Range of registers */
  479.         range = FALSE;
  480.         if (t1 > t2) {
  481.         j = t1;            /* Swap registers if backwards. */
  482.         t1 = t2;
  483.         t2 = j;
  484.         }
  485.         for (j = t1; j <= t2; j++)
  486.         multext |= (1 << j);    /* Mark all registers in range. */
  487.         if (*t == '-')
  488.         return (0);        /* Invalid range */
  489.     }
  490.     if (*t == '\0')
  491.         break;            /* Normal end of operand */
  492.     if (*t++ == '-')
  493.         range = TRUE;        /* Range indicator */
  494.     if (*t == '\0')
  495.         return (0);            /* Premature end of operand */
  496.     s = t;
  497.     }
  498.     return (multext);
  499. }
  500.  
  501.  
  502.  
  503. int GetAReg (op, len, loc) char *op; int len, loc;
  504. /* Validate an address register specification.
  505.     Valid specifications are A0 through A7, SP, or an EQUR label.
  506.     The address register number will be returned if it is valid.
  507.     Otherwise, Error will be called, using "loc" for the error
  508.     location (this is its only use), and zero (A0) will be returned. */
  509. {
  510.     register int i;
  511.  
  512.     i = IsRegister (op, len);        /* Get register number. */
  513.     if ((i >= 8) && (i <= 15))
  514.     return (i - 8);            /* Valid address register */
  515.     else {
  516.     Error (loc, AddrErr);        /* Not an address register */
  517.     return (0);            /* Set to A0. */
  518.     }
  519. }
  520.  
  521.  
  522.  
  523. int IsRegister (op, len) char *op; int len;
  524. /* Check whether the current operand is an address or data register.
  525.     Valid specifications are D0 through D7, A0 through A7, SP,
  526.     or any symbol equated to a register with the EQUR directive.
  527.     Return values:
  528.     0 through 7 - data registers 0 through 7 respectively
  529.     8 through 15 - address registers 0 through 7 respectively
  530.     -1 - not a recognizable register
  531.     -2 - Equated register list for MOVEM instruction (REG) */
  532. {
  533.     char tempop[MAXLINE];
  534.     register char *s;
  535.     register int  i;
  536.  
  537.     if (len == 2) {        /* Two-character specification */
  538.     i = toupper (*op);
  539.     s = op + 1;
  540.     if ((i == 'S') && (toupper (*s) == 'P')) {
  541.         return (15);        /* Stack Pointer */
  542.     } else if ((*s >= '0') && (*s <= '7')) {
  543.         if (i == 'A') {
  544.         return (*s - '0' + 8);    /* Address Register */
  545.         } else if (i == 'D') {
  546.         return (*s - '0');    /* Data Register */
  547.         }
  548.     }
  549.     }
  550.     if (!GotEqur)            /* If we have no EQURs to check */
  551.     return (-1);            /*  don't waste any time here.  */
  552.     for (i = 0, s = op; i < len; i++) {
  553.     if (IsOperator (s))
  554.         return (-1);        /* It sure isn't a label. */
  555.     tempop[i] = *s++;
  556.     }
  557.     tempop[i] = '\0';
  558.     if (ReadSymTab (tempop)) {
  559.     if (Sym->Flags & 0x60) {
  560.         AddRef (LineCount);        /* Found a register or list. */
  561.         return ((Sym->Flags & 0x20) ? (int) Sym->Val : -2);
  562.     }
  563.     }
  564.     return (-1);            /* Not a recognizable register */
  565. }
  566.  
  567.  
  568.  
  569. int GetInstModeSize (Mode) register int Mode;
  570. /* Determines the size for the various instruction modes. */
  571. {
  572.     switch (Mode) {
  573.     case ARDisp:
  574.     case ARDisX:
  575.     case PCDisp:
  576.     case PCDisX:
  577.     case AbsW:
  578.         return (2);
  579.     case AbsL:
  580.         return (4);
  581.     case MultiM:
  582.         return (0);        /* Accounted for by code generator */
  583.     case Imm:
  584.         if (Size == Long)
  585.         return (4);
  586.         else
  587.         return (2);
  588.     default:
  589.         return (0);
  590.     }
  591. }
  592.