Subversion Repositories pentevo

Rev

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

  1. /* code61860.c */
  2. /*****************************************************************************/
  3. /* SPDX-License-Identifier: GPL-2.0-only OR GPL-3.0-only                     */
  4. /*                                                                           */
  5. /* AS-Portierung                                                             */
  6. /*                                                                           */
  7. /* Codegenerator Sharp SC61860                                               */
  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 "asmallg.h"
  22. /* #include "onoff_common.h" */
  23. #include "asmitree.h"
  24. #include "codevars.h"
  25. #include "codepseudo.h"
  26. #include "intpseudo.h"
  27. #include "motpseudo.h"
  28. #include "headids.h"
  29. #include "errmsg.h"
  30. #include "chartrans.h"
  31.  
  32. #include "code61860.h"
  33.  
  34. /*---------------------------------------------------------------------------*/
  35.  
  36. static CPUVar CPUSC61860;
  37.  
  38. #define JR_PLUS 0x0100
  39. #define JR_MINUS 0x0200
  40.  
  41. /*---------------------------------------------------------------------------*/
  42.  
  43. static void DecodeImm8(Word Index)
  44. {
  45.         if (ChkArgCnt(1,1))
  46.         {
  47.                 Word val;
  48.                 Boolean OK;
  49.  
  50.                 val = EvalStrIntExpression(&ArgStr[1], Int8, &OK);
  51.                 if (!OK) return;
  52.  
  53.                 BAsmCode[0] = Index;
  54.                 BAsmCode[1] = val;
  55.                 CodeLen = 2;
  56.         }
  57. }
  58.  
  59. static void DecodeImm16(Word Index)
  60. {
  61.         if (ChkArgCnt(1,1))
  62.         {
  63.                 Word val;
  64.                 Boolean OK;
  65.  
  66.                 val = EvalStrIntExpression(&ArgStr[1], Int16, &OK);
  67.                 if (!OK) return;
  68.  
  69.                 BAsmCode[0] = Index;
  70.                 BAsmCode[1] = val >> 8;
  71.                 BAsmCode[2] = val & 0xff;
  72.                 CodeLen = 3;
  73.         }
  74. }
  75.  
  76. static void DecodeLP(Word Index)
  77. {
  78.         if (ChkArgCnt(1,1))
  79.         {
  80.                 Word val;
  81.                 Boolean OK;
  82.  
  83.                 val = EvalStrIntExpression(&ArgStr[1], UInt6, &OK);
  84.                 if (!OK) return;
  85.  
  86.                 BAsmCode[0] = Index | val;
  87.                 CodeLen = 1;
  88.         }
  89. }
  90.  
  91. static void DecodeFixed(Word Index)
  92. {
  93.         if (ChkArgCnt(0,0))
  94.         {
  95.                 BAsmCode[0] = Index;
  96.                 CodeLen = 1;
  97.         }
  98. }
  99.  
  100. static void DecodeRel(Word Index)
  101. {
  102.         Word OpCode = Index & 0x00ff;
  103.         LongInt disp;
  104.         Boolean ValOK;
  105.         tSymbolFlags flags;
  106.  
  107.         if (ChkArgCnt(1,1))
  108.         {
  109.                 disp = EvalStrIntExpressionWithFlags(&ArgStr[1], Int16, &ValOK, &flags) - (EProgCounter() + 1);
  110.  
  111.                 if (!mFirstPassUnknownOrQuestionable(flags))
  112.                 {
  113.                         if (disp < -255 || disp > 255)
  114.                         {
  115.                                 WrStrErrorPos(ErrNum_JmpDistTooBig, &ArgStr[1]);
  116.                                 return;
  117.                         }
  118.  
  119.                         if ((disp < 0 && (Index & JR_PLUS)) ||
  120.                                 (disp > 0 && (Index & JR_MINUS)))
  121.                         {
  122.                                 WrStrErrorPos(ErrNum_JmpDistTooBig, &ArgStr[1]);
  123.                                 return;
  124.                         }
  125.  
  126.                         if (disp < 0)
  127.                         {
  128.                                 OpCode |= 0x01;
  129.                                 disp = -disp;
  130.                         }
  131.                 }
  132.  
  133.                 BAsmCode[0] = OpCode;
  134.                 BAsmCode[1] = disp;
  135.                 CodeLen = 2;
  136.         }
  137. }
  138.  
  139. static void DecodeCAL(Word Index)
  140. {
  141.         if (ChkArgCnt(1,1))
  142.         {
  143.                 Word val;
  144.                 Boolean OK;
  145.  
  146.                 val = EvalStrIntExpression(&ArgStr[1], Int16, &OK);
  147.                 if (!OK) return;
  148.  
  149.                 if (val > 0x1fff)
  150.                 {
  151.                         WrStrErrorPos(ErrNum_NoShortAddr, &ArgStr[1]);
  152.                         return;
  153.                 }
  154.  
  155.                 BAsmCode[0] = Index | (val >> 8);
  156.                 BAsmCode[1] = val & 0xff;
  157.                 CodeLen = 2;
  158.         }
  159. }
  160.  
  161. /*---------------------------------------------------------------------------*/
  162.  
  163. static void AddImm8(const char *NName, Word NCode)
  164. {
  165.         AddInstTable(InstTable, NName, NCode, DecodeImm8);
  166. }
  167.  
  168. static void AddImm16(const char *NName, Word NCode)
  169. {
  170.         AddInstTable(InstTable, NName, NCode, DecodeImm16);
  171. }
  172.  
  173. static void AddFixed(const char *NName, Word NCode)
  174. {
  175.         AddInstTable(InstTable, NName, NCode, DecodeFixed);
  176. }
  177.  
  178. static void AddRel(const char *NName, Word NCode)
  179. {
  180.         AddInstTable(InstTable, NName, NCode, DecodeRel);
  181. }
  182.  
  183. static void InitFields(void)
  184. {
  185.         InstTable = CreateInstTable(163);
  186.  
  187.         /* [1] Data Transfer */
  188.  
  189.         AddImm8("LII",  0x00);
  190.         AddImm8("LIJ",  0x01);
  191.         AddImm8("LIA",  0x02);
  192.         AddImm8("LIB",  0x03);
  193.         AddImm16("LIDP", 0x10);
  194.         AddImm8("LIDL", 0x11);
  195.         AddImm8("LIP", 0x12);
  196.         AddImm8("LIQ", 0x13);
  197.         AddInstTable(InstTable, "LP", 0x80, DecodeLP);
  198.  
  199.         AddFixed("LDP", 0x20);
  200.         AddFixed("LDQ", 0x21);
  201.         AddFixed("LDR", 0x22);
  202.         AddFixed("STP", 0x30);
  203.         AddFixed("STQ", 0x31);
  204.         AddFixed("STR", 0x32);
  205.  
  206.         AddFixed("STD", 0x52);
  207.         AddFixed("LDD", 0x57);
  208.         AddFixed("LDM", 0x59);
  209.  
  210.         AddFixed("MVDM", 0x53);
  211.         AddFixed("MVMD", 0x55);
  212.  
  213.         AddFixed("EXAB", 0xda);
  214.         AddFixed("EXAM", 0xdb);
  215.  
  216.         AddFixed("MVW", 0x08);
  217.         AddFixed("MVB", 0x0a);
  218.         AddFixed("MVWD", 0x18);
  219.         AddFixed("MVBD", 0x1a);
  220.         AddFixed("RST", 0x35);
  221.  
  222.         AddFixed("EXW", 0x09);
  223.         AddFixed("EXB", 0x0b);
  224.         AddFixed("EXWD", 0x19);
  225.         AddFixed("EXBD", 0x1b);
  226.  
  227.         AddFixed("INCI", 0x40);
  228.         AddFixed("DECI", 0x41);
  229.         AddFixed("INCA", 0x42);
  230.         AddFixed("DECA", 0x43);
  231.         AddFixed("INCK", 0x48);
  232.         AddFixed("DECK", 0x49);
  233.         AddFixed("INCM", 0x4a);
  234.         AddFixed("DECM", 0x4b);
  235.         AddFixed("INCP", 0x50);
  236.         AddFixed("DECP", 0x51);
  237.         AddFixed("INCJ", 0xc0);
  238.         AddFixed("DECJ", 0xc1);
  239.         AddFixed("INCB", 0xc2);
  240.         AddFixed("DECB", 0xc3);
  241.         AddFixed("INCL", 0xc8);
  242.         AddFixed("DECL", 0xc9);
  243.         AddFixed("INCN", 0xca);
  244.         AddFixed("DECN", 0xcb);
  245.  
  246.         AddFixed("IX", 0x04);  
  247.         AddFixed("DX", 0x05);  
  248.         AddFixed("IY", 0x06);  
  249.         AddFixed("DY", 0x07);  
  250.  
  251.         AddFixed("IXL", 0x24);         
  252.         AddFixed("DXL", 0x25);         
  253.         AddFixed("IYS", 0x26);         
  254.         AddFixed("DYS", 0x27);         
  255.  
  256.         AddFixed("FILM", 0x1e);        
  257.         AddFixed("FILD", 0x1f);        
  258.  
  259.         /* [2] Arithmetic / Logic / Shift */
  260.        
  261.         AddImm8("ADIA", 0x74);
  262.         AddImm8("SBIA", 0x75);
  263.  
  264.         AddImm8("ADIM", 0x70);
  265.         AddImm8("SBIM", 0x71);
  266.  
  267.         AddFixed("ADM", 0x44);
  268.         AddFixed("SBM", 0x45);
  269.        
  270.         AddFixed("ADCM", 0xc4);
  271.         AddFixed("SBCM", 0xc5);
  272.        
  273.         AddFixed("ADB", 0x14);
  274.         AddFixed("SBB", 0x15);
  275.        
  276.         AddFixed("ADN", 0x0c);
  277.         AddFixed("SBN", 0x0d);
  278.         AddFixed("ADW", 0x0e);
  279.         AddFixed("SBW", 0x0f);
  280.        
  281.         AddFixed("SRW", 0x1c);
  282.         AddFixed("SLW", 0x1d);
  283.        
  284.         AddFixed("ORMA", 0x47);
  285.         AddImm8("ORIM", 0x61);
  286.         AddImm8("ORIA", 0x65);
  287.         AddImm8("ORID", 0xd5);
  288.  
  289.         AddFixed("ANMA", 0x46);
  290.         AddImm8("ANIM", 0x60);
  291.         AddImm8("ANIA", 0x64);
  292.         AddImm8("ANID", 0xd4);
  293.  
  294.         AddImm8("TSIM", 0x62);
  295.         AddImm8("TSIA", 0x66);
  296.         AddImm8("TSID", 0xd6);
  297.         AddFixed("TSMA", 0xc6);
  298.                
  299.         AddImm8("CPIM", 0x63);
  300.         AddImm8("CPIA", 0x67);
  301.         AddFixed("CPMA", 0xc7);
  302.  
  303.         AddFixed("SWP", 0x58);
  304.  
  305.         AddFixed("SL", 0x5a);
  306.         AddFixed("SR", 0xd2);
  307.  
  308.         AddFixed("SC", 0xd0);
  309.         AddFixed("RC", 0xd1);
  310.  
  311.         /* [3] Jump */
  312.  
  313.         AddRel("JRNZ", 0x28);
  314.         AddRel("JRNZP", 0x28 | JR_PLUS);
  315.         AddRel("JRNZM", 0x29 | JR_MINUS);
  316.         AddRel("JRNC", 0x2a);
  317.         AddRel("JRNCP", 0x2a | JR_PLUS);
  318.         AddRel("JRNCM", 0x2b | JR_MINUS);
  319.         AddRel("JR", 0x2c);
  320.         AddRel("JRP", 0x2c | JR_PLUS);
  321.         AddRel("JRM", 0x2d | JR_MINUS);
  322.         AddRel("JRZ", 0x38);
  323.         AddRel("JRZP", 0x38 | JR_PLUS);
  324.         AddRel("JRZM", 0x39 | JR_MINUS);
  325.         AddRel("JRC", 0x3a);
  326.         AddRel("JRCP", 0x3a | JR_PLUS);
  327.         AddRel("JRCM", 0x3b | JR_MINUS);
  328.  
  329.         AddImm16("JP", 0x79);
  330.         AddImm16("JPNZ", 0x7c);
  331.         AddImm16("JPNC", 0x7d);
  332.         AddImm16("JPZ", 0x7e);
  333.         AddImm16("JPC", 0x7f);
  334.  
  335.         /* [4] Other */
  336.  
  337.         AddRel("LOOP", 0x2f | JR_MINUS);
  338.         AddFixed("PUSH", 0x34);
  339.         AddFixed("RTN", 0x37);
  340.         AddFixed("INA", 0x4c);
  341.         AddFixed("NOPW", 0x4d);
  342.         AddImm8("WAIT", 0x4e);
  343.         AddFixed("POP", 0x5b);
  344.         AddFixed("OUTA", 0x5d);
  345.         AddFixed("OUTF", 0x5f);
  346.         AddImm8("TEST", 0x6b);
  347.         AddImm16("CALL", 0x78);
  348.         AddFixed("INB", 0xcc);
  349.         AddFixed("NOPT", 0xce);
  350.         AddFixed("LEAVE", 0xd8);
  351.         AddFixed("OUTB", 0xdd);
  352.         AddFixed("OUTC", 0xdf);
  353.         AddInstTable(InstTable, "CAL", 0xe0, DecodeCAL);
  354.  
  355.         AddFixed("PTC", 0x7a);
  356.         AddFixed("DTC", 0x69);
  357.  
  358.         /* Undocumented Instruction described in б╓е▌е▒е│еєбже▐е╖еє╕ье╓е├епб╫ */
  359.         AddFixed("MVWP", 0x35);
  360.         AddFixed("IPXL", 0x4f);
  361.         AddFixed("IPXH", 0x6f);
  362.         AddFixed("CLRA", 0x23);
  363.         AddFixed("MVMP", 0x54);
  364.         AddFixed("LDPC", 0x56);
  365.  
  366.         /* Found in PC-1350 Machine Language Reference Manual */
  367.         AddFixed("CASE1", 0x7a);
  368.         AddFixed("CASE2", 0x69);
  369.         AddFixed("CUP", 0x4f);
  370.         AddFixed("CDN", 0x6f);
  371.        
  372.         init_moto8_pseudo(InstTable, e_moto_8_be | e_moto_8_db | e_moto_8_dw);
  373. }
  374.  
  375. static void DeinitFields(void)
  376. {
  377.         DestroyInstTable(InstTable);
  378. }
  379.  
  380. /*---------------------------------------------------------------------------*/
  381.  
  382. static void MakeCode_SC61860(void)
  383. {
  384.         CodeLen = 0;
  385.         DontPrint = False;
  386.  
  387.         if (Memo("")) return;
  388.  
  389. /*      if (DecodeIntelPseudo(False)) return;   */
  390.         if (DecodeMoto16Pseudo(eSymbolSize8Bit, True)) return;
  391.  
  392.         if (!LookupInstTable(InstTable, OpPart.str.p_str))
  393.                 WrStrErrorPos(ErrNum_UnknownInstruction, &OpPart);
  394. }
  395.  
  396. static Boolean IsDef_SC61860(void)
  397. {
  398.         return False;
  399. }
  400.  
  401. static void SwitchFrom_SC61860(void)
  402. {
  403.         DeinitFields();
  404. }
  405.  
  406. static void SwitchTo_SC61860(void)
  407. {
  408.         const TFamilyDescr *pDescr;
  409.         TurnWords = False;
  410.         SetIntConstMode(eIntConstModeMoto);
  411.  
  412.         pDescr = FindFamilyByName("SC61860");
  413.         PCSymbol = "*";
  414.         HeaderID = pDescr->Id;
  415.         NOPCode = 0x4d; /* NOPW */
  416.         DivideChars = ",";
  417.         HasAttrs = False;
  418.  
  419.         ValidSegs = (1 << SegCode) | (1 << SegReg);
  420.         Grans[SegCode] = 1;
  421.         ListGrans[SegCode] = 1;
  422.         SegInits[SegCode] = 0x0000;
  423.         SegLimits[SegCode] = 0xffff;
  424.         Grans[SegReg] = 1;
  425.         ListGrans[SegReg] = 1;
  426.         SegInits[SegReg] = 0x00;
  427.         SegLimits[SegReg] = 0x5f;
  428.  
  429.         MakeCode = MakeCode_SC61860;
  430.         IsDef = IsDef_SC61860;
  431.         SwitchFrom = SwitchFrom_SC61860;
  432.         InitFields();
  433. }
  434.  
  435. void code61860_init(void)
  436. {
  437.         CPUSC61860 = AddCPU("SC61860", SwitchTo_SC61860);
  438. }
  439.