Subversion Repositories pentevo

Rev

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

  1. /* codenano.c */
  2. /*****************************************************************************/
  3. /* SPDX-License-Identifier: GPL-2.0-only OR GPL-3.0-only                     */
  4. /*                                                                           */
  5. /* AS-Portierung                                                             */
  6. /*                                                                           */
  7. /* Codegenerator HP Nanoprocessor                                            */
  8. /*                                                                           */
  9. /*****************************************************************************/
  10.  
  11. #include "stdinc.h"
  12. #include <ctype.h>
  13. #include <string.h>
  14.  
  15. #include "nls.h"
  16. #include "strutil.h"
  17. #include "chunks.h"
  18. #include "asmdef.h"
  19. #include "asmsub.h"
  20. #include "asmpars.h"
  21. #include "asmitree.h"
  22. #include "codevars.h"
  23. #include "codepseudo.h"
  24. #include "headids.h"
  25. #include "errmsg.h"
  26. #include "onoff_common.h"
  27.  
  28. #include "codenano.h"
  29.  
  30. /*---------------------------------------------------------------------------*/
  31.  
  32. static CPUVar CPUNANO;
  33.  
  34. /*---------------------------------------------------------------------------*/
  35.  
  36. static void DecodeBit(Word Index)
  37. {
  38.         if (ChkArgCnt(1,1))
  39.         {
  40.                 Word val;
  41.                 Boolean OK;
  42.  
  43.                 val = EvalStrIntExpression(&ArgStr[1], UInt3, &OK);
  44.                 if (!OK) return;
  45.  
  46.                 BAsmCode[0] = Index | val;
  47.                 CodeLen = 1;
  48.         }
  49. }
  50.  
  51. static void DecodeFixed(Word Index)
  52. {
  53.         if (ChkArgCnt(0,0))
  54.         {
  55.                 BAsmCode[0] = Index;
  56.                 CodeLen = 1;
  57.         }
  58. }
  59.  
  60. static void DecodeImm(Word Index)
  61. {
  62.         if (ChkArgCnt(1,1))
  63.         {
  64.                 Word val;
  65.                 Boolean OK;
  66.  
  67.                 val = EvalStrIntExpression(&ArgStr[1], UInt8, &OK);
  68.                 if (!OK) return;
  69.  
  70.                 BAsmCode[0] = Index;
  71.                 BAsmCode[1] = val;
  72.                 CodeLen = 2;
  73.         }
  74. }
  75.  
  76. static void DecodeReg(Word Index)
  77. {
  78.         if (ChkArgCnt(1,1))
  79.         {
  80.                 Word reg;
  81.                 Boolean OK;
  82.  
  83.                 reg = EvalStrIntExpression(&ArgStr[1], UInt4, &OK);
  84.                 if (!OK) return;
  85.  
  86.                 BAsmCode[0] = Index | reg;
  87.                 CodeLen = 1;
  88.         }
  89. }
  90.  
  91. static void DecodeRegImm(Word Index)
  92. {
  93.         if (ChkArgCnt(2,2))
  94.         {
  95.                 Word reg;
  96.                 Word val;
  97.                 Boolean OK;
  98.  
  99.                 reg = EvalStrIntExpression(&ArgStr[1], UInt4, &OK);
  100.                 if (!OK) return;
  101.  
  102.                 val = EvalStrIntExpression(&ArgStr[2], UInt8, &OK);
  103.                 if (!OK) return;
  104.  
  105.                 BAsmCode[0] = Index | reg;
  106.                 BAsmCode[1] = val;
  107.                 CodeLen = 2;
  108.         }
  109. }
  110.  
  111. static void DecodeDev(Word Index)
  112. {
  113.         if (ChkArgCnt(1,1))
  114.         {
  115.                 Word dev;
  116.                 Boolean OK;
  117.  
  118.                 dev = EvalStrIntExpression(&ArgStr[1], UInt4, &OK);
  119.                 if (!OK) return;
  120.                 if (Index == 0x50 && dev == 15) /* OTA 15 not allowed */
  121.                 {
  122.                         WrError(ErrNum_OverRange);
  123.                         return;
  124.                 }
  125.  
  126.                 BAsmCode[0] = Index | dev;
  127.                 CodeLen = 1;
  128.         }
  129. }
  130.  
  131. static void DecodeDevImm(Word Index)
  132. {
  133.         if (ChkArgCnt(2,2))
  134.         {
  135.                 Word dev;
  136.                 Word val;
  137.                 Boolean OK;
  138.  
  139.                 dev = EvalStrIntExpression(&ArgStr[1], UInt4, &OK);
  140.                 if (!OK) return;
  141.  
  142.                 val = EvalStrIntExpression(&ArgStr[2], UInt8, &OK);
  143.                 if (!OK) return;
  144.  
  145.                 if (dev == 15)  /* OTR 15,xx not allowed */
  146.                 {
  147.                         WrError(ErrNum_OverRange);
  148.                         return;
  149.                 }
  150.  
  151.                 BAsmCode[0] = Index | dev;
  152.                 BAsmCode[1] = val;
  153.                 CodeLen = 2;
  154.         }
  155. }
  156.  
  157. static void DecodeDirect(Word Index)
  158. {
  159.         if (ChkArgCnt(1,1))
  160.         {
  161.                 Word val;
  162.                 Boolean OK;
  163.  
  164.                 val = EvalStrIntExpression(&ArgStr[1], UInt3, &OK);
  165.                 if (!OK) return;
  166.                 if (val == 7)
  167.                 {
  168.                         WrError(ErrNum_OverRange);
  169.                         return;
  170.                 }
  171.  
  172.                 BAsmCode[0] = Index | val;
  173.                 CodeLen = 1;
  174.         }
  175. }
  176.  
  177. static void DecodeAddress(Word Index)
  178. {
  179.         if (ChkArgCnt(1,1))
  180.         {
  181.                 Word val;
  182.                 Boolean OK;
  183.  
  184.                 val = EvalStrIntExpression(&ArgStr[1], UInt11, &OK);
  185.                 if (!OK) return;
  186.  
  187.                 BAsmCode[0] = Index | (val >> 8);
  188.                 BAsmCode[1] = val & 0xff;
  189.                 CodeLen = 2;
  190.         }
  191. }
  192.  
  193.  
  194. /*---------------------------------------------------------------------------*/
  195.  
  196. static void AddBit(const char *NName, Word NCode)
  197. {
  198.         AddInstTable(InstTable, NName, NCode, DecodeBit);
  199. }
  200.  
  201. static void AddFixed(const char *NName, Word NCode)
  202. {
  203.         AddInstTable(InstTable, NName, NCode, DecodeFixed);
  204. }
  205.  
  206. static void AddImm(const char *NName, Word NCode)
  207. {
  208.         AddInstTable(InstTable, NName, NCode, DecodeImm);
  209. }
  210.  
  211. static void AddReg(const char *NName, Word NCode)
  212. {
  213.         AddInstTable(InstTable, NName, NCode, DecodeReg);
  214. }
  215.  
  216. static void AddRegImm(const char *NName, Word NCode)
  217. {
  218.         AddInstTable(InstTable, NName, NCode, DecodeRegImm);
  219. }
  220.  
  221. static void AddDev(const char *NName, Word NCode)
  222. {
  223.         AddInstTable(InstTable, NName, NCode, DecodeDev);
  224. }
  225.  
  226. static void AddDevImm(const char *NName, Word NCode)
  227. {
  228.         AddInstTable(InstTable, NName, NCode, DecodeDevImm);
  229. }
  230.  
  231. static void AddDirect(const char *NName, Word NCode)
  232. {
  233.         AddInstTable(InstTable, NName, NCode, DecodeDirect);
  234. }
  235.  
  236. static void AddAddress(const char *NName, Word NCode)
  237. {
  238.         AddInstTable(InstTable, NName, NCode, DecodeAddress);
  239. }
  240.  
  241. static void InitFields(void)
  242. {
  243.         InstTable = CreateInstTable(49);
  244.  
  245.         /* A. Accumulator Group */
  246.         AddBit("SBS", 0x10);
  247.         AddBit("SBZ", 0x30);
  248.         AddBit("SBN", 0x20);
  249.         AddBit("CBN", 0xA0);
  250.         AddFixed("INB", 0x00);
  251.         AddFixed("IND", 0x02);
  252.         AddFixed("DEB", 0x01);
  253.         AddFixed("DED", 0x03);
  254.         AddFixed("CLA", 0x04);
  255.         AddFixed("CMA", 0x05);
  256.         AddFixed("LSA", 0x07);
  257.         AddFixed("RSA", 0x06);
  258.         AddFixed("SES", 0x1f);
  259.         AddFixed("SEZ", 0x3f);
  260.         AddImm("LDR", 0xcf);
  261.  
  262.         /* B. Register Transfer Group */
  263.         AddReg("LDA", 0x60);
  264.         AddReg("STA", 0x70);
  265.         AddReg("LDI", 0xe0);
  266.         AddReg("STI", 0xf0);
  267.         AddRegImm("STR", 0xd0);
  268.  
  269.         /* C. Extend Register Group */
  270.         AddFixed("STE", 0xb4);
  271.         AddFixed("CLE", 0xb5);
  272.  
  273.         /* D. Interrupt Group */
  274.         AddFixed("DSI", 0xaf);
  275.         AddFixed("ENI", 0x2f);
  276.  
  277.         /* E. Comparator Group */
  278.         AddFixed("SLT", 0x09);
  279.         AddFixed("SEQ", 0x0a);
  280.         AddFixed("SAZ", 0x0b);
  281.         AddFixed("SLE", 0x0c);
  282.         AddFixed("SGE", 0x0d);
  283.         AddFixed("SNE", 0x0e);
  284.         AddFixed("SAN", 0x0f);
  285.         AddFixed("SGT", 0x08);
  286.  
  287.         /* F. Input/Output Group */
  288.         AddDev("INA", 0x40);
  289.         AddDev("OTA", 0x50);
  290.         AddDevImm("OTR", 0xc0);
  291.         AddDirect("STC", 0x28);
  292.         AddDirect("CLC", 0xa8);
  293.         AddDirect("SFS", 0x18);
  294.         AddDirect("SFZ", 0x38);
  295.         AddFixed("RTI", 0x90);
  296.         AddFixed("RTE", 0xb1);
  297.         AddFixed("NOP", 0x5f);
  298.         AddReg("JAI", 0x90);
  299.         AddReg("JAS", 0x98);
  300.  
  301.         /* G. Program Control Group */
  302.         AddAddress("JMP", 0x80);
  303.         AddAddress("JSB", 0x88);
  304.         AddFixed("RTS", 0xb8);
  305.         AddFixed("RSE", 0xb9);
  306. }
  307.  
  308. static void DeinitFields(void)
  309. {
  310.         DestroyInstTable(InstTable);
  311. }
  312.  
  313. /*---------------------------------------------------------------------------*/
  314.  
  315. static void MakeCode_NANO(void)
  316. {
  317.         CodeLen = 0;
  318.         DontPrint = False;
  319.  
  320.         if (Memo("")) return;
  321.  
  322.         if (!LookupInstTable(InstTable, OpPart.str.p_str))
  323.                 WrStrErrorPos(ErrNum_UnknownInstruction, &OpPart);
  324. }
  325.  
  326. static Boolean IsDef_NANO(void)
  327. {
  328.         return False;
  329. }
  330.  
  331. static void SwitchFrom_NANO(void)
  332. {
  333.         DeinitFields();
  334. }
  335.  
  336. static void SwitchTo_NANO(void)
  337. {
  338.         const TFamilyDescr *pDescr;
  339.  
  340.         TurnWords = False;
  341.         SetIntConstMode(eIntConstModeC);
  342.  
  343.         pDescr = FindFamilyByName("NANO");
  344.         PCSymbol = "*";
  345.         HeaderID = pDescr->Id;
  346.         NOPCode = 0x5f;
  347.         DivideChars = ",";
  348.         HasAttrs = False;
  349.  
  350.         ValidSegs = (1 << SegCode);
  351.         Grans[SegCode] = 1;
  352.         ListGrans[SegCode] = 1;
  353.         SegInits[SegCode] = 0x0000;
  354.         SegLimits[SegCode] = 0x07ff;
  355.  
  356.         MakeCode = MakeCode_NANO;
  357.         IsDef = IsDef_NANO;
  358.         SwitchFrom = SwitchFrom_NANO;
  359.         InitFields();
  360. }
  361.  
  362. void codenano_init(void)
  363. {
  364.         CPUNANO = AddCPU("NANO", SwitchTo_NANO);
  365.  
  366.         AddCopyright("HP Nanoprocessor Generator (C) 2022 Haruo Asano");
  367. }
  368.