aboutsummaryrefslogtreecommitdiffstats
path: root/code601.c
diff options
context:
space:
mode:
Diffstat (limited to 'code601.c')
-rw-r--r--code601.c2017
1 files changed, 2017 insertions, 0 deletions
diff --git a/code601.c b/code601.c
new file mode 100644
index 0000000..001444e
--- /dev/null
+++ b/code601.c
@@ -0,0 +1,2017 @@
+/* code601.c */
+/*****************************************************************************/
+/* AS-Portierung */
+/* */
+/* Codegenerator PowerPC-Familie */
+/* */
+/* Historie: 17.10.1996 Grundsteinlegung */
+/* 30. 8.1998 Umstellung auf 32-Bit-Zugriffe */
+/* Header-ID per Abfrage */
+/* 3. 1.1999 ChkPC-Anpassung */
+/* 9. 3.1999 MMU-Instruktionen */
+/* 10. 3.1999 PPC403-MMU-Befehle */
+/* 28. 3.1999 PPC403GB auf GC korrigiert (erst der hat eine MMU) */
+/* 8. 9.1999 REG-Befehl nachgeruestet */
+/* */
+/*****************************************************************************/
+
+#include "stdinc.h"
+#include <string.h>
+#include <ctype.h>
+
+#include "endian.h"
+#include "strutil.h"
+#include "asmdef.h"
+#include "asmsub.h"
+#include "asmpars.h"
+#include "asmallg.h"
+#include "codepseudo.h"
+#include "codevars.h"
+#include "headids.h"
+
+typedef struct
+ {
+ char *Name;
+ LongWord Code;
+ Byte CPUMask;
+ } BaseOrder;
+
+#define FixedOrderCount 8
+#define Reg1OrderCount 4
+#define FReg1OrderCount 2
+#define CReg1OrderCount 1
+#define CBit1OrderCount 4
+#define Reg2OrderCount 29
+#define CReg2OrderCount 2
+#define FReg2OrderCount 14
+#define Reg2BOrderCount 2
+#define Reg2SwapOrderCount 6
+#define NoDestOrderCount 10
+#define Reg3OrderCount 91
+#define CReg3OrderCount 8
+#define FReg3OrderCount 10
+#define Reg3SwapOrderCount 49
+#define MixedOrderCount 8
+#define FReg4OrderCount 16
+#define RegDispOrderCount 16
+#define FRegDispOrderCount 8
+#define Reg2ImmOrderCount 12
+#define Imm16OrderCount 7
+#define Imm16SwapOrderCount 6
+
+static BaseOrder *FixedOrders;
+static BaseOrder *Reg1Orders;
+static BaseOrder *CReg1Orders;
+static BaseOrder *CBit1Orders;
+static BaseOrder *FReg1Orders;
+static BaseOrder *Reg2Orders;
+static BaseOrder *CReg2Orders;
+static BaseOrder *FReg2Orders;
+static BaseOrder *Reg2BOrders;
+static BaseOrder *Reg2SwapOrders;
+static BaseOrder *NoDestOrders;
+static BaseOrder *Reg3Orders;
+static BaseOrder *CReg3Orders;
+static BaseOrder *FReg3Orders;
+static BaseOrder *Reg3SwapOrders;
+static BaseOrder *MixedOrders;
+static BaseOrder *FReg4Orders;
+static BaseOrder *RegDispOrders;
+static BaseOrder *FRegDispOrders;
+static BaseOrder *Reg2ImmOrders;
+static BaseOrder *Imm16Orders;
+static BaseOrder *Imm16SwapOrders;
+
+static SimpProc SaveInitProc;
+static Boolean BigEnd;
+
+static CPUVar CPU403, CPU403C, CPU505, CPU601, CPU6000;
+
+#define M_403 0x01
+#define M_403C 0x02
+#define M_505 0x04
+#define M_601 0x08
+#define M_6000 0x10
+
+/*-------------------------------------------------------------------------*/
+/*
+ PROCEDURE EnterByte(b:Byte);
+ BEGIN
+ if Odd(CodeLen)
+ BEGIN
+ BAsmCode[CodeLen]:=BAsmCode[CodeLen-1];
+ BAsmCode[CodeLen-1]:=b;
+ END
+ else
+ BEGIN
+ BAsmCode[CodeLen]:=b;
+ END;
+ Inc(CodeLen);
+END;
+*/
+/*-------------------------------------------------------------------------*/
+
+ static void AddFixed(char *NName1, char *NName2, LongInt NCode, Byte NMask)
+BEGIN
+ if (InstrZ>=FixedOrderCount) exit(255);
+ FixedOrders[InstrZ].Name=(MomCPU==CPU6000)?NName2:NName1;
+ FixedOrders[InstrZ].Code=NCode;
+ FixedOrders[InstrZ++].CPUMask=NMask;
+END
+
+ static void AddReg1(char *NName1, char *NName2, LongInt NCode, Byte NMask)
+BEGIN
+ if (InstrZ>=Reg1OrderCount) exit(255);
+ Reg1Orders[InstrZ].Name=(MomCPU==CPU6000)?NName2:NName1;
+ Reg1Orders[InstrZ].Code=NCode;
+ Reg1Orders[InstrZ++].CPUMask=NMask;
+END
+
+ static void AddCReg1(char *NName1, char *NName2, LongInt NCode, Byte NMask)
+BEGIN
+ if (InstrZ>=CReg1OrderCount) exit(255);
+ CReg1Orders[InstrZ].Name=(MomCPU==CPU6000)?NName2:NName1;
+ CReg1Orders[InstrZ].Code=NCode;
+ CReg1Orders[InstrZ++].CPUMask=NMask;
+END
+
+ static void AddCBit1(char *NName1, char *NName2, LongInt NCode, Byte NMask)
+BEGIN
+ if (InstrZ>=CBit1OrderCount) exit(255);
+ CBit1Orders[InstrZ].Name=(MomCPU==CPU6000)?NName2:NName1;
+ CBit1Orders[InstrZ].Code=NCode;
+ CBit1Orders[InstrZ++].CPUMask=NMask;
+END
+
+ static void AddFReg1(char *NName1, char *NName2, LongInt NCode, Byte NMask)
+BEGIN
+ if (InstrZ>=FReg1OrderCount) exit(255);
+ FReg1Orders[InstrZ].Name=(MomCPU==CPU6000)?NName2:NName1;
+ FReg1Orders[InstrZ].Code=NCode;
+ FReg1Orders[InstrZ++].CPUMask=NMask;
+END
+
+ static void AddSReg2(char *NName, LongInt NCode, Byte NMask)
+BEGIN
+ if (InstrZ>=Reg2OrderCount) exit(255);
+ if (NName==Nil) exit(255);
+ Reg2Orders[InstrZ].Name=NName;
+ Reg2Orders[InstrZ].Code=NCode;
+ Reg2Orders[InstrZ++].CPUMask=NMask;
+END
+
+ static void AddReg2(char *NName1, char *NName2, LongInt NCode, Byte NMask, Boolean WithOE, Boolean WithFL)
+BEGIN
+ String NName;
+
+ strcpy(NName,(MomCPU==CPU6000)?NName2:NName1);
+ AddSReg2(strdup(NName),NCode,NMask);
+ if (WithOE)
+ BEGIN
+ strcat(NName,"O");
+ AddSReg2(strdup(NName),NCode | 0x400,NMask);
+ NName[strlen(NName)-1]='\0';
+ END
+ if (WithFL)
+ BEGIN
+ strcat(NName,".");
+ AddSReg2(strdup(NName),NCode | 0x001,NMask);
+ NName[strlen(NName)-1]='\0';
+ if (WithOE)
+ BEGIN
+ strcat(NName,"O.");
+ AddSReg2(strdup(NName),NCode | 0x401,NMask);
+ END
+ END
+END
+
+ static void AddCReg2(char *NName1, char *NName2, LongWord NCode, Byte NMask)
+BEGIN
+ if (InstrZ>=CReg2OrderCount) exit(255);
+ CReg2Orders[InstrZ].Name=(MomCPU==CPU6000)?NName2:NName1;
+ CReg2Orders[InstrZ].Code=NCode;
+ CReg2Orders[InstrZ++].CPUMask=NMask;
+END
+
+ static void AddSFReg2(char *NName, LongInt NCode, Byte NMask)
+BEGIN
+ if (InstrZ>=FReg2OrderCount) exit(255);
+ if (NName==Nil) exit(255);
+ FReg2Orders[InstrZ].Name=NName;
+ FReg2Orders[InstrZ].Code=NCode;
+ FReg2Orders[InstrZ++].CPUMask=NMask;
+END
+
+ static void AddFReg2(char *NName1, char *NName2, LongInt NCode, Byte NMask, Boolean WithFL)
+BEGIN
+ String NName;
+
+ strcpy(NName,(MomCPU==CPU6000)?NName2:NName1);
+ AddSFReg2(strdup(NName),NCode,NMask);
+ if (WithFL)
+ BEGIN
+ strcat(NName,".");
+ AddSFReg2(strdup(NName),NCode | 0x001,NMask);
+ END
+END
+
+ static void AddReg2B(char *NName1, char *NName2, LongInt NCode, Byte NMask)
+BEGIN
+ if (InstrZ>=Reg2BOrderCount) exit(255);
+ Reg2BOrders[InstrZ].Name=(MomCPU==CPU6000)?NName2:NName1;
+ Reg2BOrders[InstrZ].Code=NCode;
+ Reg2BOrders[InstrZ++].CPUMask=NMask;
+END
+
+ static void AddSReg2Swap(char *NName, LongInt NCode, Byte NMask)
+BEGIN
+ if (InstrZ>=Reg2SwapOrderCount) exit(255);
+ if (NName==Nil) exit(255);
+ Reg2SwapOrders[InstrZ].Name=NName;
+ Reg2SwapOrders[InstrZ].Code=NCode;
+ Reg2SwapOrders[InstrZ++].CPUMask=NMask;
+END
+
+ static void AddReg2Swap(char *NName1, char *NName2, LongInt NCode, Byte NMask, Boolean WithOE, Boolean WithFL)
+BEGIN
+ String NName;
+
+ strcpy(NName,(MomCPU==CPU6000)?NName2:NName1);
+ AddSReg2Swap(strdup(NName),NCode,NMask);
+ if (WithOE)
+ BEGIN
+ strcat(NName,"O");
+ AddSReg2Swap(strdup(NName),NCode | 0x400,NMask);
+ NName[strlen(NName)-1]='\0';
+ END
+ if (WithFL)
+ BEGIN
+ strcat(NName,".");
+ AddSReg2Swap(strdup(NName),NCode | 0x001,NMask);
+ NName[strlen(NName)-1]='\0';
+ if (WithOE)
+ BEGIN
+ strcat(NName,"O.");
+ AddSReg2Swap(strdup(NName),NCode | 0x401,NMask);
+ END
+ END
+END
+
+ static void AddNoDest(char *NName1, char *NName2, LongInt NCode, Byte NMask)
+BEGIN
+ if (InstrZ>=NoDestOrderCount) exit(255);
+ NoDestOrders[InstrZ].Name=(MomCPU==CPU6000)?NName2:NName1;
+ NoDestOrders[InstrZ].Code=NCode;
+ NoDestOrders[InstrZ++].CPUMask=NMask;
+END
+
+ static void AddSReg3(char *NName, LongInt NCode, Byte NMask)
+BEGIN
+ if (InstrZ>=Reg3OrderCount) exit(255);
+ if (NName==Nil) exit(255);
+ Reg3Orders[InstrZ].Name=NName;
+ Reg3Orders[InstrZ].Code=NCode;
+ Reg3Orders[InstrZ++].CPUMask=NMask;
+END
+
+ static void AddReg3(char *NName1, char *NName2, LongInt NCode, Byte NMask, Boolean WithOE, Boolean WithFL)
+BEGIN
+ String NName;
+
+ strcpy(NName,(MomCPU==CPU6000)?NName2:NName1);
+ AddSReg3(strdup(NName),NCode,NMask);
+ if (WithOE)
+ BEGIN
+ strcat(NName,"O");
+ AddSReg3(strdup(NName),NCode | 0x400,NMask);
+ NName[strlen(NName)-1]='\0';
+ END
+ if (WithFL)
+ BEGIN
+ strcat(NName,".");
+ AddSReg3(strdup(NName),NCode | 0x001,NMask);
+ NName[strlen(NName)-1]='\0';
+ if (WithOE)
+ BEGIN
+ strcat(NName,"O.");
+ AddSReg3(strdup(NName),NCode | 0x401,NMask);
+ END
+ END
+END
+
+ static void AddCReg3(char *NName, LongWord NCode, CPUVar NMask)
+BEGIN
+ if (InstrZ>=CReg3OrderCount) exit(255);
+ CReg3Orders[InstrZ].Name=NName;
+ CReg3Orders[InstrZ].Code=NCode;
+ CReg3Orders[InstrZ++].CPUMask=NMask;
+END
+
+ static void AddSFReg3(char *NName, LongInt NCode, Byte NMask)
+BEGIN
+ if (InstrZ>=FReg3OrderCount) exit(255);
+ if (NName==Nil) exit(255);
+ FReg3Orders[InstrZ].Name=NName;
+ FReg3Orders[InstrZ].Code=NCode;
+ FReg3Orders[InstrZ++].CPUMask=NMask;
+END
+
+ static void AddFReg3(char *NName1, char *NName2, LongInt NCode, Byte NMask, Boolean WithFL)
+BEGIN
+ String NName;
+
+ strcpy(NName,(MomCPU==CPU6000)?NName2:NName1);
+ AddSFReg3(strdup(NName),NCode,NMask);
+ if (WithFL)
+ BEGIN
+ strcat(NName,".");
+ AddSFReg3(strdup(NName),NCode | 0x001,NMask);
+ END
+END
+
+ static void AddSReg3Swap(char *NName, LongInt NCode, Byte NMask)
+BEGIN
+ if (InstrZ>=Reg3SwapOrderCount) exit(255);
+ if (NName==Nil) exit(255);
+ Reg3SwapOrders[InstrZ].Name=NName;
+ Reg3SwapOrders[InstrZ].Code=NCode;
+ Reg3SwapOrders[InstrZ++].CPUMask=NMask;
+END
+
+ static void AddReg3Swap(char *NName1, char *NName2, LongInt NCode, Byte NMask, Boolean WithFL)
+BEGIN
+ String NName;
+
+ strcpy(NName,(MomCPU==CPU6000)?NName2:NName1);
+ AddSReg3Swap(strdup(NName),NCode,NMask);
+ if (WithFL)
+ BEGIN
+ strcat(NName,".");
+ AddSReg3Swap(strdup(NName),NCode | 0x001,NMask);
+ END
+END
+
+ static void AddMixed(char *NName1, char *NName2, LongWord NCode, Byte NMask)
+BEGIN
+ if (InstrZ>=MixedOrderCount) exit(255);
+ MixedOrders[InstrZ].Name=(MomCPU==CPU6000)?NName2:NName1;
+ MixedOrders[InstrZ].Code=NCode;
+ MixedOrders[InstrZ++].CPUMask=NMask;
+END
+
+ static void AddSFReg4(char *NName, LongWord NCode, Byte NMask)
+BEGIN
+ if (InstrZ>=FReg4OrderCount) exit(255);
+ if (NName==Nil) exit(255);
+ FReg4Orders[InstrZ].Name=NName;
+ FReg4Orders[InstrZ].Code=NCode;
+ FReg4Orders[InstrZ++].CPUMask=NMask;
+END
+
+ static void AddFReg4(char *NName1, char *NName2, LongWord NCode, Byte NMask, Boolean WithFL)
+BEGIN
+ String NName;
+
+ strcpy(NName,(MomCPU==CPU6000)?NName2:NName1);
+ AddSFReg4(strdup(NName),NCode,NMask);
+ if (WithFL)
+ BEGIN
+ strcat(NName,".");
+ AddSFReg4(strdup(NName),NCode | 0x001,NMask);
+ END
+END
+
+ static void AddRegDisp(char *NName1, char *NName2, LongWord NCode, Byte NMask)
+BEGIN
+ if (InstrZ>=RegDispOrderCount) exit(255);
+ RegDispOrders[InstrZ].Name=(MomCPU==CPU6000)?NName2:NName1;
+ RegDispOrders[InstrZ].Code=NCode;
+ RegDispOrders[InstrZ++].CPUMask=NMask;
+END
+
+ static void AddFRegDisp(char *NName1, char *NName2, LongWord NCode, Byte NMask)
+BEGIN
+ if (InstrZ>=FRegDispOrderCount) exit(255);
+ FRegDispOrders[InstrZ].Name=(MomCPU==CPU6000)?NName2:NName1;
+ FRegDispOrders[InstrZ].Code=NCode;
+ FRegDispOrders[InstrZ++].CPUMask=NMask;
+END
+
+ static void AddSReg2Imm(char *NName, LongWord NCode, Byte NMask)
+BEGIN
+ if (InstrZ>=Reg2ImmOrderCount) exit(255);
+ if (NName==Nil) exit(255);
+ Reg2ImmOrders[InstrZ].Name=NName;
+ Reg2ImmOrders[InstrZ].Code=NCode;
+ Reg2ImmOrders[InstrZ++].CPUMask=NMask;
+END
+
+ static void AddReg2Imm(char *NName1, char *NName2, LongWord NCode, Byte NMask, Boolean WithFL)
+BEGIN
+ String NName;
+
+ strcpy(NName,(MomCPU==CPU6000)?NName2:NName1);
+ AddSReg2Imm(strdup(NName),NCode,NMask);
+ if (WithFL)
+ BEGIN
+ strcat(NName,".");
+ AddSReg2Imm(strdup(NName),NCode | 0x001,NMask);
+ END
+END
+
+ static void AddImm16(char *NName1, char *NName2, LongWord NCode, Byte NMask)
+BEGIN
+ if (InstrZ>=Imm16OrderCount) exit(255);
+ Imm16Orders[InstrZ].Name=(MomCPU==CPU6000)?NName2:NName1;
+ Imm16Orders[InstrZ].Code=NCode;
+ Imm16Orders[InstrZ++].CPUMask=NMask;
+END
+
+ static void AddImm16Swap(char *NName1, char *NName2, LongWord NCode, Byte NMask)
+BEGIN
+ if (InstrZ>=Imm16SwapOrderCount) exit(255);
+ Imm16SwapOrders[InstrZ].Name=(MomCPU==CPU6000)?NName2:NName1;
+ Imm16SwapOrders[InstrZ].Code=NCode;
+ Imm16SwapOrders[InstrZ++].CPUMask=NMask;
+END
+
+#ifdef __STDC__
+#define T1 1lu
+#define T3 3lu
+#define T4 4lu
+#define T7 7lu
+#define T8 8lu
+#define T9 9lu
+#define T10 10lu
+#define T11 11lu
+#define T12 12lu
+#define T13 13lu
+#define T14 14lu
+#define T15 15lu
+#define T16 16lu
+#define T17 17lu
+#define T18 18lu
+#define T19 19lu
+#define T20 20lu
+#define T21 21lu
+#define T22 22lu
+#define T23 23lu
+#define T24 24lu
+#define T25 25lu
+#define T26 26lu
+#define T27 27lu
+#define T28 28lu
+#define T29 29lu
+#define T31 31lu
+#define T32 32lu
+#define T33 33lu
+#define T34 34lu
+#define T35 35lu
+#define T36 36lu
+#define T37 37lu
+#define T38 38lu
+#define T39 39lu
+#define T40 40lu
+#define T41 41lu
+#define T42 42lu
+#define T43 43lu
+#define T44 44lu
+#define T45 45lu
+#define T46 46lu
+#define T47 47lu
+#define T48 48lu
+#define T49 49lu
+#define T50 50lu
+#define T51 51lu
+#define T52 52lu
+#define T53 53lu
+#define T54 54lu
+#define T55 55lu
+#define T59 59lu
+#define T63 63lu
+#else
+#define T1 1l
+#define T3 3l
+#define T4 4l
+#define T7 7l
+#define T8 8l
+#define T9 9l
+#define T10 10l
+#define T11 11l
+#define T12 12l
+#define T13 13l
+#define T14 14l
+#define T15 15l
+#define T16 16l
+#define T17 17l
+#define T18 18l
+#define T19 19l
+#define T20 20l
+#define T21 21l
+#define T22 22l
+#define T23 23l
+#define T24 24l
+#define T25 25l
+#define T26 26l
+#define T27 27l
+#define T28 28l
+#define T29 29l
+#define T31 31l
+#define T32 32l
+#define T33 33l
+#define T34 34l
+#define T35 35l
+#define T36 36l
+#define T37 37l
+#define T38 38l
+#define T39 39l
+#define T40 40l
+#define T41 41l
+#define T42 42l
+#define T43 43l
+#define T44 44l
+#define T45 45l
+#define T46 46l
+#define T47 47l
+#define T48 48l
+#define T49 49l
+#define T50 50l
+#define T51 51l
+#define T52 52l
+#define T53 53l
+#define T54 54l
+#define T55 55l
+#define T59 59l
+#define T63 63l
+#endif
+
+ static void InitFields(void)
+BEGIN
+ /* --> 0 0 0 */
+
+ FixedOrders=(BaseOrder *) malloc(sizeof(BaseOrder)*FixedOrderCount); InstrZ=0;
+ AddFixed("EIEIO" ,"EIEIO" ,(T31 << 26)+(854 << 1), M_403 | M_403C | M_505 | M_601 | M_6000);
+ AddFixed("ISYNC" ,"ICS" ,(T19 << 26)+(150 << 1), M_403 | M_403C | M_505 | M_601 | M_6000);
+ AddFixed("RFI" ,"RFI" ,(T19 << 26)+( 50 << 1), M_403 | M_403C | M_505 | M_601 | M_6000);
+ AddFixed("SC" ,"SVCA" ,(T17 << 26)+( 1 << 1), M_403 | M_403C | M_505 | M_601 | M_6000);
+ AddFixed("SYNC" ,"DCS" ,(T31 << 26)+(598 << 1), M_403 | M_403C | M_505 | M_601 | M_6000);
+ AddFixed("RFCI" ,"RFCI" ,(T19 << 26)+( 51 << 1), M_403 | M_403C );
+ AddFixed("TLBIA" ,"TLBIA" ,(T31 << 26)+(370 << 1), M_403C );
+ AddFixed("TLBSYNC","TLBSYNC",(T31 << 26)+(566 << 1), M_403C );
+
+ /* D --> D 0 0 */
+
+ Reg1Orders=(BaseOrder *) malloc(sizeof(BaseOrder)*Reg1OrderCount); InstrZ=0;
+ AddReg1("MFCR" ,"MFCR" ,(T31 << 26)+( 19 << 1), M_403 | M_403C | M_505 | M_601 | M_6000);
+ AddReg1("MFMSR" ,"MFMSR" ,(T31 << 26)+( 83 << 1), M_403 | M_403C | M_505 | M_601 | M_6000);
+ AddReg1("MTMSR" ,"MTMSR" ,(T31 << 26)+(146 << 1), M_403 | M_403C | M_505 | M_601 | M_6000);
+ AddReg1("WRTEE" ,"WRTEE" ,(T31 << 26)+(131 << 1), M_403 | M_403C | M_505 | M_601 | M_6000);
+
+ /* crD --> D 0 0 */
+
+ CReg1Orders=(BaseOrder *) malloc(sizeof(BaseOrder)*CReg1OrderCount); InstrZ=0;
+ AddCReg1("MCRXR" ,"MCRXR" ,(T31 << 26)+(512 << 1), M_403 | M_403C | M_505 | M_601 | M_6000);
+
+ /* crbD --> D 0 0 */
+
+ CBit1Orders=(BaseOrder *) malloc(sizeof(BaseOrder)*CBit1OrderCount); InstrZ=0;
+ AddCBit1("MTFSB0" ,"MTFSB0" ,(T63 << 26)+( 70 << 1) , M_601 | M_6000);
+ AddCBit1("MTFSB0.","MTFSB0.",(T63 << 26)+( 70 << 1)+1, M_601 | M_6000);
+ AddCBit1("MTFSB1" ,"MTFSB1" ,(T63 << 26)+( 38 << 1) , M_601 | M_6000);
+ AddCBit1("MTFSB1.","MTFSB1.",(T63 << 26)+( 38 << 1)+1, M_601 | M_6000);
+
+ /* frD --> D 0 0 */
+
+ FReg1Orders=(BaseOrder *) malloc(sizeof(BaseOrder)*FReg1OrderCount); InstrZ=0;
+ AddFReg1("MFFS" ,"MFFS" ,(T63 << 26)+(583 << 1) , M_601 | M_6000);
+ AddFReg1("MFFS." ,"MFFS." ,(T63 << 26)+(583 << 1)+1, M_601 | M_6000);
+
+ /* D,A --> D A 0 */
+
+ Reg2Orders=(BaseOrder *) malloc(sizeof(BaseOrder)*Reg2OrderCount); InstrZ=0;
+ AddReg2("ABS" ,"ABS" ,(T31 << 26)+(360 << 1), M_6000,True ,True );
+ AddReg2("ADDME" ,"AME" ,(T31 << 26)+(234 << 1), M_403 | M_403C | M_505 | M_601 | M_6000,True ,True );
+ AddReg2("ADDZE" ,"AZE" ,(T31 << 26)+(202 << 1), M_403 | M_403C | M_505 | M_601 | M_6000,True ,True );
+ AddReg2("CLCS" ,"CLCS" ,(T31 << 26)+(531 << 1), M_6000,False,False);
+ AddReg2("NABS" ,"NABS" ,(T31 << 26)+(488 << 1), M_6000,True ,True );
+ AddReg2("NEG" ,"NEG" ,(T31 << 26)+(104 << 1), M_403 | M_403C | M_505 | M_601 | M_6000,True ,True );
+ AddReg2("SUBFME","SFME" ,(T31 << 26)+(232 << 1), M_403 | M_403C | M_505 | M_601 | M_6000,True ,True );
+ AddReg2("SUBFZE","SFZE" ,(T31 << 26)+(200 << 1), M_403 | M_403C | M_505 | M_601 | M_6000,True ,True );
+
+ /* cD,cS --> D S 0 */
+
+ CReg2Orders=(BaseOrder *) malloc(sizeof(BaseOrder)*CReg2OrderCount); InstrZ=0;
+ AddCReg2("MCRF" ,"MCRF" ,(T19 << 26)+( 0 << 1), M_403 | M_403C | M_505 | M_601 | M_6000);
+ AddCReg2("MCRFS" ,"MCRFS" ,(T63 << 26)+( 64 << 1), M_601 | M_6000);
+
+ /* fD,fB --> D 0 B */
+
+ FReg2Orders=(BaseOrder *) malloc(sizeof(BaseOrder)*FReg2OrderCount); InstrZ=0;
+ AddFReg2("FABS" ,"FABS" ,(T63 << 26)+(264 << 1), M_601 | M_6000,True );
+ AddFReg2("FCTIW" ,"FCTIW" ,(T63 << 26)+( 14 << 1), M_601 | M_6000,True );
+ AddFReg2("FCTIWZ","FCTIWZ",(T63 << 26)+( 15 << 1), M_601 | M_6000,True );
+ AddFReg2("FMR" ,"FMR" ,(T63 << 26)+( 72 << 1), M_601 | M_6000,True );
+ AddFReg2("FNABS" ,"FNABS" ,(T63 << 26)+(136 << 1), M_601 | M_6000,True );
+ AddFReg2("FNEG" ,"FNEG" ,(T63 << 26)+( 40 << 1), M_601 | M_6000,True );
+ AddFReg2("FRSP" ,"FRSP" ,(T63 << 26)+( 12 << 1), M_601 | M_6000,True );
+
+ /* D,B --> D 0 B */
+
+ Reg2BOrders=(BaseOrder *) malloc(sizeof(BaseOrder)*Reg2BOrderCount); InstrZ=0;
+ AddReg2B("MFSRIN","MFSRIN",(T31 << 26)+(659 << 1), M_601 | M_6000);
+ AddReg2B("MTSRIN","MTSRI" ,(T31 << 26)+(242 << 1), M_601 | M_6000);
+
+ /* A,S --> S A 0 */
+
+ Reg2SwapOrders=(BaseOrder *) malloc(sizeof(BaseOrder)*Reg2SwapOrderCount); InstrZ=0;
+ AddReg2Swap("CNTLZW","CNTLZ" ,(T31 << 26)+( 26 << 1), M_403 | M_403C | M_505 | M_601 | M_6000,False,True );
+ AddReg2Swap("EXTSB ","EXTSB" ,(T31 << 26)+(954 << 1), M_403 | M_403C | M_505 | M_601 | M_6000,False,True );
+ AddReg2Swap("EXTSH ","EXTS" ,(T31 << 26)+(922 << 1), M_403 | M_403C | M_505 | M_601 | M_6000,False,True );
+
+ /* A,B --> 0 A B */
+
+ NoDestOrders=(BaseOrder *) malloc(sizeof(BaseOrder)*NoDestOrderCount); InstrZ=0;
+ AddNoDest("DCBF" ,"DCBF" ,(T31 << 26)+( 86 << 1), M_403 | M_403C | M_505 | M_601 | M_6000);
+ AddNoDest("DCBI" ,"DCBI" ,(T31 << 26)+( 470 << 1), M_403 | M_403C | M_505 | M_601 | M_6000);
+ AddNoDest("DCBST" ,"DCBST" ,(T31 << 26)+( 54 << 1), M_403 | M_403C | M_505 | M_601 | M_6000);
+ AddNoDest("DCBT" ,"DCBT" ,(T31 << 26)+( 278 << 1), M_403 | M_403C | M_505 | M_601 | M_6000);
+ AddNoDest("DCBTST","DCBTST",(T31 << 26)+( 246 << 1), M_403 | M_403C | M_505 | M_601 | M_6000);
+ AddNoDest("DCBZ" ,"DCLZ" ,(T31 << 26)+(1014 << 1), M_403 | M_403C | M_505 | M_601 | M_6000);
+ AddNoDest("DCCCI" ,"DCCCI" ,(T31 << 26)+( 454 << 1), M_403 | M_403C );
+ AddNoDest("ICBI" ,"ICBI" ,(T31 << 26)+( 982 << 1), M_403 | M_403C | M_505 | M_601 | M_6000);
+ AddNoDest("ICBT" ,"ICBT" ,(T31 << 26)+( 262 << 1), M_403 | M_403C );
+ AddNoDest("ICCCI" ,"ICCCI" ,(T31 << 26)+( 966 << 1), M_403 | M_403C );
+
+ /* D,A,B --> D A B */
+
+ Reg3Orders=(BaseOrder *) malloc(sizeof(BaseOrder)*Reg3OrderCount); InstrZ=0;
+ AddReg3("ADD" ,"CAX" ,(T31 << 26)+(266 << 1), M_403 | M_403C | M_505 | M_601 | M_6000,True, True );
+ AddReg3("ADDC" ,"A" ,(T31 << 26)+( 10 << 1), M_403 | M_403C | M_505 | M_601 | M_6000,True ,True );
+ AddReg3("ADDE" ,"AE" ,(T31 << 26)+(138 << 1), M_403 | M_403C | M_505 | M_601 | M_6000,True ,True );
+ AddReg3("DIV" ,"DIV" ,(T31 << 26)+(331 << 1), M_6000,True ,True );
+ AddReg3("DIVS" ,"DIVS" ,(T31 << 26)+(363 << 1), M_6000,True ,True );
+ AddReg3("DIVW" ,"DIVW" ,(T31 << 26)+(491 << 1), M_403 | M_403C | M_505 | M_601 | M_6000,True ,True );
+ AddReg3("DIVWU" ,"DIVWU" ,(T31 << 26)+(459 << 1), M_403 | M_403C | M_505 | M_601 | M_6000,True ,True );
+ AddReg3("DOZ" ,"DOZ" ,(T31 << 26)+(264 << 1), M_6000,True ,True );
+ AddReg3("ECIWX" ,"ECIWX" ,(T31 << 26)+(310 << 1), M_6000,False,False);
+ AddReg3("LBZUX" ,"LBZUX" ,(T31 << 26)+(119 << 1), M_403 | M_403C | M_505 | M_601 | M_6000,False,False);
+ AddReg3("LBZX" ,"LBZX" ,(T31 << 26)+( 87 << 1), M_403 | M_403C | M_505 | M_601 | M_6000,False,False);
+ AddReg3("LHAUX" ,"LHAUX" ,(T31 << 26)+(375 << 1), M_403 | M_403C | M_505 | M_601 | M_6000,False,False);
+ AddReg3("LHAX" ,"LHAX" ,(T31 << 26)+(343 << 1), M_403 | M_403C | M_505 | M_601 | M_6000,False,False);
+ AddReg3("LHBRX" ,"LHBRX" ,(T31 << 26)+(790 << 1), M_403 | M_403C | M_505 | M_601 | M_6000,False,False);
+ AddReg3("LHZUX" ,"LHZUX" ,(T31 << 26)+(311 << 1), M_403 | M_403C | M_505 | M_601 | M_6000,False,False);
+ AddReg3("LHZX" ,"LHZX" ,(T31 << 26)+(279 << 1), M_403 | M_403C | M_505 | M_601 | M_6000,False,False);
+ AddReg3("LSCBX" ,"LSCBX" ,(T31 << 26)+(277 << 1), M_6000,False,True );
+ AddReg3("LSWX" ,"LSX" ,(T31 << 26)+(533 << 1), M_403 | M_403C | M_505 | M_601 | M_6000,False,False);
+ AddReg3("LWARX" ,"LWARX" ,(T31 << 26)+( 20 << 1), M_403 | M_403C | M_505 | M_601 | M_6000,False,False);
+ AddReg3("LWBRX" ,"LBRX" ,(T31 << 26)+(534 << 1), M_403 | M_403C | M_505 | M_601 | M_6000,False,False);
+ AddReg3("LWZUX" ,"LUX" ,(T31 << 26)+( 55 << 1), M_403 | M_403C | M_505 | M_601 | M_6000,False,False);
+ AddReg3("LWZX" ,"LX" ,(T31 << 26)+( 23 << 1), M_403 | M_403C | M_505 | M_601 | M_6000,False,False);
+ AddReg3("MUL" ,"MUL" ,(T31 << 26)+(107 << 1), M_6000,True ,True );
+ AddReg3("MULHW" ,"MULHW" ,(T31 << 26)+( 75 << 1), M_403 | M_403C | M_505 | M_601 | M_6000,False,True );
+ AddReg3("MULHWU","MULHWU",(T31 << 26)+( 11 << 1), M_403 | M_403C | M_505 | M_601 | M_6000,False,True );
+ AddReg3("MULLW" ,"MULS" ,(T31 << 26)+(235 << 1), M_403 | M_403C | M_505 | M_601 | M_6000,True ,True );
+ AddReg3("STBUX" ,"STBUX" ,(T31 << 26)+(247 << 1), M_403 | M_403C | M_505 | M_601 | M_6000,False,False);
+ AddReg3("STBX" ,"STBX" ,(T31 << 26)+(215 << 1), M_403 | M_403C | M_505 | M_601 | M_6000,False,False);
+ AddReg3("STHBRX","STHBRX",(T31 << 26)+(918 << 1), M_403 | M_403C | M_505 | M_601 | M_6000,False,False);
+ AddReg3("STHUX" ,"STHUX" ,(T31 << 26)+(439 << 1), M_403 | M_403C | M_505 | M_601 | M_6000,False,False);
+ AddReg3("STHX" ,"STHX" ,(T31 << 26)+(407 << 1), M_403 | M_403C | M_505 | M_601 | M_6000,False,False);
+ AddReg3("STSWX" ,"STSX" ,(T31 << 26)+(661 << 1), M_403 | M_403C | M_505 | M_601 | M_6000,False,False);
+ AddReg3("STWBRX","STBRX" ,(T31 << 26)+(662 << 1), M_403 | M_403C | M_505 | M_601 | M_6000,False,False);
+ AddReg3("STWCX.","STWCX.",(T31 << 26)+(150 << 1), M_403 | M_403C | M_505 | M_601 | M_6000,False,False);
+ AddReg3("STWUX" ,"STUX" ,(T31 << 26)+(183 << 1), M_403 | M_403C | M_505 | M_601 | M_6000,False,False);
+ AddReg3("STWX" ,"STX" ,(T31 << 26)+(151 << 1), M_403 | M_403C | M_505 | M_601 | M_6000,False,False);
+ AddReg3("SUBF" ,"SUBF" ,(T31 << 26)+( 40 << 1), M_403 | M_403C | M_505 | M_601 | M_6000,True ,True );
+ AddReg3("SUB" ,"SUB" ,(T31 << 26)+( 40 << 1), M_403 | M_403C | M_505 | M_601 | M_6000,True ,True );
+ AddReg3("SUBFC" ,"SF" ,(T31 << 26)+( 8 << 1), M_403 | M_403C | M_505 | M_601 | M_6000,True ,True );
+ AddReg3("SUBC" ,"SUBC" ,(T31 << 26)+( 8 << 1), M_403 | M_403C | M_505 | M_601 | M_6000,True ,True );
+ AddReg3("SUBFE" ,"SFE" ,(T31 << 26)+(136 << 1), M_403 | M_403C | M_505 | M_601 | M_6000,True ,True );
+ AddReg3("TLBSX" ,"TLBSX" ,(T31 << 26)+(914 << 1), M_403C ,False,True );
+
+ /* cD,cA,cB --> D A B */
+
+ CReg3Orders=(BaseOrder *) malloc(sizeof(BaseOrder)*CReg3OrderCount); InstrZ=0;
+ AddCReg3("CRAND" ,(T19 << 26)+(257 << 1), M_403 | M_403C | M_505 | M_601 | M_6000);
+ AddCReg3("CRANDC" ,(T19 << 26)+(129 << 1), M_403 | M_403C | M_505 | M_601 | M_6000);
+ AddCReg3("CREQV" ,(T19 << 26)+(289 << 1), M_403 | M_403C | M_505 | M_601 | M_6000);
+ AddCReg3("CRNAND" ,(T19 << 26)+(225 << 1), M_403 | M_403C | M_505 | M_601 | M_6000);
+ AddCReg3("CRNOR" ,(T19 << 26)+( 33 << 1), M_403 | M_403C | M_505 | M_601 | M_6000);
+ AddCReg3("CROR" ,(T19 << 26)+(449 << 1), M_403 | M_403C | M_505 | M_601 | M_6000);
+ AddCReg3("CRORC" ,(T19 << 26)+(417 << 1), M_403 | M_403C | M_505 | M_601 | M_6000);
+ AddCReg3("CRXOR" ,(T19 << 26)+(193 << 1), M_403 | M_403C | M_505 | M_601 | M_6000);
+
+ /* fD,fA,fB --> D A B */
+
+ FReg3Orders=(BaseOrder *) malloc(sizeof(BaseOrder)*FReg3OrderCount); InstrZ=0;
+ AddFReg3("FADD" ,"FA" ,(T63 << 26)+(21 << 1), M_601 | M_6000,True );
+ AddFReg3("FADDS" ,"FADDS" ,(T59 << 26)+(21 << 1), M_601 | M_6000,True );
+ AddFReg3("FDIV" ,"FD" ,(T63 << 26)+(18 << 1), M_601 | M_6000,True );
+ AddFReg3("FDIVS" ,"FDIVS" ,(T59 << 26)+(18 << 1), M_601 | M_6000,True );
+ AddFReg3("FSUB" ,"FS" ,(T63 << 26)+(20 << 1), M_601 | M_6000,True );
+
+ /* A,S,B --> S A B */
+
+ Reg3SwapOrders=(BaseOrder *) malloc(sizeof(BaseOrder)*Reg3SwapOrderCount); InstrZ=0;
+ AddReg3Swap("AND" ,"AND" ,(T31 << 26)+( 28 << 1), M_403 | M_403C | M_505 | M_601 | M_6000,True );
+ AddReg3Swap("ANDC" ,"ANDC" ,(T31 << 26)+( 60 << 1), M_403 | M_403C | M_505 | M_601 | M_6000,True );
+ AddReg3Swap("ECOWX" ,"ECOWX" ,(T31 << 26)+( 438 << 1), M_601 | M_6000,False);
+ AddReg3Swap("EQV" ,"EQV" ,(T31 << 26)+( 284 << 1), M_403 | M_403C | M_505 | M_601 | M_6000,True );
+ AddReg3Swap("MASKG" ,"MASKG" ,(T31 << 26)+( 29 << 1), M_6000,True );
+ AddReg3Swap("MASKIR","MASKIR",(T31 << 26)+( 541 << 1), M_6000,True );
+ AddReg3Swap("NAND" ,"NAND" ,(T31 << 26)+( 476 << 1), M_403 | M_403C | M_505 | M_601 | M_6000,True );
+ AddReg3Swap("NOR" ,"NOR" ,(T31 << 26)+( 124 << 1), M_403 | M_403C | M_505 | M_601 | M_6000,True );
+ AddReg3Swap("OR" ,"OR" ,(T31 << 26)+( 444 << 1), M_403 | M_403C | M_505 | M_601 | M_6000,True );
+ AddReg3Swap("ORC" ,"ORC" ,(T31 << 26)+( 412 << 1), M_403 | M_403C | M_505 | M_601 | M_6000,True );
+ AddReg3Swap("RRIB" ,"RRIB" ,(T31 << 26)+( 537 << 1), M_6000,True );
+ AddReg3Swap("SLE" ,"SLE" ,(T31 << 26)+( 153 << 1), M_6000,True );
+ AddReg3Swap("SLEQ" ,"SLEQ" ,(T31 << 26)+( 217 << 1), M_6000,True );
+ AddReg3Swap("SLLQ" ,"SLLQ" ,(T31 << 26)+( 216 << 1), M_6000,True );
+ AddReg3Swap("SLQ" ,"SLQ" ,(T31 << 26)+( 152 << 1), M_6000,True );
+ AddReg3Swap("SLW" ,"SL" ,(T31 << 26)+( 24 << 1), M_403 | M_403C | M_505 | M_601 | M_6000,True );
+ AddReg3Swap("SRAQ" ,"SRAQ" ,(T31 << 26)+( 920 << 1), M_6000,True );
+ AddReg3Swap("SRAW" ,"SRA" ,(T31 << 26)+( 792 << 1), M_403 | M_403C | M_505 | M_601 | M_6000,True );
+ AddReg3Swap("SRE" ,"SRE" ,(T31 << 26)+( 665 << 1), M_6000,True );
+ AddReg3Swap("SREA" ,"SREA" ,(T31 << 26)+( 921 << 1), M_6000,True );
+ AddReg3Swap("SREQ" ,"SREQ" ,(T31 << 26)+( 729 << 1), M_6000,True );
+ AddReg3Swap("SRLQ" ,"SRLQ" ,(T31 << 26)+( 728 << 1), M_6000,True );
+ AddReg3Swap("SRQ" ,"SRQ" ,(T31 << 26)+( 664 << 1), M_6000,True );
+ AddReg3Swap("SRW" ,"SR" ,(T31 << 26)+( 536 << 1), M_403 | M_403C | M_505 | M_601 | M_6000,True );
+ AddReg3Swap("XOR" ,"XOR" ,(T31 << 26)+( 316 << 1), M_403 | M_403C | M_505 | M_601 | M_6000,True );
+
+ /* fD,A,B --> D A B */
+
+ MixedOrders=(BaseOrder *) malloc(sizeof(BaseOrder)*MixedOrderCount); InstrZ=0;
+ AddMixed("LFDUX" ,"LFDUX" ,(T31 << 26)+(631 << 1), M_601 | M_6000);
+ AddMixed("LFDX" ,"LFDX" ,(T31 << 26)+(599 << 1), M_601 | M_6000);
+ AddMixed("LFSUX" ,"LFSUX" ,(T31 << 26)+(567 << 1), M_601 | M_6000);
+ AddMixed("LFSX" ,"LFSX" ,(T31 << 26)+(535 << 1), M_601 | M_6000);
+ AddMixed("STFDUX","STFDUX",(T31 << 26)+(759 << 1), M_601 | M_6000);
+ AddMixed("STFDX" ,"STFDX" ,(T31 << 26)+(727 << 1), M_601 | M_6000);
+ AddMixed("STFSUX","STFSUX",(T31 << 26)+(695 << 1), M_601 | M_6000);
+ AddMixed("STFSX" ,"STFSX" ,(T31 << 26)+(663 << 1), M_601 | M_6000);
+
+ /* fD,fA,fC,fB --> D A B C */
+
+ FReg4Orders=(BaseOrder *) malloc(sizeof(BaseOrder)*FReg4OrderCount); InstrZ=0;
+ AddFReg4("FMADD" ,"FMA" ,(T63 << 26)+(29 << 1), M_601 | M_6000,True );
+ AddFReg4("FMADDS" ,"FMADDS" ,(T59 << 26)+(29 << 1), M_601 | M_6000,True );
+ AddFReg4("FMSUB" ,"FMS" ,(T63 << 26)+(28 << 1), M_601 | M_6000,True );
+ AddFReg4("FMSUBS" ,"FMSUBS" ,(T59 << 26)+(28 << 1), M_601 | M_6000,True );
+ AddFReg4("FNMADD" ,"FNMA" ,(T63 << 26)+(31 << 1), M_601 | M_6000,True );
+ AddFReg4("FNMADDS","FNMADDS",(T59 << 26)+(31 << 1), M_601 | M_6000,True );
+ AddFReg4("FNMSUB" ,"FNMS" ,(T63 << 26)+(30 << 1), M_601 | M_6000,True );
+ AddFReg4("FNMSUBS","FNMSUBS",(T59 << 26)+(30 << 1), M_601 | M_6000,True );
+
+ /* D,d(A) --> D A d */
+
+ RegDispOrders=(BaseOrder *) malloc(sizeof(BaseOrder)*RegDispOrderCount); InstrZ=0;
+ AddRegDisp("LBZ" ,"LBZ" ,(T34 << 26), M_403 | M_403C | M_505 | M_601 | M_6000);
+ AddRegDisp("LBZU" ,"LBZU" ,(T35 << 26), M_403 | M_403C | M_505 | M_601 | M_6000);
+ AddRegDisp("LHA" ,"LHA" ,(T42 << 26), M_403 | M_403C | M_505 | M_601 | M_6000);
+ AddRegDisp("LHAU" ,"LHAU" ,(T43 << 26), M_403 | M_403C | M_505 | M_601 | M_6000);
+ AddRegDisp("LHZ" ,"LHZ" ,(T40 << 26), M_403 | M_403C | M_505 | M_601 | M_6000);
+ AddRegDisp("LHZU" ,"LHZU" ,(T41 << 26), M_403 | M_403C | M_505 | M_601 | M_6000);
+ AddRegDisp("LMW" ,"LM" ,(T46 << 26), M_403 | M_403C | M_505 | M_601 | M_6000);
+ AddRegDisp("LWZ" ,"L" ,(T32 << 26), M_403 | M_403C | M_505 | M_601 | M_6000);
+ AddRegDisp("LWZU" ,"LU" ,(T33 << 26), M_403 | M_403C | M_505 | M_601 | M_6000);
+ AddRegDisp("STB" ,"STB" ,(T38 << 26), M_403 | M_403C | M_505 | M_601 | M_6000);
+ AddRegDisp("STBU" ,"STBU" ,(T39 << 26), M_403 | M_403C | M_505 | M_601 | M_6000);
+ AddRegDisp("STH" ,"STH" ,(T44 << 26), M_403 | M_403C | M_505 | M_601 | M_6000);
+ AddRegDisp("STHU" ,"STHU" ,(T45 << 26), M_403 | M_403C | M_505 | M_601 | M_6000);
+ AddRegDisp("STMW" ,"STM" ,(T47 << 26), M_403 | M_403C | M_505 | M_601 | M_6000);
+ AddRegDisp("STW" ,"ST" ,(T36 << 26), M_403 | M_403C | M_505 | M_601 | M_6000);
+ AddRegDisp("STWU" ,"STU" ,(T37 << 26), M_403 | M_403C | M_505 | M_601 | M_6000);
+
+ /* fD,d(A) --> D A d */
+
+ FRegDispOrders=(BaseOrder *) malloc(sizeof(BaseOrder)*FRegDispOrderCount); InstrZ=0;
+ AddFRegDisp("LFD" ,"LFD" ,(T50 << 26), M_601 | M_6000);
+ AddFRegDisp("LFDU" ,"LFDU" ,(T51 << 26), M_601 | M_6000);
+ AddFRegDisp("LFS" ,"LFS" ,(T48 << 26), M_601 | M_6000);
+ AddFRegDisp("LFSU" ,"LFSU" ,(T49 << 26), M_601 | M_6000);
+ AddFRegDisp("STFD" ,"STFD" ,(T54 << 26), M_601 | M_6000);
+ AddFRegDisp("STFDU" ,"STFDU" ,(T55 << 26), M_601 | M_6000);
+ AddFRegDisp("STFS" ,"STFS" ,(T52 << 26), M_601 | M_6000);
+ AddFRegDisp("STFSU" ,"STFSU" ,(T53 << 26), M_601 | M_6000);
+
+ /* A,S,Imm5 --> S A Imm */
+
+ Reg2ImmOrders=(BaseOrder *) malloc(sizeof(BaseOrder)*Reg2ImmOrderCount); InstrZ=0;
+ AddReg2Imm("SLIQ" ,"SLIQ" ,(T31 << 26)+(184 << 1), M_6000,True);
+ AddReg2Imm("SLLIQ" ,"SLLIQ" ,(T31 << 26)+(248 << 1), M_6000,True);
+ AddReg2Imm("SRAIQ" ,"SRAIQ" ,(T31 << 26)+(952 << 1), M_6000,True);
+ AddReg2Imm("SRAWI" ,"SRAI" ,(T31 << 26)+(824 << 1), M_403 | M_403C | M_505 | M_601 | M_6000,True);
+ AddReg2Imm("SRIQ" ,"SRIQ" ,(T31 << 26)+(696 << 1), M_6000,True);
+ AddReg2Imm("SRLIQ" ,"SRLIQ" ,(T31 << 26)+(760 << 1), M_6000,True);
+
+ /* D,A,Imm --> D A Imm */
+
+ Imm16Orders=(BaseOrder *) malloc(sizeof(BaseOrder)*Imm16OrderCount); InstrZ=0;
+ AddImm16("ADDI" ,"CAL" ,T14 << 26, M_403 | M_403C | M_505 | M_601 | M_6000);
+ AddImm16("ADDIC" ,"AI" ,T12 << 26, M_403 | M_403C | M_505 | M_601 | M_6000);
+ AddImm16("ADDIC." ,"AI." ,T13 << 26, M_403 | M_403C | M_505 | M_601 | M_6000);
+ AddImm16("ADDIS" ,"CAU" ,T15 << 26, M_403 | M_403C | M_505 | M_601 | M_6000);
+ AddImm16("DOZI" ,"DOZI" , T9 << 26, M_6000);
+ AddImm16("MULLI" ,"MULI" , T7 << 26, M_403 | M_403C | M_505 | M_601 | M_6000);
+ AddImm16("SUBFIC" ,"SFI" , T8 << 26, M_403 | M_403C | M_505 | M_601 | M_6000);
+
+ /* A,S,Imm --> S A Imm */
+
+ Imm16SwapOrders=(BaseOrder *) malloc(sizeof(BaseOrder)*Imm16SwapOrderCount); InstrZ=0;
+ AddImm16Swap("ANDI." ,"ANDIL." ,T28 << 26, M_403 | M_403C | M_505 | M_601 | M_6000);
+ AddImm16Swap("ANDIS." ,"ANDIU." ,T29 << 26, M_403 | M_403C | M_505 | M_601 | M_6000);
+ AddImm16Swap("ORI" ,"ORIL" ,T24 << 26, M_403 | M_403C | M_505 | M_601 | M_6000);
+ AddImm16Swap("ORIS" ,"ORIU" ,T25 << 26, M_403 | M_403C | M_505 | M_601 | M_6000);
+ AddImm16Swap("XORI" ,"XORIL" ,T26 << 26, M_403 | M_403C | M_505 | M_601 | M_6000);
+ AddImm16Swap("XORIS" ,"XORIU" ,T27 << 26, M_403 | M_403C | M_505 | M_601 | M_6000);
+END
+
+ static void DeinitNames(BaseOrder *Orders, int OrderCount)
+BEGIN
+ int z;
+
+ for (z=0; z<OrderCount; free(Orders[z++].Name));
+END
+
+ static void DeinitFields(void)
+BEGIN
+ free(FixedOrders);
+ free(Reg1Orders);
+ free(FReg1Orders);
+ free(CReg1Orders);
+ free(CBit1Orders);
+ DeinitNames(Reg2Orders,Reg2OrderCount); free(Reg2Orders);
+ free(CReg2Orders);
+ DeinitNames(FReg2Orders,FReg2OrderCount); free(FReg2Orders);
+ free(Reg2BOrders);
+ DeinitNames(Reg2SwapOrders,Reg2SwapOrderCount); free(Reg2SwapOrders);
+ free(NoDestOrders);
+ DeinitNames(Reg3Orders,Reg3OrderCount); free(Reg3Orders);
+ free(CReg3Orders);
+ DeinitNames(FReg3Orders,FReg3OrderCount); free(FReg3Orders);
+ DeinitNames(Reg3SwapOrders,Reg3SwapOrderCount); free(Reg3SwapOrders);
+ free(MixedOrders);
+ DeinitNames(FReg4Orders,FReg4OrderCount); free(FReg4Orders);
+ free(RegDispOrders);
+ free(FRegDispOrders);
+ DeinitNames(Reg2ImmOrders,Reg2ImmOrderCount); free(Reg2ImmOrders);
+ free(Imm16Orders);
+ free(Imm16SwapOrders);
+END
+
+/*-------------------------------------------------------------------------*/
+
+ static void PutCode(LongWord Code)
+BEGIN
+#if 0
+ memcpy(BAsmCode,&Code,4);
+ if (NOT BigEndian) DSwap((void *)BAsmCode,4);
+#endif
+ DAsmCode[0]=Code;
+END
+
+ static void IncCode(LongWord Code)
+BEGIN
+#if 0
+ BAsmCode[0]+=(Code >> 24) & 0xff;
+ BAsmCode[1]+=(Code >> 16) & 0xff;
+ BAsmCode[2]+=(Code >> 8) & 0xff;
+ BAsmCode[3]+=(Code ) & 0xff;
+#endif
+ DAsmCode[0]+=Code;
+END
+
+/*-------------------------------------------------------------------------*/
+
+ static Boolean DecodeGenReg(char *Asc, LongWord *Erg)
+BEGIN
+ Boolean io;
+ char *s;
+
+ if (FindRegDef(Asc, &s)) Asc = s;
+
+ if ((strlen(Asc) < 2) OR (toupper(*Asc) != 'R')) return False;
+ else
+ BEGIN
+ *Erg = ConstLongInt(Asc+1,&io);
+ return ((io) AND (*Erg <= 31));
+ END
+END
+
+ static Boolean DecodeFPReg(char *Asc, LongWord *Erg)
+BEGIN
+ Boolean io;
+ char *s;
+
+ if (FindRegDef(Asc, &s)) Asc = s;
+
+ if ((strlen(Asc)<3) OR (toupper(*Asc)!='F') OR (toupper(Asc[1])!='R')) return False;
+ else
+ BEGIN
+ *Erg=ConstLongInt(Asc+2,&io);
+ return ((io) AND (*Erg<=31));
+ END
+END
+
+ static Boolean DecodeCondReg(char *Asc, LongWord *Erg)
+BEGIN
+ Boolean OK;
+
+ *Erg=EvalIntExpression(Asc,UInt3,&OK) << 2;
+ return ((OK) AND (*Erg<=31));
+END
+
+ static Boolean DecodeCondBit(char *Asc, LongWord *Erg)
+BEGIN
+ Boolean OK;
+
+ *Erg=EvalIntExpression(Asc,UInt5,&OK);
+ return ((OK) AND (*Erg<=31));
+END
+
+ static Boolean DecodeRegDisp(char *Asc, LongWord *Erg)
+BEGIN
+ char *p;
+ int l=strlen(Asc);
+ LongInt Disp;
+ Boolean OK;
+
+ if (Asc[l-1]!=')') return False; Asc[l-1]='\0'; l--;
+ p=Asc+l-1; while ((p>=Asc) AND (*p!='(')) p--;
+ if (p<Asc) return False;
+ if (NOT DecodeGenReg(p+1,Erg)) return False;
+ *p='\0';
+ Disp=EvalIntExpression(Asc,Int16,&OK); if (NOT OK) return False;
+ *Erg=(*Erg << 16)+(Disp & 0xffff); return True;
+END
+
+/*-------------------------------------------------------------------------*/
+
+ static Boolean Convert6000(char *Name1, char *Name2)
+BEGIN
+ if (NOT Memo(Name1)) return True;
+ if (MomCPU==CPU6000)
+ BEGIN
+ strmaxcpy(OpPart,Name2,255);
+ return True;
+ END
+ else
+ BEGIN
+ WrError(1200); return False;
+ END
+END
+
+ static Boolean PMemo(char *Name)
+BEGIN
+ String tmp;
+
+ if (Memo(Name)) return True;
+
+ strmaxcpy(tmp,Name,255); strmaxcat(tmp,".",255);
+ return (Memo(tmp));
+END
+
+ static void IncPoint(void)
+BEGIN
+ if (OpPart[strlen(OpPart)-1]=='.') IncCode(1);
+END
+
+ static void ChkSup(void)
+BEGIN
+ if (NOT SupAllowed) WrError(50);
+END
+
+ static Boolean ChkCPU(Byte Mask)
+BEGIN
+ return (((Mask >> (MomCPU-CPU403))&1)==1);
+END
+
+/*-------------------------------------------------------------------------*/
+
+ static Boolean DecodePseudo(void)
+BEGIN
+ if (Memo("REG"))
+ BEGIN
+ if (ArgCnt!=1) WrError(1110);
+ else AddRegDef(LabPart,ArgStr[1]);
+ return True;
+ END
+
+ return False;
+END
+
+ static void SwapCode(LongWord *Code)
+BEGIN
+ *Code=((*Code & 0x1f) << 5) | ((*Code >> 5) & 0x1f);
+END
+
+ static void MakeCode_601(void)
+BEGIN
+ int z;
+ Integer Imm;
+ LongWord Dest,Src1,Src2,Src3;
+ LongInt Dist;
+ Boolean OK;
+
+ CodeLen=0; DontPrint=False;
+
+ /* Nullanweisung */
+
+ if ((Memo("")) AND (*AttrPart=='\0') AND (ArgCnt==0)) return;
+
+ /* Pseudoanweisungen */
+
+ if (DecodePseudo()) return;
+
+ if (DecodeIntelPseudo(BigEnd)) return;
+
+ /* ohne Argument */
+
+ for (z=0; z<FixedOrderCount; z++)
+ if (Memo(FixedOrders[z].Name))
+ BEGIN
+ if (ArgCnt!=0) WrError(1110);
+ else if (NOT ChkCPU(FixedOrders[z].CPUMask)) WrXError(1500,OpPart);
+ else
+ BEGIN
+ CodeLen=4; PutCode(FixedOrders[z].Code);
+ if (Memo("RFI")) ChkSup();
+ END
+ return;
+ END
+
+ /* ein Register */
+
+ for (z=0; z<Reg1OrderCount; z++)
+ if Memo(Reg1Orders[z].Name)
+ BEGIN
+ if (ArgCnt!=1) WrError(1110);
+ else if (NOT ChkCPU(Reg1Orders[z].CPUMask)) WrXError(1500,OpPart);
+ else if (NOT DecodeGenReg(ArgStr[1],&Dest)) WrError(1350);
+ else
+ BEGIN
+ CodeLen=4; PutCode(Reg1Orders[z].Code+(Dest << 21));
+ if (Memo("MTMSR")) ChkSup();
+ END
+ return;
+ END
+
+ /* ein Steuerregister */
+
+ for (z=1; z<CReg1OrderCount; z++)
+ if (Memo(CReg1Orders[z].Name))
+ BEGIN
+ if (ArgCnt!=1) WrError(1110);
+ else if (NOT ChkCPU(CReg1Orders[z].CPUMask)) WrXError(1500,OpPart);
+ else if (NOT DecodeCondReg(ArgStr[1],&Dest)) WrError(1350);
+ else if ((Dest & 3)!=0) WrError(1351);
+ else
+ BEGIN
+ CodeLen=4; PutCode(CReg1Orders[z].Code+(Dest << 21));
+ END
+ return;
+ END
+
+ /* ein Steuerregisterbit */
+
+ for (z=0; z<CBit1OrderCount; z++)
+ if (Memo(CBit1Orders[z].Name))
+ BEGIN
+ if (ArgCnt!=1) WrError(1110);
+ else if (NOT ChkCPU(CBit1Orders[z].CPUMask)) WrXError(1500,OpPart);
+ else if (NOT DecodeCondBit(ArgStr[1],&Dest)) WrError(1350);
+ else
+ BEGIN
+ CodeLen=4; PutCode(CBit1Orders[z].Code+(Dest << 21));
+ END
+ return;
+ END
+
+ /* ein Gleitkommaregister */
+
+ for (z=0; z<FReg1OrderCount; z++)
+ if (Memo(FReg1Orders[z].Name))
+ BEGIN
+ if (ArgCnt!=1) WrError(1110);
+ else if (NOT ChkCPU(FReg1Orders[z].CPUMask)) WrXError(1500,OpPart);
+ else if (NOT DecodeFPReg(ArgStr[1],&Dest)) WrError(1350);
+ else
+ BEGIN
+ CodeLen=4; PutCode(FReg1Orders[z].Code+(Dest << 21));
+ END
+ return;
+ END
+
+ /* 1/2 Integer-Register */
+
+ for (z=0; z<Reg2OrderCount; z++)
+ if (Memo(Reg2Orders[z].Name))
+ BEGIN
+ if (ArgCnt==1)
+ BEGIN
+ ArgCnt=2; strcpy(ArgStr[2],ArgStr[1]);
+ END
+ if (ArgCnt!=2) WrError(1110);
+ else if (NOT ChkCPU(Reg2Orders[z].CPUMask)) WrXError(1500,OpPart);
+ else if (NOT DecodeGenReg(ArgStr[1],&Dest)) WrError(1350);
+ else if (NOT DecodeGenReg(ArgStr[2],&Src1)) WrError(1350);
+ else
+ BEGIN
+ CodeLen=4; PutCode(Reg2Orders[z].Code+(Dest << 21)+(Src1 << 16));
+ END
+ return;
+ END
+
+ /* 2 Bedingungs-Bits */
+
+ for (z=0; z<CReg2OrderCount; z++)
+ if Memo(CReg2Orders[z].Name)
+ BEGIN
+ if (ArgCnt!=2) WrError(1110);
+ else if (NOT ChkCPU(CReg2Orders[z].CPUMask)) WrXError(1500,OpPart);
+ else if (NOT DecodeCondReg(ArgStr[1],&Dest)) WrError(1350);
+ else if ((Dest & 3)!=0) WrError(1351);
+ else if (NOT DecodeCondReg(ArgStr[2],&Src1)) WrError(1350);
+ else if ((Src1 & 3)!=0) WrError(1351);
+ else
+ BEGIN
+ CodeLen=4; PutCode(CReg2Orders[z].Code+(Dest << 21)+(Src1 << 16));
+ END
+ return;
+ END
+
+ /* 1/2 Float-Register */
+
+ for (z=0; z<FReg2OrderCount; z++)
+ if Memo(FReg2Orders[z].Name)
+ BEGIN
+ if (ArgCnt==1)
+ BEGIN
+ ArgCnt=2; strcpy(ArgStr[2],ArgStr[1]);
+ END
+ if (ArgCnt!=2) WrError(1110);
+ else if (NOT ChkCPU(FReg2Orders[z].CPUMask)) WrXError(1500,OpPart);
+ else if (NOT DecodeFPReg(ArgStr[1],&Dest)) WrError(1350);
+ else if (NOT DecodeFPReg(ArgStr[2],&Src1)) WrError(1350);
+ else
+ BEGIN
+ CodeLen=4; PutCode(FReg2Orders[z].Code+(Dest << 21)+(Src1 << 11));
+ END
+ return;
+ END
+
+ /* 1/2 Integer-Register, Quelle in B */
+
+ for (z=0; z<Reg2BOrderCount; z++)
+ if Memo(Reg2BOrders[z].Name)
+ BEGIN
+ if (ArgCnt==1)
+ BEGIN
+ ArgCnt=2; strcpy(ArgStr[2],ArgStr[1]);
+ END
+ if (ArgCnt!=2) WrError(1110);
+ else if (NOT ChkCPU(Reg2BOrders[z].CPUMask)) WrXError(1500,OpPart);
+ else if (NOT DecodeGenReg(ArgStr[1],&Dest)) WrError(1350);
+ else if (NOT DecodeGenReg(ArgStr[2],&Src1)) WrError(1350);
+ else
+ BEGIN
+ CodeLen=4; PutCode(Reg2BOrders[z].Code+(Dest << 21)+(Src1 << 11));
+ ChkSup();
+ END
+ return;
+ END
+
+ /* 1/2 Integer-Register, getauscht */
+
+ for (z=0; z<Reg2SwapOrderCount; z++)
+ if (Memo(Reg2SwapOrders[z].Name))
+ BEGIN
+ if (ArgCnt==1)
+ BEGIN
+ ArgCnt=2; strcpy(ArgStr[2],ArgStr[1]);
+ END
+ if (ArgCnt!=2) WrError(1110);
+ else if (NOT ChkCPU(Reg2SwapOrders[z].CPUMask)) WrXError(1500,OpPart);
+ else if (NOT DecodeGenReg(ArgStr[1],&Dest)) WrError(1350);
+ else if (NOT DecodeGenReg(ArgStr[2],&Src1)) WrError(1350);
+ else
+ BEGIN
+ CodeLen=4; PutCode(Reg2SwapOrders[z].Code+(Dest << 16)+(Src1 << 21));
+ END
+ return;
+ END
+
+ /* 2 Integer-Register, kein Ziel */
+
+ for (z=0; z<NoDestOrderCount; z++)
+ if (Memo(NoDestOrders[z].Name))
+ BEGIN
+ if (ArgCnt!=2) WrError(1110);
+ else if (NOT ChkCPU(NoDestOrders[z].CPUMask)) WrXError(1500,OpPart);
+ else if (NOT DecodeGenReg(ArgStr[1],&Src1)) WrError(1350);
+ else if (NOT DecodeGenReg(ArgStr[2],&Src2)) WrError(1350);
+ else
+ BEGIN
+ CodeLen=4; PutCode(NoDestOrders[z].Code+(Src1 << 16)+(Src2 << 11));
+ END
+ return;
+ END
+
+ /* 2/3 Integer-Register */
+
+ for (z=0; z<Reg3OrderCount; z++)
+ if (Memo(Reg3Orders[z].Name))
+ BEGIN
+ if (ArgCnt==2)
+ BEGIN
+ ArgCnt=3; strcpy(ArgStr[3],ArgStr[2]); strcpy(ArgStr[2],ArgStr[1]);
+ END
+ if (ArgCnt!=3) WrError(1110);
+ else if (NOT ChkCPU(Reg3Orders[z].CPUMask)) WrXError(1500,OpPart);
+ else if (NOT DecodeGenReg(ArgStr[1],&Dest)) WrError(1350);
+ else if (NOT DecodeGenReg(ArgStr[2],&Src1)) WrError(1350);
+ else if (NOT DecodeGenReg(ArgStr[3],&Src2)) WrError(1350);
+ else
+ BEGIN
+ CodeLen=4; PutCode(Reg3Orders[z].Code+(Dest << 21)+(Src1 << 16)+(Src2 << 11));
+ END
+ return;
+ END
+
+ /* 2/3 Bedingungs-Bits */
+
+ for (z=0; z<CReg3OrderCount; z++)
+ if (Memo(CReg3Orders[z].Name))
+ BEGIN
+ if (ArgCnt==2)
+ BEGIN
+ ArgCnt=3; strcpy(ArgStr[3],ArgStr[2]); strcpy(ArgStr[2],ArgStr[1]);
+ END
+ if (ArgCnt!=3) WrError(1110);
+ else if (NOT ChkCPU(CReg3Orders[z].CPUMask)) WrXError(1500,OpPart);
+ else if (NOT DecodeCondBit(ArgStr[1],&Dest)) WrError(1350);
+ else if (NOT DecodeCondBit(ArgStr[2],&Src1)) WrError(1350);
+ else if (NOT DecodeCondBit(ArgStr[3],&Src2)) WrError(1350);
+ else
+ BEGIN
+ CodeLen=4; PutCode(CReg3Orders[z].Code+(Dest << 21)+(Src1 << 16)+(Src2 << 11));
+ END
+ return;
+ END
+
+ /* 2/3 Float-Register */
+
+ for (z=0; z<FReg3OrderCount; z++)
+ if (Memo(FReg3Orders[z].Name))
+ BEGIN
+ if (ArgCnt==2)
+ BEGIN
+ ArgCnt=3; strcpy(ArgStr[3],ArgStr[2]); strcpy(ArgStr[2],ArgStr[1]);
+ END
+ if (ArgCnt!=3) WrError(1110);
+ else if (NOT ChkCPU(FReg3Orders[z].CPUMask)) WrXError(1500,OpPart);
+ else if (NOT DecodeFPReg(ArgStr[1],&Dest)) WrError(1350);
+ else if (NOT DecodeFPReg(ArgStr[2],&Src1)) WrError(1350);
+ else if (NOT DecodeFPReg(ArgStr[3],&Src2)) WrError(1350);
+ else
+ BEGIN
+ CodeLen=4; PutCode(FReg3Orders[z].Code+(Dest << 21)+(Src1 << 16)+(Src2 << 11));
+ END
+ return;
+ END
+
+ /* 2/3 Integer-Register, Ziel & Quelle 1 getauscht */
+
+ for (z=0; z<Reg3SwapOrderCount; z++)
+ if (Memo(Reg3SwapOrders[z].Name))
+ BEGIN
+ if (ArgCnt==2)
+ BEGIN
+ ArgCnt=3; strcpy(ArgStr[3],ArgStr[2]); strcpy(ArgStr[2],ArgStr[1]);
+ END
+ if (ArgCnt!=3) WrError(1110);
+ else if (NOT ChkCPU(Reg3SwapOrders[z].CPUMask)) WrXError(1500,OpPart);
+ else if (NOT DecodeGenReg(ArgStr[1],&Dest)) WrError(1350);
+ else if (NOT DecodeGenReg(ArgStr[2],&Src1)) WrError(1350);
+ else if (NOT DecodeGenReg(ArgStr[3],&Src2)) WrError(1350);
+ else
+ BEGIN
+ CodeLen=4; PutCode(Reg3SwapOrders[z].Code+(Dest << 16)+(Src1 << 21)+(Src2 << 11));
+ END
+ return;
+ END
+
+ /* 1 Float und 2 Integer-Register */
+
+ for (z=0; z<MixedOrderCount; z++)
+ if (Memo(MixedOrders[z].Name))
+ BEGIN
+ if (ArgCnt!=3) WrError(1110);
+ else if (NOT ChkCPU(MixedOrders[z].CPUMask)) WrXError(1500,OpPart);
+ else if (NOT DecodeFPReg(ArgStr[1],&Dest)) WrError(1350);
+ else if (NOT DecodeGenReg(ArgStr[2],&Src1)) WrError(1350);
+ else if (NOT DecodeGenReg(ArgStr[3],&Src2)) WrError(1350);
+ else
+ BEGIN
+ CodeLen=4; PutCode(MixedOrders[z].Code+(Dest << 21)+(Src1 << 16)+(Src2 << 11));
+ END
+ return;
+ END
+
+ /* 3/4 Float-Register */
+
+ for (z=0; z<FReg4OrderCount; z++)
+ if (Memo(FReg4Orders[z].Name))
+ BEGIN
+ if (ArgCnt==3)
+ BEGIN
+ ArgCnt=4; strcpy(ArgStr[4],ArgStr[3]);
+ strcpy(ArgStr[3],ArgStr[2]); strcpy(ArgStr[2],ArgStr[1]);
+ END
+ if (ArgCnt!=4) WrError(1110);
+ else if (NOT ChkCPU(FReg4Orders[z].CPUMask)) WrXError(1500,OpPart);
+ else if (NOT DecodeFPReg(ArgStr[1],&Dest)) WrError(1350);
+ else if (NOT DecodeFPReg(ArgStr[2],&Src1)) WrError(1350);
+ else if (NOT DecodeFPReg(ArgStr[3],&Src3)) WrError(1350);
+ else if (NOT DecodeFPReg(ArgStr[4],&Src2)) WrError(1350);
+ else
+ BEGIN
+ CodeLen=4;
+ PutCode(FReg4Orders[z].Code+(Dest << 21)+(Src1 << 16)+(Src2 << 11)+(Src3 << 6));
+ END
+ return;
+ END
+
+ /* Register mit indiziertem Speicheroperandem */
+
+ for (z=0; z<RegDispOrderCount; z++)
+ if (Memo(RegDispOrders[z].Name))
+ BEGIN
+ if (ArgCnt!=2) WrError(1110);
+ else if (NOT DecodeGenReg(ArgStr[1],&Dest)) WrError(1350);
+ else if (NOT DecodeRegDisp(ArgStr[2],&Src1)) WrError(1350);
+ else
+ BEGIN
+ PutCode(RegDispOrders[z].Code+(Dest << 21)+Src1); CodeLen=4;
+ END
+ return;
+ END
+
+ /* Gleitkommaregister mit indiziertem Speicheroperandem */
+
+ for (z=0; z<FRegDispOrderCount; z++)
+ if (Memo(FRegDispOrders[z].Name))
+ BEGIN
+ if (ArgCnt!=2) WrError(1110);
+ else if (NOT DecodeFPReg(ArgStr[1],&Dest)) WrError(1350);
+ else if (NOT DecodeRegDisp(ArgStr[2],&Src1)) WrError(1350);
+ else
+ BEGIN
+ PutCode(FRegDispOrders[z].Code+(Dest << 21)+Src1); CodeLen=4;
+ END
+ return;
+ END
+
+ /* 2 verdrehte Register mit immediate */
+
+ for (z=0; z<Reg2ImmOrderCount; z++)
+ if (Memo(Reg2ImmOrders[z].Name))
+ BEGIN
+ if (ArgCnt!=3) WrError(1110);
+ else if (NOT ChkCPU(Reg2ImmOrders[z].CPUMask)) WrXError(1500,OpPart);
+ else if (NOT DecodeGenReg(ArgStr[1],&Dest)) WrError(1350);
+ else if (NOT DecodeGenReg(ArgStr[2],&Src1)) WrError(1350);
+ else
+ BEGIN
+ Src2=EvalIntExpression(ArgStr[3],UInt5,&OK);
+ if (OK)
+ BEGIN
+ PutCode(Reg2ImmOrders[z].Code+(Src1 << 21)+(Dest << 16)+(Src2 << 11));
+ CodeLen=4;
+ END
+ END
+ return;
+ END
+
+ /* 2 Register+immediate */
+
+ for (z=0; z<Imm16OrderCount; z++)
+ if (Memo(Imm16Orders[z].Name))
+ BEGIN
+ if (ArgCnt==2)
+ BEGIN
+ ArgCnt=3; strcpy(ArgStr[3],ArgStr[2]); strcpy(ArgStr[2],ArgStr[1]);
+ END
+ if (ArgCnt!=3) WrError(1110);
+ else if (NOT ChkCPU(Imm16Orders[z].CPUMask)) WrXError(1500,OpPart);
+ else if (NOT DecodeGenReg(ArgStr[1],&Dest)) WrError(1350);
+ else if (NOT DecodeGenReg(ArgStr[2],&Src1)) WrError(1350);
+ else
+ BEGIN
+ Imm=EvalIntExpression(ArgStr[3],Int16,&OK);
+ if (OK)
+ BEGIN
+ CodeLen=4; PutCode(Imm16Orders[z].Code+(Dest << 21)+(Src1 << 16)+(Imm & 0xffff));
+ END
+ END
+ return;
+ END
+
+ /* 2 Register+immediate, Ziel & Quelle 1 getauscht */
+
+ for (z=0; z<Imm16SwapOrderCount; z++)
+ if (Memo(Imm16SwapOrders[z].Name))
+ BEGIN
+ if (ArgCnt==2)
+ BEGIN
+ ArgCnt=3; strcpy(ArgStr[3],ArgStr[2]); strcpy(ArgStr[2],ArgStr[1]);
+ END
+ if (ArgCnt!=3) WrError(1110);
+ else if (NOT ChkCPU(Imm16SwapOrders[z].CPUMask)) WrXError(1500,OpPart);
+ else if (NOT DecodeGenReg(ArgStr[1],&Dest)) WrError(1350);
+ else if (NOT DecodeGenReg(ArgStr[2],&Src1)) WrError(1350);
+ else
+ BEGIN
+ Imm=EvalIntExpression(ArgStr[3],Int16,&OK);
+ if (OK)
+ BEGIN
+ CodeLen=4; PutCode(Imm16SwapOrders[z].Code+(Dest << 16)+(Src1 << 21)+(Imm & 0xffff));
+ END
+ END
+ return;
+ END
+
+ /* Ausreisser... */
+
+ if (NOT Convert6000("FM","FMUL")) return;
+ if (NOT Convert6000("FM.","FMUL.")) return;
+
+ if ((PMemo("FMUL")) OR (PMemo("FMULS")))
+ BEGIN
+ if (ArgCnt==2)
+ BEGIN
+ strcpy(ArgStr[3],ArgStr[2]); strcpy(ArgStr[2],ArgStr[1]); ArgCnt=3;
+ END
+ if (ArgCnt!=3) WrError(1110);
+ else if (NOT DecodeFPReg(ArgStr[1],&Dest)) WrError(1350);
+ else if (NOT DecodeFPReg(ArgStr[2],&Src1)) WrError(1350);
+ else if (NOT DecodeFPReg(ArgStr[3],&Src2)) WrError(1350);
+ else
+ BEGIN
+ PutCode((T59 << 26)+(25 << 1)+(Dest << 21)+(Src1 << 16)+(Src2 << 6));
+ if (PMemo("FMUL")) IncCode(T4 << 26);
+ IncPoint();
+ CodeLen=4;
+ END
+ return;
+ END
+
+ if (NOT Convert6000("LSI","LSWI")) return;
+ if (NOT Convert6000("STSI","STSWI")) return;
+
+ if ((Memo("LSWI")) OR (Memo("STSWI")))
+ BEGIN
+ if (ArgCnt!=3) WrError(1110);
+ else if (NOT DecodeGenReg(ArgStr[1],&Dest)) WrError(1350);
+ else if (NOT DecodeGenReg(ArgStr[2],&Src1)) WrError(1350);
+ else
+ BEGIN
+ Src2=EvalIntExpression(ArgStr[3],UInt5,&OK);
+ if (OK)
+ BEGIN
+ PutCode((T31 << 26)+(597 << 1)+(Dest << 21)+(Src1 << 16)+(Src2 << 11));
+ if (Memo("STSWI")) IncCode(128 << 1);
+ CodeLen=4;
+ END
+ END
+ return;
+ END
+
+ if ((Memo("MFSPR")) OR (Memo("MTSPR")))
+ BEGIN
+ if (Memo("MTSPR"))
+ BEGIN
+ strcpy(ArgStr[3],ArgStr[1]); strcpy(ArgStr[1],ArgStr[2]); strcpy(ArgStr[2],ArgStr[3]);
+ END
+ if (ArgCnt!=2) WrError(1110);
+ else if (NOT DecodeGenReg(ArgStr[1],&Dest)) WrError(1350);
+ else
+ BEGIN
+ Src1=EvalIntExpression(ArgStr[2],UInt10,&OK);
+ if (OK)
+ BEGIN
+ SwapCode(&Src1);
+ PutCode((T31 << 26)+(Dest << 21)+(Src1 << 11));
+ IncCode((Memo("MFSPR") ? 339 : 467) << 1);
+ CodeLen=4;
+ END
+ END
+ return;
+ END
+
+ if ((Memo("MFDCR")) OR (Memo("MTDCR")))
+ BEGIN
+ if (Memo("MTDCR"))
+ BEGIN
+ strcpy(ArgStr[3],ArgStr[1]); strcpy(ArgStr[1],ArgStr[2]); strcpy(ArgStr[2],ArgStr[3]);
+ END
+ if (ArgCnt!=2) WrError(1110);
+ else if (MomCPU>=CPU505) WrXError(1500,OpPart);
+ else if (NOT DecodeGenReg(ArgStr[1],&Dest)) WrError(1350);
+ else
+ BEGIN
+ Src1=EvalIntExpression(ArgStr[2],UInt10,&OK);
+ if (OK)
+ BEGIN
+ SwapCode(&Src1);
+ PutCode((T31 << 26)+(Dest << 21)+(Src1 << 11));
+ IncCode((Memo("MFDCR") ? 323 : 451) << 1);
+ CodeLen=4;
+ END
+ END
+ return;
+ END
+
+ if ((Memo("MFSR")) OR (Memo("MTSR")))
+ BEGIN
+ if (Memo("MTSR"))
+ BEGIN
+ strcpy(ArgStr[3],ArgStr[1]); strcpy(ArgStr[1],ArgStr[2]); strcpy(ArgStr[2],ArgStr[3]);
+ END
+ if (ArgCnt!=2) WrError(1110);
+ else if (NOT DecodeGenReg(ArgStr[1],&Dest)) WrError(1350);
+ else
+ BEGIN
+ Src1=EvalIntExpression(ArgStr[2],UInt4,&OK);
+ if (OK)
+ BEGIN
+ PutCode((T31 << 26)+(Dest << 21)+(Src1 << 16));
+ IncCode((Memo("MFSR") ? 595 : 210) << 1);
+ CodeLen=4; ChkSup();
+ END
+ END
+ return;
+ END
+
+ if (Memo("MTCRF"))
+ BEGIN
+ if ((ArgCnt<1) OR (ArgCnt>2)) WrError(1110);
+ else if (NOT DecodeGenReg(ArgStr[ArgCnt],&Src1)) WrError(1350);
+ else
+ BEGIN
+ OK=True;
+ if (ArgCnt==1) Dest=0xff;
+ else Dest=EvalIntExpression(ArgStr[1],UInt8,&OK);
+ if (OK)
+ BEGIN
+ PutCode((T31 << 26)+(Src1 << 21)+(Dest << 12)+(144 << 1));
+ CodeLen=4;
+ END
+ END
+ return;
+ END
+
+ if (PMemo("MTFSF"))
+ BEGIN
+ if (ArgCnt!=2) WrError(1110);
+ else if (NOT DecodeFPReg(ArgStr[2],&Src1)) WrError(1350);
+ else
+ BEGIN
+ Dest=EvalIntExpression(ArgStr[1],UInt8,&OK);
+ if (OK)
+ BEGIN
+ PutCode((T63 << 26)+(Dest << 17)+(Src1 << 11)+(711 << 1));
+ IncPoint();
+ CodeLen=4;
+ END
+ END
+ return;
+ END
+
+ if (PMemo("MTFSFI"))
+ BEGIN
+ if (ArgCnt!=2) WrError(1110);
+ else if (NOT DecodeCondReg(ArgStr[1],&Dest)) WrError(1350);
+ else if ((Dest & 3)!=0) WrError(1351);
+ else
+ BEGIN
+ Src1=EvalIntExpression(ArgStr[2],UInt4,&OK);
+ if (OK)
+ BEGIN
+ PutCode((T63 << 26)+(Dest << 21)+(Src1 << 12)+(134 << 1));
+ IncPoint();
+ CodeLen=4;
+ END
+ END
+ return;
+ END
+
+ if (PMemo("RLMI"))
+ BEGIN
+ if (ArgCnt!=5) WrError(1110);
+ else if (MomCPU<CPU6000) WrXError(1500,OpPart);
+ else if (NOT DecodeGenReg(ArgStr[1],&Dest)) WrError(1350);
+ else if (NOT DecodeGenReg(ArgStr[2],&Src1)) WrError(1350);
+ else if (NOT DecodeGenReg(ArgStr[3],&Src2)) WrError(1350);
+ else
+ BEGIN
+ Src3=EvalIntExpression(ArgStr[4],UInt5,&OK);
+ if (OK)
+ BEGIN
+ Imm=EvalIntExpression(ArgStr[5],UInt5,&OK);
+ if (OK)
+ BEGIN
+ PutCode((T22 << 26)+(Src1 << 21)+(Dest << 16)
+ +(Src2 << 11)+(Src3 << 6)+(Imm << 1));
+ IncPoint();
+ CodeLen=4;
+ END
+ END
+ END
+ return;
+ END
+
+ if (NOT Convert6000("RLNM","RLWNM")) return;
+ if (NOT Convert6000("RLNM.","RLWNM.")) return;
+
+ if (PMemo("RLWNM"))
+ BEGIN
+ if (ArgCnt!=5) WrError(1110);
+ else if (NOT DecodeGenReg(ArgStr[1],&Dest)) WrError(1350);
+ else if (NOT DecodeGenReg(ArgStr[2],&Src1)) WrError(1350);
+ else if (NOT DecodeGenReg(ArgStr[3],&Src2)) WrError(1350);
+ else
+ BEGIN
+ Src3=EvalIntExpression(ArgStr[4],UInt5,&OK);
+ if (OK)
+ BEGIN
+ Imm=EvalIntExpression(ArgStr[5],UInt5,&OK);
+ if (OK)
+ BEGIN
+ PutCode((T23 << 26)+(Src1 << 21)+(Dest << 16)
+ +(Src2 << 11)+(Src3 << 6)+(Imm << 1));
+ IncPoint();
+ CodeLen=4;
+ END
+ END
+ END
+ return;
+ END
+
+ if (NOT Convert6000("RLIMI","RLWIMI")) return;
+ if (NOT Convert6000("RLIMI.","RLWIMI.")) return;
+ if (NOT Convert6000("RLINM","RLWINM")) return;
+ if (NOT Convert6000("RLINM.","RLWINM.")) return;
+
+ if ((PMemo("RLWIMI")) OR (PMemo("RLWINM")))
+ BEGIN
+ if (ArgCnt!=5) WrError(1110);
+ else if (NOT DecodeGenReg(ArgStr[1],&Dest)) WrError(1350);
+ else if (NOT DecodeGenReg(ArgStr[2],&Src1)) WrError(1350);
+ else
+ BEGIN
+ Src2=EvalIntExpression(ArgStr[3],UInt5,&OK);
+ if (OK)
+ BEGIN
+ Src3=EvalIntExpression(ArgStr[4],UInt5,&OK);
+ if (OK)
+ BEGIN
+ Imm=EvalIntExpression(ArgStr[5],UInt5,&OK);
+ if (OK)
+ BEGIN
+ PutCode((T20 << 26)+(Dest << 16)+(Src1 << 21)
+ +(Src2 << 11)+(Src3 << 6)+(Imm << 1));
+ if (PMemo("RLWINM")) IncCode(T1 << 26);
+ IncPoint();
+ CodeLen=4;
+ END
+ END
+ END
+ END
+ return;
+ END
+
+ if (NOT Convert6000("TLBI","TLBIE")) return;
+
+ if (Memo("TLBIE"))
+ BEGIN
+ if (ArgCnt!=1) WrError(1110);
+ else if (NOT DecodeGenReg(ArgStr[1],&Src1)) WrError(1350);
+ else
+ BEGIN
+ PutCode((T31 << 26)+(Src1 << 11)+(306 << 1));
+ CodeLen=4; ChkSup();
+ END
+ return;
+ END
+
+ if (NOT Convert6000("T","TW")) return;
+
+ if (Memo("TW"))
+ BEGIN
+ if (ArgCnt!=3) WrError(1110);
+ else if (NOT DecodeGenReg(ArgStr[2],&Src1)) WrError(1350);
+ else if (NOT DecodeGenReg(ArgStr[3],&Src2)) WrError(1350);
+ else
+ BEGIN
+ Dest=EvalIntExpression(ArgStr[1],UInt5,&OK);
+ if (OK)
+ BEGIN
+ PutCode((T31 << 26)+(Dest << 21)+(Src1 << 16)+(Src2 << 11)+(4 << 1));
+ CodeLen=4;
+ END
+ END
+ return;
+ END
+
+ if (NOT Convert6000("TI","TWI")) return;
+
+ if (Memo("TWI"))
+ BEGIN
+ if (ArgCnt!=3) WrError(1110);
+ else if (NOT DecodeGenReg(ArgStr[2],&Src1)) WrError(1350);
+ else
+ BEGIN
+ Imm=EvalIntExpression(ArgStr[3],Int16,&OK);
+ if (OK)
+ BEGIN
+ Dest=EvalIntExpression(ArgStr[1],UInt5,&OK);
+ if (OK)
+ BEGIN
+ PutCode((T3 << 26)+(Dest << 21)+(Src1 << 16)+(Imm & 0xffff));
+ CodeLen=4;
+ END
+ END
+ END
+ return;
+ END
+
+ if (Memo("WRTEEI"))
+ BEGIN
+ if (ArgCnt!=1) WrError(1110);
+ else if (MomCPU>=CPU505) WrXError(1500,OpPart);
+ else
+ BEGIN
+ Src1=EvalIntExpression(ArgStr[1],UInt1,&OK) << 15;
+ if (OK)
+ BEGIN
+ PutCode((T31 << 26)+Src1+(163 << 1));
+ CodeLen=4;
+ END
+ END
+ return;
+ END
+
+ /* Vergleiche */
+
+ if ((Memo("CMP")) OR (Memo("CMPL")))
+ BEGIN
+ if (ArgCnt==3)
+ BEGIN
+ strcpy(ArgStr[4],ArgStr[3]); strcpy(ArgStr[3],ArgStr[2]); strmaxcpy(ArgStr[2],"0",255); ArgCnt=4;
+ END
+ if (ArgCnt!=4) WrError(1110);
+ else if (NOT DecodeGenReg(ArgStr[4],&Src2)) WrError(1350);
+ else if (NOT DecodeGenReg(ArgStr[3],&Src1)) WrError(1350);
+ else if (NOT DecodeCondReg(ArgStr[1],&Dest)) WrError(1350);
+ else if ((Dest & 3)!=0) WrError(1351);
+ else
+ BEGIN
+ Src3=EvalIntExpression(ArgStr[2],UInt1,&OK);
+ if (OK)
+ BEGIN
+ PutCode((T31 << 26)+(Dest << 21)+(Src3 << 21)+(Src1 << 16)
+ +(Src2 << 11));
+ if (Memo("CMPL")) IncCode(32 << 1);
+ CodeLen=4;
+ END
+ END
+ return;
+ END
+
+ if ((Memo("FCMPO")) OR (Memo("FCMPU")))
+ BEGIN
+ if (ArgCnt!=3) WrError(1110);
+ else if (NOT DecodeFPReg(ArgStr[3],&Src2)) WrError(1350);
+ else if (NOT DecodeFPReg(ArgStr[2],&Src1)) WrError(1350);
+ else if (NOT DecodeCondReg(ArgStr[1],&Dest)) WrError(1350);
+ else if ((Dest & 3)!=0) WrError(1351);
+ else
+ BEGIN
+ PutCode((T63 << 26)+(Dest << 21)+(Src1 << 16)+(Src2 << 11));
+ if (Memo("FCMPO")) IncCode(32 << 1);
+ CodeLen=4;
+ END
+ return;
+ END
+
+ if ((Memo("CMPI")) OR (Memo("CMPLI")))
+ BEGIN
+ if (ArgCnt==3)
+ BEGIN
+ strcpy(ArgStr[4],ArgStr[3]); strcpy(ArgStr[3],ArgStr[2]); strmaxcpy(ArgStr[2],"0",255); ArgCnt=4;
+ END
+ if (ArgCnt!=4) WrError(1110);
+ else
+ BEGIN
+ Src2=EvalIntExpression(ArgStr[4],Int16,&OK);
+ if (OK)
+ if (NOT DecodeGenReg(ArgStr[3],&Src1)) WrError(1350);
+ else if (NOT DecodeCondReg(ArgStr[1],&Dest)) WrError(1350);
+ else if ((Dest & 3)!=0) WrError(1351);
+ else
+ BEGIN
+ Src3=EvalIntExpression(ArgStr[2],UInt1,&OK);
+ if (OK)
+ BEGIN
+ PutCode((T10 << 26)+(Dest << 21)+(Src3 << 21)
+ +(Src1 << 16)+(Src2 & 0xffff));
+ if (Memo("CMPI")) IncCode(T1 << 26);
+ CodeLen=4;
+ END
+ END
+ END
+ return;
+ END
+
+ /* Spruenge */
+
+ if ((Memo("B")) OR (Memo("BL")) OR (Memo("BA")) OR (Memo("BLA")))
+ BEGIN
+ if (ArgCnt!=1) WrError(1110);
+ else
+ BEGIN
+ Dist=EvalIntExpression(ArgStr[1],Int32,&OK);
+ if (OK)
+ BEGIN
+ if ((Memo("B")) OR (Memo("BL"))) Dist-=EProgCounter();
+ if ((NOT SymbolQuestionable) AND (Dist>0x1ffffff)) WrError(1320);
+ else if ((NOT SymbolQuestionable) AND (Dist<-0x2000000l)) WrError(1315);
+ else if ((Dist & 3)!=0) WrError(1375);
+ else
+ BEGIN
+ PutCode((T18 << 26)+(Dist & 0x03fffffc));
+ if ((Memo("BA")) OR (Memo("BLA"))) IncCode(2);
+ if ((Memo("BL")) OR (Memo("BLA"))) IncCode(1);
+ CodeLen=4;
+ END
+ END
+ END
+ return;
+ END
+
+ if ((Memo("BC")) OR (Memo("BCL")) OR (Memo("BCA")) OR (Memo("BCLA")))
+ BEGIN
+ if (ArgCnt!=3) WrError(1110);
+ else
+ BEGIN
+ Src1=EvalIntExpression(ArgStr[1],UInt5,&OK); /* BO */
+ if (OK)
+ BEGIN
+ Src2=EvalIntExpression(ArgStr[2],UInt5,&OK); /* BI */
+ if (OK)
+ BEGIN
+ Dist=EvalIntExpression(ArgStr[3],Int32,&OK); /* ADR */
+ if (OK)
+ BEGIN
+ if ((Memo("BC")) OR (Memo("BCL"))) Dist-=EProgCounter();
+ if ((NOT SymbolQuestionable) AND (Dist>0x7fff)) WrError(1320);
+ else if ((NOT SymbolQuestionable) AND (Dist<-0x8000l)) WrError(1315);
+ else if ((Dist & 3)!=0) WrError(1375);
+ else
+ BEGIN
+ PutCode((T16 << 26)+(Src1 << 21)+(Src2 << 16)+(Dist & 0xfffc));
+ if ((Memo("BCA")) OR (Memo("BCLA"))) IncCode(2);
+ if ((Memo("BCL")) OR (Memo("BCLA"))) IncCode(1);
+ CodeLen=4;
+ END
+ END
+ END
+ END
+ END
+ return;
+ END
+
+ if (NOT Convert6000("BCC","BCCTR")) return;
+ if (NOT Convert6000("BCCL","BCCTRL")) return;
+ if (NOT Convert6000("BCR","BCLR")) return;
+ if (NOT Convert6000("BCRL","BCLRL")) return;
+
+ if ((Memo("BCCTR")) OR (Memo("BCCTRL")) OR (Memo("BCLR")) OR (Memo("BCLRL")))
+ BEGIN
+ if (ArgCnt!=2) WrError(1110);
+ else
+ BEGIN
+ Src1=EvalIntExpression(ArgStr[1],UInt5,&OK);
+ if (OK)
+ BEGIN
+ Src2=EvalIntExpression(ArgStr[2],UInt5,&OK);
+ if (OK)
+ BEGIN
+ PutCode((T19 << 26)+(Src1 << 21)+(Src2 << 16));
+ if ((Memo("BCCTR")) OR (Memo("BCCTRL")))
+ IncCode(528 << 1);
+ else
+ IncCode(16 << 1);
+ if ((Memo("BCCTRL")) OR (Memo("BCLRL"))) IncCode(1);
+ CodeLen=4;
+ END
+ END
+ END
+ return;
+ END
+
+ if ((Memo("TLBRE")) OR (Memo("TLBWE")))
+ BEGIN
+ if (ArgCnt!=3) WrError(1110);
+ else if (MomCPU != CPU403C) WrError(1500);
+ else if (NOT DecodeGenReg(ArgStr[1], &Src1)) WrError(1350);
+ else if (NOT DecodeGenReg(ArgStr[2], &Src2)) WrError(1350);
+ else
+ BEGIN
+ Src3 = EvalIntExpression(ArgStr[3], UInt1, &OK);
+ if (OK)
+ BEGIN
+ PutCode((T31 << 26) + (Src1 << 21) + (Src2 << 16) +
+ (Src3 << 11) + (946 << 1));
+ if (Memo("TLBWE")) IncCode(32 << 1);
+ CodeLen = 4;
+ END
+ END
+ return;
+ END
+
+ /* unbekannter Befehl */
+
+ WrXError(1200,OpPart);
+END
+
+ static Boolean IsDef_601(void)
+BEGIN
+ return Memo("REG");
+END
+
+ static void InitPass_601(void)
+BEGIN
+ SaveInitProc();
+ SetFlag(&BigEnd,BigEndianName,False);
+END
+
+ static void InternSymbol_601(char *Asc, TempResult *Erg)
+BEGIN
+ int l=strlen(Asc);
+
+ Erg->Typ=TempNone;
+ if ((l==3) OR (l==4))
+ if ((toupper(*Asc)=='C') AND (toupper(Asc[1])=='R'))
+ if ((Asc[l-1]>='0') AND (Asc[l-1]<='7'))
+ if ((l==3) != ((toupper(Asc[2])=='F') OR (toupper(Asc[3])=='B')))
+ BEGIN
+ Erg->Typ=TempInt; Erg->Contents.Int=Asc[l-1]-'0';
+ END
+END
+
+ static void SwitchFrom_601(void)
+BEGIN
+ DeinitFields(); ClearONOFF();
+END
+
+ static void SwitchTo_601(void)
+BEGIN
+ PFamilyDescr FoundDscr;
+
+ TurnWords=True; ConstMode=ConstModeC; SetIsOccupied=False;
+
+ FoundDscr=FindFamilyByName("MPC601"); if (FoundDscr==Nil) exit(255);
+
+ PCSymbol="*"; HeaderID=FoundDscr->Id; NOPCode=0x000000000;
+ DivideChars=","; HasAttrs=False;
+
+ ValidSegs=(1<<SegCode);
+ Grans[SegCode]=1; ListGrans[SegCode]=4; SegInits[SegCode]=0;
+#ifdef __STDC__
+ SegLimits[SegCode] = 0xfffffffful;
+#else
+ SegLimits[SegCode] = 0xffffffffl;
+#endif
+
+ MakeCode=MakeCode_601; IsDef=IsDef_601;
+ SwitchFrom=SwitchFrom_601; InternSymbol=InternSymbol_601;
+ AddONOFF("SUPMODE", &SupAllowed, SupAllowedName,False);
+ AddONOFF("BIGENDIAN", &BigEnd, BigEndianName, False);
+
+ InitFields();
+END
+
+
+ void code601_init(void)
+BEGIN
+ CPU403 =AddCPU("PPC403", SwitchTo_601);
+ CPU403C =AddCPU("PPC403GC", SwitchTo_601);
+ CPU505 =AddCPU("MPC505", SwitchTo_601);
+ CPU601 =AddCPU("MPC601", SwitchTo_601);
+ CPU6000 =AddCPU("RS6000", SwitchTo_601);
+
+ SaveInitProc=InitPassProc; InitPassProc=InitPass_601;
+END
+
generated by cgit v1.2.3 (git 2.25.1) at 2024-04-25 23:55:14 +0000