From 333b605b2afd472b823aeda0adf0e8b1ea9843c0 Mon Sep 17 00:00:00 2001 From: fishsoupisgood Date: Mon, 27 May 2019 02:41:51 +0100 Subject: initial commit from asl-1.41r8.tar.gz --- codeace.c | 767 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 767 insertions(+) create mode 100644 codeace.c (limited to 'codeace.c') diff --git a/codeace.c b/codeace.c new file mode 100644 index 0000000..bfe0242 --- /dev/null +++ b/codeace.c @@ -0,0 +1,767 @@ +/* codeace.c */ +/*****************************************************************************/ +/* AS-Portierung */ +/* */ +/* Codegeneratormodul ACE-Familie */ +/* */ +/* Historie:14. 8.1999 Grundsteinlegung */ +/* 15. 8.1999 Datensegment immer 256 Byte */ +/* angekuendigte Typen */ +/* nur noch Intel-Pseudos */ +/* 16. 8.1999 Fehler beseitigt */ +/* */ +/*****************************************************************************/ + +#include "stdinc.h" + +#include + +#include "bpemu.h" +#include "strutil.h" +#include "chunks.h" +#include "headids.h" +#include "asmdef.h" +#include "asmsub.h" +#include "asmpars.h" +#include "asmitree.h" +#include "codepseudo.h" +#include "codevars.h" + +#define ModNone (-1) +#define ModAcc 0 +#define MModAcc (1 << ModAcc) +#define ModX 1 +#define MModX (1 << ModX) +#define ModXInd 2 +#define MModXInd (1 << ModXInd) +#define ModXDisp 3 +#define MModXDisp (1 << ModXDisp) +#define ModDir 4 +#define MModDir (1 << ModDir) +#define ModImm 5 +#define MModImm (1 << ModImm) + +#define FixedOrderCnt 9 +#define AriOrderCnt 7 +#define SingOrderCnt 3 +#define BitOrderCnt 6 + +typedef struct + { + Byte Code; + } FixedOrder; + +typedef struct + { + Byte ImmCode, DirCode, IndCode, DispCode; + } AriOrder; + +typedef struct + { + Byte AccCode, XCode, DirCode; + } SingOrder; + +typedef struct + { + Byte AccCode, XIndCode, DirCode; + } BitOrder; + +enum {D_CPUACE1001, D_CPUACE1101, D_CPUACE2101, + D_CPUACE1202, D_CPUACE2202, D_CPUACE2404}; + +static CPUVar CPUACE1001, CPUACE1101, CPUACE2101, + CPUACE1202, CPUACE2202, CPUACE2404; + +static PInstTable InstTable; +static FixedOrder *FixedOrders; +static AriOrder *AriOrders; +static SingOrder *SingOrders; +static BitOrder *BitOrders; + +static ShortInt AdrMode; +static Byte AdrVal; +static Word WAdrVal; +static Boolean BigFlag, OpSize; +static IntType XType, CodeType; + +/*---------------------------------------------------------------------------*/ + + static void ChkAdr(Word Mask) +BEGIN + if ((AdrMode == ModXDisp) AND (MomCPU < CPUACE1202)) + BEGIN + AdrMode = ModNone; WrError(1505); + END + else if ((AdrMode != ModNone) AND ((Mask & (1 << AdrMode)) == 0)) + BEGIN + AdrMode = ModNone; WrError(1350); + END +END + + static void DecodeAdr(char *Asc, Word Mask) +BEGIN + Boolean OK, DispOcc, XOcc; + int l; + String Part; + char *p; + + AdrMode = ModNone; + + /* Register ? */ + + if (strcasecmp(Asc, "A") == 0) + AdrMode = ModAcc; + + else if (strcasecmp(Asc, "X") == 0) + AdrMode = ModX; + + /* immediate ? */ + + else if (*Asc == '#') + BEGIN + if (OpSize) + WAdrVal = EvalIntExpression(Asc + 1, XType, &OK); + else + AdrVal = EvalIntExpression(Asc + 1, Int8, &OK); + if (OK) AdrMode = ModImm; + END + + /* indirekt ? */ + + else if (*Asc == '[') + BEGIN + l = strlen(Asc) - 1; + if (Asc[l] != ']') WrError(1350); + else + BEGIN + Asc[l] = '\0'; Asc++; + DispOcc = XOcc = False; + while (*Asc != '\0') + BEGIN + p = QuotPos(Asc, ','); + if (p != Nil) *p = '\0'; + strmaxcpy(Part, Asc, 255); + KillPrefBlanks(Part); KillPostBlanks(Part); + if (strcasecmp(Part, "X") == 0) + if (XOcc) + BEGIN + WrError(1350); break; + END + else XOcc = True; + else if (DispOcc) + BEGIN + WrError(1350); break; + END + else + BEGIN + if (*Part == '#') strcpy(Part, Part +1); + AdrVal = EvalIntExpression(Part, SInt8, &OK); + if (NOT OK) break; + DispOcc = True; + END + if (p == Nil) Asc = ""; + else Asc = p + 1; + END + if (*Asc == '\0') + AdrMode = (DispOcc && (AdrVal != 0)) ? ModXDisp : ModXInd; + END + END + + /* direkt */ + + else + BEGIN + if (OpSize) + WAdrVal = EvalIntExpression(Asc, CodeType, &OK); + else + AdrVal = EvalIntExpression(Asc, UInt6, &OK); + if (OK) AdrMode = ModDir; + END + + ChkAdr(Mask); +END + +/*---------------------------------------------------------------------------*/ + + static void DecodeFixed(Word Index) +BEGIN + FixedOrder *porder = FixedOrders + Index; + + if (ArgCnt != 0) WrError(1110); + else + BEGIN + BAsmCode[0] = porder->Code; + CodeLen = 1; + END +END + + static void DecodeAri(Word Index) +BEGIN + AriOrder *porder = AriOrders + Index; + + if (ArgCnt != 2) WrError(1110); + else + BEGIN + DecodeAdr(ArgStr[1], MModAcc); + if (AdrMode != ModNone) + BEGIN + DecodeAdr(ArgStr[2], MModImm | MModDir | MModXInd | MModXDisp); + switch (AdrMode) + BEGIN + case ModImm: + BAsmCode[0] = porder->ImmCode; BAsmCode[1] = AdrVal; + CodeLen = 2; + break; + case ModDir: + BAsmCode[0] = porder->DirCode; BAsmCode[1] = AdrVal; + CodeLen = 2; + break; + case ModXInd: + BAsmCode[0] = porder->IndCode; + CodeLen = 1; + break; + case ModXDisp: + BAsmCode[0] = porder->DispCode; BAsmCode[1] = AdrVal; + CodeLen = 2; + break; + END + END + END +END + + static void DecodeSing(Word Index) +BEGIN + SingOrder *porder = SingOrders + Index; + + if (ArgCnt != 1) WrError(1110); + else + BEGIN + DecodeAdr(ArgStr[1], MModDir | MModX | MModAcc); + switch (AdrMode) + BEGIN + case ModDir: + BAsmCode[0] = porder->DirCode; BAsmCode[1] = AdrVal; + CodeLen = 2; + break; + case ModAcc: + BAsmCode[0] = porder->AccCode; + CodeLen = 1; + break; + case ModX: + BAsmCode[0] = porder->XCode; + CodeLen = 1; + break; + END + END +END + + static void DecodeBit(Word Index) +BEGIN + Byte Bit, Mask; + BitOrder *porder = BitOrders + Index; + Boolean OK; + + if (ArgCnt != 2) WrError(1110); + else + BEGIN + Bit = EvalIntExpression(ArgStr[1], UInt8, &OK); + if (OK) + BEGIN + Mask = 0; + if (porder->AccCode != 0xff) Mask |= MModAcc; + if (porder->XIndCode != 0xff) Mask |= MModXInd; + if (porder->DirCode != 0xff) Mask |= MModDir; + DecodeAdr(ArgStr[2], Mask); + switch (AdrMode) + BEGIN + case ModAcc: + BAsmCode[0] = porder->AccCode; + if (porder->AccCode & 7) + BEGIN + BAsmCode[1] = 1 << Bit; + if (porder->AccCode & 1) BAsmCode[1] = 255 - BAsmCode[1]; + CodeLen = 2; + END + else + BEGIN + BAsmCode[0] |= Bit; CodeLen = 1; + END + break; + case ModXInd: + BAsmCode[0] = porder->XIndCode + Bit; + CodeLen = 1; + break; + case ModDir: + BAsmCode[0] = porder->DirCode + Bit; BAsmCode[1] = AdrVal; + CodeLen = 2; + break; + END + END + END +END + + static void DecodeIFEQ(Word Index) +BEGIN + if (ArgCnt != 2) WrError(1110); + else + BEGIN + DecodeAdr(ArgStr[1], MModAcc | MModX | MModDir); + switch (AdrMode) + BEGIN + case ModAcc: + DecodeAdr(ArgStr[2], MModImm | MModDir | MModXInd | MModXDisp); + switch (AdrMode) + BEGIN + case ModImm: + BAsmCode[0] = 0x65; BAsmCode[1] = AdrVal; + CodeLen = 2; + break; + case ModDir: + BAsmCode[0] = 0x56; BAsmCode[1] = AdrVal; + CodeLen = 2; + break; + case ModXInd: + BAsmCode[0] = 0x09; + CodeLen = 1; + break; + case ModXDisp: + BAsmCode[0] = 0x76; BAsmCode[1] = AdrVal; + CodeLen = 2; + break; + END + break; + case ModX: + OpSize = True; + DecodeAdr(ArgStr[2], MModImm); + switch (AdrMode) + BEGIN + case ModImm: + BAsmCode[0] = 0x26; + BAsmCode[1] = Lo(WAdrVal); BAsmCode[2] = Hi(WAdrVal); + CodeLen = 3; + break; + END + break; + case ModDir: + BAsmCode[1] = AdrVal; + DecodeAdr(ArgStr[2], MModImm); + switch (AdrMode) + BEGIN + case ModImm: + BAsmCode[0] = 0x20; + BAsmCode[2] = AdrVal; + CodeLen = 3; + break; + END + break; + END + END +END + + static void DecodeIFGT(Word Index) +BEGIN + if (ArgCnt != 2) WrError(1110); + else + BEGIN + DecodeAdr(ArgStr[1], MModAcc | MModX); + switch (AdrMode) + BEGIN + case ModAcc: + DecodeAdr(ArgStr[2], MModImm | MModDir | MModXInd | MModXDisp); + switch (AdrMode) + BEGIN + case ModImm: + BAsmCode[0] = 0x67; BAsmCode[1] = AdrVal; + CodeLen = 2; + break; + case ModDir: + BAsmCode[0] = 0x55; BAsmCode[1] = AdrVal; + CodeLen = 2; + break; + case ModXInd: + BAsmCode[0] = 0x0a; + CodeLen = 1; + break; + case ModXDisp: + BAsmCode[0] = 0x77; BAsmCode[1] = AdrVal; + CodeLen = 2; + break; + END + break; + case ModX: + OpSize = True; + DecodeAdr(ArgStr[2], MModImm); + switch (AdrMode) + BEGIN + case ModImm: + BAsmCode[0] = 0x27; + BAsmCode[1] = Lo(WAdrVal); BAsmCode[2] = Hi(WAdrVal); + CodeLen = 3; + break; + END + break; + END + END +END + + static void DecodeIFLT(Word Index) +BEGIN + if (ArgCnt != 2) WrError(1110); + else + BEGIN + DecodeAdr(ArgStr[1], MModX); + switch (AdrMode) + BEGIN + case ModX: + OpSize = True; + DecodeAdr(ArgStr[2], MModImm); + switch (AdrMode) + BEGIN + case ModImm: + BAsmCode[0] = 0x28; + BAsmCode[1] = Lo(WAdrVal); BAsmCode[2] = Hi(WAdrVal); + CodeLen = 3; + break; + END + break; + END + END +END + + static void DecodeJMPJSR(Word Index) +BEGIN + if (ArgCnt != 1) WrError(1110); + else + BEGIN + OpSize = True; + DecodeAdr(ArgStr[1], MModDir | MModXDisp); + switch (AdrMode) + BEGIN + case ModDir: + BAsmCode[0] = 0x24 - Index; + BAsmCode[1] = Lo(WAdrVal); BAsmCode[2] = Hi(WAdrVal); + CodeLen = 3; + break; + case ModXDisp: + BAsmCode[0] = 0x7e + Index; BAsmCode[1] = AdrVal; + CodeLen = 2; + break; + END + END +END + + static void DecodeJP(Word Index) +BEGIN + LongInt Dist; + Boolean OK; + + if (ArgCnt != 1) WrError(1110); + else + BEGIN + Dist = EvalIntExpression(ArgStr[1], CodeType, &OK) - (EProgCounter() + 1); + if (OK) + if ((NOT SymbolQuestionable) AND ((Dist > 31) OR (Dist < -31))) WrError(1370); + else + BEGIN + if (Dist >= 0) BAsmCode[0] = 0xe0 + Dist; + else BAsmCode[0] = 0xc0 - Dist; + CodeLen = 1; + END + END +END + + static void DecodeLD(Word Index) +BEGIN + if (ArgCnt != 2) WrError(1110); + else + BEGIN + DecodeAdr(ArgStr[1], MModAcc | MModX | MModDir); + switch (AdrMode) + BEGIN + case ModAcc: + DecodeAdr(ArgStr[2], MModImm | MModDir | MModXInd | MModXDisp); + switch (AdrMode) + BEGIN + case ModImm: + BAsmCode[0] = 0x51; BAsmCode[1] = AdrVal; + CodeLen = 2; + break; + case ModDir: + BAsmCode[0] = 0x46; BAsmCode[1] = AdrVal; + CodeLen = 2; + break; + case ModXInd: + BAsmCode[0] = 0x0e; + CodeLen = 1; + break; + case ModXDisp: + BAsmCode[0] = 0x52; BAsmCode[1] = AdrVal; + CodeLen = 2; + break; + END + break; + case ModX: + OpSize = True; + DecodeAdr(ArgStr[2], MModImm); + switch (AdrMode) + BEGIN + case ModImm: + BAsmCode[0] = 0x25; + BAsmCode[1] = Lo(WAdrVal); BAsmCode[2] = Hi(WAdrVal); + CodeLen = 3; + break; + END + break; + case ModDir: + BAsmCode[1] = AdrVal; + DecodeAdr(ArgStr[2], MModImm | MModDir); + switch (AdrMode) + BEGIN + case ModImm: + BAsmCode[0] = 0x21; + BAsmCode[2] = AdrVal; + CodeLen = 3; + break; + case ModDir: + BAsmCode[0] = 0x22; + BAsmCode[2] = BAsmCode[1]; + BAsmCode[1] = AdrVal; + CodeLen = 3; + break; + END + break; + END + END +END + + static void DecodeRotate(Word Index) +BEGIN + if (ArgCnt != 1) WrError(1110); + else + BEGIN + DecodeAdr(ArgStr[1], MModAcc | MModDir); + switch (AdrMode) + BEGIN + case ModAcc: + BAsmCode[0] = 0x15 - Index - Index; + CodeLen = 1; + break; + case ModDir: + BAsmCode[0] = 0x79 + Index; BAsmCode[1] = AdrVal; + CodeLen = 2; + break; + END + END +END + + static void DecodeST(Word Index) +BEGIN + if (ArgCnt != 2) WrError(1110); + else + BEGIN + DecodeAdr(ArgStr[1], MModAcc); + switch (AdrMode) + BEGIN + case ModAcc: + DecodeAdr(ArgStr[2], MModDir | MModXInd | MModXDisp); + switch (AdrMode) + BEGIN + case ModDir: + BAsmCode[0] = 0x47; BAsmCode[1] = AdrVal; + CodeLen = 2; + break; + case ModXInd: + BAsmCode[0] = 0x11; + CodeLen = 1; + break; + case ModXDisp: + BAsmCode[0] = 0x40; BAsmCode[1] = AdrVal; + CodeLen = 2; + break; + END + break; + END + END +END + +/*---------------------------------------------------------------------------*/ + + static void AddFixed(char *NName, Byte NCode) +BEGIN + if (InstrZ >= FixedOrderCnt) exit(255); + FixedOrders[InstrZ].Code = NCode; + AddInstTable(InstTable, NName, InstrZ++, DecodeFixed); +END + + static void AddAri(char *NName, Byte NImm, Byte NDir, Byte NInd, Byte NDisp) +BEGIN + if (InstrZ >= AriOrderCnt) exit(255); + AriOrders[InstrZ].ImmCode = NImm; + AriOrders[InstrZ].DirCode = NDir; + AriOrders[InstrZ].IndCode = NInd; + AriOrders[InstrZ].DispCode = NDisp; + AddInstTable(InstTable, NName, InstrZ++, DecodeAri); +END + + static void AddSing(char *NName, Byte NAcc, Byte NX, Byte NDir) +BEGIN + if (InstrZ >= SingOrderCnt) exit(255); + SingOrders[InstrZ].AccCode = NAcc; + SingOrders[InstrZ].XCode = NX; + SingOrders[InstrZ].DirCode = NDir; + AddInstTable(InstTable, NName, InstrZ++, DecodeSing); +END + + static void AddBit(char *NName, Byte NAcc, Byte NIndX, Byte NDir) +BEGIN + if (InstrZ >= BitOrderCnt) exit(255); + BitOrders[InstrZ].AccCode = NAcc; + BitOrders[InstrZ].XIndCode = NIndX; + BitOrders[InstrZ].DirCode = NDir; + AddInstTable(InstTable, NName, InstrZ++, DecodeBit); +END + + static void InitFields(void) +BEGIN + InstTable = CreateInstTable(101); + + FixedOrders = (FixedOrder *) malloc(FixedOrderCnt * sizeof(FixedOrder)); + InstrZ = 0; + AddFixed("IFC" ,0x19); AddFixed("IFNC" ,0x1f); AddFixed("INTR" ,0x00); + AddFixed("INVC" ,0x12); AddFixed("NOP" ,0x1c); AddFixed("RC" ,0x1e); + AddFixed("RET" ,0x17); AddFixed("RETI" ,0x18); AddFixed("SC" ,0x1d); + + AriOrders = (AriOrder *) malloc(AriOrderCnt * sizeof(AriOrder)); + InstrZ = 0; + AddAri("ADC" , 0x60, 0x42, 0x02, 0x70); + AddAri("ADD" , 0x66, 0x43, 0x03, 0x71); + AddAri("AND" , 0x61, 0x50, 0x04, 0x72); + AddAri("IFNE", 0x57, 0x54, 0x0b, 0x78); + AddAri("OR" , 0x62, 0x44, 0x05, 0x73); + AddAri("SUBC", 0x63, 0x53, 0x06, 0x74); + AddAri("XOR" , 0x64, 0x45, 0x07, 0x75); + + SingOrders = (SingOrder *) malloc(SingOrderCnt * sizeof(SingOrder)); + InstrZ = 0; + AddSing("CLR" , 0x16, 0x0f, 0x7d); + AddSing("DEC" , 0x1a, 0x0c, 0x7b); + AddSing("INC" , 0x1b, 0x0d, 0x7c); + + BitOrders = (BitOrder *) malloc(BitOrderCnt * sizeof(BitOrder)); + InstrZ = 0; + AddBit("IFBIT", 0xa0, 0xa8, 0x58); + AddBit("LDC" , 0xff, 0xff, 0x80); + AddBit("RBIT" , 0x61, 0xb8, 0x68); + AddBit("SBIT" , 0x62, 0xb0, 0x48); + AddBit("STC" , 0xff, 0xff, 0x88); + + AddInstTable(InstTable, "IFEQ", 0, DecodeIFEQ); + AddInstTable(InstTable, "IFGT", 0, DecodeIFGT); + AddInstTable(InstTable, "IFLT", 0, DecodeIFLT); + AddInstTable(InstTable, "JMP" , 0, DecodeJMPJSR); + AddInstTable(InstTable, "JSR" , 1, DecodeJMPJSR); + AddInstTable(InstTable, "JP" , 0, DecodeJP); + AddInstTable(InstTable, "LD" , 0, DecodeLD); + AddInstTable(InstTable, "RLC" , 0, DecodeRotate); + AddInstTable(InstTable, "RRC" , 1, DecodeRotate); + AddInstTable(InstTable, "ST" , 0, DecodeST); +END + + static void DeinitFields(void) +BEGIN + DestroyInstTable(InstTable); + free(FixedOrders); + free(AriOrders); + free(SingOrders); + free(BitOrders); +END + +/*---------------------------------------------------------------------------*/ + + static Boolean DecodePseudo(void) +BEGIN + + if (Memo("SFR")) + BEGIN + CodeEquate(SegData,0,0xff); + return True; + END; + + return False; +END + + static void MakeCode_ACE(void) +BEGIN + CodeLen = 0; DontPrint = False; BigFlag = False; OpSize = False; + + /* zu ignorierendes */ + + if (Memo("")) return; + + /* Pseudoanweisungen */ + + if (DecodePseudo()) return; + + if (DecodeIntelPseudo(BigFlag)) return; + + if (NOT LookupInstTable(InstTable, OpPart)) + WrXError(1200,OpPart); +END + + static Boolean IsDef_ACE(void) +BEGIN + return (Memo("SFR")); +END + + static void SwitchFrom_ACE(void) +BEGIN + DeinitFields(); +END + + static void SwitchTo_ACE(void) +BEGIN + PFamilyDescr Descr; + + TurnWords = False; ConstMode = ConstModeIntel; SetIsOccupied = False; + + Descr = FindFamilyByName("ACE"); + PCSymbol = "$"; HeaderID = Descr->Id; NOPCode = 0x1c; + DivideChars = ","; HasAttrs = False; + + ValidSegs = (1 << SegCode) | (1 << SegData); + Grans[SegCode] = 1; ListGrans[SegCode] = 1; SegInits[SegCode] = 0; + Grans[SegData] = 1; ListGrans[SegData] = 1; SegInits[SegData] = 0; + SegLimits[SegData] = 0xff; + + switch (MomCPU - CPUACE1001) + BEGIN + case D_CPUACE1001: case D_CPUACE1101: case D_CPUACE2101: + SegLimits[SegCode] = 0x3ff; + CodeType = UInt10; + XType = UInt11; + break; + case D_CPUACE1202: case D_CPUACE2202: + SegLimits[SegCode] = 0x7ff; + CodeType = UInt11; + XType = UInt12; + break; + case D_CPUACE2404: + SegLimits[SegCode] = 0xfff; + CodeType = UInt12; + XType = UInt12; + break; + END + + MakeCode = MakeCode_ACE; IsDef = IsDef_ACE; + SwitchFrom = SwitchFrom_ACE; InitFields(); +END + + void codeace_init(void) +BEGIN + CPUACE1001 = AddCPU("ACE1001", SwitchTo_ACE); + CPUACE1101 = AddCPU("ACE1101", SwitchTo_ACE); + CPUACE2101 = AddCPU("ACE2101", SwitchTo_ACE); + CPUACE1202 = AddCPU("ACE1202", SwitchTo_ACE); + CPUACE2202 = AddCPU("ACE2202", SwitchTo_ACE); + CPUACE2404 = AddCPU("ACE2404", SwitchTo_ACE); +END -- cgit v1.2.3