Subversion Repositories pentevo

Rev

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

  1. /* code6804.c */
  2. /*****************************************************************************/
  3. /* SPDX-License-Identifier: GPL-2.0-only OR GPL-3.0-only                     */
  4. /*                                                                           */
  5. /* AS-Portierung                                                             */
  6. /*                                                                           */
  7. /* AS-Codegenerator Motorola/ST 6804                                         */
  8. /*                                                                           */
  9. /*****************************************************************************/
  10.  
  11. #include "stdinc.h"
  12.  
  13. #include <string.h>
  14.  
  15. #include "bpemu.h"
  16. #include "strutil.h"
  17. #include "asmdef.h"
  18. #include "asmsub.h"
  19. #include "asmpars.h"
  20. #include "asmitree.h"
  21. #include "codepseudo.h"
  22. #include "motpseudo.h"
  23. #include "intpseudo.h"
  24. #include "codevars.h"
  25. #include "errmsg.h"
  26.  
  27. #include "code6804.h"
  28.  
  29. typedef struct
  30. {
  31.   char *Name;
  32.   LongInt Code;
  33. } BaseOrder;
  34.  
  35. enum
  36. {
  37.   ModNone = -1,
  38.   ModInd = 0,
  39.   ModDir = 1,
  40.   ModImm = 2
  41. };
  42.  
  43. #define MModInd (1 << ModInd)
  44. #define MModDir (1 << ModDir)
  45. #define MModImm (1 << ModImm)
  46.  
  47. static ShortInt AdrMode;
  48. static Byte AdrVal;
  49.  
  50. static CPUVar CPU6804;
  51.  
  52. static BaseOrder *FixedOrders;
  53.  
  54. /*--------------------------------------------------------------------------*/
  55.  
  56. static void DecodeAdr(const tStrComp *pArg, Boolean MayImm)
  57. {
  58.   Boolean OK;
  59.  
  60.   AdrMode = ModNone;
  61.  
  62.   if (!as_strcasecmp(pArg->str.p_str, "(X)"))
  63.   {
  64.     AdrMode = ModInd;
  65.     AdrVal = 0x00;
  66.     goto chk;
  67.   }
  68.   if (!as_strcasecmp(pArg->str.p_str, "(Y)"))
  69.   {
  70.     AdrMode = ModInd;
  71.     AdrVal = 0x10;
  72.     goto chk;
  73.   }
  74.  
  75.   if (*pArg->str.p_str == '#')
  76.   {
  77.     AdrVal = EvalStrIntExpressionOffs(pArg, 1, Int8, &OK);
  78.     if (OK)
  79.       AdrMode = ModImm;
  80.     goto chk;
  81.   }
  82.  
  83.   AdrVal = EvalStrIntExpression(pArg, Int8, &OK);
  84.   if (OK)
  85.     AdrMode = ModDir;
  86.  
  87. chk:
  88.   if ((AdrMode == ModImm) && (!MayImm))
  89.   {
  90.     WrError(ErrNum_InvAddrMode); AdrMode = ModNone;
  91.   }
  92. }
  93.  
  94. static Boolean IsShort(Byte Adr)
  95. {
  96.   return ((Adr & 0xfc) == 0x80);
  97. }
  98.  
  99. /*--------------------------------------------------------------------------*/
  100.  
  101. /* Anweisungen ohne Argument */
  102.  
  103. static void DecodeFixed(Word Index)
  104. {
  105.   const BaseOrder *pOrder = FixedOrders + Index;
  106.  
  107.   if (ChkArgCnt(0, 0))
  108.   {
  109.     if ((pOrder->Code >> 16) != 0)
  110.       CodeLen = 3;
  111.     else
  112.       CodeLen = 1 + Ord(Hi(pOrder->Code) != 0);
  113.     if (CodeLen == 3)
  114.       BAsmCode[0] = pOrder->Code >> 16;
  115.     if (CodeLen >= 2)
  116.       BAsmCode[CodeLen - 2] = Hi(pOrder->Code);
  117.     BAsmCode[CodeLen - 1] = Lo(pOrder->Code);
  118.   }
  119. }
  120.  
  121. /* relative/absolute Spruenge */
  122.  
  123. static void DecodeRel(Word Code)
  124. {
  125.   if (ChkArgCnt(1, 1))
  126.   {
  127.     tEvalResult EvalResult;
  128.     Integer AdrInt = EvalStrIntExpressionWithResult(&ArgStr[1], Int16, &EvalResult) - (EProgCounter() + 1);
  129.  
  130.     if (EvalResult.OK)
  131.     {
  132.       if (!mSymbolQuestionable(EvalResult.Flags) && ((AdrInt < -16) || (AdrInt > 15))) WrError(ErrNum_JmpDistTooBig);
  133.       else
  134.       {
  135.         CodeLen = 1;
  136.         BAsmCode[0] = Code + (AdrInt & 0x1f);
  137.         ChkSpace(SegCode, EvalResult.AddrSpaceMask);
  138.       }
  139.     }
  140.   }
  141. }
  142.  
  143. static void DecodeJSR_JMP(Word Code)
  144. {
  145.   if (ChkArgCnt(1, 1))
  146.   {
  147.     tEvalResult EvalResult;
  148.     Word AdrInt = EvalStrIntExpressionWithResult(&ArgStr[1], UInt12, &EvalResult);
  149.  
  150.     if (EvalResult.OK)
  151.     {
  152.       CodeLen = 2;
  153.       BAsmCode[1] = Lo(AdrInt);
  154.       BAsmCode[0] = Code + (Hi(AdrInt) & 15);
  155.       ChkSpace(SegCode, EvalResult.AddrSpaceMask);
  156.     }
  157.   }
  158. }
  159.  
  160. /* AKKU-Operationen */
  161.  
  162. static void DecodeALU(Word Code)
  163. {
  164.   if (ChkArgCnt(1, 1))
  165.   {
  166.     DecodeAdr(&ArgStr[1], True);
  167.     switch (AdrMode)
  168.     {
  169.       case ModInd:
  170.         CodeLen = 1;
  171.         BAsmCode[0] = 0xe0 + AdrVal + Code;
  172.         break;
  173.       case ModDir:
  174.         CodeLen = 2;
  175.         BAsmCode[0] = 0xf8 + Code;
  176.         BAsmCode[1] = AdrVal;
  177.         break;
  178.       case ModImm:
  179.         CodeLen = 2;
  180.         BAsmCode[0] = 0xe8 + Code;
  181.         BAsmCode[1] = AdrVal;
  182.         break;
  183.     }
  184.   }
  185. }
  186.  
  187. /* Datentransfer */
  188.  
  189. static void DecodeLDA_STA(Word Code)
  190. {
  191.   if (ChkArgCnt(1, 1))
  192.   {
  193.     DecodeAdr(&ArgStr[1], !Code);
  194.     switch (AdrMode)
  195.     {
  196.       case ModInd:
  197.         CodeLen = 1;
  198.         BAsmCode[0] = 0xe0 + Code + AdrVal;
  199.         break;
  200.       case ModDir:
  201.         if (IsShort(AdrVal))
  202.         {
  203.           CodeLen = 1;
  204.           BAsmCode[0] = 0xac + (Code << 4) + (AdrVal & 3);
  205.         }
  206.         else
  207.         {
  208.           CodeLen = 2;
  209.           BAsmCode[0] = 0xf8 + Code;
  210.           BAsmCode[1] = AdrVal;
  211.         }
  212.         break;
  213.       case ModImm:
  214.         CodeLen = 2;
  215.         BAsmCode[0] = 0xe8 + Code;
  216.         BAsmCode[1] = AdrVal;
  217.         break;
  218.     }
  219.   }
  220. }
  221.  
  222. static void DecodeLDXI_LDYI(Word Code)
  223. {
  224.   if (!ChkArgCnt(1, 1));
  225.   else if (*ArgStr[1].str.p_str != '#') WrError(ErrNum_InvAddrMode);
  226.   else
  227.   {
  228.     Boolean OK;
  229.  
  230.     BAsmCode[2] = EvalStrIntExpressionOffs(&ArgStr[1], 1, Int8, &OK);
  231.     if (OK)
  232.     {
  233.       CodeLen = 3;
  234.       BAsmCode[0] = 0xb0;
  235.       BAsmCode[1] = Code;
  236.     }
  237.   }
  238. }
  239.  
  240. static void DecodeMVI(Word Code)
  241. {
  242.   UNUSED(Code);
  243.  
  244.   if (!ChkArgCnt(2, 2));
  245.   else if (*ArgStr[2].str.p_str != '#') WrError(ErrNum_InvAddrMode);
  246.   else
  247.   {
  248.     tEvalResult EvalResult;
  249.  
  250.     BAsmCode[1] = EvalStrIntExpressionWithResult(&ArgStr[1], Int8, &EvalResult);
  251.     if (EvalResult.OK)
  252.     {
  253.       ChkSpace(SegData, EvalResult.AddrSpaceMask);
  254.       BAsmCode[2] = EvalStrIntExpressionOffsWithResult(&ArgStr[2], 1, Int8, &EvalResult);
  255.       if (EvalResult.OK)
  256.       {
  257.         BAsmCode[0] = 0xb0;
  258.         CodeLen = 3;
  259.       }
  260.     }
  261.   }
  262. }
  263.  
  264. /* Read/Modify/Write-Operationen */
  265.  
  266. static void DecodeINC_DEC(Word Code)
  267. {
  268.   if (ChkArgCnt(1, 1))
  269.   {
  270.     DecodeAdr(&ArgStr[1], False);
  271.     switch (AdrMode)
  272.     {
  273.       case ModInd:
  274.         CodeLen = 1;
  275.         BAsmCode[0] = 0xe6 + Code + AdrVal;
  276.         break;
  277.       case ModDir:
  278.         if (IsShort(AdrVal))
  279.         {
  280.           CodeLen = 1;
  281.           BAsmCode[0] = 0xa8 + (Code << 4) + (AdrVal & 3);
  282.         }
  283.         else
  284.         {
  285.           CodeLen = 2;
  286.           BAsmCode[0] = 0xfe + Code;
  287.           BAsmCode[1] = AdrVal;
  288.         }
  289.         break;
  290.     }
  291.   }
  292. }
  293.  
  294. /* Bitbefehle */
  295.  
  296. static void DecodeBSET_BCLR(Word Code)
  297. {
  298.   if (ChkArgCnt(2, 2))
  299.   {
  300.     tEvalResult EvalResult;
  301.     Byte Bit = EvalStrIntExpressionWithResult(&ArgStr[1], UInt3, &EvalResult);
  302.     if (EvalResult.OK)
  303.     {
  304.       BAsmCode[0] = Code + Bit;
  305.       BAsmCode[1] = EvalStrIntExpressionWithResult(&ArgStr[2], Int8, &EvalResult);
  306.       if (EvalResult.OK)
  307.       {
  308.         CodeLen = 2;
  309.         ChkSpace(SegData, EvalResult.AddrSpaceMask);
  310.       }
  311.     }
  312.   }
  313. }
  314.  
  315. static void DecodeBRSET_BRCLR(Word Code)
  316. {
  317.   if (ChkArgCnt(3, 3))
  318.   {
  319.     tEvalResult EvalResult;
  320.     Byte Bit = EvalStrIntExpressionWithResult(&ArgStr[1], UInt3, &EvalResult);
  321.  
  322.     if (EvalResult.OK)
  323.     {
  324.       BAsmCode[0] = Code + Bit;
  325.       BAsmCode[1] = EvalStrIntExpressionWithResult(&ArgStr[2], Int8, &EvalResult);
  326.       if (EvalResult.OK)
  327.       {
  328.         Integer AdrInt;
  329.  
  330.         ChkSpace(SegData, EvalResult.AddrSpaceMask);
  331.         AdrInt = EvalStrIntExpressionWithResult(&ArgStr[3], Int16, &EvalResult) - (EProgCounter() + 3);
  332.         if (EvalResult.OK)
  333.         {
  334.           if (!mSymbolQuestionable(EvalResult.Flags) && ((AdrInt < -128) || (AdrInt > 127))) WrError(ErrNum_JmpDistTooBig);
  335.           else
  336.           {
  337.             ChkSpace(SegCode, EvalResult.AddrSpaceMask);
  338.             BAsmCode[2] = AdrInt & 0xff;
  339.             CodeLen = 3;
  340.           }
  341.         }
  342.       }
  343.     }
  344.   }
  345. }
  346.  
  347. static void DecodeSFR(Word Code)
  348. {
  349.   UNUSED(Code);
  350.  
  351.   CodeEquate(SegData, 0, 0xff);
  352. }
  353.  
  354. /*--------------------------------------------------------------------------*/
  355.  
  356. static void AddFixed(const char *NName, LongInt NCode)
  357. {
  358.   order_array_rsv_end(FixedOrders, BaseOrder);
  359.   FixedOrders[InstrZ].Code = NCode;
  360.   AddInstTable(InstTable, NName, InstrZ++, DecodeFixed);
  361. }
  362.  
  363. static void AddRel(const char *NName, LongInt NCode)
  364. {
  365.   AddInstTable(InstTable, NName, NCode, DecodeRel);
  366. }
  367.  
  368. static void AddALU(const char *NName, LongInt NCode)
  369. {
  370.   AddInstTable(InstTable, NName, NCode, DecodeALU);
  371. }
  372.  
  373. static void InitFields(void)
  374. {
  375.   InstTable = CreateInstTable(203);
  376.  
  377.   add_null_pseudo(InstTable);
  378.  
  379.   AddInstTable(InstTable, "JMP", 0x90, DecodeJSR_JMP);
  380.   AddInstTable(InstTable, "JSR", 0x80, DecodeJSR_JMP);
  381.   AddInstTable(InstTable, "LDA", 0, DecodeLDA_STA);
  382.   AddInstTable(InstTable, "STA", 1, DecodeLDA_STA);
  383.   AddInstTable(InstTable, "LDXI", 0x80, DecodeLDXI_LDYI);
  384.   AddInstTable(InstTable, "LDYI", 0x81, DecodeLDXI_LDYI);
  385.   AddInstTable(InstTable, "MVI", 0, DecodeMVI);
  386.   AddInstTable(InstTable, "INC", 0, DecodeINC_DEC);
  387.   AddInstTable(InstTable, "DEC", 1, DecodeINC_DEC);
  388.   AddInstTable(InstTable, "BSET", 0xd8, DecodeBSET_BCLR);
  389.   AddInstTable(InstTable, "BCLR", 0xd0, DecodeBSET_BCLR);
  390.   AddInstTable(InstTable, "BRSET", 0xc8, DecodeBRSET_BRCLR);
  391.   AddInstTable(InstTable, "BRCLR", 0xc0, DecodeBRSET_BRCLR);
  392.   AddInstTable(InstTable, "SFR", 0, DecodeSFR);
  393.  
  394.   InstrZ = 0;
  395.   AddFixed("CLRA", 0x00fbff);
  396.   AddFixed("CLRX", 0xb08000);
  397.   AddFixed("CLRY", 0xb08100);
  398.   AddFixed("COMA", 0x0000b4);
  399.   AddFixed("ROLA", 0x0000b5);
  400.   AddFixed("ASLA", 0x00faff);
  401.   AddFixed("INCA", 0x00feff);
  402.   AddFixed("INCX", 0x0000a8);
  403.   AddFixed("INCY", 0x0000a9);
  404.   AddFixed("DECA", 0x00ffff);
  405.   AddFixed("DECX", 0x0000b8);
  406.   AddFixed("DECY", 0x0000b9);
  407.   AddFixed("TAX" , 0x0000bc);
  408.   AddFixed("TAY" , 0x0000bd);
  409.   AddFixed("TXA" , 0x0000ac);
  410.   AddFixed("TYA" , 0x0000ad);
  411.   AddFixed("RTS" , 0x0000b3);
  412.   AddFixed("RTI" , 0x0000b2);
  413.   AddFixed("NOP" , 0x000020);
  414.  
  415.   AddRel("BCC", 0x40);
  416.   AddRel("BHS", 0x40);
  417.   AddRel("BCS", 0x60);
  418.   AddRel("BLO", 0x60);
  419.   AddRel("BNE", 0x00);
  420.   AddRel("BEQ", 0x20);
  421.  
  422.   AddALU("ADD", 0x02);
  423.   AddALU("SUB", 0x03);
  424.   AddALU("CMP", 0x04);
  425.   AddALU("AND", 0x05);
  426.  
  427.   add_moto8_pseudo(InstTable, e_moto_pseudo_flags_be | e_moto_pseudo_flags_ds);
  428.   AddInstTable(InstTable, "DB", eIntPseudoFlag_BigEndian | eIntPseudoFlag_AllowInt | eIntPseudoFlag_AllowString | eIntPseudoFlag_MotoRep, DecodeIntelDB);
  429.   AddInstTable(InstTable, "DW", eIntPseudoFlag_BigEndian | eIntPseudoFlag_AllowInt | eIntPseudoFlag_AllowString | eIntPseudoFlag_MotoRep, DecodeIntelDW);
  430. }
  431.  
  432. static void DeinitFields(void)
  433. {
  434.   DestroyInstTable(InstTable);
  435.  
  436.   order_array_free(FixedOrders);
  437. }
  438.  
  439. /*--------------------------------------------------------------------------*/
  440.  
  441. static void MakeCode_6804(void)
  442. {
  443.   if (!LookupInstTable(InstTable, OpPart.str.p_str))
  444.     WrStrErrorPos(ErrNum_UnknownInstruction, &OpPart);
  445. }
  446.  
  447. static Boolean IsDef_6804(void)
  448. {
  449.   return (Memo("SFR"));
  450. }
  451.  
  452. static void SwitchFrom_6804(void)
  453. {
  454.   DeinitFields();
  455. }
  456.  
  457. static void SwitchTo_6804(void)
  458. {
  459.   TurnWords = False;
  460.   SetIntConstMode(eIntConstModeMoto);
  461.  
  462.   PCSymbol = "PC";
  463.   HeaderID = 0x64;
  464.   NOPCode = 0x20;
  465.   DivideChars = ",";
  466.   HasAttrs = False;
  467.  
  468.   ValidSegs = (1 << SegCode) | (1 << SegData);
  469.   Grans[SegCode] = 1; ListGrans[SegCode] = 1; SegInits[SegCode] = 0;
  470.   SegLimits[SegCode] = 0xfff;
  471.   Grans[SegData] = 1; ListGrans[SegData] = 1; SegInits[SegData] = 0;
  472.   SegLimits[SegData] = 0xff;
  473.  
  474.   MakeCode = MakeCode_6804;
  475.   IsDef = IsDef_6804;
  476.   SwitchFrom = SwitchFrom_6804;
  477.   InitFields();
  478. }
  479.  
  480. void code6804_init(void)
  481. {
  482.   CPU6804 = AddCPU("6804", SwitchTo_6804);
  483. }
  484.