Subversion Repositories pentevo

Rev

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

  1. /* codecop4.c */
  2. /*****************************************************************************/
  3. /* SPDX-License-Identifier: GPL-2.0-only OR GPL-3.0-only                     */
  4. /*                                                                           */
  5. /* AS-Portierung                                                             */
  6. /*                                                                           */
  7. /* Codegeneratormodul COP4-Familie                                           */
  8. /*                                                                           */
  9. /*****************************************************************************/
  10.  
  11. #include "stdinc.h"
  12.  
  13. #include "bpemu.h"
  14. #include "asmdef.h"
  15. #include "asmpars.h"
  16. #include "asmsub.h"
  17. #include "asmitree.h"
  18. #include "headids.h"
  19. #include "codevars.h"
  20. #include "codepseudo.h"
  21. #include "intpseudo.h"
  22. #include "natpseudo.h"
  23. #include "errmsg.h"
  24.  
  25. #include "codecop4.h"
  26.  
  27. #define FixedOrderCnt 44
  28. #define ImmOrderCnt 3
  29.  
  30. #define M_CPUCOP410 (1 << 0)
  31. #define M_CPUCOP420 (1 << 1)
  32. #define M_CPUCOP440 (1 << 2)
  33. #define M_CPUCOP444 (1 << 3)
  34.  
  35. typedef struct
  36. {
  37.   Word CPUMask;
  38.   Word Code;
  39. } FixedOrder;
  40.  
  41. static CPUVar CPUCOP410, CPUCOP420, CPUCOP440, CPUCOP444;
  42. static IntType AdrInt;
  43.  
  44. static FixedOrder *FixedOrders, *ImmOrders;
  45.  
  46. /*---------------------------------------------------------------------------*/
  47. /* Code Generators */
  48.  
  49. static void DecodeFixed(Word Index)
  50. {
  51.   FixedOrder *pOrder = FixedOrders + Index;
  52.  
  53.   if (ChkArgCnt(0, 0)
  54.    && (ChkExactCPUMask(pOrder->CPUMask, CPUCOP410) >= 0))
  55.   {
  56.     if (Hi(pOrder->Code))
  57.       BAsmCode[CodeLen++] = Hi(pOrder->Code);
  58.     BAsmCode[CodeLen++] = Lo(pOrder->Code);
  59.   }
  60. }
  61.  
  62. static void DecodeSK(Word Index)
  63. {
  64.   if (ChkArgCnt(1, 1))
  65.   {
  66.     Byte Bit;
  67.     Boolean OK;
  68.  
  69.     Bit = EvalStrIntExpression(&ArgStr[1], UInt2, &OK);
  70.     if (OK)
  71.     {
  72.       if (Index)
  73.         BAsmCode[CodeLen++] = Index;
  74.       BAsmCode[CodeLen++] = 0x01 | ((Bit & 1) << 4) | (Bit & 2);
  75.     }
  76.   }
  77. }
  78.  
  79. static void DecodeImm(Word Index)
  80. {
  81.   FixedOrder *pOrder = ImmOrders + Index;
  82.  
  83.   if (ChkArgCnt(1, 1)
  84.    && (ChkExactCPUMask(pOrder->CPUMask, CPUCOP410) >= 0))
  85.   {
  86.     Byte Val;
  87.     Boolean OK;
  88.  
  89.     Val = EvalStrIntExpression(&ArgStr[1], Int4, &OK);
  90.     if (OK)
  91.     {
  92.       if (Hi(pOrder->Code))
  93.         BAsmCode[CodeLen++] = Hi(pOrder->Code);
  94.       BAsmCode[CodeLen++] = Lo(pOrder->Code) | (Val & 0x0f);
  95.     }
  96.   }
  97. }
  98.  
  99. static void DecodeJmp(Word Index)
  100. {
  101.   if (ChkArgCnt(1, 1))
  102.   {
  103.     Word Addr;
  104.     Boolean OK;
  105.  
  106.     Addr = EvalStrIntExpression(&ArgStr[1], AdrInt, &OK);
  107.     if (OK)
  108.     {
  109.       BAsmCode[CodeLen++] = Index | Hi(Addr);
  110.       BAsmCode[CodeLen++] = Lo(Addr);
  111.     }
  112.   }
  113. }
  114.  
  115. static void DecodeReg(Word Index)
  116. {
  117.   if (ChkArgCnt(1, 1))
  118.   {
  119.     Byte Reg;
  120.     Boolean OK;
  121.  
  122.     Reg = EvalStrIntExpression(&ArgStr[1], UInt2, &OK);
  123.     if (OK)
  124.     {
  125.       BAsmCode[CodeLen++] = Index | ((Reg & 3) << 4);;
  126.     }
  127.   }
  128. }
  129.  
  130. static void DecodeAISC(Word Index)
  131. {
  132.   UNUSED(Index);
  133.  
  134.   if (ChkArgCnt(1, 1))
  135.   {
  136.     Byte Val;
  137.     Boolean OK;
  138.     tSymbolFlags Flags;
  139.  
  140.     Val = EvalStrIntExpressionWithFlags(&ArgStr[1], Int4, &OK, &Flags);
  141.     if (mFirstPassUnknown(Flags))
  142.       Val = 1;
  143.     if (OK)
  144.     {
  145.       if (!Val) WrError(ErrNum_UnderRange);
  146.       else
  147.         BAsmCode[CodeLen++] = 0x50 | (Val & 0x0f);
  148.     }
  149.   }
  150. }
  151.  
  152. static void DecodeRMB(Word Index)
  153. {
  154.   UNUSED(Index);
  155.  
  156.   if (ChkArgCnt(1, 1))
  157.   {
  158.     Byte Reg;
  159.     Boolean OK;
  160.     static Byte Vals[4] = { 0x4c, 0x45, 0x42, 0x43 };
  161.  
  162.     Reg = EvalStrIntExpression(&ArgStr[1], UInt2, &OK);
  163.     if (OK)
  164.     {
  165.       BAsmCode[CodeLen++] = Vals[Reg & 3];
  166.     }
  167.   }
  168. }
  169.  
  170. static void DecodeSMB(Word Index)
  171. {
  172.   UNUSED(Index);
  173.  
  174.   if (ChkArgCnt(1, 1))
  175.   {
  176.     Byte Reg;
  177.     Boolean OK;
  178.     static Byte Vals[4] = { 0x4d, 0x47, 0x46, 0x4b };
  179.  
  180.     Reg = EvalStrIntExpression(&ArgStr[1], UInt2, &OK);
  181.     if (OK)
  182.     {
  183.       BAsmCode[CodeLen++] = Vals[Reg & 3];
  184.     }
  185.   }
  186. }
  187.  
  188. static void DecodeXAD(Word Index)
  189. {
  190.   UNUSED(Index);
  191.  
  192.   if (ChkArgCnt(2, 2))
  193.   {
  194.     Byte Reg1, Reg2;
  195.     Boolean OK;
  196.     tSymbolFlags Flags;
  197.  
  198.     Reg1 = EvalStrIntExpressionWithFlags(&ArgStr[1], UInt2, &OK, &Flags);
  199.     if (mFirstPassUnknown(Flags) && (MomCPU < CPUCOP420))
  200.       Reg1 = 3;
  201.     if (OK)
  202.     {
  203.       Reg2 = EvalStrIntExpressionWithFlags(&ArgStr[2], UInt4, &OK, &Flags);
  204.       if (mFirstPassUnknown(Flags) && (MomCPU < CPUCOP420))
  205.         Reg2 = 15;
  206.       if (OK)
  207.       {
  208.         if ((MomCPU < CPUCOP420) && ((Reg1 != 3) || (Reg2 != 15))) WrError(ErrNum_InvAddrMode);
  209.         else
  210.         {
  211.           BAsmCode[CodeLen++] = 0x23;
  212.           BAsmCode[CodeLen++] = 0x80 | (Reg1 << 4) | Reg2;
  213.         }
  214.       }
  215.     }
  216.   }
  217. }
  218.  
  219. static void DecodeLBI(Word Index)
  220. {
  221.   UNUSED(Index);
  222.  
  223.   if (ChkArgCnt(2, 2))
  224.   {
  225.     Byte Reg, Val;
  226.     Boolean OK;
  227.  
  228.     Reg = EvalStrIntExpression(&ArgStr[1], UInt2, &OK);
  229.     if (OK)
  230.     {
  231.       tSymbolFlags Flags;
  232.  
  233.       Val = EvalStrIntExpressionWithFlags(&ArgStr[2], UInt4, &OK, &Flags);
  234.       if (mFirstPassUnknown(Flags))
  235.         Val = 0;
  236.       if (OK)
  237.       {
  238.         if ((Val > 0) && (Val < 9))
  239.         {
  240.           if (ChkExactCPUMask(M_CPUCOP420 | M_CPUCOP440 | M_CPUCOP440, CPUCOP410) >= 0)
  241.           {
  242.             BAsmCode[CodeLen++] = 0x33;
  243.             BAsmCode[CodeLen++] = 0x80 | (Reg << 4) | Val;
  244.           }
  245.         }
  246.         else
  247.         {
  248.           Val = (Val - 1) & 0x0f;
  249.           BAsmCode[CodeLen++] = (Reg << 4) | Val;
  250.         }
  251.       }
  252.     }
  253.   }
  254. }
  255.  
  256. static void DecodeLDD(Word Index)
  257. {
  258.   UNUSED(Index);
  259.  
  260.   if (ChkArgCnt(2, 2)
  261.    && (ChkExactCPUMask(M_CPUCOP420 | M_CPUCOP440 | M_CPUCOP440, CPUCOP410) >= 0))
  262.   {
  263.     Byte Reg, Val;
  264.     Boolean OK;
  265.  
  266.     Reg = EvalStrIntExpression(&ArgStr[1], UInt2, &OK);
  267.     if (OK)
  268.     {
  269.       Val = EvalStrIntExpression(&ArgStr[2], UInt4, &OK);
  270.       if (OK)
  271.       {
  272.         BAsmCode[CodeLen++] = 0x23;
  273.         BAsmCode[CodeLen++] = (Reg << 4) | Val;
  274.       }
  275.     }
  276.   }
  277. }
  278.  
  279. static void DecodeJSRP(Word Index)
  280. {
  281.   UNUSED(Index);
  282.  
  283.   if (ChkArgCnt(1, 1))
  284.   {
  285.     Word Addr;
  286.     Boolean OK;
  287.     tSymbolFlags Flags;
  288.  
  289.     Addr = EvalStrIntExpressionWithFlags(&ArgStr[1], AdrInt, &OK, &Flags);
  290.     if (mFirstPassUnknown(Flags))
  291.       Addr = 2 << 6;
  292.     if (OK)
  293.     {
  294.       if (((Addr >> 6) != 2) || (Addr == 0xbf)) WrError(ErrNum_NotFromThisAddress);
  295.       else if ((EProgCounter() >> 7) == 1) WrError(ErrNum_NotOnThisAddress);
  296.       else
  297.         BAsmCode[CodeLen++] = 0x80 | (Addr & 0x3f);
  298.     }
  299.   }
  300. }
  301.  
  302. static void DecodeJP(Word Index)
  303. {
  304.   UNUSED(Index);
  305.  
  306.   if (ChkArgCnt(1, 1))
  307.   {
  308.     Word Addr, CurrPC;
  309.     Boolean OK;
  310.     tSymbolFlags Flags;
  311.  
  312.     Addr = EvalStrIntExpressionWithFlags(&ArgStr[1], AdrInt, &OK, &Flags);
  313.     if (mFirstPassUnknown(Flags))
  314.       Addr = EProgCounter() & (~0x1f);
  315.     if (OK)
  316.     {
  317.       CurrPC = EProgCounter();
  318.       if ((Addr & 0x3f) == 0x3f)
  319.         WrError(ErrNum_NotFromThisAddress);
  320.       if (((CurrPC >> 7) == 1) && ((Addr >> 7) == 1))
  321.         BAsmCode[CodeLen++] = 0x80 | (Addr & 0x7f);
  322.       else
  323.       {
  324.         Word PossPage;
  325.  
  326.         PossPage = CurrPC >> 6;
  327.         if ((CurrPC & 0x3f) == 0x3f)
  328.         {
  329.           PossPage++;
  330.           if (mFirstPassUnknown(Flags))
  331.             Addr += 0x40;
  332.         }
  333.  
  334.         if (PossPage == (Addr >> 6))
  335.           BAsmCode[CodeLen++] = 0xc0 | (Addr & 0x3f);
  336.         else
  337.           WrError(ErrNum_NotFromThisAddress);
  338.       }
  339.     }
  340.   }
  341. }
  342.  
  343. /*---------------------------------------------------------------------------*/
  344. /* Code Table Handling */
  345.  
  346. static void AddFixed(const char *NName, Word NCode, Word NMask)
  347. {
  348.   if (InstrZ >= FixedOrderCnt)
  349.     exit(0);
  350.   else
  351.   {
  352.     FixedOrders[InstrZ].Code = NCode;
  353.     FixedOrders[InstrZ].CPUMask = NMask;
  354.     AddInstTable(InstTable, NName, InstrZ++, DecodeFixed);
  355.   }
  356. }
  357.  
  358. static void AddImm(const char *NName, Word NCode, Word NMask)
  359. {
  360.   if (InstrZ >= ImmOrderCnt)
  361.     exit(0);
  362.   else
  363.   {
  364.     ImmOrders[InstrZ].Code = NCode;
  365.     ImmOrders[InstrZ].CPUMask = NMask;
  366.     AddInstTable(InstTable, NName, InstrZ++, DecodeImm);
  367.   }
  368. }
  369.  
  370. static void InitFields(void)
  371. {
  372.   InstTable = CreateInstTable(173);
  373.  
  374.   add_null_pseudo(InstTable);
  375.  
  376.   FixedOrders = (FixedOrder*)malloc(sizeof(FixedOrder) * FixedOrderCnt);
  377.   InstrZ = 0;
  378.   AddFixed("ASC"  , 0x30,   M_CPUCOP410 | M_CPUCOP420 | M_CPUCOP440 | M_CPUCOP444);
  379.   AddFixed("ADD"  , 0x31,   M_CPUCOP410 | M_CPUCOP420 | M_CPUCOP440 | M_CPUCOP444);
  380.   AddFixed("CLRA" , 0x00,   M_CPUCOP410 | M_CPUCOP420 | M_CPUCOP440 | M_CPUCOP444);
  381.   AddFixed("COMP" , 0x40,   M_CPUCOP410 | M_CPUCOP420 | M_CPUCOP440 | M_CPUCOP444);
  382.   AddFixed("NOP"  , 0x44,   M_CPUCOP410 | M_CPUCOP420 | M_CPUCOP440 | M_CPUCOP444);
  383.   AddFixed("RC"   , 0x32,   M_CPUCOP410 | M_CPUCOP420 | M_CPUCOP440 | M_CPUCOP444);
  384.   AddFixed("SC"   , 0x22,   M_CPUCOP410 | M_CPUCOP420 | M_CPUCOP440 | M_CPUCOP444);
  385.   AddFixed("XOR"  , 0x02,   M_CPUCOP410 | M_CPUCOP420 | M_CPUCOP440 | M_CPUCOP444);
  386.   AddFixed("JID"  , 0xff,   M_CPUCOP410 | M_CPUCOP420 | M_CPUCOP440 | M_CPUCOP444);
  387.   AddFixed("RET"  , 0x48,   M_CPUCOP410 | M_CPUCOP420 | M_CPUCOP440 | M_CPUCOP444);
  388.   AddFixed("RETSK", 0x49,   M_CPUCOP410 | M_CPUCOP420 | M_CPUCOP440 | M_CPUCOP444);
  389.   AddFixed("CAMQ" , 0x333c, M_CPUCOP410 | M_CPUCOP420 | M_CPUCOP440 | M_CPUCOP444);
  390.   AddFixed("CAME" , 0x331f,                             M_CPUCOP440              );
  391.   AddFixed("CAMT" , 0x333f,                             M_CPUCOP440 | M_CPUCOP444);
  392.   AddFixed("CAMR" , 0x333d,                             M_CPUCOP440              );
  393.   AddFixed("CEMA" , 0x330f,                             M_CPUCOP440              );
  394.   AddFixed("CTMA" , 0x332f,                             M_CPUCOP440 | M_CPUCOP444);
  395.   AddFixed("LQID" , 0xbf,   M_CPUCOP410 | M_CPUCOP420 | M_CPUCOP440 | M_CPUCOP444);
  396.   AddFixed("CAB"  , 0x50,   M_CPUCOP410 | M_CPUCOP420 | M_CPUCOP440 | M_CPUCOP444);
  397.   AddFixed("CBA"  , 0x4e,   M_CPUCOP410 | M_CPUCOP420 | M_CPUCOP440 | M_CPUCOP444);
  398.   AddFixed("SKC"  , 0x20,   M_CPUCOP410 | M_CPUCOP420 | M_CPUCOP440 | M_CPUCOP444);
  399.   AddFixed("SKE"  , 0x21,   M_CPUCOP410 | M_CPUCOP420 | M_CPUCOP440 | M_CPUCOP444);
  400.   AddFixed("SKGZ" , 0x3321, M_CPUCOP410 | M_CPUCOP420 | M_CPUCOP440 | M_CPUCOP444);
  401.   AddFixed("SKSZ" , 0x331c,                             M_CPUCOP440 | M_CPUCOP444);
  402.   AddFixed("ING"  , 0x332a, M_CPUCOP410 | M_CPUCOP420 | M_CPUCOP440 | M_CPUCOP444);
  403.   AddFixed("INH"  , 0x332b,                             M_CPUCOP440              );
  404.   AddFixed("INL"  , 0x332e, M_CPUCOP410 | M_CPUCOP420 | M_CPUCOP440 | M_CPUCOP444);
  405.   AddFixed("INR"  , 0x332d,                             M_CPUCOP440              );
  406.   AddFixed("OBD"  , 0x333e, M_CPUCOP410 | M_CPUCOP420 | M_CPUCOP440 | M_CPUCOP444);
  407.   AddFixed("OMG"  , 0x333a, M_CPUCOP410 | M_CPUCOP420 | M_CPUCOP440 | M_CPUCOP444);
  408.   AddFixed("OMH"  , 0x333b,                             M_CPUCOP440              );
  409.   AddFixed("XAS"  , 0x4f,   M_CPUCOP410 | M_CPUCOP420 | M_CPUCOP440 | M_CPUCOP444);
  410.   AddFixed("ADT"  , 0x4a,                 M_CPUCOP420 | M_CPUCOP440 | M_CPUCOP444);
  411.   AddFixed("CASC" , 0x10,                 M_CPUCOP420 | M_CPUCOP440 | M_CPUCOP444);
  412.   AddFixed("CQMA" , 0x332c,               M_CPUCOP420 | M_CPUCOP440 | M_CPUCOP444);
  413.   AddFixed("SKT"  , 0x41,                 M_CPUCOP420 | M_CPUCOP440 | M_CPUCOP444);
  414.   AddFixed("XABR" , 0x12,                 M_CPUCOP420 | M_CPUCOP440 | M_CPUCOP444);
  415.   AddFixed("ININ" , 0x3328,               M_CPUCOP420 | M_CPUCOP440 | M_CPUCOP444);
  416.   AddFixed("INIL" , 0x3329,               M_CPUCOP420 | M_CPUCOP440 | M_CPUCOP444);
  417.   AddFixed("OR"   , 0x331a,                             M_CPUCOP440              );
  418.   AddFixed("LID"  , 0x3319,                             M_CPUCOP440              );
  419.   AddFixed("XAN"  , 0x330b,                             M_CPUCOP440              );
  420.   AddFixed("HALT" , 0x3338,                                           M_CPUCOP444);
  421.   AddFixed("IT"   , 0x3339,                                           M_CPUCOP444);
  422.  
  423.   AddInstTable(InstTable, "SKGBZ", 0x33, DecodeSK);
  424.   AddInstTable(InstTable, "SKMBZ", 0x00, DecodeSK);
  425.  
  426.   ImmOrders = (FixedOrder*)malloc(sizeof(FixedOrder) * ImmOrderCnt);
  427.   InstrZ = 0;
  428.   AddImm("STII" , 0x70,   M_CPUCOP410 | M_CPUCOP420 | M_CPUCOP440 | M_CPUCOP444);
  429.   AddImm("LEI"  , 0x3360, M_CPUCOP410 | M_CPUCOP420 | M_CPUCOP440 | M_CPUCOP444);
  430.   AddImm("OGI"  , 0x3350,               M_CPUCOP420 | M_CPUCOP440 | M_CPUCOP444);
  431.  
  432.   AddInstTable(InstTable, "JMP"  , 0x60, DecodeJmp);
  433.   AddInstTable(InstTable, "JSR"  , 0x68, DecodeJmp);
  434.  
  435.   AddInstTable(InstTable, "LD"   , 0x05, DecodeReg);
  436.   AddInstTable(InstTable, "X"    , 0x06, DecodeReg);
  437.   AddInstTable(InstTable, "XDS"  , 0x07, DecodeReg);
  438.   AddInstTable(InstTable, "XIS"  , 0x04, DecodeReg);
  439.  
  440.   AddInstTable(InstTable, "AISC" , 0x00, DecodeAISC);
  441.   AddInstTable(InstTable, "RMB"  , 0x00, DecodeRMB);
  442.   AddInstTable(InstTable, "SMB"  , 0x00, DecodeSMB);
  443.  
  444.   AddInstTable(InstTable, "XAD"  , 0x00, DecodeXAD);
  445.  
  446.   AddInstTable(InstTable, "LBI"  , 0x00, DecodeLBI);
  447.  
  448.   AddInstTable(InstTable, "LDD"  , 0x00, DecodeLDD);
  449.  
  450.   AddInstTable(InstTable, "JSRP"  , 0x00, DecodeJSRP);
  451.  
  452.   AddInstTable(InstTable, "JP"    , 0x00, DecodeJP);
  453.  
  454.   AddNatPseudo(InstTable);
  455.   AddIntelPseudo(InstTable, eIntPseudoFlag_LittleEndian);
  456. }
  457.  
  458. static void DeinitFields(void)
  459. {
  460.   free(FixedOrders);
  461.   free(ImmOrders);
  462.   DestroyInstTable(InstTable);
  463. }
  464.  
  465. /*---------------------------------------------------------------------------*/
  466.  
  467. static void MakeCode_COP4(void)
  468. {
  469.   /* machine instructions */
  470.  
  471.   if (!LookupInstTable(InstTable, OpPart.str.p_str))
  472.     WrStrErrorPos(ErrNum_UnknownInstruction, &OpPart);
  473. }
  474.  
  475. static void SwitchFrom_COP4(void)
  476. {
  477.   DeinitFields();
  478. }
  479.  
  480. static Boolean IsDef_COP4(void)
  481. {
  482.   return False;
  483. }
  484.  
  485. static void SwitchTo_COP4(void)
  486. {
  487.   const TFamilyDescr *pDescr;
  488.  
  489.   pDescr = FindFamilyByName("COP4");
  490.  
  491.   TurnWords = False;
  492.   SetIntConstMode(eIntConstModeC);
  493.  
  494.   PCSymbol = "."; HeaderID = pDescr->Id;
  495.   NOPCode = 0x44;
  496.   DivideChars = ","; HasAttrs = False;
  497.  
  498.   ValidSegs = (1 << SegCode);
  499.   Grans[SegCode] = 1; ListGrans[SegCode] = 1; SegInits[SegCode] = 0;
  500.   if (MomCPU >= CPUCOP440)
  501.   {
  502.     SegLimits[SegCode] = 0x7ff;
  503.     AdrInt = UInt11;
  504.   }
  505.   else if (MomCPU >= CPUCOP420)
  506.   {
  507.     SegLimits[SegCode] = 0x3ff;
  508.     AdrInt = UInt10;
  509.   }
  510.   else
  511.   {
  512.     SegLimits[SegCode] = 0x1ff;
  513.     AdrInt = UInt9;
  514.   }
  515.  
  516.   MakeCode = MakeCode_COP4; IsDef = IsDef_COP4;
  517.   SwitchFrom = SwitchFrom_COP4; InitFields();
  518. }
  519.  
  520. void codecop4_init(void)
  521. {
  522.   CPUCOP410 = AddCPU("COP410", SwitchTo_COP4);
  523.   CPUCOP420 = AddCPU("COP420", SwitchTo_COP4);
  524.   CPUCOP440 = AddCPU("COP440", SwitchTo_COP4);
  525.   CPUCOP444 = AddCPU("COP444", SwitchTo_COP4);
  526. }
  527.