Subversion Repositories pentevo

Rev

Blame | Last modification | View Log | Download | RSS feed

  1. /* code68s12z.c */
  2. /*****************************************************************************/
  3. /* SPDX-License-Identifier: GPL-2.0-only OR GPL-3.0-only                     */
  4. /*                                                                           */
  5. /* AS                                                                        */
  6. /*                                                                           */
  7. /* Code Generator NXP S12Z                                                   */
  8. /*                                                                           */
  9. /*****************************************************************************/
  10.  
  11. #include "stdinc.h"
  12.  
  13. #include <ctype.h>
  14. #include <string.h>
  15.  
  16. #include "strutil.h"
  17. #include "bpemu.h"
  18. #include "asmdef.h"
  19. #include "asmpars.h"
  20. #include "asmsub.h"
  21. #include "asmallg.h"
  22. #include "asmitree.h"
  23. #include "asmstructs.h"
  24. #include "codepseudo.h"
  25. #include "motpseudo.h"
  26. #include "intpseudo.h"
  27. #include "codevars.h"
  28. #include "errmsg.h"
  29. #include "headids.h"
  30.  
  31. #include "codes12z.h"
  32.  
  33. typedef enum
  34. {
  35.   AdrModeNone = -1,
  36.   AdrModeReg = 0,
  37.   AdrModeAReg = 1,
  38.   AdrModeImm = 2,
  39.   AdrModeMemReg = 3
  40. } tAdrMode;
  41.  
  42. typedef enum
  43. {
  44.   eIndirModeNone,
  45.   eIndirModePar,
  46.   eIndirModeSquare
  47. } tIndirMode;
  48.  
  49. typedef enum
  50. {
  51.   eIncModeNone,
  52.   eIncModePreInc,
  53.   eIncModePostInc,
  54.   eIncModePreDec,
  55.   eIncModePostDec
  56. } tIncMode;
  57.  
  58. #define MModeReg (1 << AdrModeReg)
  59. #define MModeAReg (1 << AdrModeAReg)
  60. #define MModeImm (1 << AdrModeImm)
  61. #define MModeMemReg (1 << AdrModeMemReg)
  62.  
  63. #define OpSizeBitPos8 ((tSymbolSize)16)
  64. #define OpSizeBitPos16 ((tSymbolSize)17)
  65. #define OpSizeBitPos32 ((tSymbolSize)18)
  66. #define OpSizeShiftCount ((tSymbolSize)19)
  67.  
  68. typedef struct
  69. {
  70.   tAdrMode Mode;
  71.   Byte Arg, Vals[4], ShiftLSB;
  72.   unsigned ValCnt;
  73. } tAdrVals;
  74.  
  75. static tSymbolSize OpSize, OpSize2;
  76.  
  77. static const tSymbolSize RegSizes[16] =
  78. {
  79.   eSymbolSize16Bit, eSymbolSize16Bit,   /* D2/D3 */
  80.   eSymbolSize16Bit, eSymbolSize16Bit,   /* D4/D5 */
  81.   eSymbolSize8Bit,  eSymbolSize8Bit,    /* D0/D1 */
  82.   eSymbolSize32Bit, eSymbolSize32Bit,   /* D6/D7 */
  83.   eSymbolSize24Bit, eSymbolSize24Bit,   /* X/Y */
  84.   eSymbolSize24Bit, eSymbolSizeUnknown, /* S/- */
  85.   eSymbolSize8Bit,  eSymbolSize8Bit,    /* CCH/CCL */
  86.   eSymbolSize16Bit, eSymbolSizeUnknown, /* CCR/- */
  87. };
  88.  
  89. /*--------------------------------------------------------------------------*/
  90. /* Helper Functions */
  91.  
  92. static void PutCode(Word Code)
  93. {
  94.   if (Hi(Code))
  95.     BAsmCode[CodeLen++] = Hi(Code);
  96.   BAsmCode[CodeLen++] = Lo(Code);
  97. }
  98.  
  99. static void AppendAdrVals(const tAdrVals *pVals)
  100. {
  101.   memcpy(BAsmCode + CodeLen, pVals->Vals, pVals->ValCnt);
  102.   CodeLen += pVals->ValCnt;
  103. }
  104.  
  105. static Boolean DecodeRegStr(const char *pArg, Byte *pRes)
  106. {
  107.   if ((strlen(pArg) == 2)
  108.    && (toupper(*pArg) == 'D')
  109.    && ((pArg[1] >= '0') && (pArg[1] <= '7')))
  110.   {
  111.     static const Byte RegCodes[8] = { 4, 5, 0, 1, 2, 3, 6, 7 };
  112.  
  113.     *pRes = RegCodes[pArg[1] - '0'];
  114.     return True;
  115.   }
  116.   else
  117.     return False;
  118. }
  119.  
  120. static Boolean DecodeAdrRegStr(const char *pArg, Byte *pRes)
  121. {
  122.   static const char Regs[4][3] = { "X", "Y", "S", "PC" };
  123.   unsigned z;
  124.  
  125.   for (z = 0; z < 4; z++)
  126.     if (!as_strcasecmp(pArg, Regs[z]))
  127.     {
  128.       *pRes = z;
  129.       return True;
  130.     }
  131.   return False;
  132. }
  133.  
  134. static Boolean DecodeRegArg(int ArgNum, Byte *pRes, Byte Mask)
  135. {
  136.   Boolean Result = DecodeRegStr(ArgStr[ArgNum].str.p_str, pRes);
  137.  
  138.   if (!Result || !((Mask >> *pRes) & 1))
  139.     WrStrErrorPos(ErrNum_InvReg, &ArgStr[ArgNum]);
  140.   return Result;
  141. }
  142.  
  143. static Boolean DecodeAdrRegArg(int ArgNum, Byte *pRes, Byte Mask)
  144. {
  145.   Boolean Result = DecodeAdrRegStr(ArgStr[ArgNum].str.p_str, pRes);
  146.  
  147.   if (!Result || !((Mask >> *pRes) & 1))
  148.     WrStrErrorPos(ErrNum_InvReg, &ArgStr[ArgNum]);
  149.   return Result;
  150. }
  151.  
  152. static Boolean DecodeGenRegArg(int ArgNum, Byte *pRes)
  153. {
  154.   if (DecodeRegStr(ArgStr[ArgNum].str.p_str, pRes))
  155.     return True;
  156.   else if (DecodeAdrRegStr(ArgStr[ArgNum].str.p_str, pRes) && (*pRes != 3))
  157.   {
  158.     *pRes += 8;
  159.     return True;
  160.   }
  161.   else if (!as_strcasecmp(ArgStr[ArgNum].str.p_str, "CCH"))
  162.   {
  163.     *pRes = 12;
  164.     return True;
  165.   }
  166.   else if (!as_strcasecmp(ArgStr[ArgNum].str.p_str, "CCL"))
  167.   {
  168.     *pRes = 13;
  169.     return True;
  170.   }
  171.   else if (!as_strcasecmp(ArgStr[ArgNum].str.p_str, "CCW"))
  172.   {
  173.     *pRes = 14;
  174.     return True;
  175.   }
  176.   else
  177.     return False;
  178. }
  179.  
  180. static Boolean ShortImm(LongInt Value, ShortInt OpSize, Byte *pShortValue, Byte *pShiftLSB)
  181. {
  182.   if (OpSize == OpSizeShiftCount)
  183.   {
  184.     if ((Value >= 0) && (Value <= 31))
  185.     {
  186.       *pShortValue = (Value >> 1 & 15);
  187.       *pShiftLSB = Value & 1;
  188.       return True;
  189.     }
  190.     else
  191.       return False;
  192.   }
  193.   else if (OpSize < OpSizeBitPos8)
  194.   {
  195.     if (Value == -1)
  196.     {
  197.       *pShortValue = 0;
  198.       return True;
  199.     }
  200.     else if ((Value >= 1) && (Value <= 15))
  201.     {
  202.       *pShortValue = Value;
  203.       return True;
  204.     }
  205.     else if (((Value == (LongInt)0xff) && (OpSize == 0))
  206.           || ((Value == (LongInt)0xffff) && (OpSize == 1))
  207.           || ((Value == (LongInt)0xffffff) && (OpSize == eSymbolSize24Bit))
  208.           || ((Value == (LongInt)0xffffffff) && (OpSize == 2)))
  209.     {
  210.       *pShortValue = 0;
  211.       return True;
  212.     }
  213.     else
  214.       return False;
  215.   }
  216.   else
  217.     return False;
  218. }
  219.  
  220. static unsigned OpSizeByteLen(ShortInt OpSize)
  221. {
  222.   switch (OpSize)
  223.   {
  224.     case -1: return 0;
  225.     case 1: return 2;
  226.     case 2: return 4;
  227.     case eSymbolSize24Bit: return 3;
  228.     default: return 1;
  229.   }
  230. }
  231.  
  232. static void ResetAdrVals(tAdrVals *pVals)
  233. {
  234.   pVals->Mode = AdrModeNone;
  235.   pVals->Arg = 0;
  236.   pVals->ValCnt = 0;
  237.   pVals->ShiftLSB = 0;
  238. }
  239.  
  240. static Boolean IsIncDec(char ch, char *pRes)
  241. {
  242.   *pRes = ((ch == '+') || (ch == '-')) ? ch : '\0';
  243.   return !!*pRes;
  244. }
  245.  
  246. static void CopyIndirect(tStrComp *pDest, const tStrComp *pSrc)
  247. {
  248.   pDest->Pos.Len = strmemcpy(pDest->str.p_str, STRINGSIZE, pSrc->str.p_str + 1, strlen(pSrc->str.p_str) - 2);
  249.   pDest->Pos.StartCol = pSrc->Pos.StartCol + 1;
  250. }
  251.  
  252. static Boolean DecodeAdr(int ArgIndex, unsigned ModeMask, tAdrVals *pVals)
  253. {
  254.   String CompStr;
  255.   tStrComp Comp;
  256.   int l;
  257.   tIndirMode IndirMode;
  258.   LargeWord Address;
  259.   Boolean OK;
  260.  
  261.   ResetAdrVals(pVals);
  262.   StrCompMkTemp(&Comp, CompStr, sizeof(CompStr));
  263.  
  264.   /* simple register: */
  265.  
  266.   if (DecodeRegStr(ArgStr[ArgIndex].str.p_str, &pVals->Arg))
  267.   {
  268.     if (ModeMask & MModeReg)
  269.       pVals->Mode = AdrModeReg;
  270.     else
  271.     {
  272.       pVals->Mode = AdrModeMemReg;
  273.       pVals->Arg |= 0xb8;
  274.     }
  275.     goto done;
  276.   }
  277.  
  278.   if (DecodeAdrRegStr(ArgStr[ArgIndex].str.p_str, &pVals->Arg))
  279.   {
  280.     pVals->Mode = AdrModeAReg;
  281.     goto done;
  282.   }
  283.  
  284.   /* immediate: */
  285.  
  286.   if (*ArgStr[ArgIndex].str.p_str == '#')
  287.   {
  288.     Boolean OK;
  289.     LongInt Value;
  290.  
  291.     /* avoid returning AdrModeMemReg if immediate is forbidden */
  292.  
  293.     if (!(ModeMask &MModeImm))
  294.       goto error;
  295.  
  296.     switch ((int)OpSize)
  297.     {
  298.       case eSymbolSize8Bit:
  299.         Value = EvalStrIntExpressionOffs(&ArgStr[ArgIndex], 1, Int8, &OK);
  300.         break;
  301.       case eSymbolSize16Bit:
  302.         Value = EvalStrIntExpressionOffs(&ArgStr[ArgIndex], 1, Int16, &OK);
  303.         break;
  304.       case eSymbolSize32Bit:
  305.         Value = EvalStrIntExpressionOffs(&ArgStr[ArgIndex], 1, Int32, &OK);
  306.         break;
  307.       case eSymbolSize24Bit:
  308.         Value = EvalStrIntExpressionOffs(&ArgStr[ArgIndex], 1, Int24, &OK);
  309.         break;
  310.       case OpSizeBitPos8:
  311.         Value = EvalStrIntExpressionOffs(&ArgStr[ArgIndex], 1, UInt3, &OK);
  312.         break;
  313.       case OpSizeBitPos16:
  314.         Value = EvalStrIntExpressionOffs(&ArgStr[ArgIndex], 1, UInt4, &OK);
  315.         break;
  316.       case OpSizeBitPos32:
  317.       case OpSizeShiftCount:
  318.         Value = EvalStrIntExpressionOffs(&ArgStr[ArgIndex], 1, UInt5, &OK);
  319.         break;
  320.       default:
  321.         WrStrErrorPos(ErrNum_UndefOpSizes, &ArgStr[ArgIndex]);
  322.         goto done;
  323.     }
  324.  
  325.     if ((ModeMask & MModeMemReg) && (ShortImm(Value, OpSize, &pVals->Arg, &pVals->ShiftLSB)))
  326.     {
  327.       pVals->Mode = AdrModeMemReg;
  328.       pVals->Arg |= 0x70;
  329.     }
  330.     else
  331.     {
  332.       pVals->Mode = AdrModeImm;
  333.       if (OpSize == eSymbolSize32Bit)
  334.         pVals->Vals[pVals->ValCnt++] = (Value >> 24) & 0xff;
  335.       if ((OpSize == eSymbolSize32Bit) || (OpSize == eSymbolSize24Bit))
  336.         pVals->Vals[pVals->ValCnt++] = (Value >> 16) & 0xff;
  337.       if ((OpSize != eSymbolSize8Bit) && (OpSize < OpSizeBitPos8))
  338.         pVals->Vals[pVals->ValCnt++] = (Value >> 8) & 0xff;
  339.       pVals->Vals[pVals->ValCnt++] = Value & 0xff;
  340.     }
  341.     goto done;
  342.   }
  343.  
  344.   /* indirect () []: */
  345.  
  346.   l = strlen(ArgStr[ArgIndex].str.p_str);
  347.   if (IsIndirect(ArgStr[ArgIndex].str.p_str))
  348.     IndirMode = eIndirModePar;
  349.   else if ((l >= 2) && (ArgStr[ArgIndex].str.p_str[0] == '[') && (ArgStr[ArgIndex].str.p_str[l - 1] == ']'))
  350.     IndirMode = eIndirModeSquare;
  351.   else
  352.     IndirMode = eIndirModeNone;
  353.  
  354.   if (IndirMode)
  355.   {
  356.     char *pSep, IncChar;
  357.     LongInt DispAcc = 0;
  358.     Byte DataReg = 0, AdrReg = 0, AdrIncReg = 0;
  359.     Boolean AdrRegPresent = False, DataRegPresent = False, HasDisp = False;
  360.     tIncMode IncMode = eIncModeNone;
  361.     tStrComp Right, RunComp;
  362.  
  363.     CopyIndirect(&Comp, &ArgStr[ArgIndex]);
  364.     StrCompRefRight(&RunComp, &Comp, 0);
  365.  
  366.     /* split into components */
  367.  
  368.     while (True)
  369.     {
  370.       pSep = QuotPos(RunComp.str.p_str, ',');
  371.       if (pSep)
  372.         StrCompSplitRef(&RunComp, &Right, &RunComp, pSep);
  373.  
  374.       /* remove leading/trailing spaces */
  375.  
  376.       KillPrefBlanksStrCompRef(&RunComp);
  377.       KillPostBlanksStrComp(&RunComp);
  378.       l = strlen(RunComp.str.p_str);
  379.  
  380.       if (DecodeRegStr(RunComp.str.p_str, &DataReg))
  381.       {
  382.         if (DataRegPresent)
  383.         {
  384.           WrStrErrorPos(ErrNum_InvAddrMode, &RunComp);
  385.           goto done;
  386.         }
  387.         DataRegPresent = True;
  388.       }
  389.       else if (DecodeAdrRegStr(RunComp.str.p_str, &AdrReg))
  390.       {
  391.         if (AdrRegPresent)
  392.         {
  393.           WrStrErrorPos(ErrNum_InvAddrMode, &RunComp);
  394.           goto done;
  395.         }
  396.         AdrRegPresent = True;
  397.       }
  398.       else if (IsIncDec(*RunComp.str.p_str, &IncChar) && DecodeAdrRegStr(RunComp.str.p_str + 1, &AdrIncReg))
  399.       {
  400.         if (IncMode)
  401.         {
  402.           WrStrErrorPos(ErrNum_InvAddrMode, &RunComp);
  403.           goto done;
  404.         }
  405.         IncMode = (IncChar == '+') ? eIncModePreInc : eIncModePreDec;
  406.       }
  407.       else if (IsIncDec(Comp.str.p_str[l - 1], &IncChar))
  408.       {
  409.         RunComp.str.p_str[l - 1] = '\0';
  410.         if (!DecodeAdrRegStr(RunComp.str.p_str, &AdrIncReg))
  411.         {
  412.           WrStrErrorPos(ErrNum_InvReg, &RunComp);
  413.           goto done;
  414.         }
  415.         if (IncMode)
  416.         {
  417.           WrStrErrorPos(ErrNum_InvAddrMode, &RunComp);
  418.           goto done;
  419.         }
  420.         IncMode = (IncChar == '+') ? eIncModePostInc : eIncModePostDec;
  421.       }
  422.       else
  423.       {
  424.         Boolean OK;
  425.         LongInt Val = EvalStrIntExpression(&RunComp, Int24, &OK);
  426.  
  427.         if (!OK)
  428.           goto done;
  429.         DispAcc += Val;
  430.         HasDisp = True;
  431.       }
  432.  
  433.       if (pSep)
  434.         RunComp = Right;
  435.       else
  436.         break;
  437.     }
  438.  
  439.     /* pre/pos in/decrement */
  440.  
  441.     if ((IndirMode == eIndirModePar) && IncMode && !DispAcc && !AdrRegPresent && !DataRegPresent)
  442.     {
  443.       switch (AdrIncReg)
  444.       {
  445.         case 0:
  446.         case 1:
  447.           pVals->Arg = 0xc3 | (AdrIncReg << 4);
  448.           if ((IncMode == eIncModePostInc) || (IncMode == eIncModePreInc))
  449.             pVals->Arg |= 0x20;
  450.           if ((IncMode == eIncModePostInc) || (IncMode == eIncModePostDec))
  451.             pVals->Arg |= 0x04;
  452.           pVals->Mode = AdrModeMemReg;
  453.           break;
  454.         case 2:
  455.           if (IncMode == eIncModePreDec)
  456.           {
  457.             pVals->Arg = 0xfb;
  458.             pVals->Mode = AdrModeMemReg;
  459.           }
  460.           else if (IncMode == eIncModePostInc)
  461.           {
  462.             pVals->Arg = 0xff;
  463.             pVals->Mode = AdrModeMemReg;
  464.           }
  465.           else
  466.             goto error;
  467.           break;
  468.         default:
  469.           goto error;
  470.       }
  471.     }
  472.  
  473.     /* (disp,XYSP) */
  474.  
  475.     else if ((IndirMode == eIndirModePar) && AdrRegPresent && !DataRegPresent && !IncMode)
  476.     {
  477.       if ((AdrReg == 3) && (HasDisp))
  478.         DispAcc -= EProgCounter();
  479.  
  480.       if ((DispAcc >= 0) && (DispAcc <= 15) && (AdrReg != 3))
  481.       {
  482.         pVals->Arg = 0x40 | (AdrReg << 4) | (DispAcc & 15);
  483.         pVals->Mode = AdrModeMemReg;
  484.       }
  485.       else if (RangeCheck(DispAcc, SInt9))
  486.       {
  487.         pVals->Arg = 0xc0 | (AdrReg << 4) | ((DispAcc >> 8) & 1);
  488.         pVals->Vals[pVals->ValCnt++] = DispAcc & 0xff;
  489.         pVals->Mode = AdrModeMemReg;
  490.       }
  491.       else
  492.       {
  493.         pVals->Arg = 0xc2 | (AdrReg << 4);
  494.         pVals->Vals[pVals->ValCnt++] = (DispAcc >> 16) & 0xff;
  495.         pVals->Vals[pVals->ValCnt++] = (DispAcc >> 8) & 0xff;
  496.         pVals->Vals[pVals->ValCnt++] = DispAcc & 0xff;
  497.         pVals->Mode = AdrModeMemReg;
  498.       }
  499.     }
  500.  
  501.     /* (Dn,XYS) */
  502.  
  503.     else if ((IndirMode == eIndirModePar) && AdrRegPresent && DataRegPresent && !IncMode && !DispAcc)
  504.     {
  505.       if (AdrReg == 3)
  506.         goto error;
  507.       else
  508.       {
  509.         pVals->Arg = 0x88 | (AdrReg << 4) | DataReg;
  510.         pVals->Mode = AdrModeMemReg;
  511.       }
  512.     }
  513.  
  514.     /* (disp,Dn) */
  515.  
  516.     else if ((IndirMode == eIndirModePar) && !AdrRegPresent && DataRegPresent && !IncMode)
  517.     {
  518.       if (RangeCheck(DispAcc, UInt18))
  519.       {
  520.         pVals->Arg = 0x80 | DataReg | ((DispAcc >> 12) & 0x30);
  521.         pVals->Vals[pVals->ValCnt++] = (DispAcc >> 8) & 0xff;
  522.         pVals->Vals[pVals->ValCnt++] = DispAcc & 0xff;
  523.         pVals->Mode = AdrModeMemReg;
  524.       }
  525.       else
  526.       {
  527.         pVals->Arg = 0xe8 | DataReg;
  528.         pVals->Vals[pVals->ValCnt++] = (DispAcc >> 16) & 0xff;
  529.         pVals->Vals[pVals->ValCnt++] = (DispAcc >> 8) & 0xff;
  530.         pVals->Vals[pVals->ValCnt++] = DispAcc & 0xff;
  531.         pVals->Mode = AdrModeMemReg;
  532.       }
  533.     }
  534.  
  535.     /* [Dn,XY] */
  536.  
  537.     else if ((IndirMode == eIndirModeSquare) && AdrRegPresent && DataRegPresent && !IncMode && !DispAcc)
  538.     {
  539.       if (AdrReg >= 2)
  540.         goto error;
  541.       else
  542.       {
  543.         pVals->Arg = 0xc8 | (AdrReg << 4) | DataReg;
  544.         pVals->Mode = AdrModeMemReg;
  545.       }
  546.     }
  547.  
  548.     /* [disp,XYSP] */
  549.  
  550.     else if ((IndirMode == eIndirModeSquare) && AdrRegPresent && !DataRegPresent && !IncMode)
  551.     {
  552.       if ((AdrReg == 3) && (HasDisp))
  553.         DispAcc -= EProgCounter();
  554.  
  555.       if (RangeCheck(DispAcc, SInt9))
  556.       {
  557.         pVals->Arg = 0xc4 | (AdrReg << 4) | ((DispAcc >> 8) & 1);
  558.         pVals->Vals[pVals->ValCnt++] = DispAcc & 0xff;
  559.         pVals->Mode = AdrModeMemReg;
  560.       }
  561.       else
  562.       {
  563.         pVals->Arg = 0xc6 | (AdrReg << 4);
  564.         pVals->Vals[pVals->ValCnt++] = (DispAcc >> 16) & 0xff;
  565.         pVals->Vals[pVals->ValCnt++] = (DispAcc >> 8) & 0xff;
  566.         pVals->Vals[pVals->ValCnt++] = DispAcc & 0xff;
  567.         pVals->Mode = AdrModeMemReg;
  568.       }
  569.     }
  570.  
  571.     /* [disp] */
  572.  
  573.     else if ((IndirMode == eIndirModeSquare) && !AdrRegPresent && !DataRegPresent && !IncMode)
  574.     {
  575.       pVals->Arg = 0xfe;
  576.       pVals->Vals[pVals->ValCnt++] = (DispAcc >> 16) & 0xff;
  577.       pVals->Vals[pVals->ValCnt++] = (DispAcc >> 8) & 0xff;
  578.       pVals->Vals[pVals->ValCnt++] = DispAcc & 0xff;
  579.       pVals->Mode = AdrModeMemReg;
  580.     }
  581.  
  582.     else
  583.       goto error;
  584.  
  585.     goto done;
  586.   }
  587.  
  588.   /* absolute: */
  589.  
  590.   Address = EvalStrIntExpression(&ArgStr[ArgIndex], UInt24, &OK);
  591.   if (OK)
  592.   {
  593.     if (RangeCheck(Address, UInt14))
  594.     {
  595.       pVals->Arg = 0x00 | ((Address >> 8) & 0x3f);
  596.       pVals->Vals[pVals->ValCnt++] = Address & 0xff;
  597.     }
  598.     else if (RangeCheck(Address, UInt18))
  599.     {
  600.       pVals->Arg = 0xf8 | ((Address >> 16) & 1) | ((Address >> 15) & 4);
  601.       pVals->Vals[pVals->ValCnt++] = (Address >> 8) & 0xff;
  602.       pVals->Vals[pVals->ValCnt++] = Address & 0xff;
  603.     }
  604.     else
  605.     {
  606.       pVals->Arg = 0xfa;
  607.       pVals->Vals[pVals->ValCnt++] = (Address >> 16) & 0xff;
  608.       pVals->Vals[pVals->ValCnt++] = (Address >> 8) & 0xff;
  609.       pVals->Vals[pVals->ValCnt++] = Address & 0xff;
  610.     }
  611.     pVals->Mode = AdrModeMemReg;
  612.   }
  613.  
  614. done:
  615.   if ((pVals->Mode != AdrModeNone) && !((ModeMask >> pVals->Mode) & 1))
  616.   {
  617.     ResetAdrVals(pVals);
  618.     goto error;
  619.   }
  620.   return (pVals->Mode != AdrModeNone);
  621.  
  622. error:
  623.   WrStrErrorPos(ErrNum_InvAddrMode, &ArgStr[ArgIndex]);
  624.   return False;
  625. }
  626.  
  627. static Boolean IsImmediate(const tAdrVals *pVals, ShortInt OpSize, Byte *pImmVal)
  628. {
  629.   switch (pVals->Mode)
  630.   {
  631.     case AdrModeImm:
  632.       *pImmVal = pVals->Vals[pVals->ValCnt - 1];
  633.       return True;
  634.     case AdrModeMemReg:
  635.       if ((pVals->Arg & 0xf0) == 0x70)
  636.       {
  637.         *pImmVal = pVals->Arg & 15;
  638.         if (OpSize == OpSizeShiftCount)
  639.           *pImmVal = (*pImmVal << 1) | pVals->ShiftLSB;
  640.         else if (!*pImmVal && (OpSize < OpSizeBitPos8))
  641.           *pImmVal = 0xff;
  642.         return True;
  643.       }
  644.       /* else fall-through */
  645.     default:
  646.       *pImmVal = 0;
  647.       return False;
  648.   }
  649. }
  650.  
  651. static void ChangeImmediate(tAdrVals *pVals, ShortInt OpSize, Byte ImmVal)
  652. {
  653.   unsigned z;
  654.  
  655.   pVals->Mode = AdrModeImm;
  656.   pVals->Arg = 0;
  657.   pVals->ValCnt = OpSizeByteLen(OpSize);
  658.   pVals->Vals[pVals->ValCnt - 1] = ImmVal;
  659.   for (z = 1; z < pVals->ValCnt; z++)
  660.     pVals->Vals[z] = (ImmVal & 0x80) ? 0xff : 0x00;
  661. }
  662.  
  663. static Boolean IsReg(const tAdrVals *pVals, Byte *pReg)
  664. {
  665.   switch (pVals->Mode)
  666.   {
  667.     case AdrModeReg:
  668.       *pReg = pVals->Arg;
  669.       return True;
  670.     case AdrModeMemReg:
  671.       if ((pVals->Arg & 0xf8) == 0xb8)
  672.       {
  673.         *pReg = pVals->Arg & 7;
  674.         return True;
  675.       }
  676.       /* else fall-through */
  677.     default:
  678.       *pReg = 0;
  679.       return False;
  680.   }
  681. }
  682.  
  683. static Boolean SetOpSize(tSymbolSize NewOpSize)
  684. {
  685.   if ((OpSize == NewOpSize) || (OpSize == eSymbolSizeUnknown))
  686.   {
  687.     OpSize = NewOpSize;
  688.     return True;
  689.   }
  690.   else
  691.   {
  692.     char Str[30];
  693.  
  694.     as_snprintf(Str, sizeof(Str), "%d -> %d", (int)OpSize, (int)NewOpSize);
  695.     WrXError(ErrNum_ConfOpSizes, Str);
  696.     return False;
  697.   }
  698. }
  699.  
  700. static Boolean SizeCode2(ShortInt ThisOpSize, Byte *pSizeCode)
  701. {
  702.   switch (ThisOpSize)
  703.   {
  704.     case eSymbolSize8Bit: *pSizeCode = 0; break;
  705.     case eSymbolSize16Bit: *pSizeCode = 1; break;
  706.     case eSymbolSize24Bit: *pSizeCode = 2; break;
  707.     case eSymbolSize32Bit: *pSizeCode = 3; break;
  708.     default: return False;
  709.   }
  710.   return True;
  711. }
  712.  
  713. static Boolean DecodeImmBitField(tStrComp *pArg, Word *pResult)
  714. {
  715.   char *pSplit = strchr(pArg->str.p_str, ':'), Save;
  716.   tStrComp Left, Right;
  717.   Boolean OK;
  718.   tSymbolFlags Flags;
  719.  
  720.   if (!pSplit)
  721.   {
  722.     WrError(ErrNum_InvBitPos);
  723.     return False;
  724.   }
  725.   Save = StrCompSplitRef(&Left, &Right, pArg, pSplit);
  726.   *pResult = EvalStrIntExpressionWithFlags(&Left, UInt6, &OK, &Flags);
  727.   if (mFirstPassUnknown(Flags))
  728.     *pResult &= 31;
  729.   *pSplit = Save;
  730.   if (!OK || !ChkRange(*pResult, 1, 32))
  731.     return False;
  732.   *pResult = (*pResult << 5) | (EvalStrIntExpression(&Right, UInt5, &OK) & 31);
  733.   return OK;
  734. }
  735.  
  736. /*--------------------------------------------------------------------------*/
  737. /* Bit Symbol Handling */
  738.  
  739. /*
  740.  * Compact representation of bits and bit fields in symbol table:
  741.  * bits 0..2/3/4: (start) bit position
  742.  * bits 3/4/5...14/15/16: register address in I/O space (first 4K)
  743.  * bits 20/21: register size (0/1/2/3 for 8/16/32/24 bits)
  744.  * bits 24..28: length of bit field minus one (0 for individual bit)
  745.  */
  746.  
  747. /*!------------------------------------------------------------------------
  748.  * \fn     AssembleBitfieldSymbol(Byte BitPos, Byte Width, ShortInt OpSize, Word Address)
  749.  * \brief  build the compact internal representation of a bit field symbol
  750.  * \param  BitPos bit position in word
  751.  * \param  Width width of bit field
  752.  * \param  OpSize operand size (0..2)
  753.  * \param  Address register address
  754.  * \return compact representation
  755.  * ------------------------------------------------------------------------ */
  756.  
  757. static LongWord AssembleBitfieldSymbol(Byte BitPos, Byte Width, ShortInt OpSize, Word Address)
  758. {
  759.   LongWord CodeOpSize = (OpSize == eSymbolSize24Bit) ? 3 : OpSize;
  760.   int AddrShift = (OpSize == eSymbolSize24Bit) ? 5 : (3 + OpSize);
  761.  
  762.   return BitPos
  763.        | (((LongWord)Address & 0xfff) << AddrShift)
  764.        | (CodeOpSize << 20)
  765.        | (((LongWord)(Width - 1) & 31) << 24);
  766. }
  767.  
  768. /*!------------------------------------------------------------------------
  769.  * \fn     AssembleBitSymbol(Byte BitPos, ShortInt OpSize, Word Address)
  770.  * \brief  build the compact internal representation of a bit symbol
  771.  * \param  BitPos bit position in word
  772.  * \param  OpSize operand size (0..2)
  773.  * \param  Address register address
  774.  * \return compact representation
  775.  * ------------------------------------------------------------------------ */
  776.  
  777. static LongWord AssembleBitSymbol(Byte BitPos, ShortInt OpSize, Word Address)
  778. {
  779.   return AssembleBitfieldSymbol(BitPos, 1, OpSize, Address);
  780. }
  781.  
  782. /*!------------------------------------------------------------------------
  783.  * \fn     EvalBitPosition(const char *pBitArg, Boolean *pOK, ShortInt OpSize)
  784.  * \brief  evaluate constant bit position, with bit range depending on operand size
  785.  * \param  pBitArg bit position argument
  786.  * \param  pOK returns True if OK
  787.  * \param  OpSize operand size (0,1,2 -> 8,16,32 bits)
  788.  * \return bit position as number
  789.  * ------------------------------------------------------------------------ */
  790.  
  791. static Byte EvalBitPosition(const tStrComp *pBitArg, Boolean *pOK, ShortInt OpSize)
  792. {
  793.   switch (OpSize)
  794.   {
  795.     case eSymbolSize8Bit:
  796.       return EvalStrIntExpression(pBitArg, UInt3, pOK);
  797.     case eSymbolSize16Bit:
  798.       return EvalStrIntExpression(pBitArg, UInt4, pOK);
  799.     case eSymbolSize24Bit:
  800.     {
  801.       Byte Result;
  802.       tSymbolFlags Flags;
  803.  
  804.       Result = EvalStrIntExpressionWithFlags(pBitArg, UInt5, pOK, &Flags);
  805.       if (!*pOK)
  806.         return Result;
  807.       if (mFirstPassUnknown(Flags))
  808.         Result &= 15;
  809.       *pOK = ChkRange(Result, 0, 23);
  810.       return Result;
  811.     }
  812.     case eSymbolSize32Bit:
  813.       return EvalStrIntExpression(pBitArg, UInt5, pOK);
  814.     default:
  815.       WrError(ErrNum_InvOpSize);
  816.       *pOK = False;
  817.       return 0;
  818.   }
  819. }
  820.  
  821. /*!------------------------------------------------------------------------
  822.  * \fn     DecodeBitArg2(LongWord *pResult, const tStrComp *pRegArg, const tStrComp *pBitArg, ShortInt OpSize)
  823.  * \brief  encode a bit symbol, address & bit position separated
  824.  * \param  pResult resulting encoded bit
  825.  * \param  pRegArg register argument
  826.  * \param  pBitArg bit argument
  827.  * \param  OpSize register size (0/1/2 = 8/16/32 bit)
  828.  * \return True if success
  829.  * ------------------------------------------------------------------------ */
  830.  
  831. static Boolean DecodeBitArg2(LongWord *pResult, const tStrComp *pRegArg, const tStrComp *pBitArg, ShortInt OpSize)
  832. {
  833.   Boolean OK;
  834.   tSymbolFlags Flags;
  835.   LongWord Addr;
  836.   Byte BitPos;
  837.  
  838.   BitPos = EvalBitPosition(pBitArg, &OK, OpSize);
  839.   if (!OK)
  840.     return False;
  841.  
  842.   /* all I/O registers reside in the first 4K of the address space */
  843.  
  844.   Addr = EvalStrIntExpressionWithFlags(pRegArg, UInt12, &OK, &Flags);
  845.   if (!OK)
  846.     return False;
  847.  
  848.   *pResult = AssembleBitSymbol(BitPos, OpSize, Addr);
  849.  
  850.   return True;
  851. }
  852.  
  853. /*!------------------------------------------------------------------------
  854.  * \fn     DecodeBitfieldArg2(LongWord *pResult, const tStrComp *pRegArg, tStrComp *pBitArg, ShortInt OpSize)
  855.  * \brief  encode a bit field symbol, address & bit position separated
  856.  * \param  pResult resulting encoded bit
  857.  * \param  pRegArg register argument
  858.  * \param  pBitArg bit argument
  859.  * \param  OpSize register size (0/1/2 = 8/16/32 bit)
  860.  * \return True if success
  861.  * ------------------------------------------------------------------------ */
  862.  
  863. static Boolean DecodeBitfieldArg2(LongWord *pResult, const tStrComp *pRegArg, tStrComp *pBitArg, ShortInt OpSize)
  864. {
  865.   Boolean OK;
  866.   LongWord Addr;
  867.   Word BitSpec;
  868.  
  869.   if (!DecodeImmBitField(pBitArg, &BitSpec))
  870.     return False;
  871.  
  872.   /* all I/O registers reside in the first 4K of the address space */
  873.  
  874.   Addr = EvalStrIntExpression(pRegArg, UInt12, &OK);
  875.   if (!OK)
  876.     return False;
  877.  
  878.   *pResult = AssembleBitfieldSymbol(BitSpec & 31, (BitSpec >> 5) & 31, OpSize, Addr);
  879.  
  880.   return True;
  881. }
  882.  
  883. /*!------------------------------------------------------------------------
  884.  * \fn     DecodeBitArg(LongWord *pResult, int Start, int Stop, ShortInt OpSize)
  885.  * \brief  encode a bit symbol from instruction argument(s)
  886.  * \param  pResult resulting encoded bit
  887.  * \param  Start first argument
  888.  * \param  Stop last argument
  889.  * \param  OpSize register size (0/1/2 = 8/16/32 bit)
  890.  * \return True if success
  891.  * ------------------------------------------------------------------------ */
  892.  
  893. static Boolean DecodeBitArg(LongWord *pResult, int Start, int Stop, ShortInt OpSize)
  894. {
  895.   *pResult = 0;
  896.  
  897.   /* Just one argument -> parse as bit argument */
  898.  
  899.   if (Start == Stop)
  900.   {
  901.     tEvalResult EvalResult;
  902.  
  903.     *pResult = EvalStrIntExpressionWithResult(&ArgStr[Start], UInt32, &EvalResult);
  904.     if (EvalResult.OK)
  905.       ChkSpace(SegBData, EvalResult.AddrSpaceMask);
  906.     return EvalResult.OK;
  907.   }
  908.  
  909.   /* register & bit position are given as separate arguments */
  910.  
  911.   else if (Stop == Start + 1)
  912.     return DecodeBitArg2(pResult, &ArgStr[Start], &ArgStr[Stop], OpSize);
  913.  
  914.   /* other # of arguments not allowed */
  915.  
  916.   else
  917.   {
  918.     WrError(ErrNum_WrongArgCnt);
  919.     return False;
  920.   }
  921. }
  922.  
  923. /*!------------------------------------------------------------------------
  924.  * \fn     DecodeBitfieldArg(LongWord *pResult, int Start, int Stop, ShortInt OpSize)
  925.  * \brief  encode a bit symbol from instruction argument(s)
  926.  * \param  pResult resulting encoded bit
  927.  * \param  Start first argument
  928.  * \param  Stop last argument
  929.  * \return True if success
  930.  * ------------------------------------------------------------------------ */
  931.  
  932. static Boolean DecodeBitfieldArg(LongWord *pResult, int Start, int Stop, ShortInt OpSize)
  933. {
  934.   *pResult = 0;
  935.  
  936.   /* Just one argument -> parse as bit field argument */
  937.  
  938.   if (Start == Stop)
  939.   {
  940.     tEvalResult EvalResult;
  941.  
  942.     *pResult = EvalStrIntExpressionWithResult(&ArgStr[Start], UInt32, &EvalResult);
  943.     if (EvalResult.OK)
  944.       ChkSpace(SegBData, EvalResult.AddrSpaceMask);
  945.     return EvalResult.OK;
  946.   }
  947.  
  948.   /* register & bit position are given as separate arguments */
  949.  
  950.   else if (Stop == Start + 1)
  951.     return DecodeBitfieldArg2(pResult, &ArgStr[Start], &ArgStr[Stop], OpSize);
  952.  
  953.   /* other # of arguments not allowed */
  954.  
  955.   else
  956.   {
  957.     WrError(ErrNum_WrongArgCnt);
  958.     return False;
  959.   }
  960. }
  961.  
  962. /*!------------------------------------------------------------------------
  963.  * \fn     DissectBitSymbol(LongWord BitSymbol, Word *pAddress, Byte *pBitPos, Byte *pWidth, tSymbolSize *pOpSize)
  964.  * \brief  transform compact represenation of bit (field) symbol into components
  965.  * \param  BitSymbol compact storage
  966.  * \param  pAddress (I/O) register address
  967.  * \param  pBitPos (start) bit position
  968.  * \param  pWidth pWidth width of bit field, always one for individual bit
  969.  * \param  pOpSize returns register size (0/1/2 for 8/16/32 bits)
  970.  * \return constant True
  971.  * ------------------------------------------------------------------------ */
  972.  
  973. static Boolean DissectBitSymbol(LongWord BitSymbol, Word *pAddress, Byte *pBitPos, Byte *pWidth, tSymbolSize *pOpSize)
  974. {
  975.   *pOpSize = (tSymbolSize)((BitSymbol >> 20) & 3);
  976.   switch (*pOpSize)
  977.   {
  978.     case eSymbolSize8Bit:
  979.       *pAddress = (BitSymbol >> 3) & 0xfff;
  980.       *pBitPos = BitSymbol & 7;
  981.       break;
  982.     case eSymbolSize16Bit:
  983.       *pAddress = (BitSymbol >> 4) & 0xfff;
  984.       *pBitPos = BitSymbol & 15;
  985.       break;
  986.     case 3:
  987.       *pOpSize = eSymbolSize24Bit;
  988.       /* fall-through */
  989.     case eSymbolSize32Bit:
  990.       *pAddress = (BitSymbol >> 5) & 0xfff;
  991.       *pBitPos = BitSymbol & 31;
  992.     default:
  993.       break;
  994.   }
  995.   *pWidth = 1 + ((BitSymbol >> 24) & 31);
  996.   return True;
  997. }
  998.  
  999. /*!------------------------------------------------------------------------
  1000.  * \fn     DissectBit_S12Z(char *pDest, size_t DestSize, LargeWord Inp)
  1001.  * \brief  dissect compact storage of bit (field) into readable form for listing
  1002.  * \param  pDest destination for ASCII representation
  1003.  * \param  DestSize destination buffer size
  1004.  * \param  Inp compact storage
  1005.  * ------------------------------------------------------------------------ */
  1006.  
  1007. static void DissectBit_S12Z(char *pDest, size_t DestSize, LargeWord Inp)
  1008. {
  1009.   Byte BitPos, BitWidth;
  1010.   Word Address;
  1011.   tSymbolSize OpSize;
  1012.   char Attribute;
  1013.  
  1014.   DissectBitSymbol(Inp, &Address, &BitPos, &BitWidth, &OpSize);
  1015.   Attribute = (OpSize == eSymbolSize24Bit) ? 'p' : "bwl"[OpSize];
  1016.  
  1017.   if (BitWidth > 1)
  1018.     as_snprintf(pDest, DestSize, "$%x(%c).%u:%u", (unsigned)Address, Attribute, (unsigned)BitWidth, (unsigned)BitPos);
  1019.   else
  1020.     as_snprintf(pDest, DestSize, "$%x(%c).%u", (unsigned)Address, Attribute, (unsigned)BitPos);
  1021. }
  1022.  
  1023. /*!------------------------------------------------------------------------
  1024.  * \fn     ExpandS12ZBit(const tStrComp *pVarName, const struct sStructElem *pStructElem, LargeWord Base)
  1025.  * \brief  expands bit definition when a structure is instantiated
  1026.  * \param  pVarName desired symbol name
  1027.  * \param  pStructElem element definition
  1028.  * \param  Base base address of instantiated structure
  1029.  * ------------------------------------------------------------------------ */
  1030.  
  1031. static void ExpandS12ZBit(const tStrComp *pVarName, const struct sStructElem *pStructElem, LargeWord Base)
  1032. {
  1033.   LongWord Address = Base + pStructElem->Offset;
  1034.  
  1035.   if (pInnermostNamedStruct)
  1036.   {
  1037.     PStructElem pElem = CloneStructElem(pVarName, pStructElem);
  1038.  
  1039.     if (!pElem)
  1040.       return;
  1041.     pElem->Offset = Address;
  1042.     AddStructElem(pInnermostNamedStruct->StructRec, pElem);
  1043.   }
  1044.   else
  1045.   {
  1046.     ShortInt OpSize = (pStructElem->OpSize < 0) ? 0 : pStructElem->OpSize;
  1047.  
  1048.     if (!ChkRange(Address, 0, 0xfff)
  1049.      || !ChkRange(pStructElem->BitPos, 0, (8 << OpSize) - 1))
  1050.       return;
  1051.  
  1052.     PushLocHandle(-1);
  1053.     EnterIntSymbol(pVarName, AssembleBitSymbol(pStructElem->BitPos, OpSize, Address), SegBData, False);
  1054.     PopLocHandle();
  1055.     /* TODO: MakeUseList? */
  1056.   }
  1057. }
  1058.  
  1059. /*!------------------------------------------------------------------------
  1060.  * \fn     ExpandS12ZBitfield(const tStrComp *pVarName, const struct sStructElem *pStructElem, LargeWord Base)
  1061.  * \brief  expands bit field definition when a structure is instantiated
  1062.  * \param  pVarName desired symbol name
  1063.  * \param  pStructElem element definition
  1064.  * \param  Base base address of instantiated structure
  1065.  * ------------------------------------------------------------------------ */
  1066.  
  1067. static void ExpandS12ZBitfield(const tStrComp *pVarName, const struct sStructElem *pStructElem, LargeWord Base)
  1068. {
  1069.   LongWord Address = Base + pStructElem->Offset;
  1070.  
  1071.   if (pInnermostNamedStruct)
  1072.   {
  1073.     PStructElem pElem = CloneStructElem(pVarName, pStructElem);
  1074.  
  1075.     if (!pElem)
  1076.       return;
  1077.     pElem->Offset = Address;
  1078.     AddStructElem(pInnermostNamedStruct->StructRec, pElem);
  1079.   }
  1080.   else
  1081.   {
  1082.     ShortInt OpSize = (pStructElem->OpSize < 0) ? 0 : pStructElem->OpSize;
  1083.  
  1084.     if (!ChkRange(Address, 0, 0xfff)
  1085.      || !ChkRange(pStructElem->BitPos, 0, (8 << OpSize) - 1)
  1086.      || !ChkRange(pStructElem->BitPos + pStructElem->BitWidthM1, 0, (8 << OpSize) - 1))
  1087.       return;
  1088.  
  1089.     PushLocHandle(-1);
  1090.     EnterIntSymbol(pVarName, AssembleBitfieldSymbol(pStructElem->BitPos, pStructElem->BitWidthM1 + 1, OpSize, Address), SegBData, False);
  1091.     PopLocHandle();
  1092.     /* TODO: MakeUseList? */
  1093.   }
  1094. }
  1095.  
  1096. /*--------------------------------------------------------------------------*/
  1097. /* Instruction Decoders */
  1098.  
  1099. static void DecodeFixed(Word Code)
  1100. {
  1101.   if (*AttrPart.str.p_str) WrError(ErrNum_UseLessAttr);
  1102.   else if (ChkArgCnt(0, 0))
  1103.     PutCode(Code);
  1104. }
  1105.  
  1106. static Boolean DecodeBranchCore(int ArgIndex)
  1107. {
  1108.   Boolean OK;
  1109.   tSymbolFlags Flags;
  1110.   LongInt ShortDist, LongDist;
  1111.  
  1112.   /* manual says distance is relative to start of next instruction */
  1113.  
  1114.   ShortDist = EvalStrIntExpressionWithFlags(&ArgStr[ArgIndex], UInt24, &OK, &Flags) - (EProgCounter() + CodeLen + 1);
  1115.   if (!OK)
  1116.     return False;
  1117.   LongDist = ShortDist - 1;
  1118.  
  1119.   if (OpSize == eSymbolSizeUnknown)
  1120.     OpSize = ((ShortDist <= 63) && (ShortDist >= -64)) ? eSymbolSizeFloat32Bit : eSymbolSize32Bit;
  1121.   switch (OpSize)
  1122.   {
  1123.     case eSymbolSize32Bit:
  1124.       if (!mSymbolQuestionable(Flags) && !RangeCheck(LongDist, SInt15))
  1125.       {
  1126.         WrError(ErrNum_JmpDistTooBig);
  1127.         return False;
  1128.       }
  1129.       else
  1130.       {
  1131.         BAsmCode[CodeLen++] = 0x80 | ((LongDist >> 7) & 0x7f);
  1132.         BAsmCode[CodeLen++] = LongDist & 0xff;
  1133.       }
  1134.       break;
  1135.     case eSymbolSizeFloat32Bit:
  1136.       if (!mSymbolQuestionable(Flags) && !RangeCheck(ShortDist, SInt7))
  1137.       {
  1138.         WrError(ErrNum_JmpDistTooBig);
  1139.         return False;
  1140.       }
  1141.       else
  1142.       {
  1143.         BAsmCode[CodeLen++] = ShortDist & 0x7f;
  1144.       }
  1145.       break;
  1146.     default:
  1147.       WrStrErrorPos(ErrNum_InvOpSize, &AttrPart);
  1148.       return False;
  1149.   }
  1150.   return True;
  1151. }
  1152.  
  1153. static void DecodeBranch(Word Code)
  1154. {
  1155.   if (!ChkArgCnt(1, 1))
  1156.     return;
  1157.  
  1158.   PutCode(Code);
  1159.   if (!DecodeBranchCore(1))
  1160.     CodeLen = 0;
  1161. }
  1162.  
  1163. static void DecodeReg(Word Code)
  1164. {
  1165.   Byte Reg;
  1166.  
  1167.   if (ChkArgCnt(1, 1)
  1168.    && DecodeRegArg(1, &Reg, 0xff)
  1169.    && SetOpSize(RegSizes[Reg]))
  1170.     PutCode(Code | Reg);
  1171. }
  1172.  
  1173. static void DecodeTwoReg(Word Code)
  1174. {
  1175.   Byte SrcReg, DestReg;
  1176.  
  1177.   /* TODO: what is the operand order (source/dest)? The manual is
  1178.      unclear about this.  Assuming source is first argument, similar to TFR: */
  1179.  
  1180.   if (*AttrPart.str.p_str) WrError(ErrNum_UseLessAttr);
  1181.   else if (ChkArgCnt(2, 2)
  1182.         && DecodeRegArg(2, &DestReg, 0xff)
  1183.         && DecodeRegArg(1, &SrcReg, 0xff))
  1184.   {
  1185.     PutCode(Code);
  1186.     BAsmCode[CodeLen++] = DestReg | (SrcReg << 4);
  1187.   }
  1188. }
  1189.  
  1190. static void DecodeRegMemImm(Word Code)
  1191. {
  1192.   Byte Reg;
  1193.   tAdrVals AdrVals;
  1194.  
  1195.   if (ChkArgCnt(2, 2)
  1196.    && DecodeRegArg(1, &Reg, 0xff)
  1197.    && SetOpSize(RegSizes[Reg])
  1198.    && DecodeAdr(2, MModeImm | MModeMemReg, &AdrVals))
  1199.   {
  1200.     if (AdrVals.Mode == AdrModeImm)
  1201.       PutCode(Code | Reg);
  1202.     else
  1203.     {
  1204.       PutCode((Code + 0x10) | Reg);
  1205.       BAsmCode[CodeLen++] = AdrVals.Arg;
  1206.     }
  1207.     AppendAdrVals(&AdrVals);
  1208.   }
  1209. }
  1210.  
  1211. static void DecodeSUB(Word Code)
  1212. {
  1213.   Byte Reg;
  1214.   tAdrVals AdrVals;
  1215.  
  1216.   if (ArgCnt == 3)
  1217.   {
  1218.     if (DecodeRegArg(1, &Reg, 1 << 6)
  1219.      && DecodeAdrRegArg(2, &Reg, 3)
  1220.      && DecodeAdrRegArg(3, &Reg, 1 << (1 - Reg)))
  1221.     {
  1222.       BAsmCode[CodeLen++] = 0xfe - Reg;
  1223.     }
  1224.   }
  1225.   else if (ChkArgCnt(2, 3)
  1226.    && DecodeRegArg(1, &Reg, 0xff)
  1227.    && SetOpSize(RegSizes[Reg])
  1228.    && DecodeAdr(2, MModeImm | MModeMemReg, &AdrVals))
  1229.   {
  1230.     if (AdrVals.Mode == AdrModeImm)
  1231.       PutCode(Code | Reg);
  1232.     else
  1233.     {
  1234.       PutCode((Code + 0x10) | Reg);
  1235.       BAsmCode[CodeLen++] = AdrVals.Arg;
  1236.     }
  1237.     AppendAdrVals(&AdrVals);
  1238.   }
  1239. }
  1240.  
  1241. static void DecodeCMP(Word Code)
  1242. {
  1243.   if (ChkArgCnt(2, 2))
  1244.   {
  1245.     Byte Reg;
  1246.     tAdrVals AdrVals;
  1247.  
  1248.     DecodeAdr(1, MModeReg | MModeAReg, &AdrVals);
  1249.     Reg = AdrVals.Arg;
  1250.     switch (AdrVals.Mode)
  1251.     {
  1252.       case AdrModeReg:
  1253.         if (SetOpSize(RegSizes[Reg])
  1254.          && DecodeAdr(2, MModeImm | MModeMemReg, &AdrVals))
  1255.         {
  1256.           if (AdrVals.Mode == AdrModeImm)
  1257.             PutCode(Code | Reg);
  1258.           else
  1259.           {
  1260.             PutCode((Code + 0x10) | Reg);
  1261.             BAsmCode[CodeLen++] = AdrVals.Arg;
  1262.           }
  1263.           AppendAdrVals(&AdrVals);
  1264.         }
  1265.         break;
  1266.       case AdrModeAReg:
  1267.         if (Reg == 3) WrStrErrorPos(ErrNum_InvReg, &ArgStr[1]);
  1268.         else if (SetOpSize(eSymbolSize24Bit))
  1269.         {
  1270.           DecodeAdr(2, MModeImm | MModeMemReg | MModeAReg, &AdrVals);
  1271.           switch (AdrVals.Mode)
  1272.           {
  1273.             case AdrModeImm:
  1274.               PutCode((Reg == 2) ? 0x1b04 : (0xe8 | Reg));
  1275.               AppendAdrVals(&AdrVals);
  1276.               break;
  1277.             case AdrModeMemReg:
  1278.               PutCode((Reg == 2) ? 0x1b02 : (0xf8 | Reg));
  1279.               BAsmCode[CodeLen++] = AdrVals.Arg;
  1280.               AppendAdrVals(&AdrVals);
  1281.               break;
  1282.             case AdrModeAReg:
  1283.               if (Reg != 0) WrStrErrorPos(ErrNum_InvReg, &ArgStr[1]);
  1284.               else if (AdrVals.Arg != 1) WrStrErrorPos(ErrNum_InvReg, &ArgStr[2]);
  1285.               else
  1286.                 PutCode(0xfc);
  1287.               break;
  1288.             default:
  1289.               break;
  1290.           }
  1291.         }
  1292.         break;
  1293.       default:
  1294.         break;
  1295.     }
  1296.   }
  1297. }
  1298.  
  1299. static void DecodeImm8(Word Code)
  1300. {
  1301.   tAdrVals AdrVals;
  1302.  
  1303.   if (ChkArgCnt(1, 1) && SetOpSize(eSymbolSize8Bit) && DecodeAdr(1, MModeImm, &AdrVals))
  1304.   {
  1305.     PutCode(Code);
  1306.     AppendAdrVals(&AdrVals);
  1307.   }
  1308. }
  1309.  
  1310. static void DecodeShift(Word Code)
  1311. {
  1312.   if (ChkArgCnt(2,3))
  1313.   {
  1314.     tAdrVals CntAdrVals, OpAdrVals;
  1315.     tSymbolSize SaveOpSize;
  1316.     Boolean IsASL = (Code == 0xc0),
  1317.             IsASR = (Code == 0x80);
  1318.     Boolean ImmediateCnt, DestIsReg;
  1319.     Byte ImmCnt, SizeCode, OpReg, DestReg;
  1320.  
  1321.     /* force operand size to 5 bits for count */
  1322.  
  1323.     SaveOpSize = OpSize;
  1324.     OpSize = OpSizeShiftCount;
  1325.     if (!DecodeAdr(ArgCnt, MModeImm | MModeMemReg | MModeReg, &CntAdrVals))
  1326.       return;
  1327.     ImmediateCnt = IsImmediate(&CntAdrVals, OpSize, &ImmCnt);
  1328.     OpSize = SaveOpSize;
  1329.  
  1330.     /* source or source-and-dest operand */
  1331.  
  1332.     if (!DecodeAdr(ArgCnt - 1, MModeMemReg | MModeReg, &OpAdrVals))
  1333.       return;
  1334.  
  1335.     /* operand size not yet set - then set from source */
  1336.  
  1337.     if (IsReg(&OpAdrVals, &OpReg))
  1338.       SetOpSize(RegSizes[OpReg]);
  1339.     if (OpSize < 0)
  1340.     {
  1341.       WrError(ErrNum_UndefOpSizes);
  1342.       return;
  1343.     }
  1344.     else if (!SizeCode2(OpSize, &SizeCode))
  1345.     {
  1346.       WrError(ErrNum_InvOpSize);
  1347.       return;
  1348.     }
  1349.  
  1350.     /* for three args, destination is always a register */
  1351.  
  1352.     if (ArgCnt == 3)
  1353.     {
  1354.       /* dest reg does not set operand size - opsize is from src
  1355.          operand which may be memory */
  1356.  
  1357.       if (!DecodeRegArg(1, &DestReg, 0xff))
  1358.         return;
  1359.       DestIsReg = True;
  1360.     }
  1361.     else
  1362.       DestIsReg = IsReg(&OpAdrVals, &DestReg);
  1363.  
  1364.     /* REG-REG-OPR1/2/3 only allowed with ASL: convert to (REG-)OPR1/2/3-OPR1/2/3 for other instructions,
  1365.        unless count is immediate: */
  1366.  
  1367.     if (!IsASL && DestIsReg && (OpAdrVals.Mode == AdrModeReg) && !ImmediateCnt && (CntAdrVals.Mode == AdrModeMemReg))
  1368.     {
  1369.       OpAdrVals.Mode = AdrModeMemReg;
  1370.       OpAdrVals.Arg |= 0xb8;
  1371.     }
  1372.  
  1373.     /* REG-REG */
  1374.  
  1375.     if (DestIsReg && (OpAdrVals.Mode == AdrModeReg) && (CntAdrVals.Mode == AdrModeReg))
  1376.     {
  1377.       BAsmCode[CodeLen++] = 0x10 | DestReg;
  1378.       BAsmCode[CodeLen++] = Code | (IsASL ? 0x10 : 0x20) | OpAdrVals.Arg;
  1379.       BAsmCode[CodeLen++] = 0xb8 | CntAdrVals.Arg;
  1380.     }
  1381.  
  1382.     /* REG-IMM with n=1..2 */
  1383.  
  1384.     else if (DestIsReg && (OpAdrVals.Mode == AdrModeReg) && ImmediateCnt && (ImmCnt >= 1) && (ImmCnt <= 2))
  1385.     {
  1386.       BAsmCode[CodeLen++] = (IsASR ? 0x00 : 0x10) | DestReg;
  1387.       BAsmCode[CodeLen++] = Code | (IsASR ? 0x10 : 0x00) | ((ImmCnt - 1) << 3) | OpAdrVals.Arg;
  1388.     }
  1389.  
  1390.     /* REG-IMM with arbitrary n */
  1391.  
  1392.     else if (DestIsReg && (OpAdrVals.Mode == AdrModeReg) && ImmediateCnt)
  1393.     {
  1394.       BAsmCode[CodeLen++] = 0x10 | DestReg;
  1395.       BAsmCode[CodeLen++] = Code | (IsASL ? 0x00 : 0x10) | ((ImmCnt & 1) << 3) | OpAdrVals.Arg;
  1396.       BAsmCode[CodeLen++] = 0x70 | ((ImmCnt >> 1) & 7);
  1397.     }
  1398.  
  1399.     /* REG-OPR1/2/3 - ASL only */
  1400.  
  1401.     else if (IsASL && DestIsReg && (OpAdrVals.Mode == AdrModeReg) && (CntAdrVals.Mode == AdrModeMemReg))
  1402.     {
  1403.       BAsmCode[CodeLen++] = 0x10 | DestReg;
  1404.       BAsmCode[CodeLen++] = Code | (CntAdrVals.ShiftLSB << 3) | OpAdrVals.Arg;
  1405.       BAsmCode[CodeLen++] = CntAdrVals.Arg;
  1406.       AppendAdrVals(&CntAdrVals);
  1407.     }
  1408.  
  1409.     /* (REG-)OPR1/2/3-IMM with n=1..2 */
  1410.  
  1411.     else if (DestIsReg && ImmediateCnt && (ImmCnt >= 1) && (ImmCnt <= 2))
  1412.     {
  1413.       BAsmCode[CodeLen++] = 0x10 | DestReg;
  1414.       BAsmCode[CodeLen++] = Code | 0x20 | ((ImmCnt - 1) << 3) | SizeCode;
  1415.       BAsmCode[CodeLen++] = OpAdrVals.Arg;
  1416.       AppendAdrVals(&OpAdrVals);
  1417.     }
  1418.  
  1419.     /* (REG-)OPR1/2/3-IMM with arbitrary n */
  1420.  
  1421.     else if (DestIsReg && ImmediateCnt && (OpAdrVals.Mode == AdrModeMemReg))
  1422.     {
  1423.       BAsmCode[CodeLen++] = 0x10 | DestReg;
  1424.       BAsmCode[CodeLen++] = Code | 0x30 | ((ImmCnt & 1) << 3) | SizeCode;
  1425.       BAsmCode[CodeLen++] = OpAdrVals.Arg;
  1426.       AppendAdrVals(&OpAdrVals);
  1427.       BAsmCode[CodeLen++] = 0x70 | ((ImmCnt >> 1) & 0x0f);
  1428.     }
  1429.  
  1430.     /* (REG-)OPR1/2/3-OPR1/2/3 */
  1431.  
  1432.     else if (DestIsReg && (OpAdrVals.Mode == AdrModeMemReg) && (CntAdrVals.Mode == AdrModeMemReg))
  1433.     {
  1434.       BAsmCode[CodeLen++] = 0x10 | DestReg;
  1435.       BAsmCode[CodeLen++] = Code | 0x30 | (CntAdrVals.ShiftLSB << 3) | SizeCode;
  1436.       BAsmCode[CodeLen++] = OpAdrVals.Arg;
  1437.       AppendAdrVals(&OpAdrVals);
  1438.       BAsmCode[CodeLen++] = CntAdrVals.Arg;
  1439.       AppendAdrVals(&CntAdrVals);
  1440.     }
  1441.  
  1442.     /* (src-)OPR/1/2/3-IMM (n=1..2) */
  1443.  
  1444.     else if ((OpAdrVals.Mode == AdrModeMemReg) && ImmediateCnt && (ImmCnt >= 1) && (ImmCnt <= 2))
  1445.     {
  1446.       BAsmCode[CodeLen++] = 0x10;
  1447.       BAsmCode[CodeLen++] = Code | 0x34 | ((ImmCnt - 1) << 3) | SizeCode;
  1448.       BAsmCode[CodeLen++] = OpAdrVals.Arg;
  1449.       AppendAdrVals(&OpAdrVals);
  1450.     }
  1451.  
  1452.     else
  1453.       WrError(ErrNum_InvAddrMode);
  1454.   }
  1455. }
  1456.  
  1457. static void DecodeBit(Word Code)
  1458. {
  1459.   tSymbolSize SaveOpSize;
  1460.   tAdrVals PosAdrVals, OpAdrVals;
  1461.   Byte ImmPos, ImmWidth, SizeCode, OpReg;
  1462.   Boolean ImmediatePos;
  1463.  
  1464.   if (!ChkArgCnt(1, 2))
  1465.     return;
  1466.  
  1467.   /* bit operand: */
  1468.  
  1469.   if (1 == ArgCnt)
  1470.   {
  1471.     LongWord BitArg;
  1472.     tSymbolSize ThisOpSize;
  1473.     Word Address;
  1474.  
  1475.     if (DecodeBitArg(&BitArg, 1, 1, OpSize)
  1476.      && DissectBitSymbol(BitArg, &Address, &ImmPos, &ImmWidth, &ThisOpSize)
  1477.      && SetOpSize(ThisOpSize))
  1478.     {
  1479.       /* TODO: warn if ImmWidth != 1 */
  1480.       if (!SizeCode2(OpSize, &SizeCode) || (SizeCode == 2))
  1481.       {
  1482.         WrError(ErrNum_InvOpSize);
  1483.         return;
  1484.       }
  1485.       ImmediatePos = True;
  1486.       OpAdrVals.Mode = AdrModeMemReg;
  1487.       OpAdrVals.Arg = Hi(Address);
  1488.       OpAdrVals.Vals[0] = Lo(Address);
  1489.       OpAdrVals.ValCnt = 1;
  1490.     }
  1491.     else
  1492.       return;
  1493.     OpReg = 0;
  1494.   }
  1495.  
  1496.   /* other operand */
  1497.  
  1498.   else
  1499.   {
  1500.     if (!DecodeAdr(1, MModeMemReg | MModeReg, &OpAdrVals))
  1501.       return;
  1502.  
  1503.     /* operand size not yet set - then set from source */
  1504.  
  1505.     if (IsReg(&OpAdrVals, &OpReg))
  1506.       SetOpSize(RegSizes[OpReg]);
  1507.     if (OpSize < 0)
  1508.     {
  1509.       WrError(ErrNum_UndefOpSizes);
  1510.       return;
  1511.     }
  1512.  
  1513.     else if (!SizeCode2(OpSize, &SizeCode) || (SizeCode == 2))
  1514.     {
  1515.       WrError(ErrNum_InvOpSize);
  1516.       return;
  1517.     }
  1518.  
  1519.     /* force operand size to 3/4/5 bits for bit position */
  1520.  
  1521.     SaveOpSize = OpSize;
  1522.     OpSize = OpSizeBitPos8 + OpSize;
  1523.     if (!DecodeAdr(2, MModeImm | MModeReg, &PosAdrVals))
  1524.       return;
  1525.     ImmediatePos = IsImmediate(&PosAdrVals, OpSize, &ImmPos);
  1526.     OpSize = SaveOpSize;
  1527.   }
  1528.  
  1529.   switch (OpAdrVals.Mode)
  1530.   {
  1531.     case AdrModeReg:
  1532.       BAsmCode[CodeLen++] = Code;
  1533.       if (ImmediatePos)
  1534.         BAsmCode[CodeLen++] = (ImmPos << 3) | OpReg;
  1535.       else
  1536.       {
  1537.         BAsmCode[CodeLen++] = 0x81 | (PosAdrVals.Arg << 4);
  1538.         BAsmCode[CodeLen++] = 0xb8 | OpReg;
  1539.       }
  1540.       break;
  1541.     case AdrModeMemReg:
  1542.       BAsmCode[CodeLen++] = Code;
  1543.       if (ImmediatePos)
  1544.       {
  1545.         BAsmCode[CodeLen] = 0x80 | ((ImmPos & 7) << 4);
  1546.         if (OpSize >= eSymbolSize16Bit)
  1547.           BAsmCode[CodeLen] |= (1 << SizeCode) | ((ImmPos >> 3) & SizeCode);
  1548.         CodeLen++;
  1549.       }
  1550.       else
  1551.         BAsmCode[CodeLen++] = 0x81 | (PosAdrVals.Arg << 4) | (SizeCode << 2);
  1552.       BAsmCode[CodeLen++] = OpAdrVals.Arg;
  1553.       AppendAdrVals(&OpAdrVals);
  1554.       break;
  1555.     default:
  1556.       break;
  1557.   }
  1558. }
  1559.  
  1560. static void DecodeBitField(Word Code)
  1561. {
  1562.   if (!ChkArgCnt(2, 3))
  1563.     return;
  1564.  
  1565.   /* if two arguments, bit field is symbolic and is
  1566.      - the destination (first arg) for BFINS
  1567.      - the source (second arg) for BFEXT */
  1568.  
  1569.   if (2 == ArgCnt)
  1570.   {
  1571.     LongWord BitfieldArg;
  1572.     Byte Reg, ImmPos, ImmWidth, SizeCode;
  1573.     Word FieldSpec, Address;
  1574.     tSymbolSize ThisOpSize;
  1575.     int RegArg = (Code == 0x80) ? 2 : 1;
  1576.  
  1577.     if (DecodeRegArg(RegArg, &Reg, 0xff)
  1578.      && DecodeBitfieldArg(&BitfieldArg, 3 - RegArg, 3 - RegArg, OpSize)
  1579.      && DissectBitSymbol(BitfieldArg, &Address, &ImmPos, &ImmWidth, &ThisOpSize)
  1580.      && SetOpSize(ThisOpSize)
  1581.      && SizeCode2(OpSize, &SizeCode))
  1582.     {
  1583.       FieldSpec = ImmPos | ((ImmWidth < 32) ? ((Word)ImmWidth << 5) : 0);
  1584.       BAsmCode[CodeLen++] = 0x1b;
  1585.       BAsmCode[CodeLen++] = 0x08 | Reg;
  1586.       BAsmCode[CodeLen++] = (Code ? 0xf0: 0x60) | (SizeCode << 2) | Hi(FieldSpec);
  1587.       BAsmCode[CodeLen++] = Lo(FieldSpec);
  1588.       BAsmCode[CodeLen++] = Hi(Address);
  1589.       BAsmCode[CodeLen++] = Lo(Address);
  1590.     }
  1591.   }
  1592.   else
  1593.   {
  1594.     Byte ParamReg, SizeCode;
  1595.     Word ParamImm;
  1596.     tAdrVals SrcAdrVals, DestAdrVals;
  1597.  
  1598.     if (*ArgStr[3].str.p_str == '#')
  1599.     {
  1600.       tStrComp Field;
  1601.  
  1602.       StrCompRefRight(&Field, &ArgStr[3], 1);
  1603.       if (!DecodeImmBitField(&Field, &ParamImm))
  1604.         return;
  1605.       ParamReg = 16; /* immediate flag */
  1606.     }
  1607.  
  1608.     /* only D2...D5 allowed as parameter */
  1609.  
  1610.     else if (!DecodeRegStr(ArgStr[3].str.p_str, &ParamReg) || (ParamReg >= 4))
  1611.     {
  1612.       WrStrErrorPos(ErrNum_InvReg, &ArgStr[3]);
  1613.       return;
  1614.     }
  1615.  
  1616.     DecodeAdr(2, MModeReg | MModeImm | MModeMemReg, &SrcAdrVals);
  1617.     switch (SrcAdrVals.Mode)
  1618.     {
  1619.       case AdrModeReg:
  1620.         DecodeAdr(1, MModeReg | MModeMemReg, &DestAdrVals);
  1621.         switch (DestAdrVals.Mode)
  1622.         {
  1623.           case AdrModeReg:
  1624.             BAsmCode[CodeLen++] = 0x1b;
  1625.             BAsmCode[CodeLen++] = 0x08 | DestAdrVals.Arg;
  1626.             if (16 == ParamReg)
  1627.             {
  1628.               BAsmCode[CodeLen++] = Code | 0x20 | (SrcAdrVals.Arg << 2) | Hi(ParamImm);
  1629.               BAsmCode[CodeLen++] = Lo(ParamImm);
  1630.             }
  1631.             else
  1632.               BAsmCode[CodeLen++] = Code | (SrcAdrVals.Arg << 2) | ParamReg;
  1633.             break;
  1634.           case AdrModeMemReg:
  1635.             if (OpSize == eSymbolSizeUnknown) WrError(ErrNum_UndefOpSizes);
  1636.             else if (!SizeCode2(OpSize, &SizeCode)) WrError(ErrNum_InvOpSize);
  1637.             else
  1638.             {
  1639.               BAsmCode[CodeLen++] = 0x1b;
  1640.               BAsmCode[CodeLen++] = 0x08 | SrcAdrVals.Arg;
  1641.               if (16 == ParamReg)
  1642.               {
  1643.                 BAsmCode[CodeLen++] = Code | 0x70 | (SizeCode << 2) | Hi(ParamImm);
  1644.                 BAsmCode[CodeLen++] = Lo(ParamImm);
  1645.               }
  1646.               else
  1647.                 BAsmCode[CodeLen++] = Code | 0x50 | (SizeCode << 2) | ParamReg;
  1648.               BAsmCode[CodeLen++] = DestAdrVals.Arg;
  1649.               AppendAdrVals(&DestAdrVals);
  1650.             }
  1651.             break;
  1652.           default:
  1653.             break;
  1654.         }
  1655.         break;
  1656.       case AdrModeMemReg:
  1657.         DecodeAdr(1, MModeReg, &DestAdrVals);
  1658.         switch (DestAdrVals.Mode)
  1659.         {
  1660.           case AdrModeReg:
  1661.             if (OpSize  == eSymbolSizeUnknown) WrError(ErrNum_UndefOpSizes);
  1662.             else if (!SizeCode2(OpSize, &SizeCode)) WrError(ErrNum_InvOpSize);
  1663.             else
  1664.             {
  1665.               BAsmCode[CodeLen++] = 0x1b;
  1666.               BAsmCode[CodeLen++] = 0x08 | DestAdrVals.Arg;
  1667.               if (16 == ParamReg)
  1668.               {
  1669.                 BAsmCode[CodeLen++] = Code | 0x60 | (SizeCode << 2) | Hi(ParamImm);
  1670.                 BAsmCode[CodeLen++] = Lo(ParamImm);
  1671.               }
  1672.               else
  1673.                 BAsmCode[CodeLen++] = Code | 0x40 | (SizeCode << 2) | ParamReg;
  1674.               BAsmCode[CodeLen++] = SrcAdrVals.Arg;
  1675.               AppendAdrVals(&SrcAdrVals);
  1676.             }
  1677.             break;
  1678.           default:
  1679.             break;
  1680.         }
  1681.         break;
  1682.       case AdrModeImm: /* immediate only allowed for short immediate in MemReg op */
  1683.         WrStrErrorPos(ErrNum_InvAddrMode, &ArgStr[2]);
  1684.         break;
  1685.       default:
  1686.         break;
  1687.     }
  1688.   }
  1689. }
  1690.  
  1691. static void DecodeBitRel(Word Code)
  1692. {
  1693.   if (!ChkArgCnt(3, 3))
  1694.     return;
  1695.  
  1696.   ArgCnt--;
  1697.   DecodeBit(Code);
  1698.   if (!CodeLen)
  1699.     return;
  1700.  
  1701.   /* operand size attribute is consumed by bit operand */
  1702.  
  1703.   OpSize = eSymbolSizeUnknown;
  1704.   if (!DecodeBranchCore(3))
  1705.     CodeLen = 0;
  1706. }
  1707.  
  1708. static void DecodeCLR(Word Code)
  1709. {
  1710.   tAdrVals AdrVals;
  1711.  
  1712.   UNUSED(Code);
  1713.  
  1714.   if (ChkArgCnt(1, 1) && DecodeAdr(1, MModeReg | MModeAReg | MModeMemReg, &AdrVals))
  1715.   {
  1716.     switch (AdrVals.Mode)
  1717.     {
  1718.       case AdrModeReg:
  1719.         if (SetOpSize(RegSizes[AdrVals.Arg]))
  1720.           PutCode(0x0038 | AdrVals.Arg);
  1721.         break;
  1722.       case AdrModeAReg:
  1723.         if (!SetOpSize(eSymbolSize24Bit));
  1724.         else if (AdrVals.Arg > 1) WrStrErrorPos(ErrNum_InvReg, &ArgStr[1]);
  1725.         else
  1726.           PutCode(0x009a | AdrVals.Arg);
  1727.         break;
  1728.       case AdrModeMemReg:
  1729.       {
  1730.         Byte SizeCode;
  1731.  
  1732.         if (OpSize == eSymbolSizeUnknown) WrError(ErrNum_UndefOpSizes);
  1733.         else if (!SizeCode2(OpSize, &SizeCode)) WrError(ErrNum_InvOpSize);
  1734.         else
  1735.         {
  1736.           BAsmCode[CodeLen++] = 0xbc | SizeCode;
  1737.           BAsmCode[CodeLen++] = AdrVals.Arg;
  1738.           AppendAdrVals(&AdrVals);
  1739.         }
  1740.         break;
  1741.       }
  1742.       default:
  1743.         break;
  1744.     }
  1745.   }
  1746. }
  1747.  
  1748. static void DecodeCOM_NEG(Word Code)
  1749. {
  1750.   tAdrVals AdrVals;
  1751.   Byte OpReg, SizeCode;
  1752.  
  1753.   if (!ChkArgCnt(1, 1))
  1754.     return;
  1755.   DecodeAdr(1, MModeMemReg, &AdrVals);
  1756.  
  1757.   /* operand size not yet set - then set from (register) op */
  1758.  
  1759.   if (IsReg(&AdrVals, &OpReg))
  1760.   {
  1761.     if (!SetOpSize(RegSizes[OpReg]))
  1762.       return;
  1763.   }
  1764.   if (OpSize == eSymbolSizeUnknown)
  1765.   {
  1766.     WrError(ErrNum_UndefOpSizes);
  1767.     return;
  1768.   }
  1769.   if (!SizeCode2(OpSize, &SizeCode) || (OpSize == eSymbolSize24Bit))
  1770.   {
  1771.     WrError(ErrNum_InvOpSize);
  1772.     return;
  1773.   }
  1774.   PutCode(Code | SizeCode);
  1775.   BAsmCode[CodeLen++] = AdrVals.Arg;
  1776.   AppendAdrVals(&AdrVals);
  1777. }
  1778.  
  1779. static void DecodeDBcc(Word Code)
  1780. {
  1781.   tAdrVals AdrVals;
  1782.   Byte OpReg, SizeCode;
  1783.  
  1784.   if (!ChkArgCnt(2, 2))
  1785.     return;
  1786.   DecodeAdr(1, MModeReg | MModeAReg | MModeMemReg, &AdrVals);
  1787.  
  1788.   if (IsReg(&AdrVals, &OpReg))
  1789.   {
  1790.     if (!SetOpSize(RegSizes[OpReg]))
  1791.       return;
  1792.   }
  1793.   else if (AdrVals.Mode == AdrModeAReg)
  1794.   {
  1795.     if (!SetOpSize(eSymbolSize24Bit))
  1796.       return;
  1797.   }
  1798.   if (OpSize == eSymbolSizeUnknown)
  1799.   {
  1800.     WrError(ErrNum_UndefOpSizes);
  1801.     return;
  1802.   }
  1803.   if (!SizeCode2(OpSize, &SizeCode))
  1804.   {
  1805.     WrError(ErrNum_InvOpSize);
  1806.     return;
  1807.   }
  1808.   switch (AdrVals.Mode)
  1809.   {
  1810.     case AdrModeReg:
  1811.       PutCode(Code | AdrVals.Arg);
  1812.       break;
  1813.     case AdrModeAReg:
  1814.       if (AdrVals.Arg > 1) WrStrErrorPos(ErrNum_InvReg, &ArgStr[1]);
  1815.       else
  1816.         PutCode(Code | 0x0008 | AdrVals.Arg);
  1817.       break;
  1818.     case AdrModeMemReg:
  1819.       PutCode(Code | 0x000c | SizeCode);
  1820.       BAsmCode[CodeLen++] = AdrVals.Arg;
  1821.       AppendAdrVals(&AdrVals);
  1822.       break;
  1823.     default:
  1824.       break;
  1825.   }
  1826.  
  1827.   if (CodeLen > 0)
  1828.   {
  1829.     /* operand size attribute consumed by operand */
  1830.  
  1831.     OpSize = eSymbolSizeUnknown;
  1832.  
  1833.     if (!DecodeBranchCore(2))
  1834.       CodeLen = 0;
  1835.   }
  1836. }
  1837.  
  1838. static void DecodeINC_DEC(Word Code)
  1839. {
  1840.   tAdrVals AdrVals;
  1841.  
  1842.   if (ChkArgCnt(1, 1) && DecodeAdr(1, MModeReg | MModeMemReg, &AdrVals))
  1843.   {
  1844.     switch (AdrVals.Mode)
  1845.     {
  1846.       case AdrModeReg:
  1847.         if (SetOpSize(RegSizes[AdrVals.Arg]))
  1848.           PutCode(Code + AdrVals.Arg);
  1849.         break;
  1850.       case AdrModeMemReg:
  1851.       {
  1852.         Byte SizeCode;
  1853.  
  1854.         if (OpSize == eSymbolSizeUnknown) WrError(ErrNum_UndefOpSizes);
  1855.         else if (!SizeCode2(OpSize, &SizeCode) || (OpSize == eSymbolSize24Bit)) WrError(ErrNum_UndefOpSizes);
  1856.         else
  1857.         {
  1858.           BAsmCode[CodeLen++] = (Code + 0x6c) | SizeCode;
  1859.           BAsmCode[CodeLen++] = AdrVals.Arg;
  1860.           AppendAdrVals(&AdrVals);
  1861.         }
  1862.         break;
  1863.       }
  1864.       default:
  1865.         break;
  1866.     }
  1867.   }
  1868. }
  1869.  
  1870. static void DecodeDIV_MOD(Word Code)
  1871. {
  1872.   tAdrVals DividentAdrVals, DivisorAdrVals;
  1873.   Byte DividentSizeCode, DivisorSizeCode, DestReg, DivisorReg;
  1874.   Word EffCode, LoCode;
  1875.  
  1876.   EffCode = Hi(Code) | ((Lo(Code) & 0x01) ? 0x1b00 : 0x0000);
  1877.   LoCode = Lo(Code) & 0x80;
  1878.  
  1879.   /* destination is always a register */
  1880.  
  1881.   if (!ChkArgCnt(3, 3) || !DecodeRegArg(1, &DestReg, 0xff))
  1882.     return;
  1883.  
  1884.   DecodeAdr(2, MModeImm | MModeReg | MModeMemReg, &DividentAdrVals);
  1885.   switch (DividentAdrVals.Mode)
  1886.   {
  1887.     case AdrModeReg:
  1888.       DecodeAdr(3, MModeImm | MModeReg | MModeMemReg, &DivisorAdrVals);
  1889.       switch (DivisorAdrVals.Mode)
  1890.       {
  1891.         case AdrModeReg:
  1892.           PutCode(EffCode | DestReg);
  1893.           BAsmCode[CodeLen++] = LoCode | (DividentAdrVals.Arg << 3) | DivisorAdrVals.Arg;
  1894.           break;
  1895.         case AdrModeImm:
  1896.           if (!SizeCode2(OpSize, &DivisorSizeCode) || (OpSize == eSymbolSize24Bit)) WrError(ErrNum_UndefOpSizes);
  1897.           else
  1898.           {
  1899.             PutCode(EffCode | DestReg);
  1900.             BAsmCode[CodeLen++] = LoCode | 0x44 | (DividentAdrVals.Arg << 3) | DivisorSizeCode;
  1901.             AppendAdrVals(&DivisorAdrVals);
  1902.           }
  1903.           break;
  1904.         case AdrModeMemReg:
  1905.           if (!SizeCode2(OpSize, &DivisorSizeCode) || (OpSize == eSymbolSize24Bit)) WrError(ErrNum_UndefOpSizes);
  1906.           else
  1907.           {
  1908.             PutCode(EffCode | DestReg);
  1909.             BAsmCode[CodeLen++] = LoCode | 0x40 | (DividentAdrVals.Arg << 3) | DivisorSizeCode;
  1910.             BAsmCode[CodeLen++] = DivisorAdrVals.Arg;
  1911.             AppendAdrVals(&DivisorAdrVals);
  1912.           }
  1913.           break;
  1914.         default:
  1915.           break;
  1916.       }
  1917.       break;
  1918.     case AdrModeMemReg:
  1919.       /* divident==register is filtered out before, so divident size cannot be set from register */
  1920.       if (!SizeCode2(OpSize, &DividentSizeCode) || (OpSize == eSymbolSize24Bit)) WrError(ErrNum_UndefOpSizes);
  1921.       else
  1922.       {
  1923.         OpSize = OpSize2;
  1924.         DecodeAdr(3, MModeImm | MModeMemReg, &DivisorAdrVals);
  1925.         switch (DivisorAdrVals.Mode)
  1926.         {
  1927.           case AdrModeMemReg:
  1928.             if ((OpSize == eSymbolSizeUnknown) && IsReg(&DivisorAdrVals, &DivisorReg))
  1929.               SetOpSize(RegSizes[DivisorReg]);
  1930.             if (!SizeCode2(OpSize, &DivisorSizeCode) || (OpSize == eSymbolSize24Bit)) WrError(ErrNum_UndefOpSizes);
  1931.             else
  1932.             {
  1933.               PutCode(EffCode | DestReg);
  1934.               BAsmCode[CodeLen++] = LoCode | 0x42 | (DividentSizeCode << 4) | (DivisorSizeCode << 2);
  1935.               BAsmCode[CodeLen++] = DividentAdrVals.Arg;
  1936.               AppendAdrVals(&DividentAdrVals);
  1937.               BAsmCode[CodeLen++] = DivisorAdrVals.Arg;
  1938.               AppendAdrVals(&DivisorAdrVals);
  1939.             }
  1940.             break;
  1941.           case AdrModeImm: /* was only allowed for short imm in MemReg */
  1942.             WrStrErrorPos(ErrNum_InvAddrMode, &ArgStr[3]);
  1943.             break;
  1944.           default:
  1945.             break;
  1946.         }
  1947.       }
  1948.       break;
  1949.     case AdrModeImm: /* was only allowed for short imm in MemReg */
  1950.       WrStrErrorPos(ErrNum_InvAddrMode, &ArgStr[2]);
  1951.       break;
  1952.     default:
  1953.       break;
  1954.   }
  1955. }
  1956.  
  1957. static void DecodeEXG_TFR(Word Code)
  1958. {
  1959.   Byte SrcReg, DestReg;
  1960.  
  1961.   if (ChkArgCnt(2, 2)
  1962.    && DecodeGenRegArg(1, &SrcReg)
  1963.    && DecodeGenRegArg(2, &DestReg))
  1964.   {
  1965.     if ((OpSizeByteLen(RegSizes[SrcReg]) >= OpSizeByteLen(RegSizes[DestReg])) && Hi(Code))
  1966.       WrError(ErrNum_SrcLEThanDest);
  1967.     BAsmCode[CodeLen++] = Lo(Code);
  1968.     BAsmCode[CodeLen++] = (SrcReg << 4) | DestReg;
  1969.   }
  1970. }
  1971.  
  1972. static void DecodeJMP_JSR(Word Code)
  1973. {
  1974.   tAdrVals AdrVals;
  1975.  
  1976.   if (*AttrPart.str.p_str) WrError(ErrNum_UseLessAttr);
  1977.   else if (ChkArgCnt(1, 1) && DecodeAdr(1, MModeMemReg, &AdrVals))
  1978.   {
  1979.     Byte Dummy;
  1980.  
  1981.     if (IsReg(&AdrVals, &Dummy)) WrStrErrorPos(ErrNum_InvAddrMode, &ArgStr[1]);
  1982.     else
  1983.     {
  1984.       if (AdrVals.Arg == 0xfa)
  1985.         PutCode(Code | 0x10);
  1986.       else
  1987.       {
  1988.         PutCode(Code);
  1989.         BAsmCode[CodeLen++] = AdrVals.Arg;
  1990.       }
  1991.       AppendAdrVals(&AdrVals);
  1992.     }
  1993.   }
  1994. }
  1995.  
  1996. static void DecodeLD_ST(Word Code)
  1997. {
  1998.   tAdrVals SrcAdrVals, DestAdrVals;
  1999.  
  2000.   if (ChkArgCnt(2, 2) && DecodeAdr(1, MModeReg | MModeAReg, &DestAdrVals))
  2001.   {
  2002.     switch (DestAdrVals.Mode)
  2003.     {
  2004.       case AdrModeReg:
  2005.         if (!SetOpSize(RegSizes[DestAdrVals.Arg]))
  2006.           return;
  2007.         DecodeAdr(2, (Code ? 0 : MModeImm) | MModeMemReg, &SrcAdrVals);
  2008.         switch (SrcAdrVals.Mode)
  2009.         {
  2010.           case AdrModeMemReg:
  2011.           {
  2012.             Byte ImmVal;
  2013.  
  2014.             if ((OpSize == eSymbolSize8Bit) && IsImmediate(&SrcAdrVals, OpSize, &ImmVal)) /* same instr length for byte, but what people expect? */
  2015.             {
  2016.               ChangeImmediate(&SrcAdrVals, OpSize, ImmVal);
  2017.               goto immediate;
  2018.             }
  2019.             if (SrcAdrVals.Arg == 0xfa)
  2020.               BAsmCode[CodeLen++] = (0xb0 + Code) | DestAdrVals.Arg;
  2021.             else
  2022.             {
  2023.               BAsmCode[CodeLen++] = (0xa0 + Code) | DestAdrVals.Arg;
  2024.               BAsmCode[CodeLen++] = SrcAdrVals.Arg;
  2025.             }
  2026.             AppendAdrVals(&SrcAdrVals);
  2027.             break;
  2028.           }
  2029.           case AdrModeImm:
  2030.           immediate:
  2031.             BAsmCode[CodeLen++] = 0x90 | DestAdrVals.Arg;
  2032.             AppendAdrVals(&SrcAdrVals);
  2033.             break;
  2034.           default:
  2035.             break;
  2036.         }
  2037.         break;
  2038.       case AdrModeAReg:
  2039.         if (DestAdrVals.Arg > 2)
  2040.         {
  2041.           WrStrErrorPos(ErrNum_InvReg, &ArgStr[1]);
  2042.         }
  2043.         if (!SetOpSize(eSymbolSize24Bit))
  2044.           return;
  2045.         DecodeAdr(2, (Code ? 0 : MModeImm) | MModeMemReg, &SrcAdrVals);
  2046.         switch (SrcAdrVals.Mode)
  2047.         {
  2048.           case AdrModeMemReg:
  2049.             if ((DestAdrVals.Arg < 2) && (SrcAdrVals.Arg == 0xfa))
  2050.               BAsmCode[CodeLen++] = (0xb8 + Code) | DestAdrVals.Arg;
  2051.             else if (2 == DestAdrVals.Arg)
  2052.             {
  2053.               BAsmCode[CodeLen++] = 0x1b;
  2054.               BAsmCode[CodeLen++] = 0x00 + !!Code;
  2055.               BAsmCode[CodeLen++] = SrcAdrVals.Arg;
  2056.             }
  2057.             else
  2058.             {
  2059.               BAsmCode[CodeLen++] = (0xa8 + Code) | DestAdrVals.Arg;
  2060.               BAsmCode[CodeLen++] = SrcAdrVals.Arg;
  2061.             }
  2062.             AppendAdrVals(&SrcAdrVals);
  2063.             break;
  2064.           case AdrModeImm:
  2065.             /* SrcAdrVals.Cnt must be 3 */
  2066.             if ((DestAdrVals.Arg < 2) && (SrcAdrVals.Vals[0] < 0x04))
  2067.             {
  2068.               BAsmCode[CodeLen++] = 0xca | DestAdrVals.Arg | (SrcAdrVals.Vals[0] << 4);
  2069.               BAsmCode[CodeLen++] = SrcAdrVals.Vals[1];
  2070.               BAsmCode[CodeLen++] = SrcAdrVals.Vals[2];
  2071.             }
  2072.             else
  2073.             {
  2074.               PutCode((DestAdrVals.Arg == 2) ? 0x1b03 : (0x98 | DestAdrVals.Arg));
  2075.               AppendAdrVals(&SrcAdrVals);
  2076.             }
  2077.             break;
  2078.           default:
  2079.             break;
  2080.         }
  2081.         break;
  2082.       default:
  2083.         break;
  2084.     }
  2085.   }
  2086. }
  2087.  
  2088. static void DecodeLEA(Word Code)
  2089. {
  2090.   tAdrVals DestAdrVals, SrcAdrVals;
  2091.   Byte Reg;
  2092.  
  2093.   UNUSED(Code);
  2094.  
  2095.   if (*AttrPart.str.p_str) WrError(ErrNum_UseLessAttr);
  2096.   else if (ChkArgCnt(2, 2) && DecodeAdr(1, MModeReg | MModeAReg, &DestAdrVals))
  2097.   {
  2098.     switch (DestAdrVals.Mode)
  2099.     {
  2100.       case AdrModeReg:
  2101.         if (DestAdrVals.Arg < 6) WrStrErrorPos(ErrNum_InvReg, &ArgStr[1]);
  2102.         else if (DecodeAdr(2, MModeMemReg, &SrcAdrVals))
  2103.         {
  2104.           if (IsReg(&SrcAdrVals, &Reg)) WrStrErrorPos(ErrNum_InvAddrMode, &ArgStr[2]);
  2105.           else
  2106.           {
  2107.             BAsmCode[CodeLen++] = 0x00 | DestAdrVals.Arg;
  2108.             BAsmCode[CodeLen++] = SrcAdrVals.Arg;
  2109.             AppendAdrVals(&SrcAdrVals);
  2110.           }
  2111.         }
  2112.         break;
  2113.       case AdrModeAReg:
  2114.         if (DestAdrVals.Arg > 2) WrStrErrorPos(ErrNum_InvReg, &ArgStr[1]);
  2115.         else if (DecodeAdr(2, MModeMemReg, &SrcAdrVals))
  2116.         {
  2117.           if (IsReg(&SrcAdrVals, &Reg)) WrStrErrorPos(ErrNum_InvAddrMode, &ArgStr[2]);
  2118.           else
  2119.           {
  2120.             /* XYS,(i8,XYS) */
  2121.  
  2122.             if (((SrcAdrVals.Arg & 0xce) == 0xc0) /* ...,(XYS,i9) */
  2123.              && ((SrcAdrVals.Arg & 0x01) == ((SrcAdrVals.Vals[0] >> 7) & 1)) /* i9 is i8 */
  2124.              && (DestAdrVals.Arg == ((SrcAdrVals.Arg >> 4) & 3))) /* destreg==srcreg */
  2125.             {
  2126.               BAsmCode[CodeLen++] = 0x18 | DestAdrVals.Arg;
  2127.               BAsmCode[CodeLen++] = SrcAdrVals.Vals[0];
  2128.             }
  2129.             else
  2130.             {
  2131.               BAsmCode[CodeLen++] = 0x08 | DestAdrVals.Arg;
  2132.               BAsmCode[CodeLen++] = SrcAdrVals.Arg;
  2133.               AppendAdrVals(&SrcAdrVals);
  2134.             }
  2135.           }
  2136.         }
  2137.         break;
  2138.       default:
  2139.         break;
  2140.     }
  2141.   }
  2142. }
  2143.  
  2144. static void DecodeMIN_MAX(Word Code)
  2145. {
  2146.   tAdrVals AdrVals;
  2147.   Byte Reg;
  2148.  
  2149.   if (ChkArgCnt(2, 2)
  2150.    && DecodeRegArg(1, &Reg, 0xff)
  2151.    && SetOpSize(RegSizes[Reg])
  2152.    && DecodeAdr(2, MModeMemReg | MModeImm, &AdrVals))
  2153.   {
  2154.     switch (AdrVals.Mode)
  2155.     {
  2156.       case AdrModeMemReg:
  2157.         PutCode(Code | Reg);
  2158.         BAsmCode[CodeLen++] = AdrVals.Arg;
  2159.         AppendAdrVals(&AdrVals);
  2160.         break;
  2161.       case AdrModeImm: /* was only allowed for short immediate in MemReg */
  2162.         WrStrErrorPos(ErrNum_InvAddrMode, &ArgStr[2]);
  2163.         break;
  2164.       default:
  2165.         break;
  2166.     }
  2167.   }
  2168. }
  2169.  
  2170. static void DecodeMOV(Word Code)
  2171. {
  2172.   tAdrVals SrcAdrVals, DestAdrVals;
  2173.   Byte Reg, SizeCode;
  2174.  
  2175.   UNUSED(Code);
  2176.  
  2177.   if (ChkArgCnt(2, 2)
  2178.    && DecodeAdr(2, MModeMemReg, &DestAdrVals))
  2179.   {
  2180.     /* prefer attribute to destination... */
  2181.  
  2182.     if (IsReg(&DestAdrVals, &Reg) && (OpSize == eSymbolSizeUnknown))
  2183.       SetOpSize(RegSizes[Reg]);
  2184.  
  2185.     if (!DecodeAdr(1, MModeMemReg | MModeImm, &SrcAdrVals))
  2186.       return;
  2187.  
  2188.     /* ...to source operand size */
  2189.  
  2190.     if (IsReg(&SrcAdrVals, &Reg) && (OpSize == eSymbolSizeUnknown))
  2191.       SetOpSize(RegSizes[Reg]);
  2192.  
  2193.     if (!SizeCode2(OpSize, &SizeCode))
  2194.     {
  2195.       WrError(ErrNum_InvOpSize);
  2196.       return;
  2197.     }
  2198.  
  2199.     switch (SrcAdrVals.Mode)
  2200.     {
  2201.       case AdrModeImm:
  2202.         PutCode(0x0c + SizeCode);
  2203.         AppendAdrVals(&SrcAdrVals);
  2204.         BAsmCode[CodeLen++] = DestAdrVals.Arg;
  2205.         AppendAdrVals(&DestAdrVals);
  2206.         break;
  2207.       case AdrModeMemReg:
  2208.         PutCode(0x1c | SizeCode);
  2209.         BAsmCode[CodeLen++] = SrcAdrVals.Arg;
  2210.         AppendAdrVals(&SrcAdrVals);
  2211.         BAsmCode[CodeLen++] = DestAdrVals.Arg;
  2212.         AppendAdrVals(&DestAdrVals);
  2213.         break;
  2214.       default:
  2215.         break;
  2216.     }
  2217.   }
  2218. }
  2219.  
  2220. static void DecodePSH_PUL(Word Code)
  2221. {
  2222.   Word RegMask = 0, ThisRegMask;
  2223.   int z;
  2224.   Byte Reg;
  2225.   static const Word RegMasks[8] = { 0x0002, 0x0001, 0x2000, 0x1000, 0x0008, 0x004, 0x0800, 0x0400 };
  2226.  
  2227.   if (!ChkArgCnt(1, ArgCntMax))
  2228.     return;
  2229.   for (z = 1; z <= ArgCnt; z++)
  2230.   {
  2231.     if (!as_strcasecmp(ArgStr[z].str.p_str, "ALL"))
  2232.       ThisRegMask = 0x3f3f;
  2233.     else if (!as_strcasecmp(ArgStr[z].str.p_str, "ALL16b"))
  2234.       ThisRegMask = 0x3003;
  2235.     else if (DecodeRegStr(ArgStr[z].str.p_str, &Reg))
  2236.       ThisRegMask = RegMasks[Reg];
  2237.     else if (!as_strcasecmp(ArgStr[z].str.p_str, "CCH"))
  2238.       ThisRegMask = 0x0020;
  2239.     else if (!as_strcasecmp(ArgStr[z].str.p_str, "CCL"))
  2240.       ThisRegMask = 0x0010;
  2241.     else if (DecodeAdrRegStr(ArgStr[z].str.p_str, &Reg) && (Reg < 2))
  2242.       ThisRegMask = 0x0200 >> Reg;
  2243.     else
  2244.     {
  2245.       WrStrErrorPos(ErrNum_InvReg, &ArgStr[z]);
  2246.       return;
  2247.     }
  2248.     if (ThisRegMask & RegMask)
  2249.     {
  2250.       WrStrErrorPos(ErrNum_DoubleReg, &ArgStr[z]);
  2251.       return;
  2252.     }
  2253.     RegMask |= ThisRegMask;
  2254.   }
  2255.   if (RegMask == 0x3f3f)
  2256.     PutCode(Code | 0x00);
  2257.   else if (RegMask == 0x3003)
  2258.     PutCode(Code | 0x40);
  2259.   else if (Hi(RegMask) && !Lo(RegMask))
  2260.     PutCode(Code | 0x40 | Hi(RegMask));
  2261.   else if (Lo(RegMask) && !Hi(RegMask))
  2262.     PutCode(Code | 0x00 | Lo(RegMask));
  2263.   else
  2264.     WrError(ErrNum_InvRegList);
  2265. }
  2266.  
  2267. static void DecodeROL_ROR(Word Code)
  2268. {
  2269.   tAdrVals AdrVals;
  2270.   Byte Reg, SizeCode;
  2271.  
  2272.   if (ChkArgCnt(1, 1) && DecodeAdr(1, MModeMemReg, &AdrVals))
  2273.   {
  2274.     if (IsReg(&AdrVals, &Reg) && !SetOpSize(RegSizes[Reg]))
  2275.       return;
  2276.     if (OpSize == eSymbolSizeUnknown)
  2277.     {
  2278.       WrError(ErrNum_UndefOpSizes);
  2279.       return;
  2280.     }
  2281.     if (!SizeCode2(OpSize, &SizeCode))
  2282.     {
  2283.       WrError(ErrNum_InvOpSize);
  2284.       return;
  2285.     }
  2286.     PutCode(Code | SizeCode);
  2287.     BAsmCode[CodeLen++] = AdrVals.Arg;
  2288.     AppendAdrVals(&AdrVals);
  2289.   }
  2290. }
  2291.  
  2292. static void DecodeTBcc(Word Code)
  2293. {
  2294.   tAdrVals AdrVals;
  2295.  
  2296.   if (!ChkArgCnt(2, 2) || !DecodeAdr(1, MModeReg | MModeAReg | MModeMemReg | MModeImm, &AdrVals))
  2297.     return;
  2298.  
  2299.   switch (AdrVals.Mode)
  2300.   {
  2301.     case AdrModeReg:
  2302.       if (!SetOpSize(RegSizes[AdrVals.Arg]))
  2303.         return;
  2304.       PutCode(Code | AdrVals.Arg);
  2305.       break;
  2306.     case AdrModeAReg:
  2307.       if (AdrVals.Arg >= 2)
  2308.       {
  2309.         WrStrErrorPos(ErrNum_InvReg, &ArgStr[1]);
  2310.         return;
  2311.       }
  2312.       if (!SetOpSize(eSymbolSize24Bit))
  2313.         return;
  2314.       PutCode(Code | 0x0008 | AdrVals.Arg);
  2315.       break;
  2316.     case AdrModeMemReg:
  2317.     {
  2318.       Byte SizeCode;
  2319.  
  2320.       if (OpSize == eSymbolSizeUnknown)
  2321.       {
  2322.         WrError(ErrNum_UndefOpSizes);
  2323.         return;
  2324.       }
  2325.       if (!SizeCode2(OpSize, &SizeCode))
  2326.       {
  2327.         WrError(ErrNum_InvOpSize);
  2328.         return;
  2329.       }
  2330.       PutCode(Code | 0x000c | SizeCode);
  2331.       BAsmCode[CodeLen++] = AdrVals.Arg;
  2332.       AppendAdrVals(&AdrVals);
  2333.       break;
  2334.     }
  2335.     case AdrModeImm: /* was only allowed for short immediate */
  2336.       WrStrErrorPos(ErrNum_InvAddrMode, &ArgStr[1]);
  2337.       return;
  2338.     default:
  2339.       return;
  2340.   }
  2341.  
  2342.   OpSize = OpSize2;
  2343.   if (!DecodeBranchCore(2))
  2344.     CodeLen = 0;
  2345. }
  2346.  
  2347. static void DecodeTRAP(Word Code)
  2348. {
  2349.   tAdrVals AdrVals;
  2350.  
  2351.   UNUSED(Code);
  2352.  
  2353.   if (ChkArgCnt(1, 1) && SetOpSize(eSymbolSize8Bit) && DecodeAdr(1, MModeImm, &AdrVals))
  2354.   {
  2355.     BAsmCode[CodeLen++] = 0x1b;
  2356.     BAsmCode[CodeLen++] = AdrVals.Vals[0];
  2357.     switch ((AdrVals.Vals[0] >> 4) & 0x0f)
  2358.     {
  2359.       case 12: case 13: case 14: case 15:
  2360.         break;
  2361.       case 10: case 11:
  2362.         if ((AdrVals.Vals[0] & 0x0f) >= 8)
  2363.           break;
  2364.         else
  2365.           goto warn;
  2366.       case 9:
  2367.         if ((AdrVals.Vals[0] & 0x0f) >= 2)
  2368.           break;
  2369.         /* else fall-through */
  2370.       default:
  2371.       warn:
  2372.         WrError(ErrNum_TrapValidInstruction);
  2373.     }
  2374.   }
  2375. }
  2376.  
  2377. static void DecodeDEFBIT(Word Code)
  2378. {
  2379.   LongWord BitSpec;
  2380.  
  2381.   UNUSED(Code);
  2382.  
  2383.   /* if in structure definition, add special element to structure */
  2384.  
  2385.   if (ActPC == StructSeg)
  2386.   {
  2387.     Boolean OK;
  2388.     Byte BitPos;
  2389.     PStructElem pElement;
  2390.  
  2391.     if (!ChkArgCnt(2, 2))
  2392.       return;
  2393.     BitPos = EvalBitPosition(&ArgStr[2], &OK, (OpSize == eSymbolSizeUnknown) ? eSymbolSize32Bit : OpSize);
  2394.     if (!OK)
  2395.       return;
  2396.     pElement = CreateStructElem(&LabPart);
  2397.     if (!pElement)
  2398.       return;
  2399.     pElement->pRefElemName = as_strdup(ArgStr[1].str.p_str);
  2400.     pElement->OpSize = OpSize;
  2401.     pElement->BitPos = BitPos;
  2402.     pElement->ExpandFnc = ExpandS12ZBit;
  2403.     AddStructElem(pInnermostNamedStruct->StructRec, pElement);
  2404.   }
  2405.   else
  2406.   {
  2407.     if (OpSize == eSymbolSizeUnknown)
  2408.       OpSize = eSymbolSize8Bit;
  2409.     if (OpSize > eSymbolSize32Bit)
  2410.     {
  2411.       WrError(ErrNum_InvOpSize);
  2412.       return;
  2413.     }
  2414.  
  2415.     if (DecodeBitArg(&BitSpec, 1, ArgCnt, OpSize))
  2416.     {
  2417.       *ListLine = '=';
  2418.       DissectBit_S12Z(ListLine + 1, STRINGSIZE - 3, BitSpec);
  2419.       PushLocHandle(-1);
  2420.       EnterIntSymbol(&LabPart, BitSpec, SegBData, False);
  2421.       PopLocHandle();
  2422.       /* TODO: MakeUseList? */
  2423.     }
  2424.   }
  2425. }
  2426.  
  2427. static void DecodeDEFBITFIELD(Word Code)
  2428. {
  2429.   UNUSED(Code);
  2430.  
  2431.   /* if in structure definition, add special element to structure */
  2432.  
  2433.   if (ActPC == StructSeg)
  2434.   {
  2435.     Word BitField;
  2436.     PStructElem pElement;
  2437.  
  2438.     if (!ChkArgCnt(2, 2))
  2439.       return;
  2440.     if (!DecodeImmBitField(&ArgStr[2], &BitField))
  2441.       return;
  2442.     pElement = CreateStructElem(&LabPart);
  2443.     if (!pElement)
  2444.       return;
  2445.     pElement->pRefElemName = as_strdup(ArgStr[1].str.p_str);
  2446.     pElement->OpSize = OpSize;
  2447.     pElement->BitPos = BitField & 31;
  2448.     pElement->BitWidthM1 = (BitField >> 5) - 1;
  2449.     pElement->ExpandFnc = ExpandS12ZBitfield;
  2450.     AddStructElem(pInnermostNamedStruct->StructRec, pElement);
  2451.   }
  2452.   else
  2453.   {
  2454.     LongWord BitfieldSpec;
  2455.  
  2456.     /* opposed to bit operations, bit field operations also work
  2457.         24 bit operands: */
  2458.  
  2459.     if (OpSize == eSymbolSizeUnknown)
  2460.       OpSize = eSymbolSize8Bit;
  2461.     if ((OpSize > eSymbolSize32Bit) && (OpSize != eSymbolSize24Bit))
  2462.     {
  2463.       WrError(ErrNum_InvOpSize);
  2464.       return;
  2465.     }
  2466.  
  2467.     if (DecodeBitfieldArg(&BitfieldSpec, 1, ArgCnt, OpSize))
  2468.     {
  2469.       *ListLine = '=';
  2470.       DissectBit_S12Z(ListLine + 1, STRINGSIZE - 3, BitfieldSpec);
  2471.       PushLocHandle(-1);
  2472.       EnterIntSymbol(&LabPart, BitfieldSpec, SegBData, False);
  2473.       PopLocHandle();
  2474.       /* TODO: MakeUseList? */
  2475.     }
  2476.   }
  2477. }
  2478.  
  2479. /*--------------------------------------------------------------------------*/
  2480. /* Code Table Handling */
  2481.  
  2482. static void AddFixed(const char *pName, Word Code)
  2483. {
  2484.   AddInstTable(InstTable, pName, Code, DecodeFixed);
  2485. }
  2486.  
  2487. static void AddBranch(const char *pName, Word Code)
  2488. {
  2489.   AddInstTable(InstTable, pName, Code, DecodeBranch);
  2490. }
  2491.  
  2492. static void AddReg(const char *pName, Word Code)
  2493. {
  2494.   AddInstTable(InstTable, pName, Code, DecodeReg);
  2495. }
  2496.  
  2497. static void AddRegMemImm(const char *pName, Word Code)
  2498. {
  2499.   AddInstTable(InstTable, pName, Code, DecodeRegMemImm);
  2500. }
  2501.  
  2502. static void AddCondition(const char *pName, Word Code, InstProc Proc)
  2503. {
  2504.   char InstrName[20];
  2505.  
  2506.   as_snprintf(InstrName, sizeof(InstrName), pName, "NE"); AddInstTable(InstTable, InstrName, Code | (0 << 4), Proc);
  2507.   as_snprintf(InstrName, sizeof(InstrName), pName, "EQ"); AddInstTable(InstTable, InstrName, Code | (1 << 4), Proc);
  2508.   as_snprintf(InstrName, sizeof(InstrName), pName, "PL"); AddInstTable(InstTable, InstrName, Code | (2 << 4), Proc);
  2509.   as_snprintf(InstrName, sizeof(InstrName), pName, "MI"); AddInstTable(InstTable, InstrName, Code | (3 << 4), Proc);
  2510.   as_snprintf(InstrName, sizeof(InstrName), pName, "GT"); AddInstTable(InstTable, InstrName, Code | (4 << 4), Proc);
  2511.   as_snprintf(InstrName, sizeof(InstrName), pName, "LE"); AddInstTable(InstTable, InstrName, Code | (5 << 4), Proc);
  2512. }
  2513.  
  2514. static void InitFields(void)
  2515. {
  2516.   InstTable = CreateInstTable(405);
  2517.   SetDynamicInstTable(InstTable);
  2518.  
  2519.   add_null_pseudo(InstTable);
  2520.  
  2521.   AddFixed("NOP",  NOPCode);
  2522.   AddFixed("BGND", 0x0000);
  2523.   AddFixed("CLC",  0xcefe);
  2524.   AddFixed("CLI",  0xceef);
  2525.   AddFixed("CLV",  0xcefd);
  2526.   AddFixed("RTI",  0x1b90);
  2527.   AddFixed("RTS",  0x0005);
  2528.   AddFixed("SEC",  0xde01);
  2529.   AddFixed("SEI",  0xde10);
  2530.   AddFixed("SEV",  0xde02);
  2531.   AddFixed("STOP", 0x1b05);
  2532.   AddFixed("SWI",  0x00ff);
  2533.   AddFixed("SYS",  0x1b07);
  2534.   AddFixed("WAI",  0x1b06);
  2535.   AddFixed("SPARE", 0x00ef);
  2536.  
  2537.   AddBranch("BCC", 0x0024);
  2538.   AddBranch("BCS", 0x0025);
  2539.   AddBranch("BEQ", 0x0027);
  2540.   AddBranch("BGE", 0x002c);
  2541.   AddBranch("BGT", 0x002e);
  2542.   AddBranch("BHI", 0x0022);
  2543.   AddBranch("BHS", 0x0024);
  2544.   AddBranch("BLE", 0x002f);
  2545.   AddBranch("BLO", 0x0025);
  2546.   AddBranch("BLS", 0x0023);
  2547.   AddBranch("BLT", 0x002d);
  2548.   AddBranch("BMI", 0x002b);
  2549.   AddBranch("BNE", 0x0026);
  2550.   AddBranch("BPL", 0x002a);
  2551.   AddBranch("BRA", 0x0020);
  2552.   AddBranch("BSR", 0x0021);
  2553.   AddBranch("BVC", 0x0028);
  2554.   AddBranch("BVS", 0x0029);
  2555.  
  2556.   AddReg("ABS", 0x1b40);
  2557.   AddReg("SAT", 0x1ba0);
  2558.  
  2559.   AddRegMemImm("ADC",  0x1b50);
  2560.   AddRegMemImm("ADD",  0x0050);
  2561.   AddRegMemImm("AND",  0x0058);
  2562.   AddRegMemImm("BIT",  0x1b58);
  2563.   AddRegMemImm("EOR",  0x1b78);
  2564.   AddRegMemImm("OR",   0x0078);
  2565.   AddRegMemImm("SBC",  0x1b70);
  2566.  
  2567.   AddInstTable(InstTable, "SUB", 0x0070, DecodeSUB);
  2568.   AddInstTable(InstTable, "CMP", 0x00e0, DecodeCMP);
  2569.  
  2570.   AddInstTable(InstTable, "ANDCC", 0x00ce, DecodeImm8);
  2571.   AddInstTable(InstTable, "ORCC" , 0x00de, DecodeImm8);
  2572.   AddInstTable(InstTable, "TRAP" , 0, DecodeTRAP);
  2573.  
  2574.   AddInstTable(InstTable, "ASL", 0xc0, DecodeShift);
  2575.   AddInstTable(InstTable, "ASR", 0x80, DecodeShift);
  2576.   AddInstTable(InstTable, "LSL", 0x40, DecodeShift);
  2577.   AddInstTable(InstTable, "LSR", 0x00, DecodeShift);
  2578.  
  2579.   AddInstTable(InstTable, "BCLR", 0xec, DecodeBit);
  2580.   AddInstTable(InstTable, "BSET", 0xed, DecodeBit);
  2581.   AddInstTable(InstTable, "BTGL", 0xee, DecodeBit);
  2582.  
  2583.   AddInstTable(InstTable, "BFEXT", 0x00, DecodeBitField);
  2584.   AddInstTable(InstTable, "BFINS", 0x80, DecodeBitField);
  2585.  
  2586.   AddInstTable(InstTable, "BRCLR", 0x02, DecodeBitRel);
  2587.   AddInstTable(InstTable, "BRSET", 0x03, DecodeBitRel);
  2588.  
  2589.   AddInstTable(InstTable, "CLB", 0x1b91, DecodeTwoReg);
  2590.  
  2591.   AddInstTable(InstTable, "CLR", 0x0000, DecodeCLR);
  2592.   AddInstTable(InstTable, "COM", 0x00cc, DecodeCOM_NEG);
  2593.   AddInstTable(InstTable, "NEG", 0x00dc, DecodeCOM_NEG);
  2594.   AddCondition("DB%s", 0x0d80, DecodeDBcc);
  2595.   AddInstTable(InstTable, "DEC", 0x0040, DecodeINC_DEC);
  2596.   AddInstTable(InstTable, "INC", 0x0030, DecodeINC_DEC);
  2597.  
  2598.   AddInstTable(InstTable, "DIVS", 0x3081, DecodeDIV_MOD);
  2599.   AddInstTable(InstTable, "DIVU", 0x3001, DecodeDIV_MOD);
  2600.   AddInstTable(InstTable, "MODS", 0x3881, DecodeDIV_MOD);
  2601.   AddInstTable(InstTable, "MODU", 0x3801, DecodeDIV_MOD);
  2602.   AddInstTable(InstTable, "MACS", 0x4881, DecodeDIV_MOD);
  2603.   AddInstTable(InstTable, "MACU", 0x4801, DecodeDIV_MOD);
  2604.   AddInstTable(InstTable, "MULS", 0x4880, DecodeDIV_MOD);
  2605.   AddInstTable(InstTable, "MULU", 0x4800, DecodeDIV_MOD);
  2606.   AddInstTable(InstTable,"QMULS", 0xb081, DecodeDIV_MOD);
  2607.   AddInstTable(InstTable,"QMULU", 0xb001, DecodeDIV_MOD);
  2608.  
  2609.   AddInstTable(InstTable, "EXG", 0x00ae, DecodeEXG_TFR);
  2610.   AddInstTable(InstTable, "TFR", 0x009e, DecodeEXG_TFR);
  2611.   AddInstTable(InstTable, "SEX", 0x01ae, DecodeEXG_TFR);
  2612.   AddInstTable(InstTable, "ZEX", 0x019e, DecodeEXG_TFR);
  2613.  
  2614.   AddInstTable(InstTable, "JMP", 0x00aa, DecodeJMP_JSR);
  2615.   AddInstTable(InstTable, "JSR", 0x00ab, DecodeJMP_JSR);
  2616.  
  2617.   AddInstTable(InstTable, "LD" , 0x0000, DecodeLD_ST);
  2618.   AddInstTable(InstTable, "ST" , 0x0020, DecodeLD_ST);
  2619.   AddInstTable(InstTable, "MOV" , 0x0000, DecodeMOV);
  2620.   AddInstTable(InstTable, "LEA" , 0x0000, DecodeLEA);
  2621.  
  2622.   AddInstTable(InstTable, "MAXS", 0x1b28, DecodeMIN_MAX);
  2623.   AddInstTable(InstTable, "MAXU", 0x1b18, DecodeMIN_MAX);
  2624.   AddInstTable(InstTable, "MINS", 0x1b20, DecodeMIN_MAX);
  2625.   AddInstTable(InstTable, "MINU", 0x1b10, DecodeMIN_MAX);
  2626.  
  2627.   AddInstTable(InstTable, "PSH", 0x0400, DecodePSH_PUL);
  2628.   AddInstTable(InstTable, "PUL", 0x0480, DecodePSH_PUL);
  2629.  
  2630.   AddInstTable(InstTable, "ROL", 0x1064, DecodeROL_ROR);
  2631.   AddInstTable(InstTable, "ROR", 0x1024, DecodeROL_ROR);
  2632.  
  2633.   AddCondition("TB%s", 0x0b00, DecodeTBcc);
  2634.  
  2635.   AddInstTable(InstTable, "DEFBIT", 0, DecodeDEFBIT);
  2636.   AddInstTable(InstTable, "DEFBITFIELD", 0, DecodeDEFBITFIELD);
  2637.  
  2638.   add_moto8_pseudo(InstTable, e_moto_pseudo_flags_be);
  2639.   AddMoto16Pseudo(InstTable, e_moto_pseudo_flags_be);
  2640.   AddInstTable(InstTable, "DB", eIntPseudoFlag_BigEndian | eIntPseudoFlag_AllowInt | eIntPseudoFlag_AllowString | eIntPseudoFlag_MotoRep, DecodeIntelDB);
  2641.   AddInstTable(InstTable, "DW", eIntPseudoFlag_BigEndian | eIntPseudoFlag_AllowInt | eIntPseudoFlag_AllowString | eIntPseudoFlag_MotoRep, DecodeIntelDW);
  2642. }
  2643.  
  2644. static void DeinitFields(void)
  2645. {
  2646.   DestroyInstTable(InstTable);
  2647. }
  2648.  
  2649. /*--------------------------------------------------------------------------*/
  2650. /* Semiglobal Functions */
  2651.  
  2652. static Boolean DecodeAttrPart_S12Z(void)
  2653. {
  2654.   int z;
  2655.  
  2656.   if (strlen(AttrPart.str.p_str) > 2)
  2657.   {
  2658.     WrStrErrorPos(ErrNum_UndefAttr, &AttrPart);
  2659.     return False;
  2660.   }
  2661.  
  2662.   for (z = 0; z < 2; z++)
  2663.   {
  2664.     if (AttrPart.str.p_str[z] == '\0')
  2665.       break;
  2666.     if (!DecodeMoto16AttrSize(AttrPart.str.p_str[z], &AttrPartOpSize[z], True))
  2667.       return False;
  2668.   }
  2669.   return True;
  2670. }
  2671.  
  2672. static void MakeCode_S12Z(void)
  2673. {
  2674.   OpSize = (AttrPartOpSize[0] != eSymbolSizeUnknown) ? AttrPartOpSize[0] : eSymbolSizeUnknown;
  2675.   OpSize2 = (AttrPartOpSize[1] != eSymbolSizeUnknown) ? AttrPartOpSize[1] : eSymbolSizeUnknown;
  2676.  
  2677.   if (!LookupInstTable(InstTable, OpPart.str.p_str))
  2678.     WrStrErrorPos(ErrNum_UnknownInstruction, &OpPart);
  2679. }
  2680.  
  2681. static Boolean IsDef_S12Z(void)
  2682. {
  2683.   return Memo("DEFBIT") || Memo("DEFBITFIELD");
  2684. }
  2685.  
  2686. static void SwitchTo_S12Z(void)
  2687. {
  2688.   const TFamilyDescr *pDescr = FindFamilyByName("S12Z");
  2689.   TurnWords = False;
  2690.   SetIntConstMode(eIntConstModeMoto);
  2691.  
  2692.   PCSymbol = "*";
  2693.   HeaderID = pDescr->Id;
  2694.   NOPCode = 0x01;
  2695.   DivideChars = ",";
  2696.   HasAttrs = True;
  2697.   AttrChars = ".";
  2698.  
  2699.   ValidSegs = (1 << SegCode);
  2700.   Grans[SegCode] = 1; ListGrans[SegCode] = 1; SegInits[SegCode] = 0;
  2701.   SegLimits[SegCode] = 0xffffff;
  2702.   DecodeAttrPart = DecodeAttrPart_S12Z;
  2703.   MakeCode = MakeCode_S12Z;
  2704.   IsDef = IsDef_S12Z;
  2705.   SwitchFrom = DeinitFields;
  2706.   DissectBit = DissectBit_S12Z;
  2707.   InitFields();
  2708.   AddMoto16PseudoONOFF(False);
  2709. }
  2710.  
  2711. void codes12z_init(void)
  2712. {
  2713.   (void)AddCPU("S912ZVC19F0MKH" , SwitchTo_S12Z);
  2714.   (void)AddCPU("S912ZVC19F0MLF" , SwitchTo_S12Z);
  2715.   (void)AddCPU("S912ZVCA19F0MKH", SwitchTo_S12Z);
  2716.   (void)AddCPU("S912ZVCA19F0MLF", SwitchTo_S12Z);
  2717.   (void)AddCPU("S912ZVCA19F0WKH", SwitchTo_S12Z);
  2718.   (void)AddCPU("S912ZVH128F2CLQ", SwitchTo_S12Z);
  2719.   (void)AddCPU("S912ZVH128F2CLL", SwitchTo_S12Z);
  2720.   (void)AddCPU("S912ZVH64F2CLQ" , SwitchTo_S12Z);
  2721.   (void)AddCPU("S912ZVHY64F1CLQ", SwitchTo_S12Z);
  2722.   (void)AddCPU("S912ZVHY32F1CLQ", SwitchTo_S12Z);
  2723.   (void)AddCPU("S912ZVHY64F1CLL", SwitchTo_S12Z);
  2724.   (void)AddCPU("S912ZVHY32F1CLL", SwitchTo_S12Z);
  2725.   (void)AddCPU("S912ZVHL64F1CLQ", SwitchTo_S12Z);
  2726.   (void)AddCPU("S912ZVHL32F1CLQ", SwitchTo_S12Z);
  2727.   (void)AddCPU("S912ZVHL64F1CLL", SwitchTo_S12Z);
  2728.   (void)AddCPU("S912ZVHL32F1CLL", SwitchTo_S12Z);
  2729.   (void)AddCPU("S912ZVFP64F1CLQ", SwitchTo_S12Z);
  2730.   (void)AddCPU("S912ZVFP64F1CLL", SwitchTo_S12Z);
  2731.   (void)AddCPU("S912ZVH128F2VLQ", SwitchTo_S12Z);
  2732.   (void)AddCPU("S912ZVH128F2VLL", SwitchTo_S12Z);
  2733.   (void)AddCPU("S912ZVH64F2VLQ" , SwitchTo_S12Z);
  2734.   (void)AddCPU("S912ZVHY64F1VLQ", SwitchTo_S12Z);
  2735.   (void)AddCPU("S912ZVHY32F1VLQ", SwitchTo_S12Z);
  2736.   (void)AddCPU("S912ZVHY64F1VL" , SwitchTo_S12Z);
  2737.   (void)AddCPU("S912ZVHY32F1VLL", SwitchTo_S12Z);
  2738.   (void)AddCPU("S912ZVHL64F1VLQ", SwitchTo_S12Z);
  2739. }
  2740.