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.   add_null_pseudo(InstTable);
  188.  
  189.         /* [1] Data Transfer */
  190.  
  191.         AddImm8("LII",  0x00);
  192.         AddImm8("LIJ",  0x01);
  193.         AddImm8("LIA",  0x02);
  194.         AddImm8("LIB",  0x03);
  195.         AddImm16("LIDP", 0x10);
  196.         AddImm8("LIDL", 0x11);
  197.         AddImm8("LIP", 0x12);
  198.         AddImm8("LIQ", 0x13);
  199.         AddInstTable(InstTable, "LP", 0x80, DecodeLP);
  200.  
  201.         AddFixed("LDP", 0x20);
  202.         AddFixed("LDQ", 0x21);
  203.         AddFixed("LDR", 0x22);
  204.         AddFixed("STP", 0x30);
  205.         AddFixed("STQ", 0x31);
  206.         AddFixed("STR", 0x32);
  207.  
  208.         AddFixed("STD", 0x52);
  209.         AddFixed("LDD", 0x57);
  210.         AddFixed("LDM", 0x59);
  211.  
  212.         AddFixed("MVDM", 0x53);
  213.         AddFixed("MVMD", 0x55);
  214.  
  215.         AddFixed("EXAB", 0xda);
  216.         AddFixed("EXAM", 0xdb);
  217.  
  218.         AddFixed("MVW", 0x08);
  219.         AddFixed("MVB", 0x0a);
  220.         AddFixed("MVWD", 0x18);
  221.         AddFixed("MVBD", 0x1a);
  222.         AddFixed("RST", 0x35);
  223.  
  224.         AddFixed("EXW", 0x09);
  225.         AddFixed("EXB", 0x0b);
  226.         AddFixed("EXWD", 0x19);
  227.         AddFixed("EXBD", 0x1b);
  228.  
  229.         AddFixed("INCI", 0x40);
  230.         AddFixed("DECI", 0x41);
  231.         AddFixed("INCA", 0x42);
  232.         AddFixed("DECA", 0x43);
  233.         AddFixed("INCK", 0x48);
  234.         AddFixed("DECK", 0x49);
  235.         AddFixed("INCM", 0x4a);
  236.         AddFixed("DECM", 0x4b);
  237.         AddFixed("INCP", 0x50);
  238.         AddFixed("DECP", 0x51);
  239.         AddFixed("INCJ", 0xc0);
  240.         AddFixed("DECJ", 0xc1);
  241.         AddFixed("INCB", 0xc2);
  242.         AddFixed("DECB", 0xc3);
  243.         AddFixed("INCL", 0xc8);
  244.         AddFixed("DECL", 0xc9);
  245.         AddFixed("INCN", 0xca);
  246.         AddFixed("DECN", 0xcb);
  247.  
  248.         AddFixed("IX", 0x04);  
  249.         AddFixed("DX", 0x05);  
  250.         AddFixed("IY", 0x06);  
  251.         AddFixed("DY", 0x07);  
  252.  
  253.         AddFixed("IXL", 0x24);         
  254.         AddFixed("DXL", 0x25);         
  255.         AddFixed("IYS", 0x26);         
  256.         AddFixed("DYS", 0x27);         
  257.  
  258.         AddFixed("FILM", 0x1e);        
  259.         AddFixed("FILD", 0x1f);        
  260.  
  261.         /* [2] Arithmetic / Logic / Shift */
  262.        
  263.         AddImm8("ADIA", 0x74);
  264.         AddImm8("SBIA", 0x75);
  265.  
  266.         AddImm8("ADIM", 0x70);
  267.         AddImm8("SBIM", 0x71);
  268.  
  269.         AddFixed("ADM", 0x44);
  270.         AddFixed("SBM", 0x45);
  271.        
  272.         AddFixed("ADCM", 0xc4);
  273.         AddFixed("SBCM", 0xc5);
  274.        
  275.         AddFixed("ADB", 0x14);
  276.         AddFixed("SBB", 0x15);
  277.        
  278.         AddFixed("ADN", 0x0c);
  279.         AddFixed("SBN", 0x0d);
  280.         AddFixed("ADW", 0x0e);
  281.         AddFixed("SBW", 0x0f);
  282.        
  283.         AddFixed("SRW", 0x1c);
  284.         AddFixed("SLW", 0x1d);
  285.        
  286.         AddFixed("ORMA", 0x47);
  287.         AddImm8("ORIM", 0x61);
  288.         AddImm8("ORIA", 0x65);
  289.         AddImm8("ORID", 0xd5);
  290.  
  291.         AddFixed("ANMA", 0x46);
  292.         AddImm8("ANIM", 0x60);
  293.         AddImm8("ANIA", 0x64);
  294.         AddImm8("ANID", 0xd4);
  295.  
  296.         AddImm8("TSIM", 0x62);
  297.         AddImm8("TSIA", 0x66);
  298.         AddImm8("TSID", 0xd6);
  299.         AddFixed("TSMA", 0xc6);
  300.                
  301.         AddImm8("CPIM", 0x63);
  302.         AddImm8("CPIA", 0x67);
  303.         AddFixed("CPMA", 0xc7);
  304.  
  305.         AddFixed("SWP", 0x58);
  306.  
  307.         AddFixed("SL", 0x5a);
  308.         AddFixed("SR", 0xd2);
  309.  
  310.         AddFixed("SC", 0xd0);
  311.         AddFixed("RC", 0xd1);
  312.  
  313.         /* [3] Jump */
  314.  
  315.         AddRel("JRNZ", 0x28);
  316.         AddRel("JRNZP", 0x28 | JR_PLUS);
  317.         AddRel("JRNZM", 0x29 | JR_MINUS);
  318.         AddRel("JRNC", 0x2a);
  319.         AddRel("JRNCP", 0x2a | JR_PLUS);
  320.         AddRel("JRNCM", 0x2b | JR_MINUS);
  321.         AddRel("JR", 0x2c);
  322.         AddRel("JRP", 0x2c | JR_PLUS);
  323.         AddRel("JRM", 0x2d | JR_MINUS);
  324.         AddRel("JRZ", 0x38);
  325.         AddRel("JRZP", 0x38 | JR_PLUS);
  326.         AddRel("JRZM", 0x39 | JR_MINUS);
  327.         AddRel("JRC", 0x3a);
  328.         AddRel("JRCP", 0x3a | JR_PLUS);
  329.         AddRel("JRCM", 0x3b | JR_MINUS);
  330.  
  331.         AddImm16("JP", 0x79);
  332.         AddImm16("JPNZ", 0x7c);
  333.         AddImm16("JPNC", 0x7d);
  334.         AddImm16("JPZ", 0x7e);
  335.         AddImm16("JPC", 0x7f);
  336.  
  337.         /* [4] Other */
  338.  
  339.         AddRel("LOOP", 0x2f | JR_MINUS);
  340.         AddFixed("PUSH", 0x34);
  341.         AddFixed("RTN", 0x37);
  342.         AddFixed("INA", 0x4c);
  343.         AddFixed("NOPW", 0x4d);
  344.         AddImm8("WAIT", 0x4e);
  345.         AddFixed("POP", 0x5b);
  346.         AddFixed("OUTA", 0x5d);
  347.         AddFixed("OUTF", 0x5f);
  348.         AddImm8("TEST", 0x6b);
  349.         AddImm16("CALL", 0x78);
  350.         AddFixed("INB", 0xcc);
  351.         AddFixed("NOPT", 0xce);
  352.         AddFixed("LEAVE", 0xd8);
  353.         AddFixed("OUTB", 0xdd);
  354.         AddFixed("OUTC", 0xdf);
  355.         AddInstTable(InstTable, "CAL", 0xe0, DecodeCAL);
  356.  
  357.         AddFixed("PTC", 0x7a);
  358.         AddFixed("DTC", 0x69);
  359.  
  360.         /* Undocumented Instruction described in б╓е▌е▒е│еєбже▐е╖еє╕ье╓е├епб╫ */
  361.         AddFixed("MVWP", 0x35);
  362.         AddFixed("IPXL", 0x4f);
  363.         AddFixed("IPXH", 0x6f);
  364.         AddFixed("CLRA", 0x23);
  365.         AddFixed("MVMP", 0x54);
  366.         AddFixed("LDPC", 0x56);
  367.  
  368.         /* Found in PC-1350 Machine Language Reference Manual */
  369.         AddFixed("CASE1", 0x7a);
  370.         AddFixed("CASE2", 0x69);
  371.         AddFixed("CUP", 0x4f);
  372.         AddFixed("CDN", 0x6f);
  373.        
  374.         add_moto8_pseudo(InstTable, e_moto_pseudo_flags_be);
  375.   AddInstTable(InstTable, "DB", eIntPseudoFlag_BigEndian | eIntPseudoFlag_AllowInt | eIntPseudoFlag_AllowString | eIntPseudoFlag_MotoRep, DecodeIntelDB);
  376.   AddInstTable(InstTable, "DW", eIntPseudoFlag_BigEndian | eIntPseudoFlag_AllowInt | eIntPseudoFlag_AllowString | eIntPseudoFlag_MotoRep, DecodeIntelDW);
  377. /*      AddIntelPseudo(eIntPseudoFlag_LittleEndian);    */
  378.         AddMoto16Pseudo(InstTable, e_moto_pseudo_flags_be);
  379. }
  380.  
  381. static void DeinitFields(void)
  382. {
  383.         DestroyInstTable(InstTable);
  384. }
  385.  
  386. /*---------------------------------------------------------------------------*/
  387.  
  388. static void MakeCode_SC61860(void)
  389. {
  390.   AttrPartOpSize[0] = eSymbolSize8Bit;
  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.