Subversion Repositories pentevo

Rev

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

  1. /* codexgate.c */
  2. /*****************************************************************************/
  3. /* SPDX-License-Identifier: GPL-2.0-only OR GPL-3.0-only                     */
  4. /*                                                                           */
  5. /* AS-Portierung                                                             */
  6. /*                                                                           */
  7. /* Codegenerator XGATE-Kern                                                  */
  8. /*                                                                           */
  9. /*****************************************************************************/
  10.  
  11. #include "stdinc.h"
  12. #include <ctype.h>
  13. #include <string.h>
  14.  
  15. #include "nls.h"
  16. #include "be_le.h"
  17. #include "strutil.h"
  18. #include "bpemu.h"
  19. #include "asmdef.h"
  20. #include "asmsub.h"
  21. #include "asmpars.h"
  22. #include "asmallg.h"
  23. #include "headids.h"
  24. #include "codepseudo.h"
  25. #include "motpseudo.h"
  26. #include "asmitree.h"
  27. #include "codevars.h"
  28. #include "errmsg.h"
  29.  
  30. #include "codexgate.h"
  31.  
  32. /*--------------------------------------------------------------------------*/
  33. /* Variables */
  34.  
  35. #define FixedOrderCnt 2
  36.  
  37. static CPUVar CPUXGate;
  38.  
  39. /*--------------------------------------------------------------------------*/
  40. /* Address Decoders */
  41.  
  42. /*!------------------------------------------------------------------------
  43.  * \fn     DecodeRegCore(const char *pArg, Word *pResult)
  44.  * \brief  check whether argument is a CPU register
  45.  * \param  pArg argument
  46.  * \param  pResult register # if yes
  47.  * \return True if yes
  48.  * ------------------------------------------------------------------------ */
  49.  
  50. static Boolean DecodeRegCore(const char *pArg, Word *pResult)
  51. {
  52.   if ((strlen(pArg) != 2) || (as_toupper(*pArg) != 'R') || (!as_isdigit(pArg[1])))
  53.   {
  54.     *pResult = 0;
  55.     return False;
  56.   }
  57.   else
  58.   {
  59.     *pResult = pArg[1] - '0';
  60.     return *pResult <= 7;
  61.   }
  62. }
  63.  
  64. /*!------------------------------------------------------------------------
  65.  * \fn     DissectReg_XGATE(char *pDest, size_t DestSize, tRegInt Reg, tSymbolSize Size)
  66.  * \brief  dissect register symbol - XGATE version
  67.  * \param  pDest destination buffer
  68.  * \param  DestSize size of destination buffer
  69.  * \param  Reg register number
  70.  * \param  Size register size
  71.  * ------------------------------------------------------------------------ */
  72.  
  73. static void DissectReg_XGATE(char *pDest, size_t DestSize, tRegInt Reg, tSymbolSize Size)
  74. {
  75.   switch (Size)
  76.   {
  77.     case eSymbolSize16Bit:
  78.       as_snprintf(pDest, DestSize, "R%u", (unsigned)Reg);
  79.       break;
  80.     default:
  81.       as_snprintf(pDest, DestSize, "%d-%u", Size, (unsigned)Reg);
  82.   }
  83. }
  84.  
  85. /*!------------------------------------------------------------------------
  86.  * \fn     DecodeReg(const tStrComp *pArg, Word *pReg, Boolean MustBeReg)
  87.  * \brief  check whether argument is CPU register or register alias
  88.  * \param  pArg argument
  89.  * \param  pReg register number if yes
  90.  * \param  MustBeReg True if register is expected
  91.  * \return Reg eval result
  92.  * ------------------------------------------------------------------------ */
  93.  
  94. static tRegEvalResult DecodeReg(const tStrComp *pArg, Word *pReg, Boolean MustBeReg)
  95. {
  96.   tRegDescr RegDescr;
  97.   tEvalResult EvalResult;
  98.   tRegEvalResult RegEvalResult;
  99.  
  100.   if (DecodeRegCore(pArg->str.p_str, pReg))
  101.     return eIsReg;
  102.  
  103.   RegEvalResult = EvalStrRegExpressionAsOperand(pArg, &RegDescr, &EvalResult, eSymbolSize16Bit, MustBeReg);
  104.   *pReg = RegDescr.Reg;
  105.   return RegEvalResult;
  106. }
  107.  
  108. /*!------------------------------------------------------------------------
  109.  * \fn     DecodeArgReg(int Index, Word *pReg)
  110.  * \brief  check whether argument #n is CPU register or register alias
  111.  * \param  Index argument index
  112.  * \param  pReg register number if yes
  113.  * \return True if yes
  114.  * ------------------------------------------------------------------------ */
  115.  
  116. static Boolean DecodeArgReg(int Index, Word *pReg)
  117. {
  118.   return DecodeReg(&ArgStr[Index], pReg, True);
  119. }
  120.  
  121. /*--------------------------------------------------------------------------*/
  122. /* Instruction Decoders */
  123.  
  124. static void DecodeFixed(Word Index)
  125. {
  126.   if (ChkArgCnt(0, 0))
  127.   {
  128.     WAsmCode[0] = Index;
  129.     CodeLen = 2;
  130.   }
  131. }
  132.  
  133. static void DecodeBranch(Word Index)
  134. {
  135.   LongInt Dist;
  136.   Boolean OK;
  137.   tSymbolFlags Flags;
  138.  
  139.   if (ChkArgCnt(1, 1))
  140.   {
  141.     Dist = EvalStrIntExpressionWithFlags(&ArgStr[1], UInt16, &OK, &Flags) - (EProgCounter() + 2);
  142.     if (OK)
  143.     {
  144.       if (!mSymbolQuestionable(Flags) && (Dist & 1)) WrError(ErrNum_NotAligned);
  145.       else if (!mSymbolQuestionable(Flags) && ((Dist < -512) || (Dist > 510))) WrError(ErrNum_NotAligned);
  146.       else
  147.       {
  148.         WAsmCode[0] = Index | ((Dist >> 1) & 0x01ff);
  149.         CodeLen = 2;
  150.       }
  151.     }
  152.   }
  153. }
  154.  
  155. static void DecodeBRA(Word Index)
  156. {
  157.   LongInt Dist;
  158.   Boolean OK;
  159.   tSymbolFlags Flags;
  160.  
  161.   UNUSED(Index);
  162.  
  163.   if (ChkArgCnt(1, 1))
  164.   {
  165.     Dist = EvalStrIntExpressionWithFlags(&ArgStr[1], UInt16, &OK, &Flags) - (EProgCounter() + 2);
  166.     if (OK)
  167.     {
  168.       if (!mSymbolQuestionable(Flags) && (Dist & 1)) WrError(ErrNum_NotAligned);
  169.       else if (!mSymbolQuestionable(Flags) && ((Dist < -1024) || (Dist > 1022))) WrError(ErrNum_NotAligned);
  170.       else
  171.       {
  172.         WAsmCode[0] = 0x3c00 | ((Dist >> 1) & 0x03ff);
  173.         CodeLen = 2;
  174.       }
  175.     }
  176.   }
  177. }
  178.  
  179. static void DecodeShift(Word Index)
  180. {
  181.   Word DReg, SReg;
  182.   Boolean OK;
  183.  
  184.   if (!ChkArgCnt(2, 2));
  185.   else if (!DecodeArgReg(1, &DReg));
  186.   else if (*ArgStr[2].str.p_str == '#')
  187.   {
  188.     SReg = EvalStrIntExpressionOffs(&ArgStr[2], 1, UInt4, &OK);
  189.     if (OK)
  190.     {
  191.       WAsmCode[0] = 0x0808 | Index | (DReg << 8) | (SReg << 4);
  192.       CodeLen = 2;
  193.     }
  194.   }
  195.   else if (DecodeArgReg(2, &SReg))
  196.   {
  197.     WAsmCode[0] = 0x0810 | Index | (DReg << 8) | (SReg << 5);
  198.     CodeLen = 2;
  199.   }
  200. }
  201.  
  202. static void DecodeAriImm(Word Index)
  203. {
  204.   Word DReg, SReg1, SReg2;
  205.   Boolean OK;
  206.  
  207.   if (!ChkArgCnt(2, 3));
  208.   else if (!DecodeArgReg(1, &DReg));
  209.   else if (ArgCnt == 2)
  210.   {
  211.     if (*ArgStr[2].str.p_str == '#')
  212.     {
  213.       SReg1 = EvalStrIntExpressionOffs(&ArgStr[2], 1, Int16, &OK);
  214.       if (OK)
  215.       {
  216.         WAsmCode[0] = 0x8000 | (Index << 12) | (DReg << 8) | Lo(SReg1);
  217.         WAsmCode[1] = 0x8800 | (Index << 12) | (DReg << 8) | Hi(SReg1);
  218.         CodeLen = 4;
  219.       }
  220.     }
  221.     else if (DecodeArgReg(2, &SReg1))
  222.     {
  223.       WAsmCode[0] = 0x1000 | ((Index & 4) << 9) | (Index & 3) | (DReg << 8) | (DReg << 5) | (SReg1 << 2);
  224.       CodeLen = 2;
  225.     }
  226.   }
  227.   else if (DecodeArgReg(2, &SReg1) && DecodeArgReg(3, &SReg2))
  228.   {
  229.     WAsmCode[0] = 0x1000 | ((Index & 4) << 9) | (Index & 3) | (DReg << 8) | (SReg1 << 5) | (SReg2 << 2);
  230.     CodeLen = 2;
  231.   }
  232. }
  233.  
  234. static void DecodeImm8(Word Index)
  235. {
  236.   Word DReg, Src;
  237.   Boolean OK;
  238.  
  239.   if (!ChkArgCnt(2, 2));
  240.   else if (!DecodeArgReg(1, &DReg));
  241.   else if (*ArgStr[2].str.p_str != '#') WrError(ErrNum_OnlyImmAddr);
  242.   else
  243.   {
  244.     Src = EvalStrIntExpressionOffs(&ArgStr[2], 1, Int8, &OK);
  245.     if (OK)
  246.     {
  247.       WAsmCode[0] = Index | (DReg << 8) | (Src & 0xff);
  248.       CodeLen = 2;
  249.     }
  250.   }
  251. }
  252.  
  253. static void DecodeReg3(Word Index)
  254. {
  255.   Word DReg, SReg1, SReg2;
  256.  
  257.   if (ChkArgCnt(3, 3)
  258.    && DecodeArgReg(1, &DReg)
  259.    && DecodeArgReg(2, &SReg1)
  260.    && DecodeArgReg(3, &SReg2))
  261.   {
  262.     WAsmCode[0] = Index | (DReg << 8) | (SReg1 << 5) | (SReg2 << 2);
  263.     CodeLen = 2;
  264.   }
  265. }
  266.  
  267. static void DecodeReg23(Word Index)
  268. {
  269.   Word DReg, SReg1, SReg2;
  270.  
  271.   if (!ChkArgCnt(2, 3));
  272.   else if (!DecodeArgReg(1, &DReg));
  273.   else if (!DecodeArgReg(2, &SReg1));
  274.   else if (ArgCnt == 2)
  275.   {
  276.     WAsmCode[0] = Index | (DReg << 8) | (DReg << 5) | (SReg1 << 2);
  277.     CodeLen = 2;
  278.   }
  279.   else if (DecodeArgReg(3, &SReg2))
  280.   {
  281.     WAsmCode[0] = Index | (DReg << 8) | (SReg1 << 5) | (SReg2 << 2);
  282.     CodeLen = 2;
  283.   }
  284. }
  285.  
  286. static void DecodeCPC(Word Index)
  287. {
  288.   Word DReg, SReg;
  289.  
  290.   if (ChkArgCnt(2, 3)
  291.    && DecodeArgReg(1, &DReg)
  292.    && DecodeArgReg(2, &SReg))
  293.   {
  294.     WAsmCode[0] = Index | (DReg << 5) | (SReg << 2);
  295.     CodeLen = 2;
  296.   }
  297. }
  298.  
  299. static void DecodeMOV(Word Index)
  300. {
  301.   Word DReg, SReg;
  302.  
  303.   if (ChkArgCnt(2, 3)
  304.    && DecodeArgReg(1, &DReg)
  305.    && DecodeArgReg(2, &SReg))
  306.   {
  307.     WAsmCode[0] = Index | (DReg << 8) | (SReg << 2);
  308.     CodeLen = 2;
  309.   }
  310. }
  311.  
  312. static void DecodeBFFFO(Word Index)
  313. {
  314.   Word DReg, SReg;
  315.  
  316.   if (ChkArgCnt(2, 3)
  317.    && DecodeArgReg(1, &DReg)
  318.    && DecodeArgReg(2, &SReg))
  319.   {
  320.     WAsmCode[0] = Index | (DReg << 8) | (SReg << 5);
  321.     CodeLen = 2;
  322.   }
  323. }
  324.  
  325. static void DecodeReg12(Word Index)
  326. {
  327.   Word DReg, SReg;
  328.  
  329.   if (!ChkArgCnt(1, 2));
  330.   else if (!DecodeArgReg(1, &DReg));
  331.   else if (ArgCnt == 1)
  332.   {
  333.     WAsmCode[0] = Index | (DReg << 8) | (DReg << 2);
  334.     CodeLen = 2;
  335.   }
  336.   else if (DecodeArgReg(2, &SReg))
  337.   {
  338.     WAsmCode[0] = Index | (DReg << 8) | (SReg << 2);
  339.     CodeLen = 2;
  340.   }
  341. }
  342.  
  343. static void DecodeReg1(Word Index)
  344. {
  345.   Word Reg;
  346.  
  347.   if (ChkArgCnt(1, 1) && DecodeArgReg(1, &Reg))
  348.   {
  349.     WAsmCode[0] = Index | (Reg << 8);
  350.     CodeLen = 2;
  351.   }
  352. }
  353.  
  354. static void DecodeTST(Word Index)
  355. {
  356.   Word Reg;
  357.  
  358.   if (ChkArgCnt(1, 1) && DecodeArgReg(1, &Reg))
  359.   {
  360.     WAsmCode[0] = Index | (Reg << 5);
  361.     CodeLen = 2;
  362.   }
  363. }
  364.  
  365. static void DecodeSem(Word Index)
  366. {
  367.   Word Reg;
  368.   Boolean OK;
  369.  
  370.   if (!ChkArgCnt(1, 1));
  371.   else if (*ArgStr[1].str.p_str == '#')
  372.   {
  373.     Reg = EvalStrIntExpressionOffs(&ArgStr[1], 1, UInt3, &OK);
  374.     if (OK)
  375.     {
  376.       WAsmCode[0] = Index | (Reg << 8);
  377.       CodeLen = 2;
  378.     }
  379.   }
  380.   else if (DecodeArgReg(1, &Reg))
  381.   {
  382.     WAsmCode[0] = Index | (Reg << 8) | 1;
  383.     CodeLen = 2;
  384.   }
  385. }
  386.  
  387. static void DecodeSIF(Word Index)
  388. {
  389.   Word Reg;
  390.  
  391.   UNUSED(Index);
  392.  
  393.   if (ArgCnt == 0)
  394.   {
  395.     WAsmCode[0] = 0x0300;
  396.     CodeLen = 2;
  397.   }
  398.   else if (ChkArgCnt(0, 1) && DecodeArgReg(1, &Reg))
  399.   {
  400.     WAsmCode[0] = 0x00f7 | (Reg << 8);
  401.     CodeLen = 2;
  402.   }
  403. }
  404.  
  405. static void DecodeTFR(Word Index)
  406. {
  407.   Word Reg;
  408.   int RegIdx = 0;
  409.  
  410.   UNUSED(Index);
  411.  
  412.   if (ChkArgCnt(2, 2))
  413.   {
  414.     Boolean OK = True;
  415.  
  416.     if (!as_strcasecmp(ArgStr[2].str.p_str, "CCR"))
  417.     {
  418.       WAsmCode[0] = 0x00f8;
  419.       RegIdx = 1;
  420.     }
  421.     else if (!as_strcasecmp(ArgStr[1].str.p_str, "CCR"))
  422.     {
  423.       WAsmCode[0] = 0x00f9;
  424.       RegIdx = 2;
  425.     }
  426.     else if (!as_strcasecmp(ArgStr[2].str.p_str, "PC"))
  427.     {
  428.       WAsmCode[0] = 0x00fa;
  429.       RegIdx = 1;
  430.     }
  431.     else
  432.       OK = False;
  433.  
  434.     if (!OK) WrError(ErrNum_OverRange);
  435.     else if (DecodeArgReg(RegIdx, &Reg))
  436.     {
  437.       WAsmCode[0] |= (Reg << 8);
  438.       CodeLen = 2;
  439.     }
  440.   }
  441. }
  442.  
  443. static void DecodeCmp(Word Index)
  444. {
  445.   Word DReg, Src;
  446.   Boolean OK;
  447.  
  448.   UNUSED(Index);
  449.  
  450.   if (ChkArgCnt(2, 2) && DecodeArgReg(1, &DReg))
  451.   {
  452.     if (*ArgStr[2].str.p_str == '#')
  453.     {
  454.       Src = EvalStrIntExpressionOffs(&ArgStr[2], 1, Int16, &OK);
  455.       if (OK)
  456.       {
  457.         WAsmCode[0] = 0xd000 | (DReg << 8) | Lo(Src);
  458.         WAsmCode[1] = 0xd800 | (DReg << 8) | Hi(Src);
  459.         CodeLen = 4;
  460.       }
  461.     }
  462.     else if (DecodeArgReg(2, &Src))
  463.     {
  464.       WAsmCode[0] = 0x1800 | (DReg << 5) | (Src << 2);
  465.       CodeLen = 2;
  466.     }
  467.   }
  468. }
  469.  
  470. static void DecodeMem(Word Code)
  471. {
  472.   Word DReg;
  473.  
  474.   if (!ChkArgCnt(2, 2));
  475.   else if (!DecodeArgReg(1, &DReg));
  476.   else if (*ArgStr[2].str.p_str == '#')
  477.   {
  478.     /* Only allowed for LDW */
  479.     if (Code != 0x4800) WrError(ErrNum_InvAddrMode);
  480.     else
  481.     {
  482.       Word Val;
  483.       Boolean OK;
  484.  
  485.       Val = EvalStrIntExpressionOffs(&ArgStr[2], 1, Int16, &OK);
  486.       if (OK)
  487.       {
  488.         WAsmCode[0] = 0xf000 | (DReg << 8) | Lo(Val);
  489.         WAsmCode[1] = 0xf800 | (DReg << 8) | Hi(Val);
  490.         CodeLen = 4;
  491.       }
  492.     }
  493.   }
  494.   else if (!IsIndirect(ArgStr[2].str.p_str)) WrError(ErrNum_InvAddrMode);
  495.   else
  496.   {
  497.     int l = strlen(ArgStr[2].str.p_str) - 2;
  498.     char *pPos;
  499.     Word Base, Index;
  500.     Boolean OK;
  501.     tStrComp IndexComp, *pIndexComp;
  502.  
  503.     /* remove parentheses */
  504.  
  505.     StrCompCutLeft(&ArgStr[2], 1);
  506.     StrCompShorten(&ArgStr[2], 1);
  507.  
  508.     /* base present? */
  509.  
  510.     pPos = strchr(ArgStr[2].str.p_str, ',');
  511.     if (pPos)
  512.     {
  513.       tStrComp RegComp;
  514.  
  515.       StrCompSplitRef(&RegComp, &IndexComp, &ArgStr[2], pPos);
  516.       KillPostBlanksStrComp(&RegComp);
  517.       KillPrefBlanksStrCompRef(&RegComp);
  518.       OK = DecodeReg(&RegComp, &Base, True);
  519.       pIndexComp = &IndexComp;
  520.     }
  521.     else
  522.     {
  523.       Base = 0;
  524.       OK = True;
  525.       pIndexComp = &ArgStr[2];
  526.     }
  527.  
  528.     /* go on with index? */
  529.  
  530.     if (OK)
  531.     {
  532.       KillPrefBlanksStrComp(pIndexComp);
  533.       KillPostBlanksStrComp(pIndexComp);
  534.  
  535.       if (*pIndexComp->str.p_str == '#')
  536.         Index = EvalStrIntExpressionOffs(pIndexComp, 1, UInt5, &OK);
  537.       else if (*pIndexComp->str.p_str == '-')
  538.       {
  539.         tStrComp RegArg;
  540.  
  541.         Code |= 0x2000;
  542.         StrCompRefRight(&RegArg, pIndexComp, 1);
  543.         OK = DecodeReg(&RegArg, &Index, True);
  544.         if (OK)
  545.           Index = (Index << 2) | 2;
  546.       }
  547.       else if (((l = strlen(pIndexComp->str.p_str)) > 1) && (pIndexComp->str.p_str[l - 1] == '+'))
  548.       {
  549.         Code |= 0x2000;
  550.         StrCompShorten(pIndexComp, 1);
  551.         OK = DecodeReg(pIndexComp, &Index, True);
  552.         if (OK)
  553.           Index = (Index << 2) | 1;
  554.       }
  555.       else
  556.       {
  557.         Code |= 0x2000;
  558.         OK = DecodeReg(pIndexComp, &Index, True);
  559.         if (OK)
  560.           Index = (Index << 2);
  561.       }
  562.  
  563.       if (OK)
  564.       {
  565.         WAsmCode[0] = Code | (DReg << 8) | (Base << 5) | Index;
  566.         CodeLen = 2;
  567.       }
  568.     }
  569.   }
  570. }
  571.  
  572. /*!------------------------------------------------------------------------
  573.  * \fn     check_pc_even(Word index)
  574.  * \brief  check that machine instruction ends up on even address
  575.  * ------------------------------------------------------------------------ */
  576.  
  577. static void check_pc_even(Word index)
  578. {
  579.   UNUSED(index);
  580.   if (Odd(EProgCounter())) WrError(ErrNum_AddrNotAligned);
  581. }
  582.  
  583. /*--------------------------------------------------------------------------*/
  584. /* Dynamic Code Table Handling */
  585.  
  586. static void InitFields(void)
  587. {
  588.   InstTable = CreateInstTable(103);
  589.  
  590.   inst_table_set_prefix_proc(InstTable, check_pc_even, 0);
  591.  
  592.   AddInstTable(InstTable, "NOP", NOPCode, DecodeFixed);
  593.   AddInstTable(InstTable, "BRK", 0x0000 , DecodeFixed);
  594.   AddInstTable(InstTable, "RTS", 0x0200 , DecodeFixed);
  595.  
  596.   AddInstTable(InstTable, "BCC", 0x2000 , DecodeBranch);
  597.   AddInstTable(InstTable, "BCS", 0x2200 , DecodeBranch);
  598.   AddInstTable(InstTable, "BEQ", 0x2600 , DecodeBranch);
  599.   AddInstTable(InstTable, "BGE", 0x3400 , DecodeBranch);
  600.   AddInstTable(InstTable, "BGT", 0x3800 , DecodeBranch);
  601.   AddInstTable(InstTable, "BHI", 0x3000 , DecodeBranch);
  602.   AddInstTable(InstTable, "BHS", 0x2000 , DecodeBranch);
  603.   AddInstTable(InstTable, "BLE", 0x3a00 , DecodeBranch);
  604.   AddInstTable(InstTable, "BLO", 0x2200 , DecodeBranch);
  605.   AddInstTable(InstTable, "BLS", 0x3200 , DecodeBranch);
  606.   AddInstTable(InstTable, "BLT", 0x3600 , DecodeBranch);
  607.   AddInstTable(InstTable, "BMI", 0x2a00 , DecodeBranch);
  608.   AddInstTable(InstTable, "BNE", 0x2400 , DecodeBranch);
  609.   AddInstTable(InstTable, "BPL", 0x2800 , DecodeBranch);
  610.   AddInstTable(InstTable, "BVC", 0x2c00 , DecodeBranch);
  611.   AddInstTable(InstTable, "BVS", 0x2e00 , DecodeBranch);
  612.  
  613.   AddInstTable(InstTable, "BRA", 0      , DecodeBRA   );
  614.  
  615.   AddInstTable(InstTable, "ASR", 0x0001 , DecodeShift);
  616.   AddInstTable(InstTable, "CSL", 0x0002 , DecodeShift);
  617.   AddInstTable(InstTable, "CSR", 0x0003 , DecodeShift);
  618.   AddInstTable(InstTable, "LSL", 0x0004 , DecodeShift);
  619.   AddInstTable(InstTable, "LSR", 0x0005 , DecodeShift);
  620.   AddInstTable(InstTable, "ROL", 0x0006 , DecodeShift);
  621.   AddInstTable(InstTable, "ROR", 0x0007 , DecodeShift);
  622.  
  623.   AddInstTable(InstTable, "ADD" , 6, DecodeAriImm);
  624.   AddInstTable(InstTable, "AND" , 0, DecodeAriImm);
  625.   AddInstTable(InstTable, "OR"  , 2, DecodeAriImm);
  626.   AddInstTable(InstTable, "SUB" , 4, DecodeAriImm);
  627.   AddInstTable(InstTable, "XNOR", 3, DecodeAriImm);
  628.  
  629.   AddInstTable(InstTable, "ADDH" , 0xe800, DecodeImm8);
  630.   AddInstTable(InstTable, "ADDL" , 0xe000, DecodeImm8);
  631.   AddInstTable(InstTable, "ANDH" , 0x8800, DecodeImm8);
  632.   AddInstTable(InstTable, "ANDL" , 0x8000, DecodeImm8);
  633.   AddInstTable(InstTable, "BITH" , 0x9800, DecodeImm8);
  634.   AddInstTable(InstTable, "BITL" , 0x9000, DecodeImm8);
  635.   AddInstTable(InstTable, "CMPL" , 0xd000, DecodeImm8);
  636.   AddInstTable(InstTable, "CPCH" , 0xd800, DecodeImm8);
  637.   AddInstTable(InstTable, "ORH"  , 0xa800, DecodeImm8);
  638.   AddInstTable(InstTable, "ORL"  , 0xa000, DecodeImm8);
  639.   AddInstTable(InstTable, "SUBH" , 0xc800, DecodeImm8);
  640.   AddInstTable(InstTable, "SUBL" , 0xc000, DecodeImm8);
  641.   AddInstTable(InstTable, "XNORH", 0xb800, DecodeImm8);
  642.   AddInstTable(InstTable, "XNORL", 0xb000, DecodeImm8);
  643.   AddInstTable(InstTable, "LDH"  , 0xf800, DecodeImm8);
  644.   AddInstTable(InstTable, "LDL"  , 0xf000, DecodeImm8);
  645.  
  646.   AddInstTable(InstTable, "BFEXT" , 0x6003, DecodeReg3);
  647.   AddInstTable(InstTable, "BFINS" , 0x6803, DecodeReg3);
  648.   AddInstTable(InstTable, "BFINSI", 0x7003, DecodeReg3);
  649.   AddInstTable(InstTable, "BFINSX", 0x7803, DecodeReg3);
  650.  
  651.   AddInstTable(InstTable, "ADC"  , 0x1803, DecodeReg23);
  652.   AddInstTable(InstTable, "SBC"  , 0x1801, DecodeReg23);
  653.  
  654.   AddInstTable(InstTable, "CPC"  , 0x1801, DecodeCPC);
  655.   AddInstTable(InstTable, "MOV"  , 0x1002, DecodeMOV);
  656.   AddInstTable(InstTable, "BFFFO", 0x0810, DecodeBFFFO);
  657.  
  658.   AddInstTable(InstTable, "COM"  , 0x1003, DecodeReg12);
  659.   AddInstTable(InstTable, "NEG"  , 0x1800, DecodeReg12);
  660.  
  661.   AddInstTable(InstTable, "JAL"  , 0x00f6, DecodeReg1);
  662.   AddInstTable(InstTable, "PAR"  , 0x00f5, DecodeReg1);
  663.   AddInstTable(InstTable, "SEX"  , 0x00f4, DecodeReg1);
  664.  
  665.   AddInstTable(InstTable, "TST"  , 0x1800, DecodeTST);
  666.  
  667.   AddInstTable(InstTable, "CSEM" , 0x00f0, DecodeSem);
  668.   AddInstTable(InstTable, "SSEM" , 0x00f2, DecodeSem);
  669.  
  670.   AddInstTable(InstTable, "SIF"  , 0     , DecodeSIF);
  671.  
  672.   AddInstTable(InstTable, "TFR"  , 0     , DecodeTFR);
  673.  
  674.   AddInstTable(InstTable, "CMP"  , 0     , DecodeCmp);
  675.  
  676.   AddInstTable(InstTable, "LDB"  , 0x4000, DecodeMem);
  677.   AddInstTable(InstTable, "LDW"  , 0x4800, DecodeMem);
  678.   AddInstTable(InstTable, "STB"  , 0x5000, DecodeMem);
  679.   AddInstTable(InstTable, "STW"  , 0x5800, DecodeMem);
  680.  
  681.   inst_table_set_prefix_proc(InstTable, NULL, 0);
  682.   AddInstTable(InstTable, "REG", 0, CodeREG);
  683.   add_moto8_pseudo(InstTable, e_moto_pseudo_flags_be);
  684. }
  685.  
  686. static void DeinitFields(void)
  687. {
  688.   DestroyInstTable(InstTable);
  689. }
  690.  
  691. /*--------------------------------------------------------------------------*/
  692. /* Callbacks */
  693.  
  694. /*!------------------------------------------------------------------------
  695.  * \fn     InternSymbol_XGATE(char *pArg, TempResult *pResult)
  696.  * \brief  handle built-in symbols on XGATE
  697.  * \param  pArg source argument
  698.  * \param  pResult result buffer
  699.  * ------------------------------------------------------------------------ */
  700.  
  701. static void InternSymbol_XGATE(char *pArg, TempResult *pResult)
  702. {
  703.   Word Reg;
  704.  
  705.   if (DecodeRegCore(pArg, &Reg))
  706.   {
  707.     pResult->Typ = TempReg;
  708.     pResult->DataSize = eSymbolSize16Bit;
  709.     pResult->Contents.RegDescr.Reg = Reg;
  710.     pResult->Contents.RegDescr.Dissect = DissectReg_XGATE;
  711.     pResult->Contents.RegDescr.compare = NULL;
  712.   }
  713. }
  714.  
  715. static void MakeCode_XGATE(void)
  716. {
  717.   /* Nullanweisung */
  718.  
  719.   if ((*OpPart.str.p_str == '\0') && (ArgCnt == 0))
  720.     return;
  721.  
  722.   if (!LookupInstTable(InstTable, OpPart.str.p_str))
  723.     WrStrErrorPos(ErrNum_UnknownInstruction, &OpPart);
  724. }
  725.  
  726. static Boolean IsDef_XGATE(void)
  727. {
  728.   return Memo("REG");
  729. }
  730.  
  731. static void SwitchFrom_XGATE(void)
  732. {
  733.   DeinitFields();
  734. }
  735.  
  736. static void SwitchTo_XGATE(void)
  737. {
  738.   const TFamilyDescr *pDescr;
  739.  
  740.   TurnWords = True;
  741.   SetIntConstMode(eIntConstModeMoto);
  742.  
  743.   pDescr = FindFamilyByName("XGATE");
  744.   PCSymbol = "*"; HeaderID = pDescr->Id; NOPCode = 0x0100;
  745.   DivideChars = ","; HasAttrs = False;
  746.  
  747.   ValidSegs = (1 << SegCode);
  748.   Grans[SegCode] = 1; ListGrans[SegCode] = 2; SegInits[SegCode] = 0;
  749.   SegLimits[SegCode] = 0xffffl;
  750.  
  751.   MakeCode = MakeCode_XGATE;
  752.   IsDef = IsDef_XGATE;
  753.   InternSymbol = InternSymbol_XGATE;
  754.   DissectReg = DissectReg_XGATE;
  755.  
  756.   SwitchFrom = SwitchFrom_XGATE; InitFields();
  757. }
  758.  
  759. /*--------------------------------------------------------------------------*/
  760. /* Initialisierung */
  761.  
  762. void codexgate_init(void)
  763. {
  764.   CPUXGate = AddCPU("XGATE", SwitchTo_XGATE);
  765. }
  766.