diff options
Diffstat (limited to 'code77230.c')
| -rw-r--r-- | code77230.c | 1024 |
1 files changed, 1024 insertions, 0 deletions
diff --git a/code77230.c b/code77230.c new file mode 100644 index 0000000..566d8c3 --- /dev/null +++ b/code77230.c @@ -0,0 +1,1024 @@ +/* code77230.c */ +/*****************************************************************************/ +/* Makroassembler AS */ +/* */ +/* Codegenerator NEC uPD77230 */ +/* */ +/* Historie: 13. 9.1998 Grundsteinlegung */ +/* 14. 9.1998 LDI/Destregs getestet */ +/* 16. 9.1998 das instruktionelle Kleingemuese begonnen */ +/* 19. 9.1998 restliche CPU-Instruktionen */ +/* 27. 9.1998 DW-Anweisung */ +/* 28. 9.1998 String-Argument fuer DW */ +/* DS */ +/* 2. 1.1999 ChkPC-Anpassung */ +/* */ +/*****************************************************************************/ + +/*---------------------------------------------------------------------------*/ +/* Includes */ + +#include "stdinc.h" +#include <string.h> +#include <ctype.h> + +#include "strutil.h" +#include "nls.h" +#include "endian.h" + +#include "asmdef.h" +#include "asmsub.h" +#include "asmpars.h" +#include "asmitree.h" +#include "headids.h" + +/*---------------------------------------------------------------------------*/ +/* Definitionen */ + +#define SrcRegCnt 32 +#define DestRegCnt 32 +#define ALUSrcRegCnt 4 + +#define JmpOrderCnt 32 +#define ALU1OrderCnt 15 +#define ALU2OrderCnt 10 + +#define CaseCnt 17 + +typedef struct + { + LongWord Code; + } FixedOrder; + +typedef struct + { + char *Name; + LongWord Code; + } Register; + +enum {InstrLDI, InstrBranch, + InstrALU, InstrMove, + InstrM0, InstrM1, InstrDP0, InstrDP1, + InstrEA, InstrRP, InstrFC, InstrLC, + InstrBASE0, InstrBASE1, InstrRPC, + InstrP2, InstrP3, InstrEM, InstrBM, + InstrL, InstrRW, InstrWT, InstrNF, InstrWI, + InstrFIS, InstrFD, InstrSHV, InstrRPS, InstrNAL, InstrCnt}; + +static LongWord CaseMasks[CaseCnt]= + {(1l<<InstrLDI), + (1l<<InstrBranch)|(1l<<InstrMove), + (1l<<InstrALU)|(1l<<InstrMove)|(1l<<InstrM0)|(1l<<InstrM1)|(1l<<InstrDP0)|(1l<<InstrDP1), + (1l<<InstrALU)|(1l<<InstrMove)|(1l<<InstrEA)|(1l<<InstrDP0)|(1l<<InstrDP1), + (1l<<InstrALU)|(1l<<InstrMove)|(1l<<InstrRP)|(1l<<InstrM0)|(1l<<InstrDP0)|(1l<<InstrFC), + (1l<<InstrALU)|(1l<<InstrMove)|(1l<<InstrRP)|(1l<<InstrM1)|(1l<<InstrDP1)|(1l<<InstrFC), + (1l<<InstrALU)|(1l<<InstrMove)|(1l<<InstrRP)|(1l<<InstrM0)|(1l<<InstrM1)|(1l<<InstrL)|(1l<<InstrFC), + (1l<<InstrALU)|(1l<<InstrMove)|(1l<<InstrBASE0)|(1l<<InstrBASE1)|(1l<<InstrFC), + (1l<<InstrALU)|(1l<<InstrMove)|(1l<<InstrRPC)|(1l<<InstrL)|(1l<<InstrFC), + (1l<<InstrALU)|(1l<<InstrMove)|(1l<<InstrP3)|(1l<<InstrP2)|(1l<<InstrEM)|(1l<<InstrBM)|(1l<<InstrL)|(1l<<InstrFC), + (1l<<InstrALU)|(1l<<InstrMove)|(1l<<InstrRW)|(1l<<InstrL)|(1l<<InstrFC), + (1l<<InstrALU)|(1l<<InstrMove)|(1l<<InstrWT)|(1l<<InstrL)|(1l<<InstrFC), + (1l<<InstrALU)|(1l<<InstrMove)|(1l<<InstrNF)|(1l<<InstrWI)|(1l<<InstrL)|(1l<<InstrFC), + (1l<<InstrALU)|(1l<<InstrMove)|(1l<<InstrFIS)|(1l<<InstrFD)|(1l<<InstrL), + (1l<<InstrALU)|(1l<<InstrMove)|(1l<<InstrSHV), + (1l<<InstrALU)|(1l<<InstrMove)|(1l<<InstrRPS), + (1l<<InstrALU)|(1l<<InstrMove)|(1l<<InstrNAL) + }; + +static CPUVar CPU77230; +static LongWord InstrMask; +static Boolean Error; +static LongWord *InstrComps,*InstrDefs; + +static PInstTable InstTable; +static Register *SrcRegs,*ALUSrcRegs,*DestRegs; +static FixedOrder *JmpOrders,*ALU1Orders,*ALU2Orders; + +/*---------------------------------------------------------------------------*/ +/* Hilfsroutinen */ + +static int DiscCnt,SplittedArg; +static char *DiscPtr; + + static Boolean SplitArgs(int Count) +BEGIN + char *p,*p1,*p2; + + SplittedArg=DiscCnt=Count; + + if (Count==0) + BEGIN + if (ArgCnt>0) + BEGIN + DiscPtr=ArgStr[1]-1; + SplittedArg=1; + END + else DiscPtr=Nil; + return True; + END + + if (ArgCnt<Count) + BEGIN + WrError(1110); Error=True; return False; + END + + for (p=ArgStr[SplittedArg]; isspace(((usint)*p)&0xff); p++); + p1=QuotPos(p,' '); + p2=QuotPos(p,'\t'); + if ((p1==Nil) OR ((p2!=Nil) AND (p2<p1))) DiscPtr=p2; + else DiscPtr=p1; + if (DiscPtr!=Nil) *(DiscPtr)='\0'; + + return True; +END + + static void DiscardArgs(void) +BEGIN + char *p,*p2; + int z; + Boolean Eaten; + + if (DiscPtr!=Nil) + BEGIN + for (p=DiscPtr+1; isspace(((usint)*p)&0xff); p++) + if (*p=='\0') break; + for (p2=p; NOT isspace(((usint)*p2)&0xff); p2++) + if (*p2=='\0') break; + Eaten=(*p2=='\0'); *p2='\0'; + strcpy(OpPart,p); NLS_UpString(OpPart); + if (Eaten) + BEGIN + for (z=1; z<ArgCnt; z++) + strcpy(ArgStr[z],ArgStr[z+1]); + ArgCnt--; + END + else + BEGIN + if (p2!=Nil) + for (p2++; isspace(((usint)*p2)&0xff); p2++); + strcpy(ArgStr[SplittedArg],p2); + END + END + else *OpPart='\0'; + if (DiscCnt>0) + BEGIN + for (z=0; z<=ArgCnt-DiscCnt; z++) + strcpy(ArgStr[z+1],ArgStr[z+DiscCnt]); + ArgCnt-=DiscCnt-1; + END +END + + static void AddComp(int Index, LongWord Value) +BEGIN + if ((InstrMask&(1l<<Index))!=0) + BEGIN + WrError(1355); Error=True; + END + else + BEGIN + InstrMask|=(1l<<Index); InstrComps[Index]=Value; + END; +END + + static Boolean DecodeReg(char *Asc, LongWord *Erg, Register *Regs, int Cnt) +BEGIN + int z; + + for (z=0; z<Cnt; z++) + if (strcasecmp(Asc,Regs[z].Name)==0) + BEGIN + *Erg=Regs[z].Code; return True; + END + return False; +END + +/*---------------------------------------------------------------------------*/ +/* Dekoder fuer Routinen */ + + static void DecodeJmp(Word Index) +BEGIN + FixedOrder *Op=JmpOrders+Index; + int acnt=(Memo("RET")) ? 0 : 1; + LongWord Adr; + + if (NOT SplitArgs(acnt)) return; + if (acnt==0) + BEGIN + Adr=0; Error=True; + END + else Adr=EvalIntExpression(ArgStr[1],UInt13,&Error); + Error=NOT Error; + if (NOT Error) AddComp(InstrBranch,Op->Code+(Adr << 5)); + DiscardArgs(); +END + + static void DecodeMOV(Word Index) +BEGIN + LongWord DReg,SReg; + + if (NOT SplitArgs(2)) return; + if (NOT DecodeReg(ArgStr[1],&DReg,DestRegs,DestRegCnt)) + BEGIN + WrXError(1445,ArgStr[1]); Error=True; + END + else if (NOT DecodeReg(ArgStr[2],&SReg,SrcRegs,SrcRegCnt)) + BEGIN + WrXError(1445,ArgStr[2]); Error=True; + END + else AddComp(InstrMove,(SReg<<5)+DReg); + DiscardArgs(); +END + + static void DecodeLDI(Word Index) +BEGIN + LongWord DReg,Src=0; + + if (NOT SplitArgs(2)) return; + if (NOT DecodeReg(ArgStr[1],&DReg,DestRegs,DestRegCnt)) + BEGIN + WrXError(1445,ArgStr[1]); Error=True; + END + else Src=EvalIntExpression(ArgStr[2],Int24,&Error); + Error=NOT Error; + if (NOT Error) AddComp(InstrLDI,(Src<<5)+DReg); + DiscardArgs(); +END + + static void DecodeNOP(Word Index) +BEGIN + if (NOT SplitArgs(0)) return; + AddComp(InstrALU,0); + DiscardArgs(); +END + + static void DecodeALU1(Word Index) +BEGIN + FixedOrder *Op=ALU1Orders+Index; + LongWord DReg; + + if (NOT SplitArgs(1)) return; + if ((NOT DecodeReg(ArgStr[1],&DReg,DestRegs,DestRegCnt)) + OR (DReg<16) OR (DReg>23)) + BEGIN + WrXError(1445,ArgStr[1]); Error=True; + END + else AddComp(InstrALU,(Op->Code<<17)+(DReg&7)); + DiscardArgs(); +END + + static void DecodeALU2(Word Index) +BEGIN + FixedOrder *Op=ALU2Orders+Index; + LongWord DReg,SReg; + + if (NOT SplitArgs(2)) return; + if ((NOT DecodeReg(ArgStr[1],&DReg,DestRegs,DestRegCnt)) + OR (DReg<16) OR (DReg>23)) + BEGIN + WrXError(1445,ArgStr[1]); Error=True; + END + else if (NOT DecodeReg(ArgStr[2],&SReg,ALUSrcRegs,ALUSrcRegCnt)) + BEGIN + WrXError(1445,ArgStr[2]); Error=True; + END + else AddComp(InstrALU,(Op->Code<<17)+(SReg<<3)+(DReg&7)); + DiscardArgs(); +END + + static void DecodeM0(Word Index) +BEGIN + if (NOT SplitArgs(0)) return; + AddComp(InstrM0,Index); + DiscardArgs(); +END + + static void DecodeM1(Word Index) +BEGIN + if (NOT SplitArgs(0)) return; + AddComp(InstrM1,Index); + DiscardArgs(); +END + + static void DecodeDP0(Word Index) +BEGIN + if (NOT SplitArgs(0)) return; + AddComp(InstrDP0,Index); + DiscardArgs(); +END + + static void DecodeDP1(Word Index) +BEGIN + if (NOT SplitArgs(0)) return; + AddComp(InstrDP1,Index); + DiscardArgs(); +END + + static void DecodeEA(Word Index) +BEGIN + if (NOT SplitArgs(0)) return; + AddComp(InstrEA,Index); + DiscardArgs(); +END + + static void DecodeFC(Word Index) +BEGIN + if (NOT SplitArgs(0)) return; + AddComp(InstrFC,Index); + DiscardArgs(); +END + + static void DecodeRP(Word Index) +BEGIN + if (NOT SplitArgs(0)) return; + AddComp(InstrRP,Index); + DiscardArgs(); +END + + static void DecodeL(Word Index) +BEGIN + if (NOT SplitArgs(0)) return; + AddComp(InstrL,Index); + DiscardArgs(); +END + + static void DecodeBASE(Word Index) +BEGIN + LongWord Value; + + if (NOT SplitArgs(1)) return; + Value=EvalIntExpression(ArgStr[1],UInt3,&Error); Error=NOT Error; + if (NOT Error) AddComp(Index,Value); + DiscardArgs(); +END + + static void DecodeRPC(Word Index) +BEGIN + LongWord Value; + + if (NOT SplitArgs(1)) return; + FirstPassUnknown=False; + Value=EvalIntExpression(ArgStr[1],UInt4,&Error); + if (FirstPassUnknown) Value&=7; + if (Value>9) Error=True; else Error=NOT Error; + if (NOT Error) AddComp(InstrRPC,Value); + DiscardArgs(); +END + + static void DecodeP2(Word Index) +BEGIN + if (NOT SplitArgs(0)) return; + AddComp(InstrP2,Index); + DiscardArgs(); +END + + static void DecodeP3(Word Index) +BEGIN + if (NOT SplitArgs(0)) return; + AddComp(InstrP3,Index); + DiscardArgs(); +END + + static void DecodeBM(Word Index) +BEGIN + /* Wenn EM-Feld schon da war, muss es EI gewesen sein */ + + if (NOT SplitArgs(0)) return; + if ((InstrMask&(1<<InstrEM))!=0) + BEGIN + Error=(InstrComps[InstrEM]==0); + if (Error) WrError(1355); + else AddComp(InstrBM,Index); + END + else AddComp(InstrBM,Index); + DiscardArgs(); +END + + static void DecodeEM(Word Index) +BEGIN + /* Wenn BM-Feld schon da war, muss es EI sein */ + + if (NOT SplitArgs(0)) return; + if ((InstrMask&(1<<InstrBM))!=0) + BEGIN + Error=(Index==0); + if (Error) WrError(1355); + else AddComp(InstrEM,Index); + END + else + BEGIN + AddComp(InstrEM,Index); + if (Index==0) InstrComps[InstrBM]=3; + END + DiscardArgs(); +END + + static void DecodeRW(Word Index) +BEGIN + if (NOT SplitArgs(0)) return; + AddComp(InstrRW,Index); + DiscardArgs(); +END + + static void DecodeWT(Word Index) +BEGIN + if (NOT SplitArgs(0)) return; + AddComp(InstrWT,Index); + DiscardArgs(); +END + + static void DecodeNF(Word Index) +BEGIN + if (NOT SplitArgs(0)) return; + AddComp(InstrNF,Index); + DiscardArgs(); +END + + static void DecodeWI(Word Index) +BEGIN + if (NOT SplitArgs(0)) return; + AddComp(InstrWI,Index); + DiscardArgs(); +END + + static void DecodeFIS(Word Index) +BEGIN + if (NOT SplitArgs(0)) return; + AddComp(InstrFIS,Index); + DiscardArgs(); +END + + static void DecodeFD(Word Index) +BEGIN + if (NOT SplitArgs(0)) return; + AddComp(InstrFD,Index); + DiscardArgs(); +END + + static void DecodeSHV(Word Index) +BEGIN + LongWord Value; + + if (NOT SplitArgs(1)) return; + FirstPassUnknown=False; + Value=EvalIntExpression(ArgStr[1],UInt6,&Error); + if (FirstPassUnknown) Value&=31; + if (Value>46) Error=True; else Error=NOT Error; + if (NOT Error) AddComp(InstrSHV,(Index<<6)+Value); + DiscardArgs(); +END + + static void DecodeRPS(Word Index) +BEGIN + LongWord Value; + + if (NOT SplitArgs(1)) return; + Value=EvalIntExpression(ArgStr[1],UInt9,&Error); + Error=NOT Error; + if (NOT Error) AddComp(InstrRPS,Value); + DiscardArgs(); +END + + static void DecodeNAL(Word Index) +BEGIN + LongWord Value; + + if (NOT SplitArgs(1)) return; + FirstPassUnknown=False; + Value=EvalIntExpression(ArgStr[1],UInt13,&Error); + if (FirstPassUnknown) Value=(Value&0x1ff)|(EProgCounter()&0x1e00); + Error=NOT Error; + if (NOT Error) + if ((NOT SymbolQuestionable) AND ((Value^EProgCounter())&0x1e00)) WrError(1910); + else AddComp(InstrNAL,Value&0x1ff); + DiscardArgs(); +END + + static Boolean DecodePseudo(void) +BEGIN + int z; + Boolean OK; + TempResult t; + LongWord temp; + LongInt sign,mant,expo,Size; + char *cp; + + if (Memo("DW")) + BEGIN + if (ArgCnt<1) WrError(1110); + else + BEGIN + z=1; OK=True; + while ((OK) AND (z<=ArgCnt)) + BEGIN + FirstPassUnknown=FALSE; + EvalExpression(ArgStr[z],&t); + switch(t.Typ) + BEGIN + case TempInt: + if (NOT RangeCheck(t.Contents.Int,Int32)) + BEGIN + WrError(1320); OK=False; break; + END + DAsmCode[CodeLen++]=t.Contents.Int; + break; + case TempFloat: + if (NOT FloatRangeCheck(t.Contents.Float,Float32)) + BEGIN + WrError(1320); OK=False; break; + END + Double_2_ieee4(t.Contents.Float,(Byte*) &temp,BigEndian); + sign=(temp>>31)&1; + expo=(temp>>23)&255; + mant=temp&0x7fffff; + if ((mant==0) AND (expo==0)) + DAsmCode[CodeLen++]=0x80000000; + else + BEGIN + if (expo>0) + BEGIN + mant|=0x800000; + expo-=127; + END + else expo-=126; + if (mant>=0x800000) + BEGIN + mant=mant>>1; expo+=1; + END + if (sign==1) mant=((mant^0xffffff)+1); + DAsmCode[CodeLen++]=((expo&0xff)<<24)|(mant&0xffffff); + END + break; + case TempString: + for (z=0,cp=t.Contents.Ascii; *cp!='\0'; cp++,z++) + BEGIN + DAsmCode[CodeLen]=(DAsmCode[CodeLen]<<8)+CharTransTable[((usint)*cp)&0xff]; + if ((z&3)==3) CodeLen++; + END + if ((z&3)!=0) DAsmCode[CodeLen++]=(DAsmCode[CodeLen])<<((4-(z&3))<<3); + break; + default: + OK=False; + END + z++; + END + if (NOT OK) CodeLen=0; + END + return True; + END + + if (Memo("DS")) + BEGIN + if (ArgCnt!=1) WrError(1110); + else + BEGIN + FirstPassUnknown=False; + Size=EvalIntExpression(ArgStr[1],Int16,&OK); + if (FirstPassUnknown) WrError(1820); + if ((OK) AND (NOT FirstPassUnknown)) + BEGIN + DontPrint=True; + CodeLen=Size; + BookKeeping(); + END + END + return True; + END + + return FALSE; +END + +/*---------------------------------------------------------------------------*/ +/* Codetabellenverwaltung */ + +static int InstrZ; + + static void AddJmp(char *NName, LongWord NCode) +BEGIN + if (InstrZ>=JmpOrderCnt) exit(255); + JmpOrders[InstrZ].Code=NCode; + AddInstTable(InstTable,NName,InstrZ++,DecodeJmp); +END + + static void AddALU1(char *NName, LongWord NCode) +BEGIN + if (InstrZ>=ALU1OrderCnt) exit(255); + ALU1Orders[InstrZ].Code=NCode; + AddInstTable(InstTable,NName,InstrZ++,DecodeALU1); +END + + static void AddALU2(char *NName, LongWord NCode) +BEGIN + if (InstrZ>=ALU2OrderCnt) exit(255); + ALU2Orders[InstrZ].Code=NCode; + AddInstTable(InstTable,NName,InstrZ++,DecodeALU2); +END + + static void AddSrcReg(char *NName, LongWord NCode) +BEGIN + if (InstrZ>=SrcRegCnt) exit(255); + SrcRegs[InstrZ].Name=NName; + SrcRegs[InstrZ++].Code=NCode; +END + + static void AddALUSrcReg(char *NName, LongWord NCode) +BEGIN + if (InstrZ>=ALUSrcRegCnt) exit(255); + ALUSrcRegs[InstrZ].Name=NName; + ALUSrcRegs[InstrZ++].Code=NCode; +END + + static void AddDestReg(char *NName, LongWord NCode) +BEGIN + if (InstrZ>=DestRegCnt) exit(255); + DestRegs[InstrZ].Name=NName; + DestRegs[InstrZ++].Code=NCode; +END + + static void InitFields(void) +BEGIN + InstTable=CreateInstTable(201); + + AddInstTable(InstTable,"MOV",0,DecodeMOV); + AddInstTable(InstTable,"LDI",0,DecodeLDI); + AddInstTable(InstTable,"NOP",0,DecodeNOP); + + AddInstTable(InstTable,"SPCBP0",1,DecodeM0); + AddInstTable(InstTable,"SPCIX0",2,DecodeM0); + AddInstTable(InstTable,"SPCBI0",3,DecodeM0); + + AddInstTable(InstTable,"SPCBP1",1,DecodeM1); + AddInstTable(InstTable,"SPCIX1",2,DecodeM1); + AddInstTable(InstTable,"SPCBI1",3,DecodeM1); + + AddInstTable(InstTable,"INCBP0",1,DecodeDP0); + AddInstTable(InstTable,"DECBP0",2,DecodeDP0); + AddInstTable(InstTable,"CLRBP0",3,DecodeDP0); + AddInstTable(InstTable,"STIX0" ,4,DecodeDP0); + AddInstTable(InstTable,"INCIX0",5,DecodeDP0); + AddInstTable(InstTable,"DECIX0",6,DecodeDP0); + AddInstTable(InstTable,"CLRIX0",7,DecodeDP0); + + AddInstTable(InstTable,"INCBP1",1,DecodeDP1); + AddInstTable(InstTable,"DECBP1",2,DecodeDP1); + AddInstTable(InstTable,"CLRBP1",3,DecodeDP1); + AddInstTable(InstTable,"STIX1" ,4,DecodeDP1); + AddInstTable(InstTable,"INCIX1",5,DecodeDP1); + AddInstTable(InstTable,"DECIX1",6,DecodeDP1); + AddInstTable(InstTable,"CLRIX1",7,DecodeDP1); + + AddInstTable(InstTable,"INCAR" ,1,DecodeEA); + AddInstTable(InstTable,"DECAR" ,2,DecodeEA); + + AddInstTable(InstTable,"XCHPSW",1,DecodeFC); + + AddInstTable(InstTable,"INCRP" ,1,DecodeRP); + AddInstTable(InstTable,"DECRP" ,2,DecodeRP); + AddInstTable(InstTable,"INCBRP",3,DecodeRP); + + AddInstTable(InstTable,"DECLC" ,1,DecodeL); + + AddInstTable(InstTable,"MCNBP0",InstrBASE0,DecodeBASE); + AddInstTable(InstTable,"MCNBP1",InstrBASE1,DecodeBASE); + + AddInstTable(InstTable,"BITRP" ,0,DecodeRPC); + + AddInstTable(InstTable,"CLRP2" ,0,DecodeP2); + AddInstTable(InstTable,"SETP2" ,1,DecodeP2); + + AddInstTable(InstTable,"CLRP3" ,0,DecodeP3); + AddInstTable(InstTable,"SETP3" ,1,DecodeP3); + + AddInstTable(InstTable,"DI" ,0,DecodeEM); + AddInstTable(InstTable,"EI" ,1,DecodeEM); + AddInstTable(InstTable,"CLRBM" ,1,DecodeBM); + AddInstTable(InstTable,"SETBM" ,2,DecodeBM); + + AddInstTable(InstTable,"RD" ,1,DecodeRW); + AddInstTable(InstTable,"WR" ,2,DecodeRW); + + AddInstTable(InstTable,"WRBORD",1,DecodeWT); + AddInstTable(InstTable,"WRBL24",2,DecodeWT); + AddInstTable(InstTable,"WRBL23",3,DecodeWT); + AddInstTable(InstTable,"WRBEL8",4,DecodeWT); + AddInstTable(InstTable,"WRBL8E",5,DecodeWT); + AddInstTable(InstTable,"WRBXCH",6,DecodeWT); + AddInstTable(InstTable,"WRBBRV",7,DecodeWT); + + AddInstTable(InstTable,"TRNORM",2,DecodeNF); + AddInstTable(InstTable,"RDNORM",4,DecodeNF); + AddInstTable(InstTable,"FLTFIX",6,DecodeNF); + AddInstTable(InstTable,"FIXMA" ,7,DecodeNF); + + AddInstTable(InstTable,"BWRL24",1,DecodeWI); + AddInstTable(InstTable,"BWRORD",2,DecodeWI); + + AddInstTable(InstTable,"SPCPSW0",1,DecodeFIS); + AddInstTable(InstTable,"SPCPSW1",2,DecodeFIS); + AddInstTable(InstTable,"CLRPSW0",4,DecodeFIS); + AddInstTable(InstTable,"CLRPSW1",5,DecodeFIS); + AddInstTable(InstTable,"CLRPSW" ,6,DecodeFIS); + + AddInstTable(InstTable,"SPIE",1,DecodeFD); + AddInstTable(InstTable,"IESP",2,DecodeFD); + + AddInstTable(InstTable,"SETSVL",0,DecodeSHV); + AddInstTable(InstTable,"SETSVR",1,DecodeSHV); + + AddInstTable(InstTable,"SPCRA",0,DecodeRPS); + AddInstTable(InstTable,"JBLK" ,0,DecodeNAL); + + JmpOrders=(FixedOrder*) malloc(sizeof(FixedOrder)*JmpOrderCnt); InstrZ=0; + AddJmp("JMP" ,0x00); AddJmp("CALL" ,0x01); AddJmp("RET" ,0x02); + AddJmp("JNZRP" ,0x03); AddJmp("JZ0" ,0x04); AddJmp("JNZ0" ,0x05); + AddJmp("JZ1" ,0x06); AddJmp("JNZ1" ,0x07); AddJmp("JC0" ,0x08); + AddJmp("JNC0" ,0x09); AddJmp("JC1" ,0x0a); AddJmp("JNC1" ,0x0b); + AddJmp("JS0" ,0x0c); AddJmp("JNS0" ,0x0d); AddJmp("JS1" ,0x0e); + AddJmp("JNS1" ,0x0f); AddJmp("JV0" ,0x10); AddJmp("JNV0" ,0x11); + AddJmp("JV1" ,0x12); AddJmp("JNV1" ,0x13); AddJmp("JEV0" ,0x14); + AddJmp("JEV1" ,0x15); AddJmp("JNFSI" ,0x16); AddJmp("JNESO" ,0x17); + AddJmp("JIP0" ,0x18); AddJmp("JIP1" ,0x19); AddJmp("JNZIX0",0x1a); + AddJmp("JNZIX1",0x1b); AddJmp("JNZBP0",0x1c); AddJmp("JNZBP1",0x1d); + AddJmp("JRDY" ,0x1e); AddJmp("JRQM" ,0x1f); + + ALU1Orders=(FixedOrder*) malloc(sizeof(FixedOrder)*ALU1OrderCnt); InstrZ=0; + AddALU1("INC" ,0x01); AddALU1("DEC" ,0x02); AddALU1("ABS" ,0x03); + AddALU1("NOT" ,0x04); AddALU1("NEG" ,0x05); AddALU1("SHLC" ,0x06); + AddALU1("SHRC" ,0x07); AddALU1("ROL" ,0x08); AddALU1("ROR" ,0x09); + AddALU1("SHLM" ,0x0a); AddALU1("SHRM" ,0x0b); AddALU1("SHRAM",0x0c); + AddALU1("CLR" ,0x0d); AddALU1("NORM" ,0x0e); AddALU1("CVT" ,0x0f); + + ALU2Orders=(FixedOrder*) malloc(sizeof(FixedOrder)*ALU2OrderCnt); InstrZ=0; + AddALU2("ADD" ,0x10); AddALU2("SUB" ,0x11); AddALU2("ADDC" ,0x12); + AddALU2("SUBC" ,0x13); AddALU2("CMP" ,0x14); AddALU2("AND" ,0x15); + AddALU2("OR" ,0x16); AddALU2("XOR" ,0x17); AddALU2("ADDF" ,0x18); + AddALU2("SUBF" ,0x19); + + SrcRegs=(Register*) malloc(sizeof(Register)*SrcRegCnt); InstrZ=0; + AddSrcReg("NON" ,0x00); AddSrcReg("RP" ,0x01); AddSrcReg("PSW0" ,0x02); + AddSrcReg("PSW1",0x03); AddSrcReg("SVR" ,0x04); AddSrcReg("SR" ,0x05); + AddSrcReg("LC" ,0x06); AddSrcReg("STX" ,0x07); AddSrcReg("M" ,0x08); + AddSrcReg("ML" ,0x09); AddSrcReg("ROM" ,0x0a); AddSrcReg("TR" ,0x0b); + AddSrcReg("AR" ,0x0c); AddSrcReg("SI" ,0x0d); AddSrcReg("DR" ,0x0e); + AddSrcReg("DRS" ,0x0f); AddSrcReg("WR0" ,0x10); AddSrcReg("WR1" ,0x11); + AddSrcReg("WR2" ,0x12); AddSrcReg("WR3" ,0x13); AddSrcReg("WR4" ,0x14); + AddSrcReg("WR5" ,0x15); AddSrcReg("WR6" ,0x16); AddSrcReg("WR7" ,0x17); + AddSrcReg("RAM0",0x18); AddSrcReg("RAM1",0x19); AddSrcReg("BP0" ,0x1a); + AddSrcReg("BP1" ,0x1b); AddSrcReg("IX0" ,0x1c); AddSrcReg("IX1" ,0x1d); + AddSrcReg("K" ,0x1e); AddSrcReg("L" ,0x1f); + + ALUSrcRegs=(Register*) malloc(sizeof(Register)*ALUSrcRegCnt); InstrZ=0; + AddALUSrcReg("IB" ,0x00); AddALUSrcReg("M" ,0x01); + AddALUSrcReg("RAM0",0x02); AddALUSrcReg("RAM1",0x03); + + DestRegs=(Register*) malloc(sizeof(Register)*DestRegCnt); InstrZ=0; + AddDestReg("NON" ,0x00); AddDestReg("RP" ,0x01); AddDestReg("PSW0" ,0x02); + AddDestReg("PSW1",0x03); AddDestReg("SVR" ,0x04); AddDestReg("SR" ,0x05); + AddDestReg("LC" ,0x06); AddDestReg("STK" ,0x07); AddDestReg("LKR0" ,0x08); + AddDestReg("KLR1",0x09); AddDestReg("TRE" ,0x0a); AddDestReg("TR" ,0x0b); + AddDestReg("AR" ,0x0c); AddDestReg("SO" ,0x0d); AddDestReg("DR" ,0x0e); + AddDestReg("DRS" ,0x0f); AddDestReg("WR0" ,0x10); AddDestReg("WR1" ,0x11); + AddDestReg("WR2" ,0x12); AddDestReg("WR3" ,0x13); AddDestReg("WR4" ,0x14); + AddDestReg("WR5" ,0x15); AddDestReg("WR6" ,0x16); AddDestReg("WR7" ,0x17); + AddDestReg("RAM0",0x18); AddDestReg("RAM1",0x19); AddDestReg("BP0" ,0x1a); + AddDestReg("BP1" ,0x1b); AddDestReg("IX0" ,0x1c); AddDestReg("IX1" ,0x1d); + AddDestReg("K" ,0x1e); AddDestReg("L" ,0x1f); + + InstrComps=(LongWord*) malloc(sizeof(LongWord)*InstrCnt); + InstrDefs=(LongWord*) malloc(sizeof(LongWord)*InstrCnt); + for (InstrZ=0; InstrZ<InstrCnt; InstrDefs[InstrZ++]=0xffffffff); + InstrDefs[InstrALU]=0; + InstrDefs[InstrMove]=0; + InstrDefs[InstrBM]=0; + InstrDefs[InstrEM]=0; + InstrDefs[InstrDP0]=0; + InstrDefs[InstrDP1]=0; + InstrDefs[InstrEA]=0; + InstrDefs[InstrFC]=0; + InstrDefs[InstrFD]=0; + InstrDefs[InstrFIS]=0; + InstrDefs[InstrL]=0; + InstrDefs[InstrM0]=0; + InstrDefs[InstrM1]=0; + InstrDefs[InstrNF]=0; + InstrDefs[InstrRP]=0; + InstrDefs[InstrRW]=0; + InstrDefs[InstrWI]=0; + InstrDefs[InstrWT]=0; +END + + static void DeinitFields(void) +BEGIN + DestroyInstTable(InstTable); + + free(SrcRegs); free(ALUSrcRegs); free(DestRegs); + + free(JmpOrders); free(ALU1Orders); free(ALU2Orders); + + free(InstrComps); free(InstrDefs); +END + +/*---------------------------------------------------------------------------*/ +/* Callbacks */ + + static void MakeCode_77230(void) +BEGIN + int z,z2; + LongWord Diff; + + /* Nullanweisung */ + + if ((Memo("")) AND (*AttrPart=='\0') AND (ArgCnt==0)) return; + + /* Pseudoanweisungen */ + + if (DecodePseudo()) return; + + /* solange dekodieren, bis keine Operanden mehr da oder Fehler */ + + Error=False; InstrMask=0; + memset(InstrComps,0,sizeof(LongWord)*InstrCnt); + do + BEGIN + if (NOT LookupInstTable(InstTable,OpPart)) + BEGIN + WrXError(1200,OpPart); Error=True; + END + END + while ((NOT Error) AND (*OpPart!='\0')); + + /* passende Verknuepfung suchen */ + + if (NOT Error) + BEGIN + for (z=0; z<CaseCnt; z++) + BEGIN + /* Bits ermitteln, die nur in einer Maske vorhanden sind */ + + Diff=InstrMask^CaseMasks[z]; + + /* Fall nur möglich, wenn Bits im aktuellen Fall gesetzt sind, die + der Fall nicht hat */ + + if ((Diff&InstrMask)==0) + BEGIN + /* ist irgendein Feld unbenutzt, fuer das wir keinen Default haben? */ + + for (z2=0; z2<InstrCnt; z2++) + if (((Diff&(1l<<z2))!=0) AND (InstrDefs[z2]==-1)) break; + if (z2==InstrCnt) break; + END + END + + switch (z) + BEGIN + case 0: /* nur LDI */ + DAsmCode[0]=0xe0000000+InstrComps[InstrLDI]; + CodeLen=1; + break; + case 1: /* JMP+MOV */ + DAsmCode[0]=0xd0000000+(InstrComps[InstrBranch]<<10) + +InstrComps[InstrMove]; + CodeLen=1; + break; + case 2: /* ALU+MOV+M0+M1+DP0+DP1 */ + DAsmCode[0]=(InstrComps[InstrALU]<<10)+InstrComps[InstrMove] + +(InstrComps[InstrDP1]<<15)+(InstrComps[InstrDP0]<<18) + +(InstrComps[InstrM1]<<21)+(InstrComps[InstrM0]<<23); + CodeLen=1; + break; + case 3: /* ALU+MOV+EA+DP0+DP1 */ + DAsmCode[0]=(InstrComps[InstrALU]<<10)+InstrComps[InstrMove] + +(InstrComps[InstrDP1]<<15)+(InstrComps[InstrDP0]<<18) + +(InstrComps[InstrEA]<<21)+0x02000000; + CodeLen=1; + break; + case 4: /* ALU+MOV+RP+M0+DP0+FC */ + DAsmCode[0]=(InstrComps[InstrALU]<<10)+InstrComps[InstrMove] + +(InstrComps[InstrRP]<<21)+(InstrComps[InstrFC]<<15) + +(InstrComps[InstrM0]<<19)+(InstrComps[InstrDP0]<<16) + +0x02800000; + CodeLen=1; + break; + case 5: /* ALU+MOV+RP+M1+DP1+FC */ + DAsmCode[0]=(InstrComps[InstrALU]<<10)+InstrComps[InstrMove] + +(InstrComps[InstrRP]<<21)+(InstrComps[InstrFC]<<15) + +(InstrComps[InstrM1]<<19)+(InstrComps[InstrDP1]<<16) + +0x03000000; + CodeLen=1; + break; + case 6: /* ALU+MOV+RP+M0+M1+L+FC */ + DAsmCode[0]=(InstrComps[InstrALU]<<10)+InstrComps[InstrMove] + +(InstrComps[InstrRP]<<21)+(InstrComps[InstrL]<<16) + +(InstrComps[InstrM0]<<19)+(InstrComps[InstrM1]<<17) + +(InstrComps[InstrFC]<<15)+0x03800000; + CodeLen=1; + break; + case 7: /* ALU+MOV+BASE0+BASE1+FC */ + DAsmCode[0]=(InstrComps[InstrALU]<<10)+InstrComps[InstrMove] + +(InstrComps[InstrBASE0]<<19)+(InstrComps[InstrBASE1]<<16) + +(InstrComps[InstrFC]<<15)+0x04000000; + CodeLen=1; + break; + case 8: /* ALU+MOV+RPC+L+FC */ + DAsmCode[0]=(InstrComps[InstrALU]<<10)+InstrComps[InstrMove] + +(InstrComps[InstrRPC]<<18)+(InstrComps[InstrL]<<16) + +(InstrComps[InstrFC]<<15)+0x04400000; + CodeLen=1; + break; + case 9: /* ALU+MOV+P2+P3+EM+BM+L+FC */ + DAsmCode[0]=(InstrComps[InstrALU]<<10)+InstrComps[InstrMove] + +(InstrComps[InstrP2]<<20)+(InstrComps[InstrP3]<<21) + +(InstrComps[InstrEM]<<19)+(InstrComps[InstrBM]<<17) + +(InstrComps[InstrL]<<16)+(InstrComps[InstrFC]<<15) + +0x04800000; + CodeLen=1; + break; + case 10: /* ALU+MOV+RW+L+FC */ + DAsmCode[0]=(InstrComps[InstrALU]<<10)+InstrComps[InstrMove] + +(InstrComps[InstrRW]<<20)+(InstrComps[InstrL]<<16) + +(InstrComps[InstrFC]<<15)+0x04c00000; + CodeLen=1; + break; + case 11: /* ALU+MOV+WT+L+FC */ + DAsmCode[0]=(InstrComps[InstrALU]<<10)+InstrComps[InstrMove] + +(InstrComps[InstrWT]<<19)+(InstrComps[InstrL]<<16) + +(InstrComps[InstrFC]<<15)+0x05000000; + CodeLen=1; + break; + case 12: /* ALU+MOV+NF+WI+L+FC */ + DAsmCode[0]=(InstrComps[InstrALU]<<10)+InstrComps[InstrMove] + +(InstrComps[InstrNF]<<19)+(InstrComps[InstrWI]<<17) + +(InstrComps[InstrL]<<16)+(InstrComps[InstrFC]<<15) + +0x05400000; + CodeLen=1; + break; + case 13: /* ALU+MOV+FIS+FD+L */ + DAsmCode[0]=(InstrComps[InstrALU]<<10)+InstrComps[InstrMove] + +(InstrComps[InstrFIS]<<19)+(InstrComps[InstrFD]<<17) + +(InstrComps[InstrL]<<16)+0x05800000; + CodeLen=1; + break; + case 14: /* ALU+MOV+SHV */ + DAsmCode[0]=(InstrComps[InstrALU]<<10)+InstrComps[InstrMove] + +(InstrComps[InstrSHV]<<15)+0x05c00000; + CodeLen=1; + break; + case 15: /* ALU+MOV+RPS */ + DAsmCode[0]=(InstrComps[InstrALU]<<10)+InstrComps[InstrMove] + +(InstrComps[InstrRPS]<<15)+0x06000000; + CodeLen=1; + break; + case 16: /* ALU+MOV+NAL */ + DAsmCode[0]=(InstrComps[InstrALU]<<10)+InstrComps[InstrMove] + +(InstrComps[InstrNAL]<<15)+0x07000000; + CodeLen=1; + break; + default: + WrError(1355); + END + END +END + + static Boolean IsDef_77230(void) +BEGIN + return False; +END + + static void SwitchFrom_77230(void) +BEGIN + DeinitFields(); +END + + static void SwitchTo_77230(void) +BEGIN + PFamilyDescr FoundDescr; + + FoundDescr=FindFamilyByName("77230"); + + TurnWords=False; ConstMode=ConstModeIntel; SetIsOccupied=False; + PCSymbol="$"; HeaderID=FoundDescr->Id; NOPCode=0x00000000; + DivideChars=","; HasAttrs=False; + + ValidSegs=(1<<SegCode)|(1<<SegXData)|(1<<SegYData)|(1<<SegRData); + Grans[SegCode ]=4; ListGrans[SegCode ]=4; SegInits[SegCode ]=0; + SegLimits[SegCode ] = 0x1fff; + Grans[SegXData]=4; ListGrans[SegXData]=4; SegInits[SegXData]=0; + SegLimits[SegXData] = 0x1ff; + Grans[SegYData]=4; ListGrans[SegYData]=4; SegInits[SegYData]=0; + SegLimits[SegYData] = 0x1ff; + Grans[SegRData]=4; ListGrans[SegRData]=4; SegInits[SegRData]=0; + SegLimits[SegRData] = 0x3ff; + + MakeCode=MakeCode_77230; IsDef=IsDef_77230; + SwitchFrom=SwitchFrom_77230; + + InitFields(); +END + +/*---------------------------------------------------------------------------*/ +/* Initialisierung */ + + void code77230_init(void) +BEGIN + CPU77230=AddCPU("77230",SwitchTo_77230); +END |