diff options
Diffstat (limited to 'code6816.c')
| -rw-r--r-- | code6816.c | 1073 |
1 files changed, 1073 insertions, 0 deletions
diff --git a/code6816.c b/code6816.c new file mode 100644 index 0000000..6fbc5e4 --- /dev/null +++ b/code6816.c @@ -0,0 +1,1073 @@ +/* code6816.c */ +/*****************************************************************************/ +/* AS-Portierung */ +/* */ +/* Codegeneratormodul CPU16 */ +/* */ +/* Historie: 15.10.1996 Grundsteinlegung */ +/* 2. 1.1999 ChkPC-Anpassung */ +/* */ +/*****************************************************************************/ + +#include "stdinc.h" + +#include <string.h> + +#include "nls.h" +#include "bpemu.h" +#include "strutil.h" +#include "asmdef.h" +#include "asmsub.h" +#include "asmpars.h" +#include "codepseudo.h" +#include "codevars.h" + +/*---------------------------------------------------------------------------*/ + +typedef struct + { + char *Name; + Word Code; + } FixedOrder; + +typedef struct + { + char *Name; + ShortInt Size; + Word Code,ExtCode; + Byte AdrMask,ExtShift; + } GenOrder; + +typedef struct + { + char *Name; + Word Code1,Code2; + } EmuOrder; + +#define FixedOrderCnt 140 +#define RelOrderCnt 18 +#define LRelOrderCnt 3 +#define GenOrderCnt 66 +#define AuxOrderCnt 12 +#define ImmOrderCnt 4 +#define ExtOrderCnt 3 +#define EmuOrderCnt 6 +#define RegCnt 7 + +#define ModNone (-1) +#define ModDisp8 0 +#define MModDisp8 (1 << ModDisp8) +#define ModDisp16 1 +#define MModDisp16 (1 << ModDisp16) +#define ModDispE 2 +#define MModDispE (1 << ModDispE) +#define ModAbs 3 +#define MModAbs (1 << ModAbs) +#define ModImm 4 +#define MModImm (1 << ModImm) +#define ModImmExt 5 +#define MModImmExt (1 << ModImmExt) +#define ModDisp20 ModDisp16 +#define MModDisp20 MModDisp16 +#define ModAbs20 ModAbs +#define MModAbs20 MModAbs + +static ShortInt OpSize; +static ShortInt AdrMode; +static Byte AdrPart; +static Byte AdrVals[4]; + +static LongInt Reg_EK; +static SimpProc SaveInitProc; + +static FixedOrder *FixedOrders; +static FixedOrder *RelOrders; +static FixedOrder *LRelOrders; +static GenOrder *GenOrders; +static FixedOrder *AuxOrders; +static FixedOrder *ImmOrders; +static FixedOrder *ExtOrders; +static EmuOrder *EmuOrders; +static char **Regs; + +static CPUVar CPU6816; + +/*-------------------------------------------------------------------------*/ + + static void AddFixed(char *NName, Word NCode) +BEGIN + if (InstrZ>=FixedOrderCnt) exit(255); + FixedOrders[InstrZ].Name=NName; + FixedOrders[InstrZ++].Code=NCode; +END + + static void AddRel(char *NName, Word NCode) +BEGIN + if (InstrZ>=RelOrderCnt) exit(255); + RelOrders[InstrZ].Name=NName; + RelOrders[InstrZ++].Code=NCode; +END + + static void AddLRel(char *NName, Word NCode) +BEGIN + if (InstrZ>=LRelOrderCnt) exit(255); + LRelOrders[InstrZ].Name=NName; + LRelOrders[InstrZ++].Code=NCode; +END + + static void AddGen(char *NName, ShortInt NSize, Word NCode, + Word NExtCode, Byte NShift, Byte NMask) +BEGIN + if (InstrZ>=GenOrderCnt) exit(255); + GenOrders[InstrZ].Name=NName; + GenOrders[InstrZ].Code=NCode; + GenOrders[InstrZ].ExtCode=NExtCode; + GenOrders[InstrZ].Size=NSize; + GenOrders[InstrZ].AdrMask=NMask; + GenOrders[InstrZ++].ExtShift=NShift; +END + + static void AddAux(char *NName, Word NCode) +BEGIN + if (InstrZ>=AuxOrderCnt) exit(255); + AuxOrders[InstrZ].Name=NName; + AuxOrders[InstrZ++].Code=NCode; +END + + static void AddImm(char *NName, Word NCode) +BEGIN + if (InstrZ>=ImmOrderCnt) exit(255); + ImmOrders[InstrZ].Name=NName; + ImmOrders[InstrZ++].Code=NCode; +END + + static void AddExt(char *NName, Word NCode) +BEGIN + if (InstrZ>=ExtOrderCnt) exit(255); + ExtOrders[InstrZ].Name=NName; + ExtOrders[InstrZ++].Code=NCode; +END + + static void AddEmu(char *NName, Word NCode1, Word NCode2) +BEGIN + if (InstrZ>=EmuOrderCnt) exit(255); + EmuOrders[InstrZ].Name=NName; + EmuOrders[InstrZ].Code1=NCode1; + EmuOrders[InstrZ++].Code2=NCode2; +END + + static void InitFields(void) +BEGIN + FixedOrders=(FixedOrder *) malloc(sizeof(FixedOrder)*FixedOrderCnt); InstrZ=0; + AddFixed("ABA" ,0x370b); AddFixed("ABX" ,0x374f); + AddFixed("ABY" ,0x375f); AddFixed("ABZ" ,0x376f); + AddFixed("ACE" ,0x3722); AddFixed("ACED" ,0x3723); + AddFixed("ADE" ,0x2778); AddFixed("ADX" ,0x37cd); + AddFixed("ADY" ,0x37dd); AddFixed("ADZ" ,0x37ed); + AddFixed("AEX" ,0x374d); AddFixed("AEY" ,0x375d); + AddFixed("AEZ" ,0x376d); AddFixed("ASLA" ,0x3704); + AddFixed("ASLB" ,0x3714); AddFixed("ASLD" ,0x27f4); + AddFixed("ASLE" ,0x2774); AddFixed("ASLM" ,0x27b6); + AddFixed("LSLB" ,0x3714); AddFixed("LSLD" ,0x27f4); + AddFixed("LSLE" ,0x2774); AddFixed("LSLA" ,0x3704); + AddFixed("ASRA" ,0x370d); AddFixed("ASRB" ,0x371d); + AddFixed("ASRD" ,0x27fd); AddFixed("ASRE" ,0x277d); + AddFixed("ASRM" ,0x27ba); AddFixed("BGND" ,0x37a6); + AddFixed("CBA" ,0x371b); AddFixed("CLRA" ,0x3705); + AddFixed("CLRB" ,0x3715); AddFixed("CLRD" ,0x27f5); + AddFixed("CLRE" ,0x2775); AddFixed("CLRM" ,0x27b7); + AddFixed("COMA" ,0x3700); AddFixed("COMB" ,0x3710); + AddFixed("COMD" ,0x27f0); AddFixed("COME" ,0x2770); + AddFixed("DAA" ,0x3721); AddFixed("DECA" ,0x3701); + AddFixed("DECB" ,0x3711); AddFixed("EDIV" ,0x3728); + AddFixed("EDIVS" ,0x3729); AddFixed("EMUL" ,0x3725); + AddFixed("EMULS" ,0x3726); AddFixed("FDIV" ,0x372b); + AddFixed("FMULS" ,0x3727); AddFixed("IDIV" ,0x372a); + AddFixed("INCA" ,0x3703); AddFixed("INCB" ,0x3713); + AddFixed("LPSTOP",0x27f1); AddFixed("LSRA" ,0x370f); + AddFixed("LSRB" ,0x371f); AddFixed("LSRD" ,0x27ff); + AddFixed("LSRE" ,0x277f); AddFixed("MUL" ,0x3724); + AddFixed("NEGA" ,0x3702); AddFixed("NEGB" ,0x3712); + AddFixed("NEGD" ,0x27f2); AddFixed("NEGE" ,0x2772); + AddFixed("NOP" ,0x274c); AddFixed("PSHA" ,0x3708); + AddFixed("PSHB" ,0x3718); AddFixed("PSHMAC",0x27b8); + AddFixed("PULA" ,0x3709); AddFixed("PULB" ,0x3719); + AddFixed("PULMAC",0x27b9); AddFixed("ROLA" ,0x370c); + AddFixed("ROLB" ,0x371c); AddFixed("ROLD" ,0x27fc); + AddFixed("ROLE" ,0x277c); AddFixed("RORA" ,0x370e); + AddFixed("RORB" ,0x371e); AddFixed("RORD" ,0x27fe); + AddFixed("RORE" ,0x277e); AddFixed("RTI" ,0x2777); + AddFixed("RTS" ,0x27f7); AddFixed("SBA" ,0x370a); + AddFixed("SDE" ,0x2779); AddFixed("SWI" ,0x3720); + AddFixed("SXT" ,0x27f8); AddFixed("TAB" ,0x3717); + AddFixed("TAP" ,0x37fd); AddFixed("TBA" ,0x3707); + AddFixed("TBEK" ,0x27fa); AddFixed("TBSK" ,0x379f); + AddFixed("TBXK" ,0x379c); AddFixed("TBYK" ,0x379d); + AddFixed("TBZK" ,0x379e); AddFixed("TDE" ,0x277b); + AddFixed("TDMSK" ,0x372f); AddFixed("TDP" ,0x372d); + AddFixed("TED" ,0x27fb); AddFixed("TEDM" ,0x27b1); + AddFixed("TEKB" ,0x27bb); AddFixed("TEM" ,0x27b2); + AddFixed("TMER" ,0x27b4); AddFixed("TMET" ,0x27b5); + AddFixed("TMXED" ,0x27b3); AddFixed("TPA" ,0x37fc); + AddFixed("TPD" ,0x372c); AddFixed("TSKB" ,0x37af); + AddFixed("TSTA" ,0x3706); AddFixed("TSTB" ,0x3716); + AddFixed("TSTD" ,0x27f6); AddFixed("TSTE" ,0x2776); + AddFixed("TSX" ,0x274f); AddFixed("TSY" ,0x275f); + AddFixed("TSZ" ,0x276f); AddFixed("TXKB" ,0x37ac); + AddFixed("TXS" ,0x374e); AddFixed("TXY" ,0x275c); + AddFixed("TXZ" ,0x276c); AddFixed("TYKB" ,0x37ad); + AddFixed("TYS" ,0x375e); AddFixed("TYX" ,0x274d); + AddFixed("TYZ" ,0x276d); AddFixed("TZKB" ,0x37ae); + AddFixed("TZS" ,0x376e); AddFixed("TZX" ,0x274e); + AddFixed("TZY" ,0x275e); AddFixed("WAI" ,0x27f3); + AddFixed("XGAB" ,0x371a); AddFixed("XGDE" ,0x277a); + AddFixed("XGDX" ,0x37cc); AddFixed("XGDY" ,0x37dc); + AddFixed("XGDZ" ,0x37ec); AddFixed("XGEX" ,0x374c); + AddFixed("XGEY" ,0x375c); AddFixed("XGEZ" ,0x376c); + AddFixed("DES" ,0x3fff); AddFixed("INS" ,0x3f01); + AddFixed("DEX" ,0x3cff); AddFixed("INX" ,0x3c01); + AddFixed("DEY" ,0x3dff); AddFixed("INY" ,0x3d01); + AddFixed("PSHX" ,0x3404); AddFixed("PULX" ,0x3510); + AddFixed("PSHY" ,0x3408); AddFixed("PULY" ,0x3508); + + RelOrders=(FixedOrder *) malloc(sizeof(FixedOrder)*RelOrderCnt); InstrZ=0; + AddRel("BCC", 4); AddRel("BCS", 5); AddRel("BEQ", 7); + AddRel("BGE",12); AddRel("BGT",14); AddRel("BHI", 2); + AddRel("BLE",15); AddRel("BLS", 3); AddRel("BLT",13); + AddRel("BMI",11); AddRel("BNE", 6); AddRel("BPL",10); + AddRel("BRA", 0); AddRel("BRN", 1); AddRel("BVC", 8); + AddRel("BVS", 9); AddRel("BHS", 4); AddRel("BLO", 5); + + LRelOrders=(FixedOrder *) malloc(sizeof(FixedOrder)*LRelOrderCnt); InstrZ=0; + AddLRel("LBEV",0x3791); AddLRel("LBMV",0x3790); AddLRel("LBSR",0x27f9); + + GenOrders=(GenOrder *) malloc(sizeof(GenOrder)*GenOrderCnt); InstrZ=0; + AddGen("ADCA",0,0x43,0xffff,0x00,MModDisp8+MModImm+ MModDisp16+MModAbs+MModDispE); + AddGen("ADCB",0,0xc3,0xffff,0x00,MModDisp8+MModImm+ MModDisp16+MModAbs+MModDispE); + AddGen("ADCD",1,0x83,0xffff,0x20,MModDisp8+MModImm+ MModDisp16+MModAbs+MModDispE); + AddGen("ADCE",1,0x03,0xffff,0x20, MModImm+ MModDisp16+MModAbs ); + AddGen("ADDA",0,0x41,0xffff,0x00,MModDisp8+MModImm+ MModDisp16+MModAbs+MModDispE); + AddGen("ADDB",0,0xc1,0xffff,0x00,MModDisp8+MModImm+ MModDisp16+MModAbs+MModDispE); + AddGen("ADDD",1,0x81, 0xfc,0x20,MModDisp8+MModImm+MModImmExt+MModDisp16+MModAbs+MModDispE); + AddGen("ADDE",1,0x01, 0x7c,0x20, MModImm+MModImmExt+MModDisp16+MModAbs ); + AddGen("ANDA",0,0x46,0xffff,0x00,MModDisp8+MModImm+ MModDisp16+MModAbs+MModDispE); + AddGen("ANDB",0,0xc6,0xffff,0x00,MModDisp8+MModImm+ MModDisp16+MModAbs+MModDispE); + AddGen("ANDD",1,0x86,0xffff,0x20,MModDisp8+MModImm+ MModDisp16+MModAbs+MModDispE); + AddGen("ANDE",1,0x06,0xffff,0x20, MModImm+ MModDisp16+MModAbs ); + AddGen("ASL" ,0,0x04,0xffff,0x00,MModDisp8+ MModDisp16+MModAbs ); + AddGen("ASLW",0,0x04,0xffff,0x10, MModDisp16+MModAbs ); + AddGen("LSL" ,0,0x04,0xffff,0x00,MModDisp8+ MModDisp16+MModAbs ); + AddGen("LSLW",0,0x04,0xffff,0x10, MModDisp16+MModAbs ); + AddGen("ASR" ,0,0x0d,0xffff,0x00,MModDisp8+ MModDisp16+MModAbs ); + AddGen("ASRW",0,0x0d,0xffff,0x10, MModDisp16+MModAbs ); + AddGen("BITA",0,0x49,0xffff,0x00,MModDisp8+MModImm+ MModDisp16+MModAbs+MModDispE); + AddGen("BITB",0,0xc9,0xffff,0x00,MModDisp8+MModImm+ MModDisp16+MModAbs+MModDispE); + AddGen("CLR" ,0,0x05,0xffff,0x00,MModDisp8+ MModDisp16+MModAbs ); + AddGen("CLRW",0,0x05,0xffff,0x10, MModDisp16+MModAbs ); + AddGen("CMPA",0,0x48,0xffff,0x00,MModDisp8+MModImm+ MModDisp16+MModAbs+MModDispE); + AddGen("CMPB",0,0xc8,0xffff,0x00,MModDisp8+MModImm+ MModDisp16+MModAbs+MModDispE); + AddGen("COM" ,0,0x00,0xffff,0x00,MModDisp8+ MModDisp16+MModAbs ); + AddGen("COMW",0,0x00,0xffff,0x10, MModDisp16+MModAbs ); + AddGen("CPD" ,1,0x88,0xffff,0x20,MModDisp8+MModImm+ MModDisp16+MModAbs+MModDispE); + AddGen("CPE" ,1,0x08,0xffff,0x20, MModImm+ MModDisp16+MModAbs ); + AddGen("DEC" ,0,0x01,0xffff,0x00,MModDisp8+ MModDisp16+MModAbs ); + AddGen("DECW",0,0x01,0xffff,0x10, MModDisp16+MModAbs ); + AddGen("EORA",0,0x44,0xffff,0x00,MModDisp8+MModImm+ MModDisp16+MModAbs+MModDispE); + AddGen("EORB",0,0xc4,0xffff,0x00,MModDisp8+MModImm+ MModDisp16+MModAbs+MModDispE); + AddGen("EORD",1,0x84,0xffff,0x20,MModDisp8+MModImm+ MModDisp16+MModAbs+MModDispE); + AddGen("EORE",1,0x04,0xffff,0x20, MModImm+ MModDisp16+MModAbs ); + AddGen("INC" ,0,0x03,0xffff,0x00,MModDisp8+ MModDisp16+MModAbs ); + AddGen("INCW",0,0x03,0xffff,0x10, MModDisp16+MModAbs ); + AddGen("LDAA",0,0x45,0xffff,0x00,MModDisp8+MModImm+ MModDisp16+MModAbs+MModDispE); + AddGen("LDAB",0,0xc5,0xffff,0x00,MModDisp8+MModImm+ MModDisp16+MModAbs+MModDispE); + AddGen("LDD" ,1,0x85,0xffff,0x20,MModDisp8+MModImm+ MModDisp16+MModAbs+MModDispE); + AddGen("LDE" ,1,0x05,0xffff,0x20, MModImm+ MModDisp16+MModAbs ); + AddGen("LSR" ,0,0x0f,0xffff,0x00,MModDisp8+ MModDisp16+MModAbs ); + AddGen("LSRW",0,0x0f,0xffff,0x10, MModDisp16+MModAbs ); + AddGen("NEG" ,0,0x02,0xffff,0x00,MModDisp8+ MModDisp16+MModAbs ); + AddGen("NEGW",0,0x02,0xffff,0x10, MModDisp16+MModAbs ); + AddGen("ORAA",0,0x47,0xffff,0x00,MModDisp8+MModImm+ MModDisp16+MModAbs+MModDispE); + AddGen("ORAB",0,0xc7,0xffff,0x00,MModDisp8+MModImm+ MModDisp16+MModAbs+MModDispE); + AddGen("ORD" ,1,0x87,0xffff,0x20,MModDisp8+MModImm+ MModDisp16+MModAbs+MModDispE); + AddGen("ORE" ,1,0x07,0xffff,0x20, MModImm+ MModDisp16+MModAbs ); + AddGen("ROL" ,0,0x0c,0xffff,0x00,MModDisp8+ MModDisp16+MModAbs ); + AddGen("ROLW",0,0x0c,0xffff,0x10, MModDisp16+MModAbs ); + AddGen("ROR" ,0,0x0e,0xffff,0x00,MModDisp8+ MModDisp16+MModAbs ); + AddGen("RORW",0,0x0e,0xffff,0x10, MModDisp16+MModAbs ); + AddGen("SBCA",0,0x42,0xffff,0x00,MModDisp8+MModImm+ MModDisp16+MModAbs+MModDispE); + AddGen("SBCB",0,0xc2,0xffff,0x00,MModDisp8+MModImm+ MModDisp16+MModAbs+MModDispE); + AddGen("SBCD",1,0x82,0xffff,0x20,MModDisp8+MModImm+ MModDisp16+MModAbs+MModDispE); + AddGen("SBCE",1,0x02,0xffff,0x20, MModImm+ MModDisp16+MModAbs ); + AddGen("STAA",0,0x4a,0xffff,0x00,MModDisp8+ MModDisp16+MModAbs+MModDispE); + AddGen("STAB",0,0xca,0xffff,0x00,MModDisp8+ MModDisp16+MModAbs+MModDispE); + AddGen("STD" ,1,0x8a,0xffff,0x20,MModDisp8+ MModDisp16+MModAbs+MModDispE); + AddGen("STE" ,1,0x0a,0xffff,0x20, MModDisp16+MModAbs ); + AddGen("SUBA",0,0x40,0xffff,0x00,MModDisp8+MModImm+ MModDisp16+MModAbs+MModDispE); + AddGen("SUBB",0,0xc0,0xffff,0x00,MModDisp8+MModImm+ MModDisp16+MModAbs+MModDispE); + AddGen("SUBD",1,0x80,0xffff,0x20,MModDisp8+MModImm+ MModDisp16+MModAbs+MModDispE); + AddGen("SUBE",1,0x00,0xffff,0x20, MModImm+ MModDisp16+MModAbs ); + AddGen("TST" ,0,0x06,0xffff,0x00,MModDisp8+ MModDisp16+MModAbs ); + AddGen("TSTW",0,0x06,0xffff,0x10, MModDisp16+MModAbs ); + + AuxOrders=(FixedOrder *) malloc(sizeof(FixedOrder)*AuxOrderCnt); InstrZ=0; + AddAux("CPS",0x4f); AddAux("CPX",0x4c); AddAux("CPY",0x4d); AddAux("CPZ",0x4e); + AddAux("LDS",0xcf); AddAux("LDX",0xcc); AddAux("LDY",0xcd); AddAux("LDZ",0xce); + AddAux("STS",0x8f); AddAux("STX",0x8c); AddAux("STY",0x8d); AddAux("STZ",0x8e); + + ImmOrders=(FixedOrder *) malloc(sizeof(FixedOrder)*ImmOrderCnt); InstrZ=0; + AddImm("AIS",0x3f); AddImm("AIX",0x3c); AddImm("AIY",0x3d); AddImm("AIZ",0x3e); + + ExtOrders=(FixedOrder *) malloc(sizeof(FixedOrder)*ExtOrderCnt); InstrZ=0; + AddExt("LDED",0x2771); AddExt("LDHI",0x27b0);AddExt("STED",0x2773); + + EmuOrders=(EmuOrder *) malloc(sizeof(EmuOrder)*EmuOrderCnt); InstrZ=0; + AddEmu("CLC",0x373a,0xfeff); AddEmu("CLI",0x373a,0xff1f); AddEmu("CLV",0x373a,0xfdff); + AddEmu("SEC",0x373b,0x0100); AddEmu("SEI",0x373b,0x00e0); AddEmu("SEV",0x373b,0x0200); + + Regs=(char **) malloc(sizeof(char *)*RegCnt); + Regs[0]="D"; Regs[1]="E"; Regs[2]="X"; Regs[3]="Y"; + Regs[4]="Z"; Regs[5]="K"; Regs[6]="CCR"; +END + + static void DeinitFields(void) +BEGIN + free(FixedOrders); + free(RelOrders); + free(LRelOrders); + free(GenOrders); + free(AuxOrders); + free(ImmOrders); + free(ExtOrders); + free(EmuOrders); + free(Regs); +END + +/*-------------------------------------------------------------------------*/ + +typedef enum {ShortDisp,LongDisp,NoDisp} DispType; + + static void ChkAdr(Byte Mask) +BEGIN + if ((AdrMode!=ModNone) AND ((Mask AND (1 << AdrMode))==0)) + BEGIN + WrError(1350); + AdrMode=ModNone; AdrCnt=0; + END +END + + static void SplitSize(char *Asc, DispType *Erg) +BEGIN + if (strlen(Asc)<1) *Erg=NoDisp; + else if (*Asc=='>') *Erg=LongDisp; + else if (*Asc=='<') *Erg=ShortDisp; + else *Erg=NoDisp; +END + + static void DecodeAdr(int Start, int Stop, Boolean LongAdr, Byte Mask) +BEGIN + Integer V16; + LongInt V32; + Boolean OK; + String s; + DispType Size; + + AdrMode=ModNone; AdrCnt=0; + + Stop-=Start-1; + if (Stop<1) + BEGIN + WrError(1110); return; + END + + /* immediate ? */ + + if (*ArgStr[Start]=='#') + BEGIN + strmaxcpy(s,ArgStr[Start]+1,255); SplitSize(s,&Size); + switch (OpSize) + BEGIN + case -1: WrError(1132); break; + case 0: + AdrVals[0]=EvalIntExpression(s,Int8,&OK); + if (OK) + BEGIN + AdrCnt=1; AdrMode=ModImm; + END + break; + case 1: + V16=EvalIntExpression(s,(Size==ShortDisp)?SInt8:Int16,&OK); + if ((Size==NoDisp) AND (V16>=-128) AND (V16<=127) AND ((Mask & MModImmExt)!=0)) + Size=ShortDisp; + if (OK) + if (Size==ShortDisp) + BEGIN + AdrVals[0]=Lo(V16); + AdrCnt=1; AdrMode=ModImmExt; + END + else + BEGIN + AdrVals[0]=Hi(V16); + AdrVals[1]=Lo(V16); + AdrCnt=2; AdrMode=ModImm; + END + break; + case 2: + V32=EvalIntExpression(s,Int32,&OK); + if (OK) + BEGIN + AdrVals[0]=(V32 >> 24) & 0xff; + AdrVals[1]=(V32 >> 16) & 0xff; + AdrVals[2]=(V32 >> 8) & 0xff; + AdrVals[3]=V32 & 0xff; + AdrCnt=4; AdrMode=ModImm; + END + break; + END + ChkAdr(Mask); return; + END + + /* zusammengesetzt ? */ + + if (Stop==2) + BEGIN + AdrPart=0xff; + if (strcasecmp(ArgStr[Start+1],"X")==0) AdrPart=0x00; + else if (strcasecmp(ArgStr[Start+1],"Y")==0) AdrPart=0x10; + else if (strcasecmp(ArgStr[Start+1],"Z")==0) AdrPart=0x20; + else WrXError(1445,ArgStr[Start+1]); + if (AdrPart!=0xff) + if (strcasecmp(ArgStr[Start],"E")==0) AdrMode=ModDispE; + else + BEGIN + SplitSize(ArgStr[Start],&Size); + if (Size==ShortDisp) + V32=EvalIntExpression(ArgStr[Start],UInt8,&OK); + else if (LongAdr) + V32=EvalIntExpression(ArgStr[Start],SInt20,&OK); + else + V32=EvalIntExpression(ArgStr[Start],SInt16,&OK); + if (OK) + BEGIN + if (Size==NoDisp) + if ((V32>=0) AND (V32<=255) AND ((Mask & MModDisp8)!=0)) Size=ShortDisp; + if (Size==ShortDisp) + BEGIN + AdrVals[0]=V32 & 0xff; + AdrCnt=1; AdrMode=ModDisp8; + END + else if (LongAdr) + BEGIN + AdrVals[0]=(V32 >> 16) & 0x0f; + AdrVals[1]=(V32 >> 8) & 0xff; + AdrVals[2]=V32 & 0xff; + AdrCnt=3; AdrMode=ModDisp16; + END + else + BEGIN + AdrVals[0]=(V32 >> 8) & 0xff; + AdrVals[1]=V32 & 0xff; + AdrCnt=2; AdrMode=ModDisp16; + END + END + END + ChkAdr(Mask); return; + END + + /* absolut ? */ + + else + BEGIN + SplitSize(ArgStr[Start],&Size); + V32=EvalIntExpression(ArgStr[Start],UInt20,&OK); + if (OK) + if (LongAdr) + BEGIN + AdrVals[0]=(V32 >> 16) & 0xff; + AdrVals[1]=(V32 >> 8) & 0xff; + AdrVals[2]=V32 & 0xff; + AdrMode=ModAbs; AdrCnt=3; + END + else + BEGIN + if ((V32 >> 16)!=Reg_EK) WrError(110); + AdrVals[0]=(V32 >> 8) & 0xff; + AdrVals[1]=V32 & 0xff; + AdrMode=ModAbs; AdrCnt=2; + END + ChkAdr(Mask); return; + END +END + +/*-------------------------------------------------------------------------*/ + + static Boolean DecodePseudo(void) +BEGIN +#define ASSUME6816Count 1 + static ASSUMERec ASSUME6816s[ASSUME6816Count]= + {{"EK" , &Reg_EK , 0 , 0xff , 0x100}}; + + if (Memo("ASSUME")) + BEGIN + CodeASSUME(ASSUME6816s,ASSUME6816Count); + return True; + END + + return False; +END + + static void MakeCode_6816(void) +BEGIN + int z,z2; + Boolean OK; + Byte Mask; + LongInt AdrLong; + + CodeLen=0; DontPrint=False; AdrCnt=0; OpSize=(-1); + + /* zu ignorierendes */ + + if (Memo("")) return; + + /* Pseudoanweisungen */ + + if (DecodePseudo()) return; + + if (DecodeMotoPseudo(True)) return; + + /* Anweisungen ohne Argument */ + + for (z=0; z<FixedOrderCnt; z++) + if Memo(FixedOrders[z].Name) + BEGIN + if (ArgCnt!=0) WrError(1110); + else + BEGIN + BAsmCode[0]=Hi(FixedOrders[z].Code); BAsmCode[1]=Lo(FixedOrders[z].Code); + CodeLen=2; + END + return; + END + + for (z=0; z<EmuOrderCnt; z++) + if Memo(EmuOrders[z].Name) + BEGIN + if (ArgCnt!=0) WrError(1110); + else + BEGIN + BAsmCode[0]=Hi(EmuOrders[z].Code1); BAsmCode[1]=Lo(EmuOrders[z].Code1); + BAsmCode[2]=Hi(EmuOrders[z].Code2); BAsmCode[3]=Lo(EmuOrders[z].Code2); + CodeLen=4; + END + return; + END + + /* Datentransfer */ + + for (z=0; z<AuxOrderCnt; z++) + if (Memo(AuxOrders[z].Name)) + BEGIN + if ((ArgCnt<1) OR (ArgCnt>2)) WrError(1110); + else + BEGIN + OpSize=1; + DecodeAdr(1,ArgCnt,False,(*OpPart=='S'?0:MModImm)+MModDisp8+MModDisp16+MModAbs); + switch (AdrMode) + BEGIN + case ModDisp8: + BAsmCode[0]=AuxOrders[z].Code+AdrPart; + BAsmCode[1]=AdrVals[0]; CodeLen=2; + break; + case ModDisp16: + BAsmCode[0]=0x17; + BAsmCode[1]=AuxOrders[z].Code+AdrPart; + memcpy(BAsmCode+2,AdrVals,AdrCnt); CodeLen=2+AdrCnt; + break; + case ModAbs: + BAsmCode[0]=0x17; + BAsmCode[1]=AuxOrders[z].Code+0x30; + memcpy(BAsmCode+2,AdrVals,AdrCnt); CodeLen=2+AdrCnt; + break; + case ModImm: + BAsmCode[0]=0x37; BAsmCode[1]=AuxOrders[z].Code+0x30; + if (*OpPart=='L') BAsmCode[1]-=0x40; + memcpy(BAsmCode+2,AdrVals,AdrCnt); CodeLen=2+AdrCnt; + break; + END + END + return; + END + + for (z=0; z<ExtOrderCnt; z++) + if (Memo(ExtOrders[z].Name)) + BEGIN + if (ArgCnt!=1) WrError(1110); + else + BEGIN + OpSize=1; DecodeAdr(1,1,False,MModAbs); + switch (AdrMode) + BEGIN + case ModAbs: + BAsmCode[0]=Hi(ExtOrders[z].Code); BAsmCode[1]=Lo(ExtOrders[z].Code); + memcpy(BAsmCode+2,AdrVals,AdrCnt); CodeLen=2+AdrCnt; + break; + END + END + return; + END + + if ((Memo("PSHM")) OR (Memo("PULM"))) + BEGIN + if (ArgCnt<1) WrError(1110); + else + BEGIN + OK=True; Mask=0; + for (z=1; z<=ArgCnt; z++) + if (OK) + BEGIN + z2=0; NLS_UpString(ArgStr[z]); + while ((z2<RegCnt) AND (strcmp(ArgStr[z],Regs[z2])!=0)) z2++; + if (z2>=RegCnt) + BEGIN + WrXError(1445,ArgStr[z]); OK=False; + END + else if (Memo("PSHM")) Mask+=(1 << z2); + else Mask+=(1 << (RegCnt-1-z2)); + END + if (OK) + BEGIN + BAsmCode[0]=0x34+Ord(Memo("PULM")); BAsmCode[1]=Mask; + CodeLen=2; + END + END + return; + END + + if ((Memo("MOVB")) OR (Memo("MOVW"))) + BEGIN + z=Ord(Memo("MOVW")); + if (ArgCnt==2) + BEGIN + DecodeAdr(1,1,False,MModAbs); + if (AdrMode==ModAbs) + BEGIN + memcpy(BAsmCode+2,AdrVals,2); + DecodeAdr(2,2,False,MModAbs); + if (AdrMode==ModAbs) + BEGIN + memcpy(BAsmCode+4,AdrVals,2); + BAsmCode[0]=0x37; BAsmCode[1]=0xfe + z; /* ANSI :-0 */ + CodeLen=6; + END + END + END + else if (ArgCnt!=3) WrError(1110); + else if (strcasecmp(ArgStr[2],"X")==0) + BEGIN + BAsmCode[1]=EvalIntExpression(ArgStr[1],SInt8,&OK); + if (OK) + BEGIN + DecodeAdr(3,3,False,MModAbs); + if (AdrMode==ModAbs) + BEGIN + memcpy(BAsmCode+2,AdrVals,2); + BAsmCode[0]=0x30+z; + CodeLen=4; + END + END + END + else if (strcasecmp(ArgStr[3],"X")==0) + BEGIN + BAsmCode[3]=EvalIntExpression(ArgStr[2],SInt8,&OK); + if (OK) + BEGIN + DecodeAdr(1,1,False,MModAbs); + if (AdrMode==ModAbs) + BEGIN + memcpy(BAsmCode+1,AdrVals,2); + BAsmCode[0]=0x32+z; + CodeLen=4; + END + END + END + else WrError(1350); + return; + END + + /* Arithmetik */ + + for (z=0; z<GenOrderCnt; z++) + if (Memo(GenOrders[z].Name)) + BEGIN + if ((ArgCnt<1) OR (ArgCnt>2)) WrError(1110); + else + BEGIN + OpSize=GenOrders[z].Size; + DecodeAdr(1,ArgCnt,False,GenOrders[z].AdrMask); + switch (AdrMode) + BEGIN + case ModDisp8: + BAsmCode[0]=GenOrders[z].Code+AdrPart; + BAsmCode[1]=AdrVals[0]; CodeLen=2; + break; + case ModDisp16: + BAsmCode[0]=0x17+GenOrders[z].ExtShift; + BAsmCode[1]=GenOrders[z].Code+(OpSize << 6)+AdrPart; + memcpy(BAsmCode+2,AdrVals,AdrCnt); CodeLen=2+AdrCnt; + break; + case ModDispE: + BAsmCode[0]=0x27; BAsmCode[1]=GenOrders[z].Code+AdrPart; + CodeLen=2; + break; + case ModAbs: + BAsmCode[0]=0x17+GenOrders[z].ExtShift; + BAsmCode[1]=GenOrders[z].Code+(OpSize << 6)+0x30; + memcpy(BAsmCode+2,AdrVals,AdrCnt); CodeLen=2+AdrCnt; + break; + case ModImm: + if (OpSize==0) + BEGIN + BAsmCode[0]=GenOrders[z].Code+0x30; + BAsmCode[1]=AdrVals[0]; CodeLen=2; + END + else + BEGIN + BAsmCode[0]=0x37; BAsmCode[1]=GenOrders[z].Code+0x30; + memcpy(BAsmCode+2,AdrVals,AdrCnt); CodeLen=2+AdrCnt; + END + break; + case ModImmExt: + BAsmCode[0]=GenOrders[z].ExtCode; + BAsmCode[1]=AdrVals[0]; CodeLen=2; + break; + END + END + return; + END + + for (z=0; z<ImmOrderCnt; z++) + if (Memo(ImmOrders[z].Name)) + BEGIN + if (ArgCnt!=1) WrError(1110); + else + BEGIN + OpSize=1; DecodeAdr(1,1,False,MModImm+MModImmExt); + switch (AdrMode) + BEGIN + case ModImm: + BAsmCode[0]=0x37; BAsmCode[1]=ImmOrders[z].Code; + memcpy(BAsmCode+2,AdrVals,AdrCnt); CodeLen=2+AdrCnt; + break; + case ModImmExt: + BAsmCode[0]=ImmOrders[z].Code; BAsmCode[1]=AdrVals[0]; CodeLen=2; + break; + END + END + return; + END + + if ((Memo("ANDP")) OR (Memo("ORP"))) + BEGIN + if (ArgCnt!=1) WrError(1110); + else + BEGIN + OpSize=1; DecodeAdr(1,1,False,MModImm); + switch (AdrMode) + BEGIN + case ModImm: + BAsmCode[0]=0x37; BAsmCode[1]=0x3a+Ord(Memo("ORP")); + memcpy(BAsmCode+2,AdrVals,AdrCnt); CodeLen=2+AdrCnt; + break; + END + END + return; + END + + if ((Memo("MAC")) OR (Memo("RMAC"))) + BEGIN + if (ArgCnt!=2) WrError(1110); + else + BEGIN + z=EvalIntExpression(ArgStr[1],UInt4,&OK); + if (OK) + BEGIN + BAsmCode[1]=EvalIntExpression(ArgStr[2],UInt4,&OK); + if (OK) + BEGIN + BAsmCode[1]+=(z << 4); + BAsmCode[0]=0x7b+(Ord(Memo("RMAC")) << 7); + CodeLen=2; + END + END + END + return; + END + + /* Bitoperationen */ + + if ((Memo("BCLR")) OR (Memo("BSET"))) + BEGIN + if ((ArgCnt<2) OR (ArgCnt>3)) WrError(1110); + else + BEGIN + OpSize=0; z=Ord(Memo("BSET")); + DecodeAdr(ArgCnt,ArgCnt,False,MModImm); + switch (AdrMode) + BEGIN + case ModImm: + Mask=AdrVals[0]; + DecodeAdr(1,ArgCnt-1,False,MModDisp8+MModDisp16+MModAbs); + switch (AdrMode) + BEGIN + case ModDisp8: + BAsmCode[0]=0x17; BAsmCode[1]=0x08+z+AdrPart; + BAsmCode[2]=Mask; BAsmCode[3]=AdrVals[0]; + CodeLen=4; + break; + case ModDisp16: + BAsmCode[0]=0x08+z+AdrPart; BAsmCode[1]=Mask; + memcpy(BAsmCode+2,AdrVals,AdrCnt); + CodeLen=2+AdrCnt; + break; + case ModAbs: + BAsmCode[0]=0x38+z; BAsmCode[1]=Mask; + memcpy(BAsmCode+2,AdrVals,AdrCnt); + CodeLen=2+AdrCnt; + break; + END + break; + END + END + return; + END + + if ((Memo("BCLRW")) OR (Memo("BSETW"))) + BEGIN + if ((ArgCnt<2) OR (ArgCnt>3)) WrError(1110); + else + BEGIN + OpSize=1; z=Ord(Memo("BSETW")); + DecodeAdr(ArgCnt,ArgCnt,False,MModImm); + switch (AdrMode) + BEGIN + case ModImm: + memcpy(BAsmCode+2,AdrVals,AdrCnt); + DecodeAdr(1,ArgCnt-1,False,MModDisp16+MModAbs); + switch (AdrMode) + BEGIN + case ModDisp16: + BAsmCode[0]=0x27; BAsmCode[1]=0x08+z+AdrPart; + memcpy(BAsmCode+4,AdrVals,AdrCnt); + CodeLen=4+AdrCnt; + break; + case ModAbs: + BAsmCode[0]=0x27; BAsmCode[1]=0x38+z; + memcpy(BAsmCode+4,AdrVals,AdrCnt); + CodeLen=4+AdrCnt; + break; + END + END + END + return; + END + + if ((Memo("BRCLR")) OR (Memo("BRSET"))) + BEGIN + if ((ArgCnt<3) OR (ArgCnt>4)) WrError(1110); + else + BEGIN + z=Ord(Memo("BRSET")); + OpSize=0; DecodeAdr(ArgCnt-1,ArgCnt-1,False,MModImm); + if (AdrMode==ModImm) + BEGIN + BAsmCode[1]=AdrVals[0]; + AdrLong=EvalIntExpression(ArgStr[ArgCnt],UInt20,&OK)-EProgCounter()-6; + if (OK) + BEGIN + OK=SymbolQuestionable; + DecodeAdr(1,ArgCnt-2,False,MModDisp8+MModDisp16+MModAbs); + switch (AdrMode) + BEGIN + case ModDisp8: + if ((AdrLong>=-128) AND (AdrLong<127)) + BEGIN + BAsmCode[0]=0xcb-(z << 6)+AdrPart; + BAsmCode[2]=AdrVals[0]; + BAsmCode[3]=AdrLong & 0xff; + CodeLen=4; + END + else if ((NOT OK) AND ((AdrLong<-0x8000l) OR (AdrLong>0x7fffl))) WrError(1370); + else + BEGIN + BAsmCode[0]=0x0a+AdrPart+z; + BAsmCode[2]=0; + BAsmCode[3]=AdrVals[0]; + BAsmCode[4]=(AdrLong >> 8) & 0xff; + BAsmCode[5]=AdrLong & 0xff; + CodeLen=6; + END + break; + case ModDisp16: + if ((NOT OK) AND ((AdrLong<-0x8000l) OR (AdrLong>0x7fffl))) WrError(1370); + else + BEGIN + BAsmCode[0]=0x0a+AdrPart+z; + memcpy(BAsmCode+2,AdrVals,2); + BAsmCode[4]=(AdrLong >> 8) & 0xff; + BAsmCode[5]=AdrLong & 0xff; + CodeLen=6; + END + break; + case ModAbs: + if ((NOT OK) AND ((AdrLong<-0x8000l) OR (AdrLong>0x7fffl))) WrError(1370); + else + BEGIN + BAsmCode[0]=0x3a+z; + memcpy(BAsmCode+2,AdrVals,2); + BAsmCode[4]=(AdrLong >> 8) & 0xff; + BAsmCode[5]=AdrLong & 0xff; + CodeLen=6; + END + break; + END + END + END + END + return; + END + + /* Spruenge */ + + if ((Memo("JMP")) OR (Memo("JSR"))) + BEGIN + if ((ArgCnt<1) OR (ArgCnt>2)) WrError(1110); + else + BEGIN + OpSize=1; + DecodeAdr(1,ArgCnt,True,MModAbs20+MModDisp20); + switch (AdrMode) + BEGIN + case ModAbs20: + BAsmCode[0]=0x7a+(Ord(Memo("JSR")) << 7); + memcpy(BAsmCode+1,AdrVals,AdrCnt); + CodeLen=1+AdrCnt; + break; + case ModDisp20: + BAsmCode[0]=(Memo("JMP"))?0x4b:0x89; + BAsmCode[0]+=AdrPart; + memcpy(BAsmCode+1,AdrVals,AdrCnt); + CodeLen=1+AdrCnt; + break; + END + END + return; + END + + for (z=0; z<RelOrderCnt; z++) + if ((Memo(RelOrders[z].Name)) OR ((*OpPart=='L') AND (strcmp(OpPart+1,RelOrders[z].Name)==0))) + BEGIN + if (ArgCnt!=1) WrError(1110); + else + BEGIN + AdrLong=EvalIntExpression(ArgStr[1],UInt24,&OK)-EProgCounter()-6; + if ((AdrLong&1)==1) WrError(1325); + else if (*OpPart=='L') + if ((NOT SymbolQuestionable) AND ((AdrLong>0x7fffl) OR (AdrLong<-0x8000l))) WrError(1370); + else + BEGIN + BAsmCode[0]=0x37; BAsmCode[1]=RelOrders[z].Code+0x80; + BAsmCode[2]=(AdrLong >> 8) & 0xff; + BAsmCode[3]=AdrLong & 0xff; + CodeLen=4; + END + else + if ((NOT SymbolQuestionable) AND ((AdrLong>0x7fl) OR (AdrLong<-0x80l))) WrError(1370); + else + BEGIN + BAsmCode[0]=0xb0+RelOrders[z].Code; + BAsmCode[1]=AdrLong & 0xff; + CodeLen=2; + END + END + return; + END + + for (z=0; z<LRelOrderCnt; z++) + if (Memo(LRelOrders[z].Name)) + BEGIN + if (ArgCnt!=1) WrError(1110); + else + BEGIN + AdrLong=EvalIntExpression(ArgStr[1],UInt24,&OK)-EProgCounter()-6; + if ((AdrLong&1)==1) WrError(1325); + else if ((NOT SymbolQuestionable) AND ((AdrLong>0x7fffl) OR (AdrLong<-0x8000l))) WrError(1370); + else + BEGIN + BAsmCode[0]=Hi(LRelOrders[z].Code); BAsmCode[1]=Lo(LRelOrders[z].Code); + BAsmCode[2]=(AdrLong >> 8) & 0xff; + BAsmCode[3]=AdrLong & 0xff; + CodeLen=4; + END + END + return; + END + + if (Memo("BSR")) + BEGIN + if (ArgCnt!=1) WrError(1110); + else + BEGIN + AdrLong=EvalIntExpression(ArgStr[1],UInt24,&OK)-EProgCounter()-6; + if ((AdrLong&1)==1) WrError(1325); + else if ((NOT SymbolQuestionable) AND ((AdrLong>0x7fl) OR (AdrLong<-0x80l))) WrError(1370); + else + BEGIN + BAsmCode[0]=0x36; + BAsmCode[1]=AdrLong & 0xff; + CodeLen=2; + END + END + return; + END + + WrXError(1200,OpPart); +END + + static void InitCode_6816(void) +BEGIN + SaveInitProc(); + Reg_EK=0; +END + + static Boolean IsDef_6816(void) +BEGIN + return False; +END + + static void SwitchFrom_6816(void) +BEGIN + DeinitFields(); +END + + static void SwitchTo_6816(void) +BEGIN + TurnWords=False; ConstMode=ConstModeMoto; SetIsOccupied=False; + + PCSymbol="*"; HeaderID=0x65; NOPCode=0x274c; + DivideChars=","; HasAttrs=False; + + ValidSegs=(1<<SegCode); + Grans[SegCode]=1; ListGrans[SegCode]=1; SegInits[SegCode]=0; + SegLimits[SegCode] = 0xfffffl; + + MakeCode=MakeCode_6816; IsDef=IsDef_6816; + SwitchFrom=SwitchFrom_6816; + + InitFields(); +END + + void code6816_init(void) +BEGIN + CPU6816=AddCPU("68HC16",SwitchTo_6816); + + SaveInitProc=InitPassProc; InitPassProc=InitCode_6816; +END |