Subversion Repositories pentevo

Rev

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

  1. /* codeuc43.c */
  2. /*****************************************************************************/
  3. /* SPDX-License-Identifier: GPL-2.0-only OR GPL-3.0-only                     */
  4. /*                                                                           */
  5. /* AS                                                                        */
  6. /*                                                                           */
  7. /* Code Generator NEC uCOM-43/44/45                                          */
  8. /*                                                                           */
  9. /*****************************************************************************/
  10.  
  11. #include "stdinc.h"
  12. #include <string.h>
  13. #include <ctype.h>
  14.  
  15. #include "nls.h"
  16. #include "chunks.h"
  17. #include "bpemu.h"
  18. #include "strutil.h"
  19.  
  20. #include "asmdef.h"
  21. #include "asmsub.h"
  22. #include "asmpars.h"
  23. #include "asmitree.h"
  24. #include "codevars.h"
  25. #include "headids.h"
  26. #include "intpseudo.h"
  27. #include "errmsg.h"
  28.  
  29. #include "codeuc43.h"
  30.  
  31. /*--------------------------------------------------------------------------*/
  32. /* Local Types */
  33.  
  34. typedef enum
  35. {
  36.   e_ucom_45,
  37.   e_ucom_44,
  38.   e_ucom_43
  39. } family_t;
  40.  
  41. typedef struct
  42. {
  43.   char name[8];
  44.   Word rom_end;
  45.   Byte ram_end, family;
  46. } cpu_props_t;
  47.  
  48. static const cpu_props_t *p_curr_cpu_props;
  49.  
  50. /*--------------------------------------------------------------------------*/
  51. /* Instruction Decoders */
  52.  
  53. static void put_code(Word code)
  54. {
  55.   if (Hi(code))
  56.     BAsmCode[CodeLen++] = Hi(code);
  57.   BAsmCode[CodeLen++] = Lo(code);
  58. }
  59.  
  60. static Boolean chk_family(family_t min_family)
  61. {
  62.   if (p_curr_cpu_props->family < min_family)
  63.   {
  64.     WrStrErrorPos(ErrNum_InstructionNotSupported, &OpPart);
  65.     return False;
  66.   }
  67.   return True;
  68. }
  69.  
  70. /*!------------------------------------------------------------------------
  71.  * \fn     decode_fixed(Word code)
  72.  * \brief  handle instructions without arguments
  73.  * \param  code machine code
  74.  * ------------------------------------------------------------------------ */
  75.  
  76. static void decode_fixed(Word code)
  77. {
  78.   if (ChkArgCnt(0, 0))
  79.     put_code(code);
  80. }
  81.  
  82. /*!------------------------------------------------------------------------
  83.  * \fn     decode_fixed_uc43(Word code)
  84.  * \brief  handle instructions without arguments, uCOM-43 only
  85.  * \param  code machine code
  86.  * ------------------------------------------------------------------------ */
  87.  
  88. static void decode_fixed_uc43(Word code)
  89. {
  90.   if (chk_family(e_ucom_43))
  91.     decode_fixed(code);
  92. }
  93.  
  94. /*!------------------------------------------------------------------------
  95.  * \fn     decode_imm2(Word code)
  96.  * \brief  handle instructions with 2 bit immediate argument
  97.  * \param  code machine code
  98.  * ------------------------------------------------------------------------ */
  99.  
  100. static void decode_imm2(Word code)
  101. {
  102.   if (ChkArgCnt(1, 1))
  103.   {
  104.     Boolean ok;
  105.  
  106.     code |= (EvalStrIntExpression(&ArgStr[1], UInt2, &ok) & 3);
  107.     if (ok)
  108.       put_code(code);
  109.   }
  110. }
  111.  
  112. /*!------------------------------------------------------------------------
  113.  * \fn     decode_imm2_uc43(Word code)
  114.  * \brief  handle instructions with 2 bit immediate argument, uCOM-43 only
  115.  * \param  code machine code
  116.  * ------------------------------------------------------------------------ */
  117.  
  118. static void decode_imm2_uc43(Word code)
  119. {
  120.   if (chk_family(e_ucom_43))
  121.     decode_imm2(code);
  122. }
  123.  
  124. /*!------------------------------------------------------------------------
  125.  * \fn     decode_imm4(Word code)
  126.  * \brief  handle instructions with 4 bit immediate argument
  127.  * \param  code machine code
  128.  * ------------------------------------------------------------------------ */
  129.  
  130. static void decode_imm4(Word code)
  131. {
  132.   if (ChkArgCnt(1, 1))
  133.   {
  134.     Boolean ok;
  135.  
  136.     code |= (EvalStrIntExpression(&ArgStr[1], Int4, &ok) & 15);
  137.     if (ok)
  138.       put_code(code);
  139.   }
  140. }
  141.  
  142. /*!------------------------------------------------------------------------
  143.  * \fn     decode_stm(Word code)
  144.  * \brief  handle STM instruction
  145.  * \param  code machine code
  146.  * ------------------------------------------------------------------------ */
  147.  
  148. static void decode_stm(Word code)
  149. {
  150.   if (chk_family(e_ucom_43)
  151.    && ChkArgCnt(1, 1))
  152.   {
  153.     Boolean ok;
  154.  
  155.     code |= (EvalStrIntExpression(&ArgStr[1], Int6, &ok) & 63);
  156.     if (ok)
  157.       put_code(code);
  158.   }
  159. }
  160.  
  161. /*!------------------------------------------------------------------------
  162.  * \fn     decode_ldi(Word code)
  163.  * \brief  handle LDI instruction
  164.  * \param  code machine code
  165.  * ------------------------------------------------------------------------ */
  166.  
  167. static void decode_ldi(Word code)
  168. {
  169.   if (ChkArgCnt(1, 1))
  170.   {
  171.     tEvalResult eval_result;
  172.     Byte address = EvalStrIntExpressionWithResult(&ArgStr[1], UInt7, &eval_result);
  173.  
  174.     if (eval_result.OK)
  175.     {
  176.       ChkSpace(SegData, eval_result.AddrSpaceMask);
  177.       if (!mFirstPassUnknownOrQuestionable(eval_result.Flags) && (address > SegLimits[SegData]))
  178.         WrStrErrorPos(ErrNum_WOverRange, &ArgStr[1]);
  179.       put_code(code | (address & 0x7f));
  180.     }
  181.   }
  182. }
  183.  
  184. /*!------------------------------------------------------------------------
  185.  * \fn     decode_jmp(Word code)
  186.  * \brief  handle instructions with absolute address argument
  187.  * \param  code machine code
  188.  * ------------------------------------------------------------------------ */
  189.  
  190. static void decode_jmp(Word code)
  191. {
  192.   if (ChkArgCnt(1, 1))
  193.   {
  194.     tEvalResult eval_result;
  195.     Word address = EvalStrIntExpressionWithResult(&ArgStr[1], UInt11, &eval_result);
  196.  
  197.     if (eval_result.OK)
  198.     {
  199.       ChkSpace(SegCode, eval_result.AddrSpaceMask);
  200.       put_code(code | ((Hi(address) & 7)));
  201.       BAsmCode[CodeLen++] = Lo(address);
  202.     }
  203.   }
  204. }
  205.  
  206. /*!------------------------------------------------------------------------
  207.  * \fn     decode_jcp(Word code)
  208.  * \brief  handle JCP instruction
  209.  * \param  code machine code
  210.  * ------------------------------------------------------------------------ */
  211.  
  212. static void decode_jcp(Word code)
  213. {
  214.   if (ChkArgCnt(1, 1))
  215.   {
  216.     tEvalResult eval_result;
  217.     Word address = EvalStrIntExpressionWithResult(&ArgStr[1], UInt11, &eval_result);
  218.  
  219.     if (eval_result.OK)
  220.     {
  221.       /* PC[0..7] is not auto-incremented after fetching a jump or call
  222.          instruction.  So JCP always remains in the current 64 byte page,
  223.          even if it is located in the last byte of a 64 byte page: */
  224.  
  225.       ChkSpace(SegCode, eval_result.AddrSpaceMask);
  226.       if (!mFirstPassUnknownOrQuestionable(eval_result.Flags))
  227.       {
  228.         if ((EProgCounter() & 0x7c0) != (address & 0x7c0))
  229.         {
  230.           WrStrErrorPos(ErrNum_TargOnDiffPage, &ArgStr[1]);
  231.           return;
  232.         }
  233.       }
  234.       put_code(code | (address & 0x3f));
  235.     }
  236.   }
  237. }
  238.  
  239. /*!------------------------------------------------------------------------
  240.  * \fn     decode_czp(Word code)
  241.  * \brief  handle CZP instruction
  242.  * \param  code machine code
  243.  * ------------------------------------------------------------------------ */
  244.  
  245. static void decode_czp(Word code)
  246. {
  247.   if (ChkArgCnt(1, 1))
  248.   {
  249.     tEvalResult eval_result;
  250.     Word address = EvalStrIntExpressionWithResult(&ArgStr[1], UInt11, &eval_result);
  251.  
  252.     if (!eval_result.OK)
  253.       return;
  254.  
  255.     /* Check whether the argument is an address (00h, 04h, 08h...3ch) or a vector (0..15): */
  256.  
  257.     /* If the argument is larger than 15, it must be an address (in code space)
  258.        of the form 4*n with n <= 15: */
  259.  
  260.     if (address > 15)
  261.     {
  262.       ChkSpace(SegCode, eval_result.AddrSpaceMask);
  263.       if (!mFirstPassUnknownOrQuestionable(eval_result.Flags))
  264.       {
  265.         if ((address & 3) || (address > 63))
  266.         {
  267.           WrStrErrorPos(ErrNum_NotFromThisAddress, &ArgStr[1]);
  268.           return;
  269.         }
  270.       }
  271.       address = (address >> 2) & 15;
  272.     }
  273.  
  274.     /* Otherwise, if the argument is zero, the distinction is irrelevant.  If
  275.        the argument is not a multiple of four, it must be a vector: */
  276.  
  277.     else if ((address & 3) || !address)
  278.     {
  279.     }
  280.  
  281.     /* So this leaves 4, 8, and 12 that might be a vector or an address.
  282.        Distinguish by whether the symbol is in code space: */
  283.  
  284.     else if (eval_result.AddrSpaceMask & (1 << SegCode))
  285.       address = (address >> 2) & 15;
  286.  
  287.     else
  288.       WrStrErrorPos(ErrNum_TreatedAsVector, &ArgStr[1]);
  289.  
  290.     put_code(code | address);
  291.   }
  292. }
  293.  
  294. /*!------------------------------------------------------------------------
  295.  * \fn     decode_ocd(Word code)
  296.  * \brief  handle OCD instruction
  297.  * \param  code machine code
  298.  * ------------------------------------------------------------------------ */
  299.  
  300. static void decode_ocd(Word code)
  301. {
  302.   if (ChkArgCnt(1, 1))
  303.   {
  304.     Boolean ok;
  305.     Byte value = EvalStrIntExpression(&ArgStr[1], Int8, &ok);
  306.  
  307.     if (ok)
  308.     {
  309.       put_code(code);
  310.       BAsmCode[CodeLen++] = value;
  311.     }
  312.   }
  313. }
  314.  
  315. /*--------------------------------------------------------------------------*/
  316. /* Code Table Handling */
  317.  
  318. /*!------------------------------------------------------------------------
  319.  * \fn     init_fields(void)
  320.  * \brief  set up instruction hash table
  321.  * ------------------------------------------------------------------------ */
  322.  
  323. static void add_fixed(const char *p_name, Word code)
  324. {
  325.   AddInstTable(InstTable, p_name, code, decode_fixed);
  326. }
  327.  
  328. static void add_fixed_uc43(const char *p_name, Word code)
  329. {
  330.   AddInstTable(InstTable, p_name, code, decode_fixed_uc43);
  331. }
  332.  
  333. static void add_imm2(const char *p_name, Word code)
  334. {
  335.   AddInstTable(InstTable, p_name, code, decode_imm2);
  336. }
  337.  
  338. static void add_imm2_uc43(const char *p_name, Word code)
  339. {
  340.   AddInstTable(InstTable, p_name, code, decode_imm2_uc43);
  341. }
  342.  
  343. static void add_imm4(const char *p_name, Word code)
  344. {
  345.   AddInstTable(InstTable, p_name, code, decode_imm4);
  346. }
  347.  
  348. static void init_fields(void)
  349. {
  350.   InstTable = CreateInstTable(203);
  351.  
  352.   add_fixed("CLA", 0x90);
  353.   add_fixed("CLC", 0x0b);
  354.   add_fixed("CMA", 0x10);
  355.   add_fixed("CIA", 0x11);
  356.   add_fixed("INC", 0x0d);
  357.   add_fixed("DEC", 0x0f);
  358.   add_fixed("STC", 0x1b);
  359.   add_fixed_uc43("XC",  0x1a);
  360.   add_fixed_uc43("RAR", 0x30);
  361.   add_fixed_uc43("INM", 0x1d);
  362.   add_fixed_uc43("DEM", 0x1f);
  363.   add_fixed("AD",  0x08);
  364.   add_fixed("ADS", 0x09);
  365.   add_fixed("ADC", 0x19);
  366.   add_fixed("DAA", 0x06);
  367.   add_fixed("DAS", 0x0a);
  368.   add_fixed("EXL", 0x18);
  369.   add_imm4 ("LI",  0x90);
  370.   add_fixed("S",   0x02);
  371.   add_fixed("L",   0x38); /* == LM 0 */
  372.   add_imm2 ("LM",  0x38);
  373.   add_fixed("X",   0x28); /* == XM 0 */
  374.   add_imm2 ("XM",  0x28);
  375.   add_fixed("XD",  0x2c); /* == XMD 0 */
  376.   add_imm2 ("XMD", 0x2c);
  377.   add_fixed("XI",  0x3c); /* == XMI 0 */
  378.   add_imm2 ("XMI", 0x3c);
  379.   AddInstTable(InstTable, "LDI", 0x1500, decode_ldi);
  380.   add_imm4 ("LDZ", 0x80);
  381.   add_fixed("DED", 0x13);
  382.   add_fixed("IND", 0x33);
  383.   add_fixed("TAL", 0x07);
  384.   add_fixed("TLA", 0x12);
  385.   add_fixed_uc43("XHX", 0x4f);
  386.   add_fixed_uc43("XLY", 0x4e);
  387.   add_fixed_uc43("THX", 0x47);
  388.   add_fixed_uc43("TLY", 0x46);
  389.   add_fixed_uc43("XAZ", 0x4a);
  390.   add_fixed_uc43("XAW", 0x4b);
  391.   add_fixed_uc43("TAZ", 0x42);
  392.   add_fixed_uc43("TAW", 0x43);
  393.   add_fixed_uc43("XHR", 0x4d);
  394.   add_fixed_uc43("XLS", 0x4c);
  395.   add_imm2 ("SMB", 0x78);
  396.   add_imm2 ("RMB", 0x68);
  397.   add_imm2 ("TMB", 0x58);
  398.   add_imm2 ("TAB", 0x24);
  399.   add_imm2 ("CMB", 0x34);
  400.   add_imm2_uc43 ("SFB", 0x7c);
  401.   add_imm2_uc43 ("RFB", 0x6c);
  402.   add_imm2_uc43 ("FBT", 0x5c);
  403.   add_imm2_uc43 ("FBF", 0x20);
  404.   add_fixed("CM",  0x0c);
  405.   add_imm4 ("CI",  0x17c0);
  406.   add_imm4 ("CLI", 0x16e0);
  407.   add_fixed("TC",  0x04);
  408.   add_fixed_uc43("TTM", 0x05);
  409.   add_fixed("TIT", 0x03);
  410.   AddInstTable(InstTable, "JCP", 0xc0, decode_jcp);
  411.   AddInstTable(InstTable, "JMP", 0xa0, decode_jmp);
  412.   add_fixed("JPA", 0x41);
  413.   add_fixed_uc43("EI",  0x31);
  414.   add_fixed_uc43("DI",  0x01);
  415.   AddInstTable(InstTable, "CZP", 0xb0, decode_czp);
  416.   AddInstTable(InstTable, "CAL", 0xa8, decode_jmp);
  417.   add_fixed("RT",  0x48);
  418.   add_fixed("RTS", 0x49);
  419.   add_imm2 ("SEB", 0x74);
  420.   add_imm2 ("REB", 0x64);
  421.   add_imm2 ("SPB", 0x70);
  422.   add_imm2 ("RPB", 0x60);
  423.   add_imm2 ("TPA", 0x54);
  424.   add_imm2 ("TPB", 0x50);
  425.   add_fixed("OE",  0x44);
  426.   add_fixed("OP",  0x0e);
  427.   AddInstTable(InstTable, "OCD", 0x1e, decode_ocd);
  428.   add_fixed("IA",  0x40);
  429.   add_fixed("IP",  0x32);
  430.   AddInstTable(InstTable, "STM", 0x1480, decode_stm);
  431.   add_fixed("NOP", NOPCode);
  432.  
  433.   AddIntelPseudo(InstTable, eIntPseudoFlag_BigEndian);
  434. }
  435.  
  436. /*!------------------------------------------------------------------------
  437.  * \fn     deinit_fields(void)
  438.  * \brief  dissolve instruction hash table
  439.  * ------------------------------------------------------------------------ */
  440.  
  441. static void deinit_fields(void)
  442. {
  443.   DestroyInstTable(InstTable);
  444. }
  445.  
  446. /*--------------------------------------------------------------------------*/
  447. /* Callbacks */
  448.  
  449. /*!------------------------------------------------------------------------
  450.  * \fn     make_code_uc43(void)
  451.  * \brief  transform machine instruction to binary code
  452.  * ------------------------------------------------------------------------ */
  453.  
  454. static void make_code_uc43(void)
  455. {
  456.   /* Empty Instruction */
  457.  
  458.   if (!*OpPart.str.p_str)
  459.     return;
  460.  
  461.   /* via table */
  462.  
  463.   if (!LookupInstTable(InstTable, OpPart.str.p_str))
  464.     WrStrErrorPos(ErrNum_UnknownInstruction, &OpPart);
  465. }
  466.  
  467. /*!------------------------------------------------------------------------
  468.  * \fn     is_def_uc43(void)
  469.  * \brief  check whether instruction consumes label field
  470.  * \return True if yes
  471.  * ------------------------------------------------------------------------ */
  472.  
  473. static Boolean is_def_uc43(void)
  474. {
  475.   return False;
  476. }
  477.  
  478. /*!------------------------------------------------------------------------
  479.  * \fn     switch_from_uc43(void)
  480.  * \brief  cleanups when switching away from uCOM-43 target
  481.  * ------------------------------------------------------------------------ */
  482.  
  483. static void switch_from_uc43(void)
  484. {
  485.   deinit_fields();
  486. }
  487.  
  488. /*!------------------------------------------------------------------------
  489.  * \fn     switch_to_uc43(void *p_user)
  490.  * \brief  set up for uCOM-43 target
  491.  * \param  points to selected properties
  492.  * ------------------------------------------------------------------------ */
  493.  
  494. static void switch_to_uc43(void *p_user)
  495. {
  496.   const TFamilyDescr *p_descr;
  497.  
  498.   p_curr_cpu_props = (const cpu_props_t*)p_user;
  499.  
  500.   TurnWords = False;
  501.   SetIntConstMode(eIntConstModeIntel);
  502.  
  503.   p_descr = FindFamilyByName("uCOM-43");
  504.   PCSymbol = "$";
  505.   HeaderID = p_descr->Id;
  506.   NOPCode = 0x00;
  507.   DivideChars = ",";
  508.   HasAttrs = False;
  509.  
  510.   ValidSegs = (1 << SegCode) | (1 << SegData);
  511.   Grans[SegCode] = 1; ListGrans[SegCode] = 1; SegInits[SegCode] = 0;
  512.   SegLimits[SegCode] = p_curr_cpu_props->rom_end;
  513.   Grans[SegData] = 1; ListGrans[SegData] = 1; SegInits[SegData] = 0;
  514.   SegLimits[SegData] = p_curr_cpu_props->ram_end;
  515.  
  516.   MakeCode = make_code_uc43; IsDef = is_def_uc43;
  517.   SwitchFrom = switch_from_uc43; init_fields();
  518. }
  519.  
  520. /*--------------------------------------------------------------------------*/
  521. /* Initialisierung */
  522.  
  523. static const cpu_props_t cpu_props[] =
  524. {
  525.   { "uPD546", 1999, 95, e_ucom_43 },
  526.   { "uPD547",  999, 63, e_ucom_44 },
  527.   { "uPD550",  639, 31, e_ucom_45 },
  528.   { "uPD552",  999, 63, e_ucom_44 },
  529.   { "uPD553", 1999, 95, e_ucom_43 },
  530.   { "uPD554",  999, 31, e_ucom_45 },
  531.   { "uPD556", 1999, 95, e_ucom_43 }, /* ROM is external */
  532.   { "uPD557", 1999, 95, e_ucom_43 },
  533.   { "uPD650", 1999, 95, e_ucom_43 },
  534.   { "uPD651",  999, 63, e_ucom_44 },
  535.   { "uPD652",  999, 31, e_ucom_45 },
  536.   { "",          0,  0, e_ucom_45 }
  537. };
  538.  
  539. void codeuc43_init(void)
  540. {
  541.   const cpu_props_t *p_run;
  542.  
  543.   for (p_run = cpu_props; p_run->name[0]; p_run++)
  544.     (void)AddCPUUser(p_run->name, switch_to_uc43, (void*)p_run, NULL);
  545. }
  546.