diff options
| author | Ash Wolf <ninji@wuffs.org> | 2022-11-20 00:07:22 -0500 |
|---|---|---|
| committer | Ash Wolf <ninji@wuffs.org> | 2022-11-20 00:07:22 -0500 |
| commit | 9d2728a5605f651934fe67a6fe6986b3e4a2c011 (patch) | |
| tree | e81e0a3588a0c8d1855bf28316efe27d86b04d66 | |
| parent | 9a46dd0e2e80790d9848c0bbd718932a27c23269 (diff) | |
| download | MWCC-9d2728a5605f651934fe67a6fe6986b3e4a2c011.tar.gz MWCC-9d2728a5605f651934fe67a6fe6986b3e4a2c011.zip | |
add a bunch of code and a ton of stub files for later
190 files changed, 23691 insertions, 1172 deletions
diff --git a/CMakeLists.txt b/CMakeLists.txt index a67979d..46669f5 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -8,85 +8,205 @@ include_directories(includes) include_directories(sdk_hdrs) add_executable(mwcc - command_line/CmdLine/Src/Callbacks/CLCompilerLinkerDropin_V10.cpp - command_line/CmdLine/Src/Callbacks/CLDropinCallbacks_V10.cpp - command_line/CmdLine/Src/Callbacks/CLParserCallbacks_v1.cpp - command_line/CmdLine/Src/Clients/ClientGlue.c command_line/CmdLine/Src/Clients/CLStaticMain.c - command_line/CmdLine/Src/Envir/CLErrors.c - command_line/CmdLine/Src/Envir/CLIO.c - command_line/CmdLine/Src/MacEmul/ErrMgr.c - command_line/CmdLine/Src/MacEmul/Files.c - command_line/CmdLine/Src/MacEmul/LowMem.c - command_line/CmdLine/Src/MacEmul/Memory.c + command_line/CmdLine/Src/Clients/ClientGlue.c + command_line/CmdLine/Src/CLMain.c command_line/CmdLine/Src/MacEmul/Resources.c + command_line/CmdLine/Src/Envir/CLErrors.c command_line/CmdLine/Src/MacEmul/ResourceStrings.c - command_line/CmdLine/Src/MacEmul/TextUtils.c - command_line/CmdLine/Src/OSLib/FileHandles.c - command_line/CmdLine/Src/OSLib/Generic.c - command_line/CmdLine/Src/OSLib/MacFileTypes.c - command_line/CmdLine/Src/OSLib/MacSpecs.c - command_line/CmdLine/Src/OSLib/MemUtils.c + command_line/CmdLine/Src/Plugins/CLPlugins.c + command_line/CmdLine/Src/Callbacks/CLParserCallbacks_v1.cpp + command_line/CmdLine/Src/Envir/CLIO.c + command_line/CmdLine/Src/CLToolExec.c command_line/CmdLine/Src/OSLib/Posix.c command_line/CmdLine/Src/OSLib/StringExtras.c - command_line/CmdLine/Src/OSLib/StringUtils.c - command_line/CmdLine/Src/Plugins/CLPlugins.c + command_line/CmdLine/Src/OSLib/Generic.c + command_line/CmdLine/Src/Project/CLProj.c + command_line/CmdLine/Src/CLLicenses.c + command_line/CmdLine/Src/OSLib/MemUtils.c + command_line/CmdLine/Src/CLPluginRequests.cpp + command_line/CmdLine/Src/MacEmul/LowMem.c + command_line/CmdLine/Src/CLFileOps.c + command_line/CmdLine/Src/CLPrefs.c + command_line/CmdLine/Src/CLTarg.c command_line/CmdLine/Src/Project/CLAccessPaths.c + command_line/CmdLine/Src/OSLib/MacSpecs.c + command_line/CmdLine/Src/OSLib/StringUtils.c + command_line/CmdLine/Src/MacEmul/Memory.c + command_line/CmdLine/Src/MacEmul/Files.c + command_line/CmdLine/Src/MacEmul/TextUtils.c + command_line/CmdLine/Src/uFileTypeMappings.c command_line/CmdLine/Src/Project/CLFiles.c command_line/CmdLine/Src/Project/CLOverlays.c - command_line/CmdLine/Src/Project/CLProj.c command_line/CmdLine/Src/Project/CLSegs.c - command_line/CmdLine/Src/CLBrowser.c + command_line/CmdLine/Src/Callbacks/CLDropinCallbacks_V10.cpp + command_line/CmdLine/Src/OSLib/MacFileTypes.c + command_line/CmdLine/Src/OSLib/FileHandles.c + command_line/CmdLine/Src/Callbacks/CLCompilerLinkerDropin_V10.cpp command_line/CmdLine/Src/CLDependencies.c - command_line/CmdLine/Src/CLFileOps.c + command_line/CmdLine/Src/CLWriteObjectFile.c + command_line/CmdLine/Src/CLBrowser.c command_line/CmdLine/Src/CLIncludeFileCache.c - command_line/CmdLine/Src/CLLicenses.c command_line/CmdLine/Src/CLLoadAndCache.c - command_line/CmdLine/Src/CLMain.c - command_line/CmdLine/Src/CLPrefs.c - command_line/CmdLine/Src/CLTarg.c - command_line/CmdLine/Src/CLToolExec.c - command_line/CmdLine/Src/CLWriteObjectFile.c - unsorted/ParserFace.c - unsorted/uContext1.cpp - unsorted/uContextCL.cpp - unsorted/uContextParser.cpp - unsorted/uContextSecret.cpp - unsorted/StaticParserGlue.c - unsorted/ParserHelpers.c - unsorted/ToolHelpers.c - unsorted/ParserHelpers-cc.c - unsorted/ToolHelpers-cc.c - unsorted/IO.c - unsorted/Projects.c - unsorted/Targets.c - unsorted/ParserErrors.c - unsorted/Utils.c + command_line/CmdLine/Src/MacEmul/ErrMgr.c compiler_and_linker/CmdLine_Tools/MacOS_PPC/Tools_PPC/Src/Static/cc-mach-ppc-mw.c + compiler_and_linker/CmdLine_Tools/MacOS_PPC/Tools_PPC/Src/Options/Glue/ParserGlue-mach-ppc-cc.c compiler_and_linker/CmdLine_Tools/MacOS_PPC/Tools_PPC/Src/Plugin/cc-mach-ppc.c compiler_and_linker/CmdLine_Tools/MacOS_PPC/Tools_PPC/Src/Plugin/libimp-mach-ppc.c - command_line/C++_Parser/Src/Library/WarningHelpers.c - unsorted/uLibImporter.c - command_line/CmdLine/Src/CLPluginRequests.cpp - unsorted/uCOS.c - command_line/CmdLine/Src/uFileTypeMappings.c - compiler_and_linker/CmdLine_Tools/MacOS_PPC/Tools_PPC/Src/Options/Glue/ParserGlue-mach-ppc-cc.c - unsorted/Arguments.c - unsorted/Help.c - unsorted/Option.c - unsorted/Parameter.c unsorted/TargetOptimizer-ppc-mach.c unsorted/OptimizerHelpers.c compiler_and_linker/CmdLine_Tools/MacOS_PPC/Tools_PPC/Src/Options/Glue/TargetWarningHelpers-ppc-cc.c + command_line/C++_Parser/Src/Library/WarningHelpers.c + compiler_and_linker/unsorted/CCompiler.c - unsorted/CmdLineBuildDate.c + compiler_and_linker/unsorted/CParser.c + compiler_and_linker/FrontEnd/Common/CompilerTools.c + compiler_and_linker/unsorted/CodeGenOptPPC.c + compiler_and_linker/unsorted/IrOptimizer.c + compiler_and_linker/unsorted/CodeGen.c + compiler_and_linker/FrontEnd/C/CPrep.c compiler_and_linker/FrontEnd/C/CScope.c - compiler_and_linker/unsorted/CPrec.c - compiler_and_linker/unsorted/CError.c - compiler_and_linker/unsorted/CInt64.c compiler_and_linker/unsorted/CMachine.c + compiler_and_linker/unsorted/CExpr.c + compiler_and_linker/unsorted/CFunc.c + compiler_and_linker/unsorted/CTemplateNew.c + compiler_and_linker/unsorted/CError.c + compiler_and_linker/unsorted/ObjGenMachO.c + compiler_and_linker/unsorted/CDecl.c + compiler_and_linker/unsorted/CMangler.c + compiler_and_linker/unsorted/CSOM.c + compiler_and_linker/unsorted/CABI.c + compiler_and_linker/unsorted/CInit.c + compiler_and_linker/unsorted/CClass.c + compiler_and_linker/unsorted/CIRTransform.c + compiler_and_linker/unsorted/CObjC.c + compiler_and_linker/unsorted/CInline.c compiler_and_linker/FrontEnd/C/CPrepTokenizer.c - compiler_and_linker/FrontEnd/C/CPrep.c + compiler_and_linker/unsorted/CTemplateTools.c + compiler_and_linker/unsorted/IroPointerAnalysis.c + compiler_and_linker/unsorted/InstrSelection.c + compiler_and_linker/unsorted/IroFlowgraph.c + compiler_and_linker/unsorted/IroLinearForm.c + compiler_and_linker/unsorted/IroUtil.c + compiler_and_linker/unsorted/IroCSE.c + compiler_and_linker/unsorted/IroPropagate.c + compiler_and_linker/unsorted/IROUseDef.c + compiler_and_linker/unsorted/InlineAsmPPC.c + compiler_and_linker/unsorted/IroDump.c + compiler_and_linker/unsorted/IroTransform.c + compiler_and_linker/unsorted/IroVars.c + compiler_and_linker/unsorted/IroEval.c + compiler_and_linker/unsorted/IroJump.c + compiler_and_linker/unsorted/IroRangePropagation.c + compiler_and_linker/unsorted/IroEmptyLoop.c + compiler_and_linker/unsorted/IroUnrollLoop.c + compiler_and_linker/unsorted/IroLoop.c + compiler_and_linker/unsorted/IroExprRegeneration.c + compiler_and_linker/unsorted/IroSubable.c + compiler_and_linker/unsorted/RegisterInfo.c + compiler_and_linker/unsorted/TOC.c + compiler_and_linker/unsorted/StackFrame.c + compiler_and_linker/unsorted/Registers.c compiler_and_linker/unsorted/PCode.c + compiler_and_linker/unsorted/Switch.c + compiler_and_linker/unsorted/ValueNumbering.c + compiler_and_linker/unsorted/PCodeUtilities.c + compiler_and_linker/unsorted/Operands.c + compiler_and_linker/unsorted/Exceptions.c + + compiler_and_linker/unsorted/COptimizer.c + compiler_and_linker/unsorted/GlobalOptimizer.c + compiler_and_linker/unsorted/PCodeListing.c + compiler_and_linker/unsorted/Peephole.c + compiler_and_linker/unsorted/Scheduler.c + compiler_and_linker/unsorted/Coloring.c + compiler_and_linker/unsorted/PCodeAssembly.c + compiler_and_linker/unsorted/Intrinsics.c + compiler_and_linker/unsorted/PPCError.c + compiler_and_linker/unsorted/CExpr2.c + compiler_and_linker/unsorted/CInt64.c + compiler_and_linker/unsorted/CPrec.c + compiler_and_linker/unsorted/CBrowse.c + compiler_and_linker/unsorted/CPreprocess.c + compiler_and_linker/unsorted/FuncLevelAsmPPC.c + compiler_and_linker/unsorted/CException.c + compiler_and_linker/unsorted/CTemplateClass.c + + compiler_and_linker/unsorted/CRTTI.c + compiler_and_linker/unsorted/CObjCModern.c + compiler_and_linker/unsorted/InlineAsm.c + compiler_and_linker/unsorted/Unmangle.c + compiler_and_linker/unsorted/MachO.c + compiler_and_linker/unsorted/GenStabs.c + compiler_and_linker/unsorted/CTemplateFunc.c + compiler_and_linker/unsorted/IroMalloc.c compiler_and_linker/unsorted/PCodeInfo.c - compiler_and_linker/unsorted/RegisterInfo.c compiler_and_linker/unsorted/Registers.c compiler_and_linker/unsorted/CMangler.c compiler_and_linker/unsorted/CodeGen.c includes/compiler/Operands.h compiler_and_linker/unsorted/Operands.c includes/compiler/PCodeUtilities.h compiler_and_linker/unsorted/PCodeUtilities.c compiler_and_linker/unsorted/TOC.c compiler_and_linker/unsorted/StackFrame.c includes/compiler/StackFrame.h includes/compiler/TOC.h includes/compiler/CInit.h compiler_and_linker/unsorted/CInit.c compiler_and_linker/unsorted/CExpr.c includes/compiler/CExpr.h compiler_and_linker/unsorted/CExpr2.c includes/compiler/CParser.h compiler_and_linker/unsorted/CParser.c compiler_and_linker/unsorted/CDecl.c includes/compiler/CDecl.h compiler_and_linker/unsorted/CABI.c includes/compiler/CABI.h includes/compiler/CMachine.h includes/compiler/CMangler.h includes/compiler/CScope.h includes/compiler/CPrep.h includes/compiler/CPrepTokenizer.h includes/compiler/CodeGen.h includes/compiler/CClass.h compiler_and_linker/unsorted/CClass.c compiler_and_linker/unsorted/CFunc.c includes/compiler/CFunc.h includes/compiler/CInline.h compiler_and_linker/unsorted/CInline.c) + compiler_and_linker/unsorted/StructMoves.c + compiler_and_linker/unsorted/FunctionCalls.c + compiler_and_linker/unsorted/IroBitVect.c + compiler_and_linker/unsorted/InlineAsmRegistersPPC.c + compiler_and_linker/unsorted/InlineAsmMnemonicsPPC.c + compiler_and_linker/unsorted/InlineAsmRegisters.c + compiler_and_linker/unsorted/Alias.c + compiler_and_linker/unsorted/LoopDetection.c + compiler_and_linker/unsorted/CopyPropagation.c + compiler_and_linker/unsorted/CodeMotion.c + compiler_and_linker/unsorted/StrengthReduction.c + compiler_and_linker/unsorted/LoopOptimization.c + compiler_and_linker/unsorted/ConstantPropagation.c + compiler_and_linker/unsorted/AddPropagation.c + compiler_and_linker/unsorted/UseDefChains.c + compiler_and_linker/unsorted/LoadDeletion.c + compiler_and_linker/unsorted/VectorArraysToRegs.c + + compiler_and_linker/unsorted/InterferenceGraph.c + compiler_and_linker/unsorted/SpillCode.c + compiler_and_linker/unsorted/GCCInlineAsm.c + compiler_and_linker/unsorted/BitVectors.c + + unsorted/StaticParserGlue.c + unsorted/ParserFace.c + unsorted/ParserHelpers.c + unsorted/ToolHelpers.c + unsorted/ParserHelpers-cc.c + unsorted/Arguments.c + unsorted/ToolHelpers-cc.c + unsorted/IO.c + unsorted/Projects.c + unsorted/Targets.c + unsorted/Option.c + unsorted/ParserErrors.c + unsorted/Utils.c + unsorted/Parameter.c + unsorted/Help.c + unsorted/uContext1.cpp + unsorted/uContextCL.cpp + unsorted/uContextSecret.cpp + unsorted/uCOS.c + unsorted/uContextParser.cpp + unsorted/uLibImporter.c + unsorted/CmdLineBuildDate.c + + includes/compiler/RegisterInfo.h + includes/compiler/Registers.h + includes/compiler/InstrSelection.h + includes/compiler/CCompiler.h + includes/compiler/CABI.h + includes/compiler/CMachine.h + includes/compiler/CMangler.h + includes/compiler/CScope.h + includes/compiler/CPrep.h + includes/compiler/CPrepTokenizer.h + includes/compiler/CodeGen.h + includes/compiler/CClass.h + includes/compiler/CFunc.h + includes/compiler/CInline.h + includes/compiler/Operands.h + includes/compiler/PCodeUtilities.h + includes/compiler/StackFrame.h + includes/compiler/TOC.h + includes/compiler/CInit.h + includes/compiler/CExpr.h + includes/compiler/CParser.h + includes/compiler/CDecl.h + ) diff --git a/compiler_and_linker/FrontEnd/C/CPrep.c b/compiler_and_linker/FrontEnd/C/CPrep.c index 4e3ffea..4b66e88 100644 --- a/compiler_and_linker/FrontEnd/C/CPrep.c +++ b/compiler_and_linker/FrontEnd/C/CPrep.c @@ -46,15 +46,6 @@ static void gotonexttoken(); extern SInt16 *CLT_filesp; extern CPrepFileInfo **CLT_filestack; -//#define OPT_OFFSET(optname) ((short) (((char *) (&copts.optname)) - ((char *) &copts))) -#define OPT_OFFSET(optname) ((short) ( &((COpts *)0)->optname )) -enum { - OPT_OFFSET_MASK = 0x1FFF, - OPT_FLAG_2000 = 0x2000, - OPT_FLAG_4000 = 0x4000, - OPT_FLAG_8000 = 0x8000 -}; - struct CompilerOption { char *name; short bits; diff --git a/compiler_and_linker/unsorted/AddPropagation.c b/compiler_and_linker/unsorted/AddPropagation.c new file mode 100644 index 0000000..e69de29 --- /dev/null +++ b/compiler_and_linker/unsorted/AddPropagation.c diff --git a/compiler_and_linker/unsorted/Alias.c b/compiler_and_linker/unsorted/Alias.c new file mode 100644 index 0000000..e69de29 --- /dev/null +++ b/compiler_and_linker/unsorted/Alias.c diff --git a/compiler_and_linker/unsorted/BitVectors.c b/compiler_and_linker/unsorted/BitVectors.c new file mode 100644 index 0000000..e69de29 --- /dev/null +++ b/compiler_and_linker/unsorted/BitVectors.c diff --git a/compiler_and_linker/unsorted/CABI.c b/compiler_and_linker/unsorted/CABI.c index 0b29b9d..e903797 100644 --- a/compiler_and_linker/unsorted/CABI.c +++ b/compiler_and_linker/unsorted/CABI.c @@ -9,7 +9,7 @@ static void *cabi_pathcur; // TODO type static TypeClass *cabi_loop_class; static Boolean cabi_loop_construct; -short CABI_GetStructResultArgumentIndex(void) { +short CABI_GetStructResultArgumentIndex(TypeFunc *tfunc) { return 0; } diff --git a/compiler_and_linker/unsorted/CBrowse.c b/compiler_and_linker/unsorted/CBrowse.c new file mode 100644 index 0000000..e69de29 --- /dev/null +++ b/compiler_and_linker/unsorted/CBrowse.c diff --git a/compiler_and_linker/unsorted/CClass.c b/compiler_and_linker/unsorted/CClass.c index 7932586..0d2091b 100644 --- a/compiler_and_linker/unsorted/CClass.c +++ b/compiler_and_linker/unsorted/CClass.c @@ -1,4 +1,11 @@ #include "compiler/CClass.h" +#include "compiler/CError.h" +#include "compiler/CInline.h" +#include "compiler/CMangler.h" +#include "compiler/CParser.h" +#include "compiler/CompilerTools.h" +#include "compiler/CodeGen.h" +#include "compiler/objects.h" typedef struct OVClassBase { struct OVClassBase *next; @@ -23,8 +30,17 @@ typedef struct OVClass { Boolean alloced_vtable; } OVClass; +typedef struct ThunkList { + struct ThunkList *next; + Object *thunkobj; + Object *obj; + SInt32 a; + SInt32 b; + SInt32 c; +} ThunkList; + static TypeClass *main_class; -static void *cclass_thunklist; // TODO type +static ThunkList *cclass_thunklist; static TypeClass *cclass_isbase_mostderived; static void *cclass_isbase_foundoffset; // TODO type static Boolean cclass_isambigbase; @@ -45,8 +61,45 @@ static SInt32 cclass_dominator_ooffset; static Object *cclass_dominator_eobject; void CClass_Init(void) {} -void CClass_GenThunks(void) {} -static Object *CClass_ThunkObject(Object *obj, SInt32 a, SInt32 b, SInt32 c) {} + +void CClass_GenThunks(void) { + ThunkList *list; + + for (list = cclass_thunklist; list; list = list->next) { + list->obj->flags |= OBJECT_FLAGS_4; + CodeGen_GenVDispatchThunk(list->thunkobj, list->obj, list->a, list->b, list->c); + } +} + +static Object *CClass_ThunkObject(Object *obj, SInt32 a, SInt32 b, SInt32 c) { + Object *thunkobj; + ThunkList *list; + + CInline_ObjectAddrRef(obj); + for (list = cclass_thunklist; list; list = list->next) { + if (obj == list->obj && a == list->a && b == list->b && c == list->c) + return list->thunkobj; + } + + thunkobj = CParser_NewCompilerDefFunctionObject(); + thunkobj->name = CMangler_ThunkName(obj, a, b, c); + thunkobj->type = TYPE(&rt_func); + thunkobj->sclass = TK_EXTERN; + thunkobj->qual = Q_20000; + thunkobj->u.func.linkname = thunkobj->name; + + list = galloc(sizeof(ThunkList)); + list->thunkobj = thunkobj; + list->obj = obj; + list->a = a; + list->b = b; + list->c = c; + list->next = cclass_thunklist; + cclass_thunklist = list; + + return thunkobj; +} + static Boolean CClass_IsZeroOffsetClass(TypeClass *a, TypeClass *b) {} static UInt8 CClass_IsCovariantResult(Type *a, UInt32 qualA, Type *b, UInt32 qualB) {} UInt8 CClass_GetOverrideKind(TypeFunc *a, TypeFunc *b, Boolean errorflag) {} @@ -58,7 +111,7 @@ ENode *CClass_DefaultConstructorCall(TypeClass *a, TypeClass *b, ENode *expr, SI Object *CClass_AssignmentOperator(TypeClass *tclass) {} Object *CClass_CopyConstructor(TypeClass *tclass) {} NameSpaceObjectList *CClass_MemberObject(TypeClass *tclass, HashNameNode *name) {} -Object *CClass_Constructor(TypeClass *tclass) {} +NameSpaceObjectList *CClass_Constructor(TypeClass *tclass) {} Object *CClass_Destructor(TypeClass *tclass) {} Boolean CClass_IsConstructor(Object *obj) {} Boolean CClass_IsDestructor(Object *obj) {} diff --git a/compiler_and_linker/unsorted/CCompiler.c b/compiler_and_linker/unsorted/CCompiler.c index 8339cf6..6159517 100644 --- a/compiler_and_linker/unsorted/CCompiler.c +++ b/compiler_and_linker/unsorted/CCompiler.c @@ -1,9 +1,10 @@ -#include "compiler/common.h" -#include "compiler.h" +#include "compiler/CCompiler.h" +#include "compiler/CParser.h" +#include "compiler/CPrep.h" +#include "compiler/CompilerTools.h" +#include "compiler/CodeGen.h" #include "compiler/types.h" #include "pref_structs.h" -#include "compiler/CompilerTools.h" -#include "compiler/CPrep.h" Boolean systemHandles; diff --git a/compiler_and_linker/unsorted/CException.c b/compiler_and_linker/unsorted/CException.c new file mode 100644 index 0000000..e69de29 --- /dev/null +++ b/compiler_and_linker/unsorted/CException.c diff --git a/compiler_and_linker/unsorted/CExpr.c b/compiler_and_linker/unsorted/CExpr.c index e73c4bb..9968bab 100644 --- a/compiler_and_linker/unsorted/CExpr.c +++ b/compiler_and_linker/unsorted/CExpr.c @@ -1,123 +1,5057 @@ #include "compiler/CExpr.h" +#include "compiler/CABI.h" +#include "compiler/CClass.h" +#include "compiler/CDecl.h" #include "compiler/CError.h" +#include "compiler/CInit.h" +#include "compiler/CInline.h" +#include "compiler/CMachine.h" +#include "compiler/CMangler.h" +#include "compiler/CInt64.h" +#include "compiler/CParser.h" +#include "compiler/CPrep.h" +#include "compiler/CPrepTokenizer.h" +#include "compiler/CodeGen.h" +#include "compiler/CompilerTools.h" +#include "compiler/objects.h" +#include "compiler/scopes.h" +#include "compiler/templates.h" -Boolean (*name_obj_check)(void *, Object *); // TODO figure out the right type +Boolean (*name_obj_check)(HashNameNode *, Object *); Boolean disallowgreaterthan; -void CExpr_RewriteConst() {} -void optimizecomm() {} -static void checkadditive() {} -static void CExpr_CompareConvert() {} -static void CExpr_ConstResult() {} -static void makemultnode() {} -static void makedivnode() {} -static void canadd2() {} -void canadd() {} -static void addconst() {} -static void integralpointerpromote() {} -static void padd() {} -static void psub() {} -static void makeaddnode() {} -static void makesubnode() {} -void checkreference() {} -static ENode *pointer_generation2(ENode *expr) {} -ENode *pointer_generation(ENode *expr) {} -void CExpr_PointerGeneration() {} -static void CExpr_ConstPointerCheck() {} -void oldassignmentpromotion() {} -void argumentpromotion() {} -void classargument() {} -ENodeList *CExpr_ScanExpressionList(Boolean flag) {} -static void skipcommaexpr() {} -void CExpr_DoExplicitConversion() {} -static void CExpr_TemplArgDepCast() {} -static void CExpr_ParseExplicitConversion() {} -static void CExpr_MemberVarAccess() {} -static void CExpr_IsTemplateFunc() {} -static void CExpr_ExplicitTemplateArgCheck() {} -void CExpr_MakeNameLookupResultExpr() {} -static void CExpr_NewPTMType() {} -static void CExpr_ParseNameResultExpr() {} -static void CExpr_ParseRotate() {} -static void CExpr_ParseNextArg() {} -static void CExpr_ParseVecStep() {} -static void CExpr_BuiltInComputeAlign() {} -static void CExpr_AtomTypeID() {} -static void CExpr_BuiltInComputeType() {} -static void CExpr_BuiltInClassifyType() {} -static void CExpr_BuiltInComputeVArgType() {} -static void CExpr_ParseTypeExpression() {} -static void CExpr_ParseBuiltin() {} -static void CExpr_ParseBuiltin_isintconst() {} -static void primary_expression() {} -static void CExpr_SimpleExplicitConversion() {} -static void CExpr_NewPTMFCall() {} -static void call_ptmf() {} -static void CExpr_DummyDestr() {} -static void postfix_expression() {} -static void CExpr_ParseSizeof() {} -void scansizeof() {} -static void CExpr_ParseAlignof() {} -void scanalignof() {} -static void logicalexpression() {} -void getnodeaddress() {} -static void CExpr_MakeStaticMemberList() {} -static void CExpr_MakePTDM() {} -void getpointertomemberfunc() {} -static void getpointertomember() {} -void CExpr_New_ELOGNOT_Node() {} -void CExpr_New_EMONMIN_Node() {} -void CExpr_New_EBINNOT_Node() {} -void unary_expression() {} -void do_castnullcheck() {} -void CExpr_SafeClassPointerCast() {} -void PointerToMemberCast() {} -void CExpr_MemberPointerConversion() {} -static void CExpr_MemberPointerCast() {} -void do_typecast() {} -static void isvectorconst() {} -void cast_expression() {} -static void pm_expression() {} -void CExpr_New_EMUL_Node() {} -void CExpr_New_EDIV_Node() {} -void CExpr_New_EMODULO_Node() {} -void CExpr_New_EADD_Node() {} -void CExpr_New_ESUB_Node() {} -void CExpr_New_ESHL_Node() {} -void CExpr_New_ESHR_Node() {} -static void pointercompare() {} -static void unsigncheck() {} -void CExpr_New_ELESS_Node() {} -void CExpr_New_ELESSEQU_Node() {} -void CExpr_New_EGREATER_Node() {} -void CExpr_New_EGREATEREQU_Node() {} -void memberpointercompare() {} -void CExpr_New_EEQU_Node() {} -void CExpr_New_ENOTEQU_Node() {} -void CExpr_New_EAND_Node() {} -void CExpr_New_EXOR_Node() {} -void CExpr_New_EOR_Node() {} -void CExpr_New_ELAND_Node() {} -void CExpr_New_ELOR_Node() {} -void CExpr_NewDyadicNode() {} -static void CExpr_GetDyadicInfo() {} -static void CExpr_ParseDyadicExpression() {} -static void CExpr_IsBlockMoveType() {} -void CExpr_New_ECOND_Node() {} -static void conditional_expression() {} -static void CExpr_MakeOpAssNode() {} -static void makeassignmentnode() {} -static void makepassignmentnode() {} -static void makemulassignmentnode() {} -static void CExpr_TransformOpAssign() {} -ENode *assignment_expression(void) {} -ENode *conv_assignment_expression(void) {} -static void CExpr_HasSideEffect() {} -void CExpr_CheckUnusedExpression() {} -void s_expression() {} -ENode *expression(void) {} -void CExpr_IntegralConstExprType() {} -ENode *CExpr_IntegralConstOrDepExpr(void) {} -void CExpr_IntegralConstExpr() {} -void CExpr_CheckUnwantedAssignment() {} -void CExpr_ParseAsmExpr() {} +// MOVE ME +extern ENode *CIRTrans_TransformOpAss(ENode *); +extern ENode *CTempl_MakeTemplDepExpr(ENode *, ENodeType, ENode *); +extern Boolean CTemplTool_IsTemplateArgumentDependentType(Type *type); +extern Boolean CTemplTool_IsTemplateArgumentDependentExpression(ENode *expr); +extern ENode *CSOM_MemberVarAccess(BClassList *path, ObjMemberVar *var, ENode *expr); +extern TemplArg *CTempl_ParseUncheckTemplArgs(void *a, Boolean flag); +extern Boolean CObjC_IsCompatibleType(Type *a, Type *b); +extern Type *CObjC_GetObjCType_id(Boolean flag); +extern ENode *CExcept_ScanThrowExpression(void); +extern void PPCError_Error(int code, ...); +extern ENode *CObjC_ParseSelectorExpression(void); +extern ENode *CObjC_ParseEncodeExpression(void); +extern ENode *CObjC_ParseProtocolExpression(void); +extern ENode *CObjC_ParseAtExpression(void); +extern ENode *CObjC_ParseMessageExpression(void); +extern ENode *CRTTI_Parse_const_cast(void); +extern ENode *CRTTI_Parse_dynamic_cast(void); +extern ENode *CRTTI_Parse_reinterpret_cast(void); +extern ENode *CRTTI_Parse_static_cast(void); +extern ENode *CRTTI_ParseTypeID(void); +extern Boolean CObjC_IsType_id(Type *type); +extern ENode *CObjC_CheckModernSendMessage(Type *type, ENode *expr); + +// forward declarations +static ENode *makeaddnode(ENode *left, ENode *right); +static ENode *makesubnode(ENode *left, ENode *right); + +ENode *CExpr_RewriteConst(ENode *expr) { + Object *obj; + +restart: + if (ENODE_IS(expr, EINDIRECT) && ENODE_IS(expr->data.monadic, EOBJREF)) { + obj = expr->data.monadic->data.objref; + if (obj->datatype == DALIAS) { + CExpr_AliasTransform(expr->data.monadic); + goto restart; + } + + if ((obj->qual & Q_10000) && expr->rtype == obj->type) { + switch (expr->rtype->type) { + case TYPEINT: + case TYPEENUM: + expr->type = EINTCONST; + expr->data.intval = obj->u.data.u.intconst; + break; + case TYPEPOINTER: + expr->type = EINTCONST; + expr->data.intval = obj->u.data.u.intconst; + expr->rtype = TYPE(&stunsignedlong); + expr = makemonadicnode(expr, ETYPCON); + expr->rtype = obj->type; + break; + case TYPEFLOAT: + expr->type = EFLOATCONST; + if (obj->u.data.u.floatconst) + expr->data.floatval = *obj->u.data.u.floatconst; + else + expr->data.floatval = CMach_CalcFloatConvertFromInt(TYPE(&stsignedlong), cint64_zero); + break; + default: +#line 105 + CError_FATAL(); + } + } + } + + return expr; +} + +void optimizecomm(ENode *expr) { + ENode *right; + ENode *left; + + if (ENODE_IS((right = expr->data.diadic.right), EINTCONST)) + return; + if (ENODE_IS((left = expr->data.diadic.left), EINTCONST)) { + swap: + expr->data.diadic.right = left; + expr->data.diadic.left = right; + return; + } + + if (ENODE_IS(left, EFLOATCONST)) + return; + if (ENODE_IS(right, EFLOATCONST)) + goto swap; + + if (expr->rtype->type > TYPEFLOAT) + return; + + if (left->cost > right->cost) + goto swap; +} + +static void checkadditive(ENode *expr) { + switch (expr->rtype->type) { + case TYPEINT: + if (expr->rtype == TYPE(&stbool)) + break; + case TYPEFLOAT: + return; + case TYPEENUM: + if (copts.cplusplus) + break; + return; + case TYPEPOINTER: + if (TPTR_TARGET(expr->rtype)->size == 0) + CDecl_CompleteType(TPTR_TARGET(expr->rtype)); + if (TPTR_TARGET(expr->rtype)->size == 0) + break; + return; + case TYPEARRAY: + if (ENODE_IS(expr, EOBJREF)) + return; + } + + CError_Error(CErrorStr376, expr->rtype, ENODE_QUALS(expr)); +} + +static void CExpr_CompareConvert(ENode **leftp, char *opname, ENode **rightp, Boolean flag) { + ENode *left; + ENode *right; + CInt64 val; + + left = *leftp; + right = *rightp; + + switch (left->rtype->type) { + case TYPEINT: + break; + case TYPEFLOAT: + if (left->rtype != right->rtype) + CExpr_ArithmeticConversion(leftp, rightp); + return; + case TYPEENUM: + left->rtype = TYPE_ENUM(left->rtype)->enumtype; + break; + default: + CError_Error(CErrorStr377, + left->rtype, ENODE_QUALS(left), + opname, + right->rtype, ENODE_QUALS(right)); + left = nullnode(); + } + + switch (right->rtype->type) { + case TYPEINT: + break; + case TYPEFLOAT: + CExpr_ArithmeticConversion(leftp, rightp); + return; + case TYPEENUM: + right->rtype = TYPE_ENUM(right->rtype)->enumtype; + break; + default: + CError_Error(CErrorStr377, + left->rtype, ENODE_QUALS(left), + opname, + right->rtype, ENODE_QUALS(right)); + right = nullnode(); + } + + if (left->rtype == right->rtype) { + *leftp = left; + *rightp = right; + return; + } + + if (left->rtype->size == right->rtype->size) { + if (is_unsigned(left->rtype) == is_unsigned(right->rtype)) { + left->rtype = right->rtype; + *leftp = left; + *rightp = right; + return; + } + } else { + if (ENODE_IS(right, EINTCONST) && left->rtype->size <= right->rtype->size && (is_unsigned(left->rtype) == is_unsigned(right->rtype) || is_unsigned(left->rtype))) { + val = CMach_CalcIntDiadic(left->rtype, right->data.intval, '+', cint64_zero); + val = CMach_CalcIntDiadic(right->rtype, val, '+', cint64_zero); + if (CInt64_Equal(val, right->data.intval)) { + right->rtype = left->rtype; + *leftp = left; + *rightp = right; + return; + } + } + + if (ENODE_IS(left, EINTCONST) && left->rtype->size >= right->rtype->size && (is_unsigned(left->rtype) == is_unsigned(right->rtype) || is_unsigned(right->rtype))) { + val = CMach_CalcIntDiadic(right->rtype, left->data.intval, '+', cint64_zero); + val = CMach_CalcIntDiadic(left->rtype, val, '+', cint64_zero); + if (CInt64_Equal(val, left->data.intval)) { + left->rtype = right->rtype; + *leftp = left; + *rightp = right; + return; + } + } + } + + *leftp = left; + *rightp = right; + CExpr_ArithmeticConversion(leftp, rightp); +} + +static ENode *CExpr_ConstResult(ENode *expr, SInt32 value) { + ENode *constnode; + + if (IS_TYPE_FLOAT(expr->rtype)) { + constnode = intconstnode(TYPE(&stsignedint), value); + constnode->type = EFLOATCONST; + constnode->data.floatval = CMach_CalcFloatConvertFromInt(TYPE(&stsignedint), constnode->data.intval); + constnode->rtype = expr->rtype; + } else { + constnode = intconstnode(expr->rtype, value); + } + + if (CInline_ExpressionHasSideEffect(expr)) + return makediadicnode(expr, constnode, ECOMMA); + else + return constnode; +} + +static ENode *makemultnode(ENode *left, ENode *right) { + CExpr_ArithmeticConversion(&left, &right); + if (iszero(left)) + return CExpr_ConstResult(right, 0); + if (iszero(right)) + return CExpr_ConstResult(left, 0); + + if (CExpr_IsOne(right)) + return left; + if (CExpr_IsOne(left)) + return right; + + if (ENODE_IS(left, EINTCONST) && ENODE_IS(right, EINTCONST)) { + left->data.intval = CMach_CalcIntDiadic(left->rtype, left->data.intval, '*', right->data.intval); + return left; + } + if (ENODE_IS(left, EFLOATCONST) && ENODE_IS(right, EFLOATCONST)) { + left->data.floatval = CMach_CalcFloatDiadic(left->rtype, left->data.floatval, '*', right->data.floatval); + return left; + } + + left = makediadicnode(left, right, EMUL); + optimizecomm(left); + if (IS_TYPE_INT(left->rtype) && left->rtype->size > 2) { + left->cost++; + if (left->cost > 200) + left->cost = 200; + } + + if (IS_TYPE_FLOAT(left->rtype)) + left = CExpr_BinaryFloatExpression(left); + + return left; +} + +static ENode *makedivnode(ENode *left, ENode *right, Boolean no_warning) { + CExpr_ArithmeticConversion(&left, &right); + if (iszero(right) && IS_TYPE_INT(right->rtype)) { + if (!no_warning) + CError_Warning(CErrorStr139); + return right; + } + + if (CExpr_IsOne(right)) + return left; + + if (iszero(left) && IS_TYPE_INT(left->rtype)) + return CExpr_ConstResult(right, 0); + + if (ENODE_IS(left, EINTCONST) && ENODE_IS(right, EINTCONST)) { + left->data.intval = CMach_CalcIntDiadic(left->rtype, left->data.intval, '/', right->data.intval); + return left; + } + if (ENODE_IS(left, EFLOATCONST) && ENODE_IS(right, EFLOATCONST)) { + left->data.floatval = CMach_CalcFloatDiadic(left->rtype, left->data.floatval, '/', right->data.floatval); + return left; + } + + left = makediadicnode(left, right, EDIV); + if (IS_TYPE_FLOAT(left->rtype)) + left = CExpr_BinaryFloatExpression(left); + + return left; +} + +static short canadd2(ENode *expr, CInt64 value) { + Float tmp; + + if (CInt64_IsZero(&value)) + return 1; + + switch (expr->type) { + case EINTCONST: + expr->data.intval = CMach_CalcIntDiadic(expr->rtype, expr->data.intval, '+', value); + return 1; + case EFLOATCONST: + tmp = CMach_CalcFloatConvertFromInt(TYPE(&stsignedlong), value); + expr->data.floatval = CMach_CalcFloatDiadic(expr->rtype, expr->data.floatval, '+', tmp); + return 1; + case EADD: + if (canadd2(expr->data.diadic.left, value)) + return 1; + if (canadd2(expr->data.diadic.right, value)) + return 1; + return 0; + case ESUB: + if (canadd2(expr->data.diadic.left, value)) + return 1; + if (canadd2(expr->data.diadic.right, CInt64_Neg(value))) + return 1; + return 0; + case ETYPCON: + if (IS_TYPE_POINTER_ONLY(expr->rtype) && ENODE_IS(expr->data.monadic, EINTCONST)) { + expr->data.monadic->data.intval = CMach_CalcIntDiadic(TYPE(&stunsignedlong), expr->data.monadic->data.intval, '+', value); + return 1; + } + return 0; + default: + return 0; + } +} + +short canadd(ENode *expr, SInt32 value) { + CInt64 value64; + CInt64_SetLong(&value64, value); + return canadd2(expr, value64); +} + +static ENode *addconst(ENode *expr, SInt32 value) { + ENode *right; + + if (canadd(expr, value)) + return expr; + + if (stsignedint.size < 4 && (value > 0x7FFF || value < -0x8000)) + right = intconstnode(TYPE(&stsignedlong), value); + else + right = intconstnode(TYPE(&stsignedint), value); + + CExpr_ArithmeticConversion(&expr, &right); + expr = makediadicnode(expr, right, EADD); + return expr; +} + +static ENode *integralpointerpromote(ENode *expr) { + Boolean uns; + Type *type; + + if (!IS_TYPE_INT(expr->rtype)) + expr = forceintegral(expr); + + if (expr->rtype->size != 4) { + type = TYPE(&stunsignedlong); + if (is_unsigned(type) != (uns = is_unsigned(expr->rtype))) { + if (uns) { + if (stunsignedlong.size == 4) { + type = TYPE(&stunsignedlong); + } else if (stunsignedint.size == 4) { + type = TYPE(&stunsignedint); + } else { +#line 480 + CError_FATAL(); + } + } else { + if (stsignedlong.size == 4) { + type = TYPE(&stsignedlong); + } else if (stsignedint.size == 4) { + type = TYPE(&stsignedint); + } else { +#line 486 + CError_FATAL(); + } + } + } + + if (ENODE_IS(expr, EINTCONST)) + expr->data.intval = CExpr_IntConstConvert(type, expr->rtype, expr->data.intval); + else + expr = makemonadicnode(expr, ETYPCON); + + expr->rtype = type; + } + + return expr; +} + +static ENode *padd(ENode *left, ENode *right) { + Type *innertype; + SInt32 innersize; + ENode *expr; + + right = integralpointerpromote(right); + innertype = TPTR_TARGET(left->rtype); + innersize = innertype->size; + if (innersize == 0) { + CDecl_CompleteType(innertype); + innersize = innertype->size; + if (innersize == 0) { + CError_Error(CErrorStr146); + return left; + } + } + + expr = makemultnode( + right, + intconstnode((innersize > 0x7FFF) ? TYPE(&stsignedlong) : TYPE(&stsignedint), innersize)); + + if (ENODE_IS(expr, EINTCONST) && canadd2(left, expr->data.intval)) + return left; + + if (ENODE_IS(left, EADD) && ENODE_IS(left->data.diadic.right, EINTCONST)) { + left->data.diadic.left = makediadicnode(left->data.diadic.left, expr, EADD); + return left; + } + + expr = makediadicnode(left, expr, EADD); + expr->rtype = left->rtype; + expr->flags = left->flags; + return expr; +} + +static ENode *psub(ENode *left, ENode *right) { + Type *innertype; + SInt32 innersize; + ENode *expr; + + if (IS_TYPE_POINTER(right->rtype)) { + innersize = TPTR_TARGET(left->rtype)->size; + if (innersize == 0) { + CDecl_CompleteType(TPTR_TARGET(left->rtype)); + innersize = TPTR_TARGET(left->rtype)->size; + if (innersize == 0) { + CError_Error(CErrorStr146); + return left; + } + } + + if (!is_typeequal(left->rtype, right->rtype)) { + CError_Error(CErrorStr245, left->rtype, ENODE_QUALS(left), right->rtype, ENODE_QUALS(right)); + return left; + } + + if (ENODE_IS(left, ETYPCON) && ENODE_IS(left->data.monadic, EINTCONST) && ENODE_IS(right, ETYPCON) && ENODE_IS(right->data.monadic, EINTCONST)) { + left->data.monadic->rtype = right->data.monadic->rtype = CABI_GetPtrDiffTType(); + expr = makesubnode(left->data.monadic, right->data.monadic); + if (innersize > 1) + expr = makedivnode(expr, intconstnode(CABI_GetPtrDiffTType(), innersize), 11); + return expr; + } + + expr = makediadicnode(left, right, ESUB); + expr->rtype = CABI_GetPtrDiffTType(); + if (innersize > 1) + expr = makediadicnode(expr, intconstnode(CABI_GetPtrDiffTType(), innersize), EDIV); + return expr; + } + + right = integralpointerpromote(right); + innertype = TPTR_TARGET(left->rtype); + innersize = innertype->size; + if (innersize == 0) { + CDecl_CompleteType(innertype); + innersize = innertype->size; + if (innersize == 0) { + CError_Error(CErrorStr146); + return left; + } + } + + expr = makemultnode(right, intconstnode(CABI_GetPtrDiffTType(), innersize)); + if (ENODE_IS(expr, EINTCONST) && canadd2(left, CInt64_Neg(expr->data.intval))) + return left; + + expr = makediadicnode(left, expr, ESUB); + expr->rtype = left->rtype; + expr->flags = left->flags; + return expr; +} + +static ENode *makeaddnode(ENode *left, ENode *right) { + if (IS_TYPE_POINTER(left->rtype)) + return padd(left, right); + if (IS_TYPE_POINTER(right->rtype)) + return padd(right, left); + + CExpr_ArithmeticConversion(&left, &right); + if (iszero(right)) + return left; + if (iszero(left)) + return right; + + if (ENODE_IS(left, EINTCONST) && ENODE_IS(right, EINTCONST)) { + left->data.intval = CMach_CalcIntDiadic(left->rtype, left->data.intval, '+', right->data.intval); + return left; + } + if (ENODE_IS(left, EFLOATCONST) && ENODE_IS(right, EFLOATCONST)) { + left->data.floatval = CMach_CalcFloatDiadic(left->rtype, left->data.floatval, '+', right->data.floatval); + return left; + } + + if (ENODE_IS(left, EINTCONST) && canadd2(right, left->data.intval)) + return right; + if (ENODE_IS(right, EINTCONST) && canadd2(left, right->data.intval)) + return left; + + left = makediadicnode(left, right, EADD); + optimizecomm(left); + if (IS_TYPE_FLOAT(left->rtype)) + left = CExpr_BinaryFloatExpression(left); + return left; +} + +static ENode *makesubnode(ENode *left, ENode *right) { + if (ENODE_IS(right, EINTCONST) && !is_unsigned(right->rtype) && !IS_TYPE_FLOAT(left->rtype)) { + right->data.intval = CInt64_Neg(right->data.intval); + return makeaddnode(left, right); + } + + if (IS_TYPE_POINTER(left->rtype)) + return psub(left, right); + + CExpr_ArithmeticConversion(&left, &right); + if (iszero(right)) + return left; + if (iszero(left)) { + if (ENODE_IS(right, EINTCONST)) { + right->data.intval = CInt64_Neg(right->data.intval); + return right; + } + if (ENODE_IS(right, EFLOATCONST)) { + right->data.floatval = CMach_CalcFloatMonadic(right->rtype, '-', right->data.floatval); + return right; + } + return CExpr_UnaryFloatExpression(makemonadicnode(right, EMONMIN)); + } + + if (ENODE_IS(left, EINTCONST) && ENODE_IS(right, EINTCONST)) { + left->data.intval = CMach_CalcIntDiadic(left->rtype, left->data.intval, '-', right->data.intval); + return left; + } + if (ENODE_IS(left, EFLOATCONST) && ENODE_IS(right, EFLOATCONST)) { + left->data.floatval = CMach_CalcFloatDiadic(left->rtype, left->data.floatval, '-', right->data.floatval); + return left; + } + + if (ENODE_IS(right, EINTCONST) && canadd2(left, CInt64_Neg(right->data.intval))) + return left; + + left = makediadicnode(left, right, ESUB); + if (IS_TYPE_FLOAT(left->rtype)) + left = CExpr_BinaryFloatExpression(left); + return left; +} + +ENode *checkreference(ENode *expr) { + if (!IS_TYPE_REFERENCE(expr->rtype)) + return expr; + + expr = makemonadicnode(expr, EINDIRECT); + expr->rtype = TPTR_TARGET(expr->rtype); + return expr; +} + +static ENode *pointer_generation2(ENode *expr) { + switch (expr->type) { + case EINDIRECT: + switch (expr->rtype->type) { + case TYPEARRAY: + switch (expr->data.monadic->type) { + case EPOSTINC: + case EPOSTDEC: + case EPREINC: + case EPREDEC: + expr->type = ETYPCON; + expr->rtype = CDecl_NewPointerType(TPTR_TARGET(expr->rtype)); + return expr; + default: + expr->data.monadic->rtype = CDecl_NewPointerType(TPTR_TARGET(expr->rtype)); + expr->data.monadic->flags = expr->flags; + return expr->data.monadic; + } + case TYPEFUNC: + expr = expr->data.monadic; + if (ENODE_IS(expr, EOBJREF) && expr->data.objref->datatype == DINLINEFUNC) + CError_Error(CErrorStr175); + return expr; + } + } + return expr; +} + +ENode *pointer_generation(ENode *expr) { + return CExpr_RewriteConst(pointer_generation2(expr)); +} + +ENode *CExpr_PointerGeneration(ENode *expr) { + switch (expr->type) { + case EINDIRECT: + switch (expr->rtype->type) { + case TYPEARRAY: + expr->data.monadic->rtype = CDecl_NewPointerType(TPTR_TARGET(expr->rtype)); + return expr->data.monadic; + case TYPEFUNC: + return expr->data.monadic; + } + } + return expr; +} + +static void CExpr_ConstPointerCheck(ENode *expr, Type *type, short qual) { + Type *exprtype; + Type *b; + Type *a; + short exprqual; + + exprtype = expr->rtype; + if (IS_TYPE_POINTER_ONLY(type) && IS_TYPE_POINTER_ONLY(exprtype)) { + exprqual = expr->flags; + + if (TPTR_TARGET(type) == &stvoid) { + exprqual = CParser_GetCVTypeQualifiers(TPTR_TARGET(exprtype), exprqual); + } else { + a = TPTR_TARGET(type); + b = TPTR_TARGET(exprtype); + while (IS_TYPE_POINTER_ONLY(a) && IS_TYPE_POINTER_ONLY(b)) { + if (CParser_IsMoreCVQualified(TPTR_QUAL(b), TPTR_QUAL(a))) { + CError_Warning(CErrorStr220, expr->rtype, ENODE_QUALS(expr), type, qual); + return; + } + a = TPTR_TARGET(a); + b = TPTR_TARGET(b); + } + } + + if (CParser_IsMoreCVQualified(exprqual, qual)) { + CError_Warning(CErrorStr220, expr->rtype, ENODE_QUALS(expr), type, (UInt32) qual); + } + } +} + +ENode *oldassignmentpromotion(ENode *expr, Type *type, short qual, Boolean flag) { + Boolean is_ref; + UInt32 ref_qual; + short orig_qual; + + is_ref = 0; + if (!IS_TYPE_MEMBERPOINTER(type)) { + if (IS_TYPE_REFERENCE(type)) { + if (ENODE_IS(expr, ECOND)) + expr = CExpr_LValue(expr, 0, 0); + expr = pointer_generation2(expr); + ref_qual = CParser_GetCVTypeQualifiers(expr->rtype, expr->flags); + is_ref = 1; + } else { + expr = pointer_generation(expr); + } + } + + if (ENODE_IS(expr, EMEMBER)) + expr = getpointertomemberfunc(expr, type, 1); + + if (!is_ref) + CExpr_ConstPointerCheck(expr, type, qual); + else + CExpr_ConstPointerCheck(expr, TPTR_TARGET(type), qual); + + if (!(assign_check(expr, type, orig_qual = qual, 1, 0, flag))) + return expr; + + if (is_ref) { + if (temp_reference_init) { + switch (TPTR_TARGET(type)->type) { + case TYPEPOINTER: + qual = TPTR_QUAL(TPTR_TARGET(type)); + } + if (!(qual & Q_CONST)) + CError_Warning(CErrorStr228); + } else { + if (ref_qual && ref_qual > CParser_GetCVTypeQualifiers(TPTR_TARGET(type), orig_qual)) + CError_Warning(CErrorStr259); + } + } + + return assign_node; +} + +ENode *argumentpromotion(ENode *expr, Type *type, short qual, Boolean flag) { + ENode *tmp; + ENodeList *list; + + if (IS_TYPE_CLASS(type) && CClass_ReferenceArgument(TYPE_CLASS(type))) { + if ((tmp = CExpr_IsTempConstruction(expr, type, NULL))) + return tmp; + + list = lalloc(sizeof(ENodeList)); + list->next = NULL; + list->node = expr; + tmp = CExpr_ConstructObject( + TYPE_CLASS(type), + create_temp_node(type), + list, 1, 1, 1, 1, 0); + return getnodeaddress(tmp, 0); + } + + return CExpr_AssignmentPromotion(expr, type, qual, flag); +} + +ENode *classargument(ENode *expr) { + ENodeList *list; + + if (CClass_CopyConstructor(TYPE_CLASS(expr->rtype))) { + list = lalloc(sizeof(ENodeList)); + list->next = NULL; + list->node = expr; + return CExpr_ConstructObject( + TYPE_CLASS(expr->rtype), + create_temp_node(expr->rtype), + list, 1, 1, 1, 1, 0); + } + + return expr; +} + +ENodeList *CExpr_ScanExpressionList(Boolean is_parens) { + ENodeList *list; + ENodeList *current; + + if (is_parens && tk == ')') + return NULL; + + list = current = lalloc(sizeof(ENodeList)); + + while (1) { + current->next = NULL; + current->node = assignment_expression(); + if (copts.old_argmatch && !ENODE_IS(current->node, EMEMBER)) + current->node = pointer_generation(current->node); + + if (is_parens) { + if (tk == ')') + break; + } else { + if (tk == ']') + break; + } + + if (tk != ',') { + CError_ErrorSkip(CErrorStr116); + break; + } + + tk = lex(); + current->next = lalloc(sizeof(ENodeList)); + current = current->next; + } + + return list; +} + +static ENode *skipcommaexpr(ENode *expr) { + while (ENODE_IS(expr, ECOMMA)) + expr = expr->data.diadic.right; + return expr; +} + +ENode *CExpr_DoExplicitConversion(Type *type, UInt32 qual, ENodeList *list) { + Object *obj; + ENode *tmp; + + if (!IS_TYPE_CLASS(type)) { + if (!list) + return do_typecast(nullnode(), type, qual); + if (list->next) + CError_Error(CErrorStr356); + return do_typecast(pointer_generation(list->node), type, qual); + } + + CDecl_CompleteType(type); + if (!(TYPE_CLASS(type)->flags & CLASS_FLAGS_2)) + CError_Error(CErrorStr136, type, 0); + + CanCreateObject(type); + if (!list && CClass_IsPODClass(TYPE_CLASS(type))) { + obj = CParser_NewGlobalDataObject(NULL); + obj->name = CParser_GetUniqueName(); + obj->nspace = cscope_root; + obj->type = type; + obj->qual = qual; + obj->sclass = TK_STATIC; + CInit_DeclareData(obj, NULL, NULL, type->size); + + tmp = makemonadicnode(create_temp_node(type), EINDIRECT); + tmp->rtype = type; + tmp->flags = qual & ENODE_FLAG_QUALS; + return makediadicnode(tmp, create_objectnode(obj), EASS); + } + + return CExpr_ConstructObject(TYPE_CLASS(type), create_temp_node(type), list, 1, 1, 1, 1, 1); +} + +static ENode *CExpr_TemplArgDepCast(Type *type, UInt32 qual, ENodeList *args) { + ENode *expr = CExpr_NewTemplDepENode(TDE_CAST); + expr->data.templdep.u.cast.args = args; + expr->data.templdep.u.cast.type = type; + expr->data.templdep.u.cast.qual = qual; + return expr; +} + +static ENode *CExpr_ParseExplicitConversion(Type *type, UInt32 qual) { + ENodeList *args; + ENodeList *scan; + + if (IS_TEMPL_CLASS(type) && !CParser_CheckTemplateClassUsage(TEMPL_CLASS(type), 1)) + type = TYPE(&stsignedint); + + if (tk == '(') + tk = lex(); + else + CError_Error(114); + + args = CExpr_ScanExpressionList(1); + if (tk != ')') { + CError_Error(115); + return nullnode(); + } + + tk = lex(); + if (CTemplTool_IsTemplateArgumentDependentType(type)) + return CExpr_TemplArgDepCast(type, qual, args); + + for (scan = args; scan; scan = scan->next) { + if (CTemplTool_IsTemplateArgumentDependentExpression(scan->node)) + return CExpr_TemplArgDepCast(type, qual, args); + } + + return CExpr_DoExplicitConversion(type, qual, args); +} + +static ENode *CExpr_MemberVarAccess(BClassList *path, ObjMemberVar *var, ENode *expr) { + ENode *accessnode; + BClassList *varpath; + +#line 1152 + CError_ASSERT(path); + + if (TYPE_CLASS(path->type)->sominfo) + return CSOM_MemberVarAccess(path, var, expr); + + varpath = NULL; + if (var->has_path) + varpath = OBJ_MEMBER_VAR_PATH(var)->path; + accessnode = CExpr_GetClassAccessNode(path, varpath, expr, NULL, var->access, 1); + if (!accessnode) + return nullnode(); + + return CClass_AccessMember(accessnode, var->type, var->qual, var->offset); +} + +static Boolean CExpr_IsTemplateFunc(Object *obj) { + return IS_TEMPL_FUNC(obj->type); +} + +static ENode *CExpr_ExplicitTemplateArgCheck(CScopeParseResult *pr) { + NameSpaceObjectList *list; + NameSpaceObjectList *newhead; + NameSpaceObjectList *newlist; + ENode *expr; + + if (pr->obj_10) { + if (pr->obj_10->otype != OT_OBJECT || !CExpr_IsTemplateFunc(OBJECT(pr->obj_10))) + return NULL; + + list = lalloc(sizeof(NameSpaceObjectList)); + memclrw(list, sizeof(NameSpaceObjectList)); + list->object = pr->obj_10; + } else if (pr->nsol_14) { + for (list = pr->nsol_14; list; list = list->next) { + if (list->object->otype == OT_OBJECT && CExpr_IsTemplateFunc(OBJECT(list->object))) { + newhead = newlist = galloc(sizeof(NameSpaceObjectList)); + *newlist = *list; + newlist->next = NULL; + while ((list = list->next)) { + if (list->object->otype == OT_OBJECT && CExpr_IsTemplateFunc(OBJECT(list->object))) { + newlist->next = galloc(sizeof(NameSpaceObjectList)); + newlist = newlist->next; + *newlist = *list; + newlist->next = NULL; + } + } + list = newhead; + break; + } + } + if (!list) + return NULL; + } else { + return NULL; + } + + expr = CExpr_NewENode(EOBJLIST); + expr->rtype = OBJECT(list->object)->type; + expr->data.objlist.list = list; + expr->data.objlist.templargs = CTempl_ParseUncheckTemplArgs(NULL, 0); + + tk = lex(); + return expr; +} + +ENode *CExpr_MakeNameLookupResultExpr(CScopeParseResult *pr) { + ENode *expr; + + if (pr->obj_10) { + switch (pr->obj_10->otype) { + case OT_OBJECT: + CClass_CheckObjectAccess(pr->bcl_18, OBJECT(pr->obj_10)); + return create_objectnode(OBJECT(pr->obj_10)); + case OT_ENUMCONST: + CClass_CheckEnumAccess(pr->bcl_18, OBJ_ENUM_CONST(pr->obj_10)); + expr = lalloc(sizeof(ENode)); + expr->type = EINTCONST; + expr->cost = 0; + expr->flags = 0; + expr->rtype = OBJ_ENUM_CONST(pr->obj_10)->type; + expr->data.intval = OBJ_ENUM_CONST(pr->obj_10)->val; + return expr; + case OT_MEMBERVAR: + CError_Error(0xDD); + return nullnode(); + default: +#line 1268 + CError_FATAL(); + } + } + + if (pr->nsol_14) { + expr = CExpr_NewENode(EOBJLIST); + expr->rtype = OBJECT(pr->nsol_14->object)->type; + expr->data.objlist.list = pr->nsol_14; + return expr; + } + +#line 1278 + CError_FATAL(); + return NULL; +} + +static Type *CExpr_NewPTMType(EMemberInfo *member, Object *obj) { + TypeMemberPointer *ptm; + TypeMethod *tmethod; + BClassList *path; + + ptm = galloc(sizeof(TypeMemberPointer)); + memclrw(ptm, sizeof(TypeMemberPointer)); + ptm->type = TYPEMEMBERPOINTER; + + if (member->list->object->otype == OT_MEMBERVAR) { + path = member->path; + while (path->next) + path = path->next; + ptm->size = 4; + ptm->ty2 = path->type; + ptm->ty1 = OBJ_MEMBER_VAR(member->list->object)->type; + } else { + if (!obj) { +#line 1306 + CError_ASSERT(member->list->object->otype == OT_OBJECT); + obj = OBJECT(member->list->object); +#line 1308 + CError_ASSERT(IS_TYPE_FUNC(obj->type)); + } + + tmethod = galloc(sizeof(TypeMethod)); + memclrw(tmethod, sizeof(TypeMethod)); + *tmethod = *TYPE_METHOD(obj->type); + +#line 1312 + CError_ASSERT(tmethod->args); + + tmethod->args = tmethod->args->next; + CDecl_MakePTMFuncType(TYPE_FUNC(tmethod)); + tmethod->flags &= ~FUNC_FLAGS_2; + + ptm->size = 12; + ptm->ty2 = TYPE(tmethod->theclass); + ptm->ty1 = TYPE(tmethod); + } + + return TYPE(ptm); +} + +static ENode *CExpr_ParseNameResultExpr(CScopeParseResult *pr, ENode *expr, Boolean flag1, Boolean flag2) { + ENode *result; + ENode *ta_expr; + ObjEnumConst *oec; + TemplateAction *act; + EMemberInfo *member; + NameSpaceObjectList *list; + Object *obj; + TypeFunc *tfunc; + SInt32 val; + + if (pr->x8) { + if (copts.cplusplus) { + if (IS_TYPE_TEMPLATE(pr->x8)) { + if (TYPE_TEMPLATE(pr->x8)->dtype == TEMPLDEP_ARGUMENT && TYPE_TEMPLATE(pr->x8)->u.pid.type == TPT_NONTYPE) { + result = CExpr_NewTemplDepENode(TDE_PARAM); + result->data.templdep.u.pid = TYPE_TEMPLATE(pr->x8)->u.pid; + tk = lex(); + return result; + } + if (TYPE_TEMPLATE(pr->x8)->dtype == TEMPLDEP_QUALNAME && !pr->x20) { + result = CExpr_NewTemplDepENode(TDE_QUALNAME); + result->data.templdep.u.qual.type = TYPE_TEMPLATE(pr->x8)->u.qual.type; + result->data.templdep.u.qual.name = TYPE_TEMPLATE(pr->x8)->u.qual.name; + tk = lex(); + return result; + } + } + tk = lex(); + return CExpr_ParseExplicitConversion(pr->x8, pr->xC); + } + CError_ErrorSkip(CErrorStr141); + tk = lex(); + return nullnode(); + } + + if (pr->obj_10) { + switch (pr->obj_10->otype) { + case OT_OBJECT: + if (OBJECT(pr->obj_10)->nspace && OBJECT(pr->obj_10)->nspace->theclass && (OBJECT(pr->obj_10)->nspace->theclass->flags & CLASS_FLAGS_100)) { + result = CExpr_NewTemplDepENode(TDE_QUALTEMPL); // not sure this is right tbh + result->data.templdep.u.obj = OBJECT(pr->obj_10); + tk = lex(); + return result; + } + if (!expr || !IS_TEMPL_FUNC(OBJECT(pr->obj_10)->type)) { + if (!IS_TYPE_NONSTATIC_METHOD(OBJECT(pr->obj_10)->type)) { + tk = lex(); + if (tk == '<' && (ta_expr = CExpr_ExplicitTemplateArgCheck(pr))) + return ta_expr; + if (OBJECT(pr->obj_10)->datatype == DLOCAL && OBJECT(pr->obj_10)->u.var.info->func != cscope_currentfunc) { + CError_Error(CErrorStr330); + return nullnode(); + } + if (OBJECT(pr->obj_10)->datatype == DEXPR) { + result = CInline_CopyExpression(OBJECT(pr->obj_10)->u.expr, CopyMode0); + if (IS_TYPE_POINTER_ONLY(result->rtype) && ENODE_IS(result, EINTCONST)) { + result = makemonadicnode(result, ETYPCON); + result->data.monadic->rtype = TYPE(&stunsignedlong); + } + return result; + } + CClass_CheckObjectAccess(pr->bcl_18, OBJECT(pr->obj_10)); + if (tk == '(' && flag2 && OBJECT(pr->obj_10)->datatype == DFUNC && copts.cplusplus && !pr->x1D && !IS_TYPEFUNC_METHOD(TYPE_FUNC(OBJECT(pr->obj_10)->type))) { + result = CExpr_NewENode(EOBJLIST); + result->rtype = OBJECT(pr->obj_10)->type; + result->data.objlist.list = galloc(sizeof(NameSpaceObjectList)); + result->data.objlist.list->next = pr->nsol_14; + result->data.objlist.list->object = pr->obj_10; + result->data.objlist.name = OBJECT(pr->obj_10)->name; + return result; + } + + result = create_objectnode(OBJECT(pr->obj_10)); + if (expr) { + while (ENODE_IS(expr, EINDIRECT)) + expr = expr->data.monadic; + switch (expr->type) { + case EINTCONST: + case EOBJREF: + case EOBJLIST: + break; + default: + result = makecommaexpression(expr, result); + } + } + return result; + } + if (CClass_IsDestructor(OBJECT(pr->obj_10))) { + if ((tk = lex()) != '(') { + CError_Error(114); + return nullnode(); + } + if ((tk = lex()) != ')') { + CError_Error(115); + return nullnode(); + } + if (!expr && (!cscope_currentfunc || !cscope_currentclass || !cscope_is_member_func)) { + CError_Error(221); + return nullnode(); + } + if (pr->isambig) + CError_Error(188); + + if ((expr = CExpr_GetClassAccessNode(pr->bcl_18, NULL, expr, OBJECT(pr->obj_10), pr->obj_10->access, 1))) { + tk = lex(); + return CABI_DestroyObject(OBJECT(pr->obj_10), expr->data.monadic, 1, pr->x1D, 0); + } + } + } + break; + case OT_ENUMCONST: + CClass_CheckEnumAccess(pr->bcl_18, OBJ_ENUM_CONST(pr->obj_10)); + oec = OBJ_ENUM_CONST(pr->obj_10); + if (CInt64_IsZero(&oec->val) && IS_TYPE_ENUM(oec->type) && TYPE_ENUM(oec->type)->nspace && TYPE_ENUM(oec->type)->nspace->theclass && (TYPE_ENUM(oec->type)->nspace->theclass->flags & CLASS_FLAGS_100)) { + val = 0; + expr = NULL; + for (act = TEMPL_CLASS(TYPE_ENUM(oec->type)->nspace->theclass)->actions; act; act = act->next) { + if (act->type == TAT_ENUMERATOR) { + if (act->u.enumerator.initexpr) { + expr = act->u.enumerator.initexpr; + val = 0; + } else { + val++; + } + if (act->u.enumerator.objenumconst == oec) { +#line 1521 + CError_ASSERT(expr); + expr = CInline_CopyExpression(expr, CopyMode0); + if (val) + expr = makediadicnode(expr, intconstnode(TYPE(&stsignedlong), val), EADD); + tk = lex(); + return expr; + } + } + } + } + result = lalloc(sizeof(ENode)); + result->type = EINTCONST; + result->cost = 0; + result->flags = 0; + result->rtype = OBJ_ENUM_CONST(pr->obj_10)->type; + result->data.intval = OBJ_ENUM_CONST(pr->obj_10)->val; + tk = lex(); + return result; + case OT_MEMBERVAR: + if (!flag1 || expr || !pr->x1D) { + if (pr->isambig) + CError_Error(188); + result = checkreference(CExpr_MemberVarAccess(pr->bcl_18, OBJ_MEMBER_VAR(pr->obj_10), expr)); + tk = lex(); + return result; + } + break; + default: +#line 1552 + CError_FATAL(); + } + + member = lalloc(sizeof(EMemberInfo)); + memclrw(member, sizeof(EMemberInfo)); + member->path = pr->bcl_18; + member->expr = expr; + member->pr_1D = pr->x1D; + member->isambig = pr->isambig; + if ((tk = lex()) == '<' && (ta_expr = CExpr_ExplicitTemplateArgCheck(pr))) { +#line 1564 + CError_ASSERT(ENODE_IS(ta_expr, EOBJLIST)); + member->list = ta_expr->data.objlist.list; + member->templargs = ta_expr->data.objlist.templargs; + } else { + member->list = galloc(sizeof(NameSpaceObjectList)); + member->list->next = NULL; + member->list->object = pr->obj_10; + } + + result = CExpr_NewENode(EMEMBER); + result->data.emember = member; + result->rtype = &stvoid; + return result; + } + + if (pr->nsol_14) { + if ((tk = lex()) == '<' && (ta_expr = CExpr_ExplicitTemplateArgCheck(pr))) { +#line 1591 + CError_ASSERT(ENODE_IS(ta_expr, EOBJLIST)); + for (list = ta_expr->data.objlist.list; list; list = list->next) { + if (list->object->otype == OT_OBJECT && IS_TYPE_NONSTATIC_METHOD(OBJECT(list->object)->type)) { + member = lalloc(sizeof(EMemberInfo)); + memclrw(member, sizeof(EMemberInfo)); + + member->path = pr->bcl_18; + member->expr = expr; + member->list = ta_expr->data.objlist.list; + member->templargs = ta_expr->data.objlist.templargs; + member->pr_1D = pr->x1D; + member->isambig = pr->isambig; + + result = CExpr_NewENode(EMEMBER); + result->data.emember = member; + result->rtype = &stvoid; + return result; + } + } + return ta_expr; + } + + for (list = pr->nsol_14; list; list = list->next) { + if (list->object->otype == OT_OBJECT && IS_TYPE_NONSTATIC_METHOD(OBJECT(list->object)->type)) { + member = lalloc(sizeof(EMemberInfo)); + memclrw(member, sizeof(EMemberInfo)); + + member->path = pr->bcl_18; + member->expr = expr; + member->list = pr->nsol_14; + member->pr_1D = pr->x1D; + member->isambig = pr->isambig; + + result = CExpr_NewENode(EMEMBER); + result->data.emember = member; + result->rtype = &stvoid; + return result; + } + } + + if (tk == '<' && (ta_expr = CExpr_ExplicitTemplateArgCheck(pr))) + return ta_expr; + + result = CExpr_NewENode(EOBJLIST); + result->rtype = OBJECT(pr->nsol_14->object)->type; + result->data.objlist.list = pr->nsol_14; + if (tk == '(' && copts.cplusplus && flag2 && !pr->x1D && pr->nsol_14->object->otype == OT_OBJECT) + result->data.objlist.name = OBJECT(pr->nsol_14->object)->name; + return result; + } + + if (pr->name_4) { + if (copts.cplusplus && flag2) { + if (lookahead() == '(') { + result = CExpr_NewENode(EOBJLIST); + result->rtype = &stvoid; + result->data.objlist.name = pr->name_4; + tk = lex(); + return result; + } + CError_Error(CErrorStr140, pr->name_4->name); + tk = lex(); + return nullnode(); + } + + if (lookahead() != '(') { + CError_Error(CErrorStr140, pr->name_4->name); + tk = lex(); + return nullnode(); + } + + if (copts.require_prototypes) + CError_Error(178); + + tfunc = galloc(sizeof(TypeFunc)); + memclrw(tfunc, sizeof(TypeFunc)); + tfunc->type = TYPEFUNC; + tfunc->functype = TYPE(&stsignedint); + tfunc->args = &oldstyle; + CDecl_SetFuncFlags(tfunc, 0); + + obj = CParser_NewFunctionObject(NULL); + obj->name = pr->name_4; + obj->sclass = TK_EXTERN; + obj->nspace = cscope_root; + obj->type = TYPE(tfunc); + + CScope_AddGlobalObject(obj); + tk = lex(); + return create_objectrefnode(obj); + } + +#line 1711 + CError_FATAL(); + return NULL; +} + +static ENode *CExpr_ParseRotate(Boolean is_right) { + ENode *expr1; + ENode *expr2; + + if (lex() != '(') { + CError_Error(114); + return nullnode(); + } + + tk = lex(); + expr1 = assignment_expression(); + + if (tk != ',') { + CError_Error(116); + return nullnode(); + } + + tk = lex(); + expr2 = assignment_expression(); + + if (tk != ')') { + CError_Error(115); + return nullnode(); + } + + if (!IS_TYPE_INT(expr1->rtype)) + expr1 = forceintegral(expr1); + expr2 = integralpromote(expr2); + + tk = lex(); + if (iszero(expr1) || iszero(expr2)) + return expr1; + + return makediadicnode(expr1, expr2, is_right ? EROTR : EROTL); +} + +static ENode *CExpr_ParseNextArg(void) { + NameSpaceObjectList *list; + CScopeParseResult pr; + ENode *expr; + SInt32 rounded_size; + + if ((tk = lex()) != '(') { + CError_Error(114); + return nullnode(); + } + if ((tk = lex()) != TK_IDENTIFIER) { + CError_Error(0x6B); + return nullnode(); + } + + list = CScope_FindObjectList(&pr, tkidentifier); + if (!list) { + CError_Error(140, tkidentifier->name); + return nullnode(); + } + + if (list->object->otype != OT_OBJECT || OBJECT(list->object)->datatype != DLOCAL) { + CError_Error(140, tkidentifier->name); + return nullnode(); + } + + rounded_size = CMach_RoundedSizeOf(OBJECT(list->object)); + expr = CExpr_MakeObjRefNode(OBJECT(list->object), 1); + expr = makediadicnode(expr, intconstnode(CABI_GetPtrDiffTType(), rounded_size), EADD); + expr->rtype = TYPE(&void_ptr); + + if ((tk = lex()) != ')') { + CError_Error(115); + return expr; + } else { + tk = lex(); + return expr; + } +} + +static ENode *CExpr_ParseVecStep(void) { + ENode *expr; + Type *type; + SInt32 value; + DeclInfo di; + + expr = intconstnode(TYPE(&stsignedint), 0); + if ((tk = lex()) == '(') { + if (tk == '(' && islookaheaddeclaration()) { + tk = lex(); + memclrw(&di, sizeof(DeclInfo)); + CParser_GetDeclSpecs(&di, 0); + scandeclarator(&di); + if (di.name) + CError_Error(121); + + if (tk != ')') + CError_ErrorSkip(115); + else + tk = lex(); + + type = di.thetype; + if (IS_TYPE_REFERENCE(type)) + type = TPTR_TARGET(type); + } else { + expr = unary_expression(); + if (ENODE_IS(expr, EINDIRECT) && ENODE_IS(expr->data.monadic, EBITFIELD)) + CError_Error(144); + type = expr->rtype; + } + + CDecl_CompleteType(type); + if (IS_TYPE_VECTOR(type)) { + switch (TYPE_STRUCT(type)->stype) { + case STRUCT_TYPE_4: + case STRUCT_TYPE_5: + case STRUCT_TYPE_6: + value = 16; + break; + case STRUCT_TYPE_7: + case STRUCT_TYPE_8: + case STRUCT_TYPE_9: + case STRUCT_TYPE_E: + value = 8; + break; + default: + value = 4; + } + expr = intconstnode(TYPE(&stsignedint), value); + } else { + PPCError_Error(104, "vec_step", "vec_step", type, 0); + } + } else { + CError_Error(114); + } + + return expr; +} + +static SInt32 CExpr_BuiltInComputeAlign(Type *type) { + return CMach_GetTypeAlign(type); +} + +static SInt32 CExpr_AtomTypeID(IntegralType what) { + switch (what) { + case IT_BOOL: return 1; + case IT_CHAR: return 2; + case IT_SCHAR: return 3; + case IT_UCHAR: return 4; + case IT_WCHAR_T: return 5; + case IT_SHORT: return 6; + case IT_USHORT: return 7; + case IT_INT: return 8; + case IT_UINT: return 9; + case IT_LONG: return 10; + case IT_ULONG: return 10; + case IT_LONGLONG: return 12; + case IT_ULONGLONG: return 13; + case IT_FLOAT: return 14; + case IT_SHORTDOUBLE: return 15; + case IT_DOUBLE: return 16; + case IT_LONGDOUBLE: return 17; + case IT_17: return 32; + case IT_18: return 33; + case IT_19: return 34; + case IT_20: return 35; + case IT_21: return 36; + case IT_22: return 37; + case IT_23: return 38; + case IT_24: return 39; + default: +#line 1976 + CError_FATAL(); + return 0; + } +} + +static SInt32 CExpr_BuiltInComputeType(Type *type) { + switch (type->type) { + case TYPEINT: + return 0x100 | CExpr_AtomTypeID(TYPE_INTEGRAL(type)->integral); + case TYPEFLOAT: + return 0x200 | CExpr_AtomTypeID(TYPE_INTEGRAL(type)->integral); + case TYPEENUM: + return 0x400 | (CExpr_BuiltInComputeType(TYPE_ENUM(type)->enumtype) & 0xFF); + case TYPEPOINTER: + return 0x800; + case TYPEARRAY: + return 0x1000; + case TYPESTRUCT: + return 0x2000; + case TYPECLASS: + return 0x2000; + case TYPEMEMBERPOINTER: + return 0x4000; + case TYPEFUNC: + return 0x8000; + default: + CError_Error(146); + case TYPEVOID: + return 0; + } +} + +static SInt32 CExpr_BuiltInClassifyType(Type *type) { + switch (type->type) { + case TYPEVOID: return 0; + case TYPEFUNC: return 10; + case TYPEENUM: return 3; + case TYPEINT: return 1; + case TYPEFLOAT: return 8; + case TYPEPOINTER: case TYPEMEMBERPOINTER: return 5; + case TYPEARRAY: return 14; + case TYPESTRUCT: return 12; + case TYPECLASS: return 12; + case TYPEBITFIELD: return -1; + case TYPETEMPLATE: return -1; + default: return -1; + } +} + +static SInt32 CExpr_BuiltInComputeVArgType(Type *type) { + switch (type->type) { + case TYPEINT: + case TYPEENUM: + return 0; + case TYPEFLOAT: + return 1; + default: + return 2; + } +} + +static Type *CExpr_ParseTypeExpression(Boolean *outflag) { + ENode *expr; + Type *type; + DeclInfo di; + + tk = lex(); + if (tk == '(' && islookaheaddeclaration()) { + tk = lex(); + memclrw(&di, sizeof(DeclInfo)); + CParser_GetDeclSpecs(&di, 0); + scandeclarator(&di); + if (di.name) + CError_Error(121); + + if (tk != ')') + CError_ErrorSkip(115); + else + tk = lex(); + + type = di.thetype; + if (IS_TYPE_REFERENCE(type)) + type = TPTR_TARGET(type); + } else { + expr = unary_expression(); + if (ENODE_IS(expr, EINDIRECT) && ENODE_IS(expr->data.monadic, EBITFIELD)) + CError_Error(144); + + if (outflag) + *outflag = ENODE_IS(expr, EINTCONST) && CInt64_IsZero(&expr->data.intval); + + type = expr->rtype; + } + + CDecl_CompleteType(type); + return type; +} + +static ENode *CExpr_ParseBuiltin(SInt32 (*parser)(Type *)) { + ENode *expr; + expr = intconstnode(TYPE(&stsignedint), 0); + CInt64_SetLong(&expr->data.intval, parser(CExpr_ParseTypeExpression(NULL))); + return expr; +} + +static ENode *CExpr_ParseBuiltin_isintconst(void) { + ENode *expr; + expr = intconstnode(TYPE(&stsignedint), 0); + + tk = lex(); + if (tk != '(') + CError_ErrorSkip(121); + else + tk = lex(); + + if (ENODE_IS(expression(), EINTCONST)) + CInt64_SetLong(&expr->data.intval, 1); + + if (tk != ')') + CError_ErrorSkip(115); + else + tk = lex(); + + return expr; +} + +static ENode *primary_expression(Boolean flag) { + CScopeParseResult pr; + ENode *expr; + + switch (tk) { + case TK_TRUE: + expr = lalloc(sizeof(ENode)); + expr->type = EINTCONST; + expr->cost = 0; + expr->flags = 0; + expr->rtype = TYPE(&stbool); + CInt64_SetULong(&expr->data.intval, 1); + tk = lex(); + return expr; + case TK_FALSE: + expr = lalloc(sizeof(ENode)); + expr->type = EINTCONST; + expr->cost = 0; + expr->flags = 0; + expr->rtype = TYPE(&stbool); + CInt64_SetULong(&expr->data.intval, 0); + tk = lex(); + return expr; + case TK_INTCONST: + expr = lalloc(sizeof(ENode)); + expr->type = EINTCONST; + expr->cost = 0; + expr->flags = 0; + expr->rtype = atomtype(); + expr->data.intval = tkintconst; + tk = lex(); + return expr; + case TK_FLOATCONST: + expr = lalloc(sizeof(ENode)); + expr->type = EFLOATCONST; + expr->cost = 0; + expr->flags = 0; + expr->rtype = atomtype(); + expr->data.floatval = tkfloatconst; + tk = lex(); + return expr; + case TK_STRING: + expr = CExpr_NewENode(ESTRINGCONST); + expr->rtype = CDecl_NewArrayType(ispascalstring ? TYPE(&stunsignedchar) : TYPE(&stchar), tksize); + expr->data.string.size = tksize; + expr->data.string.data = tkstring; + expr->data.string.ispascal = ispascalstring; + if (copts.const_strings) + expr->flags = ENODE_FLAG_CONST; + expr = makemonadicnode(expr, EINDIRECT); + expr->data.monadic->rtype = CDecl_NewPointerType(expr->rtype); + tk = lex(); + return expr; + case TK_STRING_WIDE: + expr = CExpr_NewENode(ESTRINGCONST); + expr->rtype = CDecl_NewArrayType(CParser_GetWCharType(), tksize); + expr->data.string.size = tksize; + expr->data.string.data = tkstring; + expr->data.string.ispascal = ispascalstring; + if (copts.const_strings) + expr->flags = ENODE_FLAG_CONST; + expr = makemonadicnode(expr, EINDIRECT); + expr->data.monadic->rtype = CDecl_NewPointerType(expr->rtype); + tk = lex(); + return expr; + case TK_THIS: + case TK_SELF: + expr = CClass_CreateThisSelfExpr(); + if (!expr) + expr = nullnode(); + tk = lex(); + return expr; + case TK_AT_SELECTOR: + return CObjC_ParseSelectorExpression(); + case TK_AT_ENCODE: + return CObjC_ParseEncodeExpression(); + case TK_AT_PROTOCOL: + return CObjC_ParseProtocolExpression(); + case '@': + if (copts.objective_c) + return CObjC_ParseAtExpression(); + break; + case '(': + tk = lex(); + expr = s_expression(); + if (tk != ')') + CError_ErrorSkip(115); + else + tk = lex(); + if (ENODE_IS(expr, EASS)) + expr->flags |= ENODE_FLAG_80; + return expr; + case '[': + if (copts.objective_c) + return CObjC_ParseMessageExpression(); + break; + case TK_IDENTIFIER: + if (tkidentifier->name[0] == '_' && tkidentifier->name[1] == '_') { + if (!strcmp(tkidentifier->name, "__builtin_align")) + return CExpr_ParseBuiltin(CExpr_BuiltInComputeAlign); + if (!strcmp(tkidentifier->name, "__builtin_ntype")) + return CExpr_ParseBuiltin(CExpr_BuiltInComputeType); + if (!strcmp(tkidentifier->name, "__builtin_type") || !strcmp(tkidentifier->name, "__builtin_vargtype")) + return CExpr_ParseBuiltin(CExpr_BuiltInComputeVArgType); + if (!strcmp(tkidentifier->name, "__builtin_classify_type")) + return CExpr_ParseBuiltin(CExpr_BuiltInClassifyType); + if (!strcmp(tkidentifier->name, "__builtin_next_arg")) + return CExpr_ParseNextArg(); + } + if (copts.altivec_model && !strcmp("vec_step", tkidentifier->name)) + return CExpr_ParseVecStep(); + case '~': + case TK_OPERATOR: + case TK_INHERITED: + case TK_COLON_COLON: + if (CScope_ParseExprName(&pr)) + return CExpr_ParseNameResultExpr(&pr, NULL, flag, 1); + tk = lex(); + return nullnode(); + } + + CError_ErrorSkip(141); + return nullnode(); +} + +static ENode *CExpr_SimpleExplicitConversion(void) { + DeclInfo di; + + memclrw(&di, sizeof(DeclInfo)); + + if (!copts.cpp_extensions && tk != TK_UU_TYPEOF_UU && tk != TK_TYPENAME && lookahead() != '(') + CError_Error(114); + + CParser_GetDeclSpecs(&di, 0); + return CExpr_ParseExplicitConversion(di.thetype, di.qual); +} + +static ENode *CExpr_NewPTMFCall(void) { + tk = lex(); + CExpr_ScanExpressionList(1); + + if (tk != ')') { + CError_Error(115); + return nullnode(); + } else { +#line 2465 + CError_FATAL(); + return nullnode(); + } +} + +static ENode *call_ptmf(ENode *expr) { + Type *rettype; + ENodeList *args; + ENodeList *list1; + ENodeList *list2; + Object *callobj; + + rettype = TYPE_FUNC(TPTR_TARGET(expr->data.mfpointer.mfpointer->rtype))->functype; + tk = lex(); + args = CExpr_ScanExpressionList(1); + + if (tk != ')') { + CError_Error(115); + return nullnode(); + } + + if (IS_TYPE_STRUCT(rettype) || IS_TYPE_CLASS(rettype) || IS_TYPE_12BYTES_MEMBERPOINTER(rettype)) + callobj = rt_ptmf_scall4; + else + callobj = rt_ptmf_scall; + + list1 = lalloc(sizeof(ENodeList)); + list1->next = args; + list1->node = expr->data.mfpointer.accessnode->data.monadic; + + list2 = lalloc(sizeof(ENodeList)); + list2->next = list1; + list2->node = expr->data.mfpointer.mfpointer->data.monadic; + + if (!copts.old_argmatch) { +#line 2568 + CError_ASSERT(IS_TYPE_POINTER_ONLY(list2->node->rtype)); + list2->node->rtype = TYPE(&void_ptr); + } + + expr = CExpr_GenericPtmfCall( + callobj, + TYPE_FUNC(TPTR_TARGET(expr->data.mfpointer.mfpointer->rtype)), + list2); + tk = lex(); + return expr; +} + +static ENode *CExpr_DummyDestr(ENode *expr) { + SInt32 state; + CScopeParseResult pr; + DeclInfo di; + NameSpace *nspace; + + CPrep_TokenStreamGetState(&state); + nspace = cscope_current; + if ((tk = lex()) == TK_COLON_COLON) { + nspace = cscope_root; + tk = lex(); + } else if (tk != '~' && tk != TK_IDENTIFIER && !(tk >= TK_AUTO && tk <= TK_BYREF)) { + CPrep_TokenStreamSetCurState(&state); + return NULL; + } + +loop: + if (tk == '~') + goto is_tilde; + if (tk == TK_IDENTIFIER) { + if (CScope_FindTypeName(nspace, tkidentifier, &pr)) { + tk = lex(); + if (pr.nspace_0) { + if (tk == TK_COLON_COLON) { + tk = lex(); + nspace = pr.nspace_0; + goto loop; + } + } else if (IS_TYPE_CLASS(pr.x8) && tk == TK_COLON_COLON) { + tk = lex(); + nspace = TYPE_CLASS(pr.x8)->nspace; + goto loop; + } else { + if (!is_typesame(pr.x8, expr->rtype)) + CError_Error(146); + if (tk == TK_COLON_COLON && ((tk = lex()) == '~') && ((tk = lex()) == TK_IDENTIFIER)) { + parse_dtor: + if (CScope_FindTypeName(nspace, tkidentifier, &pr) && !pr.nspace_0) { + if (!is_typesame(pr.x8, expr->rtype)) + CError_Error(146); + tk = lex(); + goto parsed; + } + } + } + } + } else if (tk >= TK_AUTO && tk <= TK_BYREF) { + memclrw(&di, sizeof(DeclInfo)); + CParser_GetDeclSpecs(&di, 0); + if (di.storageclass || di.qual || !is_typesame(di.thetype, expr->rtype)) + CError_Error(146); + if (tk == TK_COLON_COLON && ((tk = lex()) == '~')) { + is_tilde: + if ((tk = lex()) == TK_IDENTIFIER) + goto parse_dtor; + memclrw(&di, sizeof(DeclInfo)); + CParser_GetDeclSpecs(&di, 0); + if (di.storageclass || !is_typesame(di.thetype, expr->rtype)) + CError_Error(146); + goto parsed; + } + } + + CError_Error(141); + return NULL; + +parsed: + if (tk == '(') { + if ((tk = lex()) != ')') + CError_Error(115); + else + tk = lex(); + } else { + CError_Error(114); + } + + expr = makemonadicnode(expr, ETYPCON); + expr->rtype = &stvoid; + return expr; +} + +static ENode *postfix_expression(Boolean flag) { + CScopeParseResult pr; + Conversion conv; + ENode *expr; + ENode *subexpr; + ENode *funcexpr; + ENodeList *args; + ENode *copy; + ENode *tmp; + StructMember *member; + + if (copts.cplusplus) { + switch (tk) { + case TK_VOID: + case TK_CHAR: + case TK_SHORT: + case TK_INT: + case TK_LONG: + case TK_FLOAT: + case TK_DOUBLE: + case TK_SIGNED: + case TK_UNSIGNED: + case TK_UNK_113: + case TK_UNK_114: + case TK_UNK_115: + case TK_UNK_116: + case TK_UNK_117: + case TK_UNK_118: + case TK_UNK_119: + case TK_UNK_11A: + case TK_UU_TYPEOF_UU: + case TK_BOOL: + case TK_WCHAR_T: + case TK_TYPENAME: + expr = CExpr_SimpleExplicitConversion(); + break; + default: + expr = primary_expression(flag); + break; + case TK_CONST_CAST: + expr = CRTTI_Parse_const_cast(); + break; + case TK_DYNAMIC_CAST: + expr = CRTTI_Parse_dynamic_cast(); + break; + case TK_REINTERPRET_CAST: + expr = CRTTI_Parse_reinterpret_cast(); + break; + case TK_STATIC_CAST: + expr = CRTTI_Parse_static_cast(); + break; + case TK_TYPEID: + expr = CRTTI_ParseTypeID(); + break; + } + } else { + expr = primary_expression(flag); + } + +loop: + switch (tk) { + case '[': + expr = pointer_generation(expr); + tk = lex(); + subexpr = expression(); + if (copts.cplusplus && CExpr_CheckOperator('[', expr, subexpr, &conv)) { + if ((expr = conv.x0)) { + if (tk != ']') + CError_ErrorSkip(125); + else + tk = lex(); + goto loop; + } + +#line 2753 + CError_ASSERT((expr = conv.left)); + CError_ASSERT((subexpr = conv.right)); + } + + if (IS_TYPE_POINTER(expr->rtype)) { + expr = padd(expr, subexpr); + } else if (IS_TYPE_POINTER(subexpr->rtype)) { + expr = padd(subexpr, expr); + } else { + CError_Error(148); + goto dont_do_indirect; + } + expr = makemonadicnode(expr, EINDIRECT); + expr->rtype = TPTR_TARGET(expr->rtype); + dont_do_indirect: + if (tk != ']') + CError_ErrorSkip(125); + else + tk = lex(); + goto loop; + + case '(': + funcexpr = CExpr_PointerGeneration(expr); + if (copts.cplusplus) { + if (CExpr_CheckOperator('(', funcexpr, NULL, &conv)) { +#line 2775 + CError_ASSERT((expr = conv.x0)); + goto loop; + } + if (ENODE_IS(funcexpr, EMFPOINTER)) { + expr = checkreference(call_ptmf(funcexpr)); + goto loop; + } + } + + tk = lex(); + args = CExpr_ScanExpressionList(1); + if (tk != ')') + CError_Error(115); + + if (ENODE_IS(funcexpr, ETEMPLDEP)) { + expr = CExpr_NewENode(EFUNCCALL); + expr->rtype = &sttemplexpr; + expr->data.funccall.funcref = funcexpr; + expr->data.funccall.args = args; + expr->data.funccall.functype = &rt_func; + tk = lex(); + } else { + expr = checkreference(CExpr_MakeFunctionCall(funcexpr, args)); + tk = lex(); + } + goto loop; + + case TK_ARROW: + expr = pointer_generation(expr); + if (copts.cplusplus) { + while (IS_TYPE_CLASS(expr->rtype) && CExpr_CheckOperator(TK_ARROW, expr, NULL, &conv)) { +#line 2810 + CError_ASSERT((subexpr = conv.x0)); + expr = pointer_generation(subexpr); + } + } + + if (!IS_TYPE_POINTER(expr->rtype)) { + CError_ErrorSkip(148); + return expr; + } + + if (copts.cplusplus && copts.objective_c && CObjC_IsType_id(expr->rtype)) { + expr = makemonadicnode(expr, EINDIRECT); + expr->rtype = TPTR_TARGET(expr->rtype); + if ((subexpr = CObjC_CheckModernSendMessage(NULL, expr))) + return subexpr; + } else { + expr = makemonadicnode(expr, EINDIRECT); + expr->rtype = TPTR_TARGET(expr->rtype); + } + case '.': + expr = pointer_generation(expr); + if (IS_TYPE_CLASS(expr->rtype)) { + CDecl_CompleteType(expr->rtype); + if (TYPE_CLASS(expr->rtype)->objcinfo && copts.cplusplus && (subexpr = CObjC_CheckModernSendMessage(expr->rtype, expr))) + return subexpr; + + if (!(TYPE_CLASS(expr->rtype)->flags & CLASS_FLAGS_2)) + CError_Error(136, expr->rtype, 0); + + if ((tk = lex()) == TK_TEMPLATE && (tk = lex()) != TK_IDENTIFIER) + CError_Error(107); + + if (CScope_ParseMemberName(TYPE_CLASS(expr->rtype), &pr, 0)) { + if (pr.x1C) { + if ((tk = lex()) == '(') { + if ((tk = lex()) != ')') + CError_Error(115); + else + tk = lex(); + } else { + CError_Error(114); + } + + expr = makemonadicnode(expr, ETYPCON); + expr->rtype = &stvoid; + } else { + expr = checkreference(CExpr_ParseNameResultExpr(&pr, expr, 0, 0)); + } + } + goto loop; + } + if (!IS_TYPE_STRUCT(expr->rtype) || TYPE_STRUCT(expr->rtype)->stype > STRUCT_TYPE_3) { + if (copts.cplusplus && (subexpr = CExpr_DummyDestr(expr))) + return subexpr; + CError_ErrorSkip(149); + return expr; + } + if (!ENODE_IS(expr, EINDIRECT)) { + subexpr = CExpr_NewETEMPNode(expr->rtype, 1); + copy = lalloc(sizeof(ENode)); + *copy = *subexpr; + + tmp = makemonadicnode(subexpr, EINDIRECT); + tmp->rtype = expr->rtype; + + tmp = makediadicnode(tmp, expr, EASS); + tmp = makediadicnode(tmp, copy, ECOMMA); + tmp->rtype = copy->rtype; + + tmp = makemonadicnode(tmp, EINDIRECT); + tmp->rtype = expr->rtype; + expr = tmp; + } + if ((tk = lex()) != TK_IDENTIFIER) { + CError_Error(107); + return expr; + } + + member = ismember(TYPE_STRUCT(expr->rtype), tkidentifier); + if (!member) { + if (!expr->rtype->size) + CError_Error(136, expr->rtype, 0); + else + CError_Error(150, tkidentifier->name); + return expr; + } + + if (!IS_TYPE_POINTER(expr->data.monadic->rtype)) { + CError_ErrorSkip(149); + return expr; + } + + expr = checkreference(CClass_AccessMember(expr, member->type, member->qual, member->offset)); + tk = lex(); + goto loop; + + case TK_INCREMENT: + tmp = pointer_generation(expr); + if (copts.cplusplus && CExpr_CheckOperator(TK_INCREMENT, tmp, nullnode(), &conv)) { + if ((expr = conv.x0)) { + tk = lex(); + goto loop; + } +#line 2952 + CError_ASSERT((tmp = conv.left)); + } + tmp = CExpr_LValue(tmp, 1, 1); + if (tmp->rtype == TYPE(&stbool)) { + expr = CExpr_TempModifyExpr(tmp); + tk = lex(); + } else { + checkadditive(tmp); + expr = makemonadicnode(tmp, EPOSTINC); + tk = lex(); + } + goto loop; + + case TK_DECREMENT: + tmp = pointer_generation(expr); + if (copts.cplusplus && CExpr_CheckOperator(TK_DECREMENT, tmp, nullnode(), &conv)) { + if ((expr = conv.x0)) { + tk = lex(); + goto loop; + } +#line 2976 + CError_ASSERT((tmp = conv.left)); + } + tmp = CExpr_LValue(tmp, 1, 1); + checkadditive(tmp); + expr = makemonadicnode(tmp, EPOSTDEC); + tk = lex(); + goto loop; + } + + return expr; +} + +static ENode *CExpr_ParseSizeof(void) { + Type *type; + ENode *expr; + + type = CExpr_ParseTypeExpression(NULL); + if (IS_TYPE_CLASS(type) && TYPE_CLASS(type)->sominfo) + CError_Error(286); + + if (CTemplTool_IsTemplateArgumentDependentType(type)) { + expr = CExpr_NewTemplDepENode(TDE_TYPEEXPR); + expr->data.templdep.u.typeexpr.u.type = type; + return expr; + } + + if (type->size == 0) { + if (copts.gcc_extensions && (IS_TYPE_FUNC(type) || IS_TYPE_VOID(type))) + return intconstnode(CABI_GetSizeTType(), 1); + + if (IS_TYPE_CLASS(type) || IS_TYPE_STRUCT(type)) + CError_Error(136, type, 0); + else + CError_Error(146); + } + + return intconstnode(CABI_GetSizeTType(), type->size); +} + +SInt32 scansizeof(void) { + ENode *expr; + + expr = CExpr_ParseSizeof(); + if (!ENODE_IS(expr, EINTCONST)) { + CError_Error(190); + return 0; + } + + return CInt64_GetULong(&expr->data.intval); +} + +static ENode *CExpr_ParseAlignof(void) { + Type *type; + ENode *expr; + SInt16 align; + + type = CExpr_ParseTypeExpression(NULL); + if (IS_TYPE_CLASS(type) && TYPE_CLASS(type)->sominfo) + CError_Error(364); + + if (CTemplTool_IsTemplateArgumentDependentType(type)) { + expr = CExpr_NewTemplDepENode(TDE_unk2); + expr->data.templdep.u.typeexpr.u.type = type; + return expr; + } + + if (type->size == 0) { + if (IS_TYPE_CLASS(type) || IS_TYPE_STRUCT(type)) + CError_Error(136, type, 0); + else + CError_Error(146); + } + + align = CMach_GetTypeAlign(type); + if (align == 0) + align = 1; + + return intconstnode(CABI_GetSizeTType(), align); +} + +SInt32 scanalignof(void) { + ENode *expr; + + expr = CExpr_ParseAlignof(); + if (!ENODE_IS(expr, EINTCONST)) { + CError_Error(190); + return 0; + } + + return CInt64_GetULong(&expr->data.intval); +} + +static ENode *logicalexpression(ENode *expr) { + if (copts.cplusplus && copts.booltruefalse) + expr->rtype = TYPE(&stbool); + else + expr->rtype = TYPE(&stsignedint); + return expr; +} + +ENode *getnodeaddress(ENode *expr, Boolean flag) { + ENode *result; + Object *obj; + + if (!ENODE_IS(expr, EINDIRECT)) { + expr = CExpr_LValue(expr, flag, flag); + if (!ENODE_IS(expr, EINDIRECT)) { + if (!flag) + CError_Error(142); + return nullnode(); + } + } else { + if (flag && + ENODE_IS(expr->data.monadic, EOBJREF) && + expr->data.monadic->data.objref->name == this_name_node && + cscope_currentfunc && + cscope_currentclass && + expr->data.monadic->data.objref == CClass_ThisSelfObject()) + CError_Error(189); + } + + result = lalloc(sizeof(ENode)); + *result = *expr; +restart: + switch (result->data.monadic->type) { + case EPOSTINC: + case EPOSTDEC: + case EPREINC: + case EPREDEC: + result->type = ETYPCON; + if (IS_TYPE_POINTER_ONLY(result->rtype)) + result->flags = TPTR_QUAL(result->rtype) & ENODE_FLAG_QUALS; + result->rtype = CDecl_NewPointerType(result->rtype); + return result; + case EOBJREF: + obj = result->data.monadic->data.objref; + if (obj->datatype == DALIAS) { + CExpr_AliasTransform(result->data.monadic); + goto restart; + } + if (obj->datatype == DINLINEFUNC) + CError_Error(175); + obj->flags |= OBJECT_FLAGS_2; + if (flag && !copts.cplusplus && obj->sclass == TK_REGISTER) + CError_Error(163); + break; + case EFUNCCALL: + if (flag && !IS_TYPE_POINTER_ONLY(result->data.monadic->data.funccall.functype->functype)) + CError_Warning(142); + break; + case EBITFIELD: + CError_Error(144); + return nullnode(); + } + + switch (result->rtype->type) { + case TYPEPOINTER: + result->data.monadic->rtype = CDecl_NewPointerType(result->rtype); + result->data.monadic->flags = result->flags; + break; + default: + result->data.monadic->rtype = CDecl_NewPointerType(result->rtype); + result->data.monadic->flags = result->flags; + } + + return result->data.monadic; +} + +static ENode *CExpr_MakeStaticMemberList(NameSpaceObjectList *list) { + NameSpaceObjectList *newlist; + NameSpaceObjectList *n; + ENode *result; + + newlist = NULL; + while (list) { + if (list->object->otype == OT_OBJECT && IS_TYPE_STATIC_METHOD(OBJECT(list->object)->type)) { + n = galloc(sizeof(NameSpaceObjectList)); + *n = *list; + n->next = newlist; + newlist = n; + } + list = list->next; + } + + if (!newlist) { + CError_Warning(331); + return nullnode(); + } + + result = CExpr_NewENode(EOBJLIST); + result->rtype = OBJECT(newlist->object)->type; + result->data.objlist.list = newlist; + return result; +} + +static ENode *CExpr_MakePTDM(ENode *expr) { + ENode *result; + +#line 3414 + CError_ASSERT(ENODE_IS(expr, EMEMBER) && expr->data.emember->list->object->otype == OT_MEMBERVAR); + + result = nullnode(); + result->rtype = CExpr_NewPTMType(expr->data.emember, NULL); + CInt64_SetLong(&result->data.intval, OBJ_MEMBER_VAR(expr->data.emember->list->object)->offset + 1); + return result; +} + +ENode *getpointertomemberfunc(ENode *expr, Type *type, Boolean flag) { + NameSpaceObjectList *list; + Object *obj; + Object *dataobj; + Type *ptmtype; + TypeMethod *tmethod; + OLinkList *olist; + SInt32 data[3]; + +#line 3442 + CError_ASSERT(ENODE_IS(expr, EMEMBER)); + + if (expr->data.emember->expr && !copts.cpp_extensions) + CError_Error(141); + + if (!copts.cpp_extensions) { + if (!(expr->data.emember->x11 && expr->data.emember->pr_1D)) { + if (type && IS_TYPE_MEMBERPOINTER(type)) + CError_Warning(331); + } + } + + if (expr->data.emember->list->next) { + if (type) { + if (IS_TYPE_MEMBERPOINTER(type)) { + type = TYPE_MEMBER_POINTER(type)->ty1; + for (list = expr->data.emember->list; list; list = list->next) { + if (list->object->otype == OT_OBJECT && is_memberpointerequal(OBJECT(list->object)->type, type)) { + obj = OBJECT(list->object); + break; + } + } + if (!list) { + CError_Error(146); + return nullnode(); + } + } else { + return CExpr_MakeStaticMemberList(expr->data.emember->list); + } + } else { + obj = OBJECT(expr->data.emember->list->object); + } + } else { + obj = OBJECT(expr->data.emember->list->object); + } + + while (obj->datatype == DALIAS) + obj = obj->u.alias.object; + +#line 3503 + CError_ASSERT(obj->otype == OT_OBJECT && IS_TYPE_NONSTATIC_METHOD(obj->type)); + + if (TYPE_FUNC(obj->type)->flags & FUNC_FLAGS_100000) + CError_Error(190); + + ptmtype = CExpr_NewPTMType(expr->data.emember, obj); + tmethod = TYPE_METHOD(obj->type); + dataobj = CParser_NewGlobalDataObject(NULL); + dataobj->name = CParser_GetUniqueName(); + dataobj->nspace = cscope_root; + dataobj->type = ptmtype; + dataobj->sclass = TK_STATIC; + + if (flag) { + data[0] = 0; + if (obj->datatype == DVFUNC) { + olist = NULL; + data[1] = tmethod->x1E; + data[2] = tmethod->theclass->vtable->offset; + } else { + data[1] = -1; + data[2] = 0; + olist = galloc(sizeof(OLinkList)); + olist->next = NULL; + olist->obj = obj; + olist->somevalue = 0; + olist->offset = 8; + } + CInit_DeclareData(dataobj, data, olist, dataobj->type->size); + } + + return create_objectnode(dataobj); +} + +static ENode *getpointertomember(ENode *expr) { +#line 3554 + CError_ASSERT(ENODE_IS(expr, EMEMBER)); + + if (expr->data.emember->expr) + CError_Error(141); + + expr->data.emember->x11 = 1; + if (!expr->data.emember->list->next) { + if (expr->data.emember->list->object->otype == OT_MEMBERVAR) + return CExpr_MakePTDM(expr); + else + return getpointertomemberfunc(expr, NULL, 1); + } + + return expr; +} + +ENode *CExpr_New_ELOGNOT_Node(ENode *input) { + ENode *expr; + Conversion conv; + + if (IS_TYPE_TEMPLDEPEXPR(input->rtype)) + return CTempl_MakeTemplDepExpr(NULL, ELOGNOT, input); + + expr = pointer_generation(input); + if (copts.cplusplus && CExpr_CheckOperator('!', expr, NULL, &conv)) { + if ((input = conv.x0)) + return input; +#line 3593 + CError_ASSERT((expr = conv.left)); + } + + switch (expr->rtype->type) { + case TYPEINT: + case TYPEFLOAT: + case TYPEPOINTER: + case TYPEARRAY: + break; + case TYPEENUM: + expr = forceintegral(expr); + break; + case TYPEMEMBERPOINTER: + expr = CExpr_ConvertToCondition(expr); + break; + default: + CError_Error(144); + return expr; + } + + switch (expr->type) { + case EINTCONST: + expr->data.intval = CInt64_Not(expr->data.intval); + break; + case EFLOATCONST: + expr->type = EINTCONST; + CInt64_SetLong(&expr->data.intval, CMach_FloatIsZero(expr->data.floatval)); + break; + default: + expr = makemonadicnode(expr, ELOGNOT); + } + + return logicalexpression(expr); +} + +ENode *CExpr_New_EMONMIN_Node(ENode *input) { + ENode *expr; + Conversion conv; + + if (IS_TYPE_TEMPLDEPEXPR(input->rtype)) + return CTempl_MakeTemplDepExpr(NULL, EMONMIN, input); + + expr = pointer_generation(input); + if (copts.cplusplus && CExpr_CheckOperator('-', expr, NULL, &conv)) { + if ((input = conv.x0)) + return input; +#line 3652 + CError_ASSERT((expr = conv.left)); + } + + switch (expr->rtype->type) { + case TYPEINT: + case TYPEENUM: + expr = integralpromote(expr); + if (ENODE_IS(expr, EINTCONST)) { + expr->data.intval = CMach_CalcIntMonadic(expr->rtype, '-', expr->data.intval); + return expr; + } + return makemonadicnode(expr, EMONMIN); + case TYPEFLOAT: + if (ENODE_IS(expr, EFLOATCONST)) { + expr->data.floatval = CMach_CalcFloatMonadic(expr->rtype, '-', expr->data.floatval); + return expr; + } + return CExpr_UnaryFloatExpression(makemonadicnode(expr, EMONMIN)); + default: + CError_Error(144); + return expr; + } +} + +ENode *CExpr_New_EBINNOT_Node(ENode *input) { + ENode *expr; + Conversion conv; + + if (IS_TYPE_TEMPLDEPEXPR(input->rtype)) + return CTempl_MakeTemplDepExpr(NULL, EBINNOT, input); + + expr = pointer_generation(input); + if (copts.cplusplus && CExpr_CheckOperator('~', expr, NULL, &conv)) { + if ((input = conv.x0)) + return input; +#line 3702 + CError_ASSERT((expr = conv.left)); + } + + expr = integralpromote(expr); + + if (ENODE_IS(expr, EINTCONST)) { + expr->data.intval = CMach_CalcIntMonadic(expr->rtype, '~', expr->data.intval); + return expr; + } + return makemonadicnode(expr, EBINNOT); +} + +ENode *unary_expression(void) { + ENode *expr; + ENode *tmp; + Conversion conv; + + switch (tk) { + case TK_COLON_COLON: + switch (lookahead()) { + case TK_NEW: + tk = lex(); + return scannew(1); + case TK_DELETE: + tk = lex(); + return scandelete(1); + } + return postfix_expression(0); + + case TK_NEW: + return scannew(0); + case TK_DELETE: + return scandelete(0); + case TK_INCREMENT: + tk = lex(); + if (copts.cplusplus) { + expr = pointer_generation(cast_expression()); + if (CExpr_CheckOperator(TK_INCREMENT, expr, NULL, &conv)) { + if (conv.x0) + return conv.x0; +#line 3748 + CError_ASSERT((expr = conv.left)); + } + } else { + expr = pointer_generation(unary_expression()); + } + expr = CExpr_LValue(expr, 1, 1); + if (expr->rtype == TYPE(&stbool)) { + tmp = nullnode(); + tmp->rtype = TYPE(&stbool); + CInt64_SetLong(&tmp->data.intval, 1); + return makediadicnode(expr, tmp, EASS); + } else { + checkadditive(expr); + return makemonadicnode(expr, EPREINC); + } + case TK_DECREMENT: + tk = lex(); + if (copts.cplusplus) { + expr = pointer_generation(cast_expression()); + if (CExpr_CheckOperator(TK_DECREMENT, expr, NULL, &conv)) { + if (conv.x0) + return conv.x0; +#line 3776 + CError_ASSERT((expr = conv.left)); + } + } else { + expr = pointer_generation(unary_expression()); + } + expr = CExpr_LValue(expr, 1, 1); + checkadditive(expr); + return makemonadicnode(expr, EPREDEC); + + case '&': + if (copts.cplusplus) { + switch ((tk = lex())) { + case TK_IDENTIFIER: + case TK_INHERITED: + case TK_COLON_COLON: + expr = postfix_expression(1); + if (ENODE_IS(expr, EMEMBER)) + return getpointertomember(expr); + break; + default: + expr = cast_expression(); + } + + if (CExpr_CheckOperator('&', expr, NULL, &conv)) { +#line 3809 + CError_ASSERT(conv.x0); + return conv.x0; + } + } else { + tk = lex(); + expr = cast_expression(); + } + + if (copts.mpwc_relax && !copts.cplusplus && IS_TYPE_ARRAY(expr->rtype) && ENODE_IS(expr, EINDIRECT)) + return pointer_generation(expr); + if (ENODE_IS(expr, EOBJLIST)) + return expr; + + if (IS_TYPE_TEMPLDEPEXPR(expr->rtype)) { + tmp = CExpr_NewTemplDepENode(TDE_MONAND); + tmp->data.templdep.u.monadic = expr; + return tmp; + } + + return getnodeaddress(expr, 1); + + case '*': + tk = lex(); + expr = pointer_generation(cast_expression()); + if (copts.cplusplus && CExpr_CheckOperator('*', expr, NULL, &conv)) { + if (conv.x0) + return conv.x0; +#line 3840 + CError_ASSERT((expr = conv.left)); + } + + if (!IS_TYPE_POINTER(expr->rtype)) { + CError_Error(148); + return expr; + } + + tmp = makemonadicnode(expr, EINDIRECT); + CDecl_CompleteType(tmp->rtype = TPTR_TARGET(tmp->rtype)); + return tmp; + + case '+': + tk = lex(); + expr = pointer_generation(cast_expression()); + if (copts.cplusplus && CExpr_CheckOperator('+', expr, NULL, &conv)) { + if (conv.x0) + return conv.x0; +#line 3852 + CError_ASSERT((expr = conv.left)); + } + + switch (expr->rtype->type) { + case TYPEINT: + case TYPEENUM: + return integralpromote(expr); + case TYPEFLOAT: + case TYPEPOINTER: + case TYPEARRAY: + return expr; + default: + CError_Error(144); + return expr; + } + + case '-': + tk = lex(); + return CExpr_New_EMONMIN_Node(cast_expression()); + case '~': + tk = lex(); + return CExpr_New_EBINNOT_Node(cast_expression()); + case '!': + tk = lex(); + return CExpr_New_ELOGNOT_Node(cast_expression()); + + case TK_SIZEOF: + return CExpr_ParseSizeof(); + case TK_UU_ALIGNOF_UU: + return CExpr_ParseAlignof(); + + case TK_LOGICAL_AND: + if (copts.ANSI_strict) + break; + + if ((tk = lex()) != TK_IDENTIFIER) { + CError_Error(107); + return nullnode(); + } + + expr = lalloc(sizeof(ENode)); + expr->type = ELABEL; + expr->cost = 0; + expr->flags = 0; + expr->rtype = TYPE(&void_ptr); + expr->data.label = findlabel(); + if (!expr->data.label) { + expr->data.label = newlabel(); + expr->data.label->name = tkidentifier; + expr->data.label->next = Labels; + Labels = expr->data.label; + } + tk = lex(); + return expr; + } + + return postfix_expression(0); +} + +ENode *do_castnullcheck(ENode *condexpr, ENode *nullcheckexpr) { + ENode *result; + + if (isnotzero(nullcheckexpr)) + return condexpr; + + result = lalloc(sizeof(ENode)); + *result = *condexpr; + result->type = ENULLCHECK; + result->data.nullcheck.nullcheckexpr = lalloc(sizeof(ENode)); + *result->data.nullcheck.nullcheckexpr = *nullcheckexpr; + result->data.nullcheck.condexpr = condexpr; + result->data.nullcheck.precompid = CParser_GetUniqueID(); + + nullcheckexpr->type = EPRECOMP; + nullcheckexpr->data.precompid = result->data.nullcheck.precompid; + + return result; +} + +ENode *CExpr_SafeClassPointerCast(ENode *expr, TypeClass *a, TypeClass *b, Boolean typconflag, Boolean pathcheckflag) { + ENode *result; + + result = CClass_ClassPointerCast(expr, a, b, typconflag, 1, pathcheckflag); + if (result != expr) { + if (!(ENODE_IS(result, ETYPCON) && result->data.monadic == expr)) + result = do_castnullcheck(result, expr); + } + return result; +} + +ENode *PointerToMemberCast(ENode *expr, TypeMemberPointer *tm1, TypeMemberPointer *tm2, Boolean flag) { + BClassList *path; + Boolean negate; + short depth; + Boolean isambig; + SInt32 pathoffset; + CInt64 pathoffset64; + ENode *tmp; + +#line 3984 + CError_ASSERT(IS_TYPE_CLASS(tm1->ty2)); +#line 3985 + CError_ASSERT(IS_TYPE_CLASS(tm2->ty2)); + + if (tm1->ty2 == tm2->ty2) { + expr->rtype = TYPE(tm2); + return expr; + } + + negate = 0; + path = CClass_GetBasePath(TYPE_CLASS(tm2->ty2), TYPE_CLASS(tm1->ty2), &depth, &isambig); + if (!path) { + path = CClass_GetBasePath(TYPE_CLASS(tm1->ty2), TYPE_CLASS(tm2->ty2), &depth, &isambig); + if (!path) + goto failed; + negate = 1; + } + + if (isambig) + CError_Error(188); + + if ((pathoffset = CClass_GetPathOffset(path)) < 0) + goto failed; + if (negate) + pathoffset = -pathoffset; + + if (flag) + CClass_CheckPathAccess(path, NULL, ACCESSPUBLIC); + + if (tm1->size != tm2->size) { + failed: + CError_Error(247, tm1, 0, tm2, 0); + return nullnode(); + } + + if (!pathoffset) { + expr->rtype = TYPE(tm2); + return expr; + } + + if (tm1->size == 4u) { + if (ENODE_IS(expr, EINTCONST)) { + if (!CInt64_IsZero(&expr->data.intval)) { + CInt64_SetLong(&pathoffset64, pathoffset); + expr->data.intval = CInt64_Add(expr->data.intval, pathoffset64); + } + expr->rtype = TYPE(tm2); + return expr; + } else { + expr->rtype = TYPE(&stunsignedlong); + tmp = intconstnode(TYPE(&stunsignedlong), pathoffset); + tmp = makediadicnode(expr, tmp, EADD); + tmp = makemonadicnode(tmp, ETYPCON); + tmp->rtype = TYPE(tm2); + return do_castnullcheck(tmp, expr); + } + } else { + tmp = create_temp_node(TYPE(&ptmstruct)); + expr = getnodeaddress(expr, 0); + tmp = funccallexpr(rt_ptmf_cast, intconstnode(TYPE(&stsignedlong), pathoffset), expr, tmp, NULL); + tmp = makemonadicnode(tmp, EINDIRECT); + tmp->rtype = TYPE(tm2); + return tmp; + } +} + +ENode *CExpr_MemberPointerConversion(ENode *expr, TypeMemberPointer *type, Boolean flag1) { + if (ENODE_IS(expr, EINTCONST) && CInt64_IsZero(&expr->data.intval)) { + if (IS_TYPE_FUNC(type->ty1)) + expr = create_objectnode(rt_ptmf_null); + expr->rtype = TYPE(type); + } else if (ENODE_IS(expr, EMEMBER)) { + expr = getpointertomemberfunc(expr, TYPE(type), flag1); + } + + return expr; +} + +static ENode *CExpr_MemberPointerCast(ENode *expr, TypeMemberPointer *type, UInt32 qual) { + if (!IS_TYPE_MEMBERPOINTER(expr->rtype)) + expr = CExpr_MemberPointerConversion(expr, type, 1); + + if (!IS_TYPE_MEMBERPOINTER(expr->rtype)) { + CError_Error(164); + return nullnode(); + } + + expr = PointerToMemberCast(expr, TYPE_MEMBER_POINTER(expr->rtype), type, 0); + expr->flags = qual & ENODE_FLAG_QUALS; + return expr; +} + +ENode *do_typecast(ENode *expr, Type *type, UInt32 qual) { + TypePointer *tptr; + ENode *tmp; + UInt32 flags; + + if (!copts.old_argmatch) + return CExpr_Convert(expr, type, qual, 1, 0); + + if (copts.cpp_extensions && is_typesame(expr->rtype, type) && !ENODE_IS(expr, EOBJLIST)) { + expr->rtype = type; + expr->flags &= ~ENODE_FLAG_QUALS; + expr->flags |= qual & ENODE_FLAG_QUALS; + return expr; + } + + switch (type->type) { + case TYPEARRAY: + CError_Error(247, expr->rtype, ENODE_QUALS(expr), type, qual); + return expr; + case TYPEMEMBERPOINTER: + if (!IS_TYPE_CLASS(expr->rtype)) + return CExpr_MemberPointerCast(expr, TYPE_MEMBER_POINTER(type), qual); + } + + flags = qual & ENODE_FLAG_QUALS; + + if (ENODE_IS(expr, EOBJLIST)) + return CExpr_AssignmentPromotion(expr, type, flags, 1); + + if (ENODE_IS(expr, EOBJREF) && IS_TYPE_NONSTATIC_METHOD(expr->data.objref->type)) { + CError_Error(221); + return nullnode(); + } + + if (type == &stvoid) { + expr = makemonadicnode(expr, ETYPCON); + expr->rtype = type; + expr->flags = flags; + return expr; + } + + if (IS_TYPE_REFERENCE(type)) { + tmp = getnodeaddress(expr, 0); + tptr = galloc(sizeof(TypePointer)); + *tptr = *TYPE_POINTER(type); + tptr->qual &= ~Q_REFERENCE; + + tmp = do_typecast(tmp, TYPE(tptr), qual); + tmp = makemonadicnode(tmp, EINDIRECT); + tmp->rtype = TPTR_TARGET(type); + tmp->flags = flags; + return tmp; + } + + if (IS_TYPE_CLASS(expr->rtype) || IS_TYPE_CLASS(type)) { + if (expr->rtype->size == 0) + CDecl_CompleteType(expr->rtype); + + if (expr->rtype == type && !CClass_CopyConstructor(TYPE_CLASS(type))) + return expr; + + if (user_assign_check(expr, type, qual, 1, 1, 1)) { + assign_node->flags = flags; + return assign_node; + } + + CError_Error(247, expr->rtype, ENODE_QUALS(expr), type, qual); + return nullnode(); + } + + if (IS_TYPE_STRUCT(type) && copts.cplusplus && is_typesame(expr->rtype, type)) { + expr->rtype = type; + expr->flags = flags; + return expr; + } + + if (type == TYPE(&stbool)) { + expr = CExpr_ConvertToBool(expr, 1); + expr->flags = flags; + return expr; + } + + if (IS_TYPE_ENUM(type)) { + tmp = do_typecast(expr, TYPE_ENUM(type)->enumtype, qual); + if (!ENODE_IS(tmp, EINTCONST)) + tmp = makemonadicnode(tmp, ETYPCON); + tmp->rtype = type; + tmp->flags = flags; + return tmp; + } + + if (IS_TYPE_INT_OR_FLOAT(type)) { + if (ENODE_IS(expr, ETYPCON) && expr->rtype->type == type->type && expr->rtype->size == type->size) { + if (is_unsigned(expr->rtype) == is_unsigned(type) && ENODE_QUALS(expr) == qual) { + expr->rtype = type; + expr->flags |= ENODE_FLAG_80; + return expr; + } + } + + if (IS_TYPE_ENUM(expr->rtype)) + expr = forceintegral(expr); + + if (IS_TYPE_INT_OR_FLOAT(expr->rtype)) { + expr = promote(expr, type); + expr->flags = flags; + return expr; + } + + if (!(IS_TYPE_POINTER_ONLY(expr->rtype) && !IS_TYPE_FLOAT(type))) + CError_Error(247, expr->rtype, ENODE_QUALS(expr), type, qual); + + if (ENODE_IS(expr, ETYPCON) && ENODE_IS(tmp = expr->data.monadic, EINTCONST)) { + tmp->rtype = type; + tmp->flags = flags; + tmp->data.intval = CExpr_IntConstConvert(type, TYPE(&stunsignedlong), tmp->data.intval); + return tmp; + } + + if (type->size != 4) { + expr = makemonadicnode(expr, ETYPCON); + expr->rtype = TYPE(&stunsignedlong); + } + + expr = makemonadicnode(expr, ETYPCON); + expr->rtype = type; + expr->flags = flags; + return expr; + } + + if (IS_TYPE_POINTER(type)) { + if (IS_TYPE_POINTER(expr->rtype)) { + if (IS_TYPE_CLASS(TPTR_TARGET(expr->rtype)) && IS_TYPE_CLASS(TPTR_TARGET(type))) + expr = CExpr_SafeClassPointerCast(expr, TYPE_CLASS(TPTR_TARGET(expr->rtype)), TYPE_CLASS(TPTR_TARGET(type)), 1, 0); + + if (!ENODE_IS(expr, ETYPCON)) + expr = makemonadicnode(expr, ETYPCON); + + expr->rtype = type; + expr->flags = flags; + return expr; + } + + if (!IS_TYPE_INT(expr->rtype)) { + if (!IS_TYPE_ENUM(expr->rtype)) { + CError_Error(247, expr->rtype, ENODE_QUALS(expr), type, qual); + return expr; + } + expr = forceintegral(expr); + } + + if (expr->rtype->size != 4) { + if (!ENODE_IS(expr, EINTCONST)) + expr = makemonadicnode(expr, ETYPCON); + expr->rtype = TYPE(&stunsignedlong); + } + + expr = makemonadicnode(expr, ETYPCON); + expr->rtype = type; + expr->flags = flags; + return expr; + } + + if ((tmp = CodeGen_HandleTypeCast(expr, type, qual))) + return tmp; + + CError_Error(247, expr->rtype, ENODE_QUALS(expr), type, qual); + return nullnode(); +} + +static Boolean isvectorconst(ENode *node) { + if (ENODE_IS3(node, ECOMMA, EINTCONST, EFLOATCONST)) + return 1; + else + return 0; +} + +ENode *cast_expression(void) { + ENode *expr; + ENode *tmp; + ENodeList *args; + MWVector128 vec; + DeclInfo di; + + if (!(tk == '(' && islookaheaddeclaration())) + return unary_expression(); + tk = lex(); + + memclrw(&di, sizeof(DeclInfo)); + CParser_GetDeclSpecs(&di, 0); + scandeclarator(&di); + + if (tk != ')') + CError_ErrorSkip(115); + else + tk = lex(); + + if (di.name) + CError_Error(164); + + if (copts.altivec_model && tk == '(' && IS_TYPE_VECTOR(di.thetype)) { + tk = lex(); + expr = s_expression(); + if (tk != ')') + CError_ErrorSkip(115); + else + tk = lex(); + + if (CodeGen_CollapseVectorExpression(expr, &vec, di.thetype)) { + tmp = lalloc(sizeof(ENode)); + tmp->type = EVECTOR128CONST; + if ((tmp->cost = expr->cost) == 0) + tmp->cost = 1; + tmp->flags = ENODE_QUALS(expr); + tmp->rtype = di.thetype; + tmp->data.vector128val = vec; + } else { + tmp = makemonadicnode(expr, ETYPCON); + } + tmp->rtype = di.thetype; + tmp->flags = expr->flags; + return tmp; + } + + if (tk == '{' && (!copts.ANSI_strict || copts.c9x) && !IS_TYPE_VECTOR(di.thetype)) + return CInit_AutoObject(NULL, di.thetype, di.qual); + + expr = cast_expression(); + if (copts.cplusplus && (CTemplTool_IsTemplateArgumentDependentType(di.thetype) || + CTemplTool_IsTemplateArgumentDependentExpression(expr))) { + args = lalloc(sizeof(ENodeList)); + args->next = NULL; + args->node = expr; + return CExpr_TemplArgDepCast(di.thetype, di.qual, args); + } + + if (!IS_TYPE_REFERENCE(di.thetype)) + expr = pointer_generation(expr); + return do_typecast(expr, di.thetype, di.qual); +} + +static ENode *pm_expression(void) { + ENode *left; + ENode *right; + ENode *tmp; + Type *type; + UInt32 qual; + short flags; + Conversion conv; + + left = cast_expression(); +restart: + switch (tk) { + case TK_ARROW_STAR: + left = pointer_generation(left); + tk = lex(); + right = pointer_generation(cast_expression()); + + if (CExpr_CheckOperator(TK_ARROW_STAR, left, right, &conv)) { +#line 4457 + CError_ASSERT((left = conv.x0)); + goto restart; + } + + if (!IS_TYPE_POINTER(left->rtype)) { + CError_Error(148); + return left; + } + + left = makemonadicnode(left, EINDIRECT); + left->rtype = TPTR_TARGET(left->rtype); + goto common_part; + case TK_DOT_STAR: + left = pointer_generation(left); + tk = lex(); + right = pointer_generation(cast_expression()); + if (!ENODE_IS(left, EINDIRECT)) { + CError_Error(142); + return left; + } + common_part: + if (!IS_TYPE_CLASS(left->rtype)) { + CError_Error(149); + return left; + } + if (!IS_TYPE_MEMBERPOINTER(right->rtype)) { + CError_Error(144); + return left; + } + if (left->rtype != TYPE_MEMBER_POINTER(right->rtype)->ty2) { + if (CClass_IsBaseClass(TYPE_CLASS(left->rtype), TYPE_CLASS(TYPE_MEMBER_POINTER(right->rtype)->ty2), NULL, 1, 1)) { + left->data.monadic = CClass_ClassPointerCast( + left->data.monadic, + TYPE_CLASS(left->rtype), + TYPE_CLASS(TYPE_MEMBER_POINTER(right->rtype)->ty2), + 0, 1, 1); + left->rtype = TYPE_MEMBER_POINTER(right->rtype)->ty2; + } else { + CError_Error(146); + return left; + } + } + type = CClass_CombineClassAccessQualifiers( + TYPE_MEMBER_POINTER(right->rtype)->ty1, + ENODE_QUALS(right), + left->flags, + &qual); + flags = qual; + if (!IS_TYPE_FUNC(type)) { + if (!ENODE_IS(right, EINTCONST)) { + if (!canadd(left->data.monadic, -1)) { + left->data.monadic = makediadicnode(left->data.monadic, nullnode(), EADD); + CInt64_SetLong(&left->data.monadic->data.diadic.right->data.intval, -1); + optimizecomm(left->data.monadic); + } + right->rtype = TYPE(&stunsignedlong); + left->data.monadic = makediadicnode(left->data.monadic, right, EADD); + optimizecomm(left->data.monadic); + } else { + right->data.intval = CInt64_Sub(right->data.intval, cint64_one); + if (!canadd2(left->data.monadic, right->data.intval)) { + right->rtype = TYPE(&stunsignedlong); + left->data.monadic = makediadicnode(left->data.monadic, right, EADD); + optimizecomm(left->data.monadic); + } + } + + if (IS_TYPE_BITFIELD(type)) { + left->data.monadic = makemonadicnode(left->data.monadic, EBITFIELD); + left->data.monadic->rtype = type; + left->rtype = TYPE_BITFIELD(type)->bitfieldtype; + } else { + left->rtype = type; + } + left->flags = flags; + left = checkreference(left); + goto restart; + } else { +#line 4535 + CError_ASSERT(ENODE_IS(right, EINDIRECT)); + tmp = lalloc(sizeof(ENode)); + tmp->type = EMFPOINTER; + tmp->cost = 4; + tmp->flags = 0; + tmp->rtype = &stvoid; + tmp->data.mfpointer.accessnode = left; + tmp->data.mfpointer.mfpointer = right; + return tmp; + } + default: + return left; + } +} + +ENode *CExpr_New_EMUL_Node(ENode *left, ENode *right) { + Conversion conv; + + if (IS_TYPE_TEMPLDEPEXPR(left->rtype) || IS_TYPE_TEMPLDEPEXPR(right->rtype)) + return CTempl_MakeTemplDepExpr(left, EMUL, right); + + left = pointer_generation(left); + right = pointer_generation(right); + if (copts.cplusplus && CExpr_CheckOperator('*', left, right, &conv)) { + if (conv.x0) + return conv.x0; +#line 4566 + CError_ASSERT((left = conv.left)); + CError_ASSERT((right = conv.right)); + } + + return makemultnode(left, right); +} + +ENode *CExpr_New_EDIV_Node(ENode *left, ENode *right, Boolean no_warning) { + Conversion conv; + + if (IS_TYPE_TEMPLDEPEXPR(left->rtype) || IS_TYPE_TEMPLDEPEXPR(right->rtype)) + return CTempl_MakeTemplDepExpr(left, EDIV, right); + + left = pointer_generation(left); + right = pointer_generation(right); + if (copts.cplusplus && CExpr_CheckOperator('/', left, right, &conv)) { + if (conv.x0) + return conv.x0; +#line 4592 + CError_ASSERT((left = conv.left)); + CError_ASSERT((right = conv.right)); + } + + return makedivnode(left, right, no_warning); +} + +ENode *CExpr_New_EMODULO_Node(ENode *left, ENode *right, Boolean no_warning) { + Conversion conv; + + if (IS_TYPE_TEMPLDEPEXPR(left->rtype) || IS_TYPE_TEMPLDEPEXPR(right->rtype)) + return CTempl_MakeTemplDepExpr(left, EMODULO, right); + + left = pointer_generation(left); + right = pointer_generation(right); + if (copts.cplusplus && CExpr_CheckOperator('%', left, right, &conv)) { + if (conv.x0) + return conv.x0; +#line 4618 + CError_ASSERT((left = conv.left)); + CError_ASSERT((right = conv.right)); + } + + left = integralpromote(left); + right = integralpromote(right); + CExpr_ArithmeticConversion(&left, &right); + + if (iszero(right)) { + if (!no_warning) + CError_Warning(139); + return left; + } + + if (ENODE_IS(left, EINTCONST) && ENODE_IS(right, EINTCONST)) { + left->data.intval = CMach_CalcIntDiadic(left->rtype, left->data.intval, '%', right->data.intval); + return left; + } + + if (iszero(left)) + return makediadicnode(right, left, ECOMMA); + + if (CExpr_IsOne(right)) { + right = nullnode(); + right->rtype = left->rtype; + return makediadicnode(left, right, ECOMMA); + } + + return makediadicnode(left, right, EMODULO); +} + +ENode *CExpr_New_EADD_Node(ENode *left, ENode *right) { + Conversion conv; + + if (IS_TYPE_TEMPLDEPEXPR(left->rtype) || IS_TYPE_TEMPLDEPEXPR(right->rtype)) + return CTempl_MakeTemplDepExpr(left, EADD, right); + + left = pointer_generation(left); + right = pointer_generation(right); + if (copts.cplusplus && CExpr_CheckOperator('+', left, right, &conv)) { + if (conv.x0) + return conv.x0; +#line 4665 + CError_ASSERT((left = conv.left)); + CError_ASSERT((right = conv.right)); + } + + return makeaddnode(left, right); +} + +ENode *CExpr_New_ESUB_Node(ENode *left, ENode *right) { + Conversion conv; + + if (IS_TYPE_TEMPLDEPEXPR(left->rtype) || IS_TYPE_TEMPLDEPEXPR(right->rtype)) + return CTempl_MakeTemplDepExpr(left, ESUB, right); + + left = pointer_generation(left); + right = pointer_generation(right); + if (copts.cplusplus && CExpr_CheckOperator('-', left, right, &conv)) { + if (conv.x0) + return conv.x0; +#line 4690 + CError_ASSERT((left = conv.left)); + CError_ASSERT((right = conv.right)); + } + + return makesubnode(left, right); +} + +ENode *CExpr_New_ESHL_Node(ENode *left, ENode *right) { + Conversion conv; + + if (IS_TYPE_TEMPLDEPEXPR(left->rtype) || IS_TYPE_TEMPLDEPEXPR(right->rtype)) + return CTempl_MakeTemplDepExpr(left, ESHL, right); + + left = pointer_generation(left); + right = pointer_generation(right); + if (copts.cplusplus && CExpr_CheckOperator(TK_SHL, left, right, &conv)) { + if (conv.x0) + return conv.x0; +#line 4715 + CError_ASSERT((left = conv.left)); + CError_ASSERT((right = conv.right)); + } + + left = integralpromote(left); + right = integralpromote(right); + + if (iszero(left) || iszero(right)) { + return left; + } + + if (ENODE_IS(left, EINTCONST) && ENODE_IS(right, EINTCONST)) { + left->data.intval = CMach_CalcIntDiadic(left->rtype, left->data.intval, TK_SHL, right->data.intval); + return left; + } + + return makediadicnode(left, right, ESHL); +} + +ENode *CExpr_New_ESHR_Node(ENode *left, ENode *right) { + Conversion conv; + + if (IS_TYPE_TEMPLDEPEXPR(left->rtype) || IS_TYPE_TEMPLDEPEXPR(right->rtype)) + return CTempl_MakeTemplDepExpr(left, ESHR, right); + + left = pointer_generation(left); + right = pointer_generation(right); + if (copts.cplusplus && CExpr_CheckOperator(TK_SHR, left, right, &conv)) { + if (conv.x0) + return conv.x0; +#line 4752 + CError_ASSERT((left = conv.left)); + CError_ASSERT((right = conv.right)); + } + + left = integralpromote(left); + right = integralpromote(right); + + if (iszero(left) || iszero(right)) { + return left; + } + + if (ENODE_IS(left, EINTCONST) && ENODE_IS(right, EINTCONST)) { + left->data.intval = CMach_CalcIntDiadic(left->rtype, left->data.intval, TK_SHR, right->data.intval); + return left; + } + + return makediadicnode(left, right, ESHR); +} + +static ENode *pointercompare(ENodeType nt, ENode *left, ENode *right) { + Type *ltype; + Type *rtype; + + ltype = left->rtype; + rtype = right->rtype; + if (IS_TYPE_POINTER_ONLY(ltype) && IS_TYPE_POINTER_ONLY(rtype)) { + ltype = TPTR_TARGET(left->rtype); + rtype = TPTR_TARGET(right->rtype); + if (IS_TYPE_CLASS(ltype) && IS_TYPE_CLASS(rtype)) { + if (ltype != rtype) { + if (ltype == TPTR_TARGET(left->rtype)) { + if (CClass_IsBaseClass(TYPE_CLASS(ltype), TYPE_CLASS(rtype), NULL, 0, 1)) { + left = CExpr_SafeClassPointerCast(left, TYPE_CLASS(ltype), TYPE_CLASS(rtype), 0, 1); + } else if (CClass_IsBaseClass(TYPE_CLASS(rtype), TYPE_CLASS(ltype), NULL, 0, 1)) { + right = CExpr_SafeClassPointerCast(right, TYPE_CLASS(rtype), TYPE_CLASS(ltype), 0, 1); + } else { + CError_Error(245, left->rtype, ENODE_QUALS(left), right->rtype, ENODE_QUALS(right)); + } + } else { + CError_Error(245, left->rtype, ENODE_QUALS(left), right->rtype, ENODE_QUALS(right)); + } + } + } else if (!is_typeequal(left->rtype, right->rtype)) { + if (!copts.objective_c || !CObjC_IsCompatibleType(left->rtype, right->rtype)) { + CError_Error(245, left->rtype, ENODE_QUALS(left), right->rtype, ENODE_QUALS(right)); + } + } + } else if (nt == EEQU || nt == ENOTEQU) { + if (IS_TYPE_INT(ltype)) { + if (!(ENODE_IS(left, EINTCONST) && CInt64_IsZero(&left->data.intval))) + CError_Error(144); +#line 4847 + CError_ASSERT(IS_TYPE_POINTER_ONLY(rtype)); + left->rtype = TYPE(&stunsignedlong); + } else if (IS_TYPE_INT(rtype)) { + if (!(ENODE_IS(right, EINTCONST) && CInt64_IsZero(&right->data.intval))) + CError_Error(144); +#line 4855 + CError_ASSERT(IS_TYPE_POINTER_ONLY(ltype)); + right->rtype = TYPE(&stunsignedlong); + } else if (!is_typeequal(ltype, rtype)) { + CError_Error(245, left->rtype, ENODE_QUALS(left), right->rtype, ENODE_QUALS(right)); + } + } else { + if (!is_typeequal(ltype, rtype)) + CError_Error(245, left->rtype, ENODE_QUALS(left), right->rtype, ENODE_QUALS(right)); + } + + return logicalexpression(makediadicnode(left, right, nt)); +} + +static ENode *unsigncheck(ENode *expr, Boolean flag1, Boolean flag2) { + if (is_unsigned(expr->data.diadic.left->rtype)) { + if (ENODE_IS(expr->data.diadic.left, EINTCONST) && CInt64_IsZero(&expr->data.diadic.left->data.intval)) { + flag1 = !flag1; + } else if (!(ENODE_IS(expr->data.diadic.right, EINTCONST) && CInt64_IsZero(&expr->data.diadic.right->data.intval))) { + return logicalexpression(expr); + } + + if (flag1 && flag2) { + expr->type = EEQU; + return logicalexpression(expr); + } + if (!flag1 && !flag2) { + expr->type = ENOTEQU; + return logicalexpression(expr); + } + return CExpr_ConstResult(logicalexpression(expr), !flag1); + } + return logicalexpression(expr); +} + +ENode *CExpr_New_ELESS_Node(ENode *left, ENode *right) { + Conversion conv; + + if (IS_TYPE_TEMPLDEPEXPR(left->rtype) || IS_TYPE_TEMPLDEPEXPR(right->rtype)) + return CTempl_MakeTemplDepExpr(left, ELESS, right); + + left = pointer_generation(left); + right = pointer_generation(right); + if (copts.cplusplus && CExpr_CheckOperator('<', left, right, &conv)) { + if (conv.x0) + return conv.x0; +#line 4929 + CError_ASSERT((left = conv.left)); + CError_ASSERT((right = conv.right)); + } + + if (IS_TYPE_POINTER(left->rtype) || IS_TYPE_POINTER(right->rtype)) + return pointercompare(ELESS, left, right); + + CExpr_CompareConvert(&left, "<", &right, 0); + if (ENODE_IS(left, EINTCONST) && ENODE_IS(right, EINTCONST)) { + left->data.intval = CMach_CalcIntDiadic(left->rtype, left->data.intval, '<', right->data.intval); + left->rtype = CParser_GetBoolType(); + } else if (ENODE_IS(left, EFLOATCONST) && ENODE_IS(right, EFLOATCONST)) { + CInt64_SetLong(&left->data.intval, CMach_CalcFloatDiadicBool(left->rtype, left->data.floatval, '<', right->data.floatval)); + left->type = EINTCONST; + left->rtype = CParser_GetBoolType(); + } else { + left = unsigncheck(makediadicnode(left, right, ELESS), 1, 0); + } + + return left; +} + +ENode *CExpr_New_ELESSEQU_Node(ENode *left, ENode *right) { + Conversion conv; + + if (IS_TYPE_TEMPLDEPEXPR(left->rtype) || IS_TYPE_TEMPLDEPEXPR(right->rtype)) + return CTempl_MakeTemplDepExpr(left, ELESSEQU, right); + + left = pointer_generation(left); + right = pointer_generation(right); + if (copts.cplusplus && CExpr_CheckOperator(TK_LESS_EQUAL, left, right, &conv)) { + if (conv.x0) + return conv.x0; +#line 4976 + CError_ASSERT((left = conv.left)); + CError_ASSERT((right = conv.right)); + } + + if (IS_TYPE_POINTER(left->rtype) || IS_TYPE_POINTER(right->rtype)) + return pointercompare(ELESSEQU, left, right); + + CExpr_CompareConvert(&left, "<=", &right, 0); + if (ENODE_IS(left, EINTCONST) && ENODE_IS(right, EINTCONST)) { + left->data.intval = CMach_CalcIntDiadic(left->rtype, left->data.intval, TK_LESS_EQUAL, right->data.intval); + left->rtype = CParser_GetBoolType(); + } else if (ENODE_IS(left, EFLOATCONST) && ENODE_IS(right, EFLOATCONST)) { + CInt64_SetLong(&left->data.intval, CMach_CalcFloatDiadicBool(left->rtype, left->data.floatval, TK_LESS_EQUAL, right->data.floatval)); + left->type = EINTCONST; + left->rtype = CParser_GetBoolType(); + } else { + left = unsigncheck(makediadicnode(left, right, ELESSEQU), 1, 1); + } + + return left; +} + +ENode *CExpr_New_EGREATER_Node(ENode *left, ENode *right) { + Conversion conv; + + if (IS_TYPE_TEMPLDEPEXPR(left->rtype) || IS_TYPE_TEMPLDEPEXPR(right->rtype)) + return CTempl_MakeTemplDepExpr(left, EGREATER, right); + + left = pointer_generation(left); + right = pointer_generation(right); + if (copts.cplusplus && CExpr_CheckOperator('>', left, right, &conv)) { + if (conv.x0) + return conv.x0; +#line 5023 + CError_ASSERT((left = conv.left)); + CError_ASSERT((right = conv.right)); + } + + if (IS_TYPE_POINTER(left->rtype) || IS_TYPE_POINTER(right->rtype)) + return pointercompare(EGREATER, left, right); + + CExpr_CompareConvert(&left, ">", &right, 0); + if (ENODE_IS(left, EINTCONST) && ENODE_IS(right, EINTCONST)) { + left->data.intval = CMach_CalcIntDiadic(left->rtype, left->data.intval, '>', right->data.intval); + left->rtype = CParser_GetBoolType(); + } else if (ENODE_IS(left, EFLOATCONST) && ENODE_IS(right, EFLOATCONST)) { + CInt64_SetLong(&left->data.intval, CMach_CalcFloatDiadicBool(left->rtype, left->data.floatval, '>', right->data.floatval)); + left->type = EINTCONST; + left->rtype = CParser_GetBoolType(); + } else { + left = unsigncheck(makediadicnode(left, right, EGREATER), 0, 0); + } + + return left; +} + +ENode *CExpr_New_EGREATEREQU_Node(ENode *left, ENode *right) { + Conversion conv; + + if (IS_TYPE_TEMPLDEPEXPR(left->rtype) || IS_TYPE_TEMPLDEPEXPR(right->rtype)) + return CTempl_MakeTemplDepExpr(left, EGREATEREQU, right); + + left = pointer_generation(left); + right = pointer_generation(right); + if (copts.cplusplus && CExpr_CheckOperator(TK_GREATER_EQUAL, left, right, &conv)) { + if (conv.x0) + return conv.x0; +#line 5070 + CError_ASSERT((left = conv.left)); + CError_ASSERT((right = conv.right)); + } + + if (IS_TYPE_POINTER(left->rtype) || IS_TYPE_POINTER(right->rtype)) + return pointercompare(EGREATEREQU, left, right); + + CExpr_CompareConvert(&left, ">=", &right, 0); + if (ENODE_IS(left, EINTCONST) && ENODE_IS(right, EINTCONST)) { + left->data.intval = CMach_CalcIntDiadic(left->rtype, left->data.intval, TK_GREATER_EQUAL, right->data.intval); + left->rtype = CParser_GetBoolType(); + } else if (ENODE_IS(left, EFLOATCONST) && ENODE_IS(right, EFLOATCONST)) { + CInt64_SetLong(&left->data.intval, CMach_CalcFloatDiadicBool(left->rtype, left->data.floatval, TK_GREATER_EQUAL, right->data.floatval)); + left->type = EINTCONST; + left->rtype = CParser_GetBoolType(); + } else { + left = unsigncheck(makediadicnode(left, right, EGREATEREQU), 0, 1); + } + + return left; +} + +ENode *memberpointercompare(ENodeType nt, ENode *left, ENode *right) { + Object *func; + ENodeList *arg; + + if (!IS_TYPE_MEMBERPOINTER(left->rtype)) { + if (!(IS_TYPE_INT(left->rtype) && ENODE_IS(left, EINTCONST) && CInt64_IsZero(&left->data.intval))) { + CError_Error(144); + return nullnode(); + } + } else if (!IS_TYPE_MEMBERPOINTER(right->rtype)) { + if (!(IS_TYPE_INT(right->rtype) && ENODE_IS(right, EINTCONST) && CInt64_IsZero(&right->data.intval))) { + CError_Error(144); + return nullnode(); + } + } else if (!is_typeequal(left->rtype, right->rtype)) { + left = PointerToMemberCast(left, TYPE_MEMBER_POINTER(left->rtype), TYPE_MEMBER_POINTER(right->rtype), 1); + } + + if ((ENODE_IS(left, EINTCONST) || !IS_TYPE_FUNC(TYPE_MEMBER_POINTER(left->rtype)->ty1)) && (ENODE_IS(right, EINTCONST) || !IS_TYPE_FUNC(TYPE_MEMBER_POINTER(right->rtype)->ty1))) { + left->rtype = TYPE(&stunsignedlong); + right->rtype = TYPE(&stunsignedlong); + return logicalexpression(makediadicnode(left, right, nt)); + } + + arg = lalloc(sizeof(ENodeList)); + if (ENODE_IS(left, EINTCONST) || ENODE_IS(right, EINTCONST)) { + func = rt_ptmf_test; + if (ENODE_IS(left, EINTCONST)) + arg->node = getnodeaddress(right, 0); + else + arg->node = getnodeaddress(left, 0); + arg->next = NULL; + } else { + func = rt_ptmf_cmpr; + arg->next = lalloc(sizeof(ENodeList)); + arg->node = getnodeaddress(left, 0); + arg->next->node = getnodeaddress(right, 0); + arg->next->next = NULL; + } + + left = lalloc(sizeof(ENode)); + left->type = EFUNCCALL; + left->rtype = TYPE(&stsignedlong); + left->cost = 4; + left->data.funccall.funcref = create_objectrefnode(func); + left->data.funccall.args = arg; + left->data.funccall.functype = TYPE_FUNC(func->type); + left->flags = TYPE_FUNC(func->type)->qual & ENODE_FLAG_QUALS; + + if (nt == EEQU) + left = makemonadicnode(left, ELOGNOT); + + return left; +} + +ENode *CExpr_New_EEQU_Node(ENode *left, ENode *right) { + Conversion conv; + + if (IS_TYPE_TEMPLDEPEXPR(left->rtype) || IS_TYPE_TEMPLDEPEXPR(right->rtype)) + return CTempl_MakeTemplDepExpr(left, EEQU, right); + + left = pointer_generation(left); + right = pointer_generation(right); + if (copts.cplusplus && CExpr_CheckOperator(TK_LOGICAL_EQ, left, right, &conv)) { + if (conv.x0) + return conv.x0; +#line 5201 + CError_ASSERT((left = conv.left)); + CError_ASSERT((right = conv.right)); + } + + if (IS_TYPE_POINTER(left->rtype) || IS_TYPE_POINTER(right->rtype)) + return pointercompare(EEQU, left, right); + if (IS_TYPE_MEMBERPOINTER(left->rtype) || IS_TYPE_MEMBERPOINTER(right->rtype)) + return memberpointercompare(EEQU, left, right); + + CExpr_CompareConvert(&left, "==", &right, 1); + if (ENODE_IS(left, EINTCONST) && ENODE_IS(right, EINTCONST)) { + left->data.intval = CMach_CalcIntDiadic(left->rtype, left->data.intval, TK_LOGICAL_EQ, right->data.intval); + left->rtype = CParser_GetBoolType(); + } else if (ENODE_IS(left, EFLOATCONST) && ENODE_IS(right, EFLOATCONST)) { + left->type = EINTCONST; + CInt64_SetLong(&left->data.intval, CMach_CalcFloatDiadicBool(left->rtype, left->data.floatval, TK_LOGICAL_EQ, right->data.floatval)); + left->type = EINTCONST; + left->rtype = CParser_GetBoolType(); + } else { + left = makediadicnode(left, right, EEQU); + optimizecomm(left); + } + + return logicalexpression(left); +} + +ENode *CExpr_New_ENOTEQU_Node(ENode *left, ENode *right) { + Conversion conv; + + if (IS_TYPE_TEMPLDEPEXPR(left->rtype) || IS_TYPE_TEMPLDEPEXPR(right->rtype)) + return CTempl_MakeTemplDepExpr(left, ENOTEQU, right); + + left = pointer_generation(left); + right = pointer_generation(right); + if (copts.cplusplus && CExpr_CheckOperator(TK_LOGICAL_NE, left, right, &conv)) { + if (conv.x0) + return conv.x0; +#line 5261 + CError_ASSERT((left = conv.left)); + CError_ASSERT((right = conv.right)); + } + + if (IS_TYPE_POINTER(left->rtype) || IS_TYPE_POINTER(right->rtype)) + return pointercompare(ENOTEQU, left, right); + if (IS_TYPE_MEMBERPOINTER(left->rtype) || IS_TYPE_MEMBERPOINTER(right->rtype)) + return memberpointercompare(ENOTEQU, left, right); + + CExpr_CompareConvert(&left, "!=", &right, 1); + if (ENODE_IS(left, EINTCONST) && ENODE_IS(right, EINTCONST)) { + left->data.intval = CMach_CalcIntDiadic(left->rtype, left->data.intval, TK_LOGICAL_NE, right->data.intval); + left->rtype = CParser_GetBoolType(); + } else if (ENODE_IS(left, EFLOATCONST) && ENODE_IS(right, EFLOATCONST)) { + CInt64_SetLong(&left->data.intval, CMach_CalcFloatDiadicBool(left->rtype, left->data.floatval, TK_LOGICAL_NE, right->data.floatval)); + left->type = EINTCONST; + left->rtype = CParser_GetBoolType(); + } else { + left = makediadicnode(left, right, ENOTEQU); + optimizecomm(left); + } + + return logicalexpression(left); +} + +ENode *CExpr_New_EAND_Node(ENode *left, ENode *right) { + Conversion conv; + + if (IS_TYPE_TEMPLDEPEXPR(left->rtype) || IS_TYPE_TEMPLDEPEXPR(right->rtype)) + return CTempl_MakeTemplDepExpr(left, EAND, right); + + left = pointer_generation(left); + right = pointer_generation(right); + if (copts.cplusplus && CExpr_CheckOperator('&', left, right, &conv)) { + if (conv.x0) + return conv.x0; +#line 5321 + CError_ASSERT((left = conv.left)); + CError_ASSERT((right = conv.right)); + } + + left = integralpromote(left); + right = integralpromote(right); + CExpr_ArithmeticConversion(&left, &right); + + if (iszero(left) || CExpr_AllBitsSet(right)) + return left; + if (iszero(right) || CExpr_AllBitsSet(left)) + return right; + + if (ENODE_IS(left, EINTCONST) && ENODE_IS(right, EINTCONST)) { + left->data.intval = CMach_CalcIntDiadic(left->rtype, left->data.intval, '&', right->data.intval); + return left; + } + + left = makediadicnode(left, right, EAND); + optimizecomm(left); + return left; +} + +ENode *CExpr_New_EXOR_Node(ENode *left, ENode *right) { + Conversion conv; + + if (IS_TYPE_TEMPLDEPEXPR(left->rtype) || IS_TYPE_TEMPLDEPEXPR(right->rtype)) + return CTempl_MakeTemplDepExpr(left, EXOR, right); + + left = pointer_generation(left); + right = pointer_generation(right); + if (copts.cplusplus && CExpr_CheckOperator('^', left, right, &conv)) { + if (conv.x0) + return conv.x0; +#line 5360 + CError_ASSERT((left = conv.left)); + CError_ASSERT((right = conv.right)); + } + + left = integralpromote(left); + right = integralpromote(right); + CExpr_ArithmeticConversion(&left, &right); + + if (iszero(right)) + return left; + if (iszero(left)) + return right; + + if (ENODE_IS(left, EINTCONST) && ENODE_IS(right, EINTCONST)) { + left->data.intval = CMach_CalcIntDiadic(left->rtype, left->data.intval, '^', right->data.intval); + return left; + } + + left = makediadicnode(left, right, EXOR); + optimizecomm(left); + return left; +} + +ENode *CExpr_New_EOR_Node(ENode *left, ENode *right) { + Conversion conv; + + if (IS_TYPE_TEMPLDEPEXPR(left->rtype) || IS_TYPE_TEMPLDEPEXPR(right->rtype)) + return CTempl_MakeTemplDepExpr(left, EOR, right); + + left = pointer_generation(left); + right = pointer_generation(right); + if (copts.cplusplus && CExpr_CheckOperator('|', left, right, &conv)) { + if (conv.x0) + return conv.x0; +#line 5399 + CError_ASSERT((left = conv.left)); + CError_ASSERT((right = conv.right)); + } + + left = integralpromote(left); + right = integralpromote(right); + CExpr_ArithmeticConversion(&left, &right); + + if (iszero(right) || CExpr_AllBitsSet(left)) + return left; + if (iszero(left) || CExpr_AllBitsSet(right)) + return right; + + if (ENODE_IS(left, EINTCONST) && ENODE_IS(right, EINTCONST)) { + left->data.intval = CMach_CalcIntDiadic(left->rtype, left->data.intval, '|', right->data.intval); + return left; + } + + left = makediadicnode(left, right, EOR); + optimizecomm(left); + return left; +} + +ENode *CExpr_New_ELAND_Node(ENode *left, ENode *right) { + Conversion conv; + + if (IS_TYPE_TEMPLDEPEXPR(left->rtype) || IS_TYPE_TEMPLDEPEXPR(right->rtype)) + return CTempl_MakeTemplDepExpr(left, ELAND, right); + + left = pointer_generation(left); + right = pointer_generation(right); + if (copts.cplusplus && CExpr_CheckOperator(TK_LOGICAL_AND, left, right, &conv)) { + if (conv.x0) + return conv.x0; +#line 5438 + CError_ASSERT((left = conv.left)); + CError_ASSERT((right = conv.right)); + } + + switch (left->rtype->type) { + case TYPEINT: + case TYPEFLOAT: + case TYPEPOINTER: + case TYPEARRAY: + break; + case TYPEENUM: + case TYPEMEMBERPOINTER: + left = CExpr_ConvertToCondition(left); + break; + default: + CError_Error(144); + left = nullnode(); + } + switch (right->rtype->type) { + case TYPEINT: + case TYPEFLOAT: + case TYPEPOINTER: + case TYPEARRAY: + break; + case TYPEENUM: + case TYPEMEMBERPOINTER: + right = CExpr_ConvertToCondition(right); + break; + default: + CError_Error(144); + right = nullnode(); + } + + if (iszero(left)) { + left->type = EINTCONST; + left->rtype = CParser_GetBoolType(); + CInt64_SetLong(&left->data.intval, 0); + return left; + } + + if (isnotzero(left)) { + if (iszero(right)) { + left->type = EINTCONST; + left->rtype = CParser_GetBoolType(); + CInt64_SetLong(&left->data.intval, 0); + return left; + } else if (isnotzero(right)) { + left->type = EINTCONST; + left->rtype = CParser_GetBoolType(); + CInt64_SetLong(&left->data.intval, 1); + return left; + } else { + left = makemonadicnode(right, ELOGNOT); + left->rtype = CParser_GetBoolType(); + return makemonadicnode(left, ELOGNOT); + } + } else { + if (isnotzero(right)) { + left = makemonadicnode(left, ELOGNOT); + left->rtype = CParser_GetBoolType(); + return makemonadicnode(left, ELOGNOT); + } else if (iszero(right)) { + right->type = EINTCONST; + right->rtype = CParser_GetBoolType(); + CInt64_SetLong(&right->data.intval, 0); + return makecommaexpression(left, right); + } else { + left = makediadicnode(left, right, ELAND); + left->rtype = CParser_GetBoolType(); + return left; + } + } +} + +ENode *CExpr_New_ELOR_Node(ENode *left, ENode *right) { + Conversion conv; + + if (IS_TYPE_TEMPLDEPEXPR(left->rtype) || IS_TYPE_TEMPLDEPEXPR(right->rtype)) + return CTempl_MakeTemplDepExpr(left, ELOR, right); + + left = pointer_generation(left); + right = pointer_generation(right); + if (copts.cplusplus && CExpr_CheckOperator(TK_LOGICAL_OR, left, right, &conv)) { + if (conv.x0) + return conv.x0; +#line 5543 + CError_ASSERT((left = conv.left)); + CError_ASSERT((right = conv.right)); + } + + switch (left->rtype->type) { + case TYPEINT: + case TYPEFLOAT: + case TYPEPOINTER: + case TYPEARRAY: + break; + case TYPEENUM: + case TYPEMEMBERPOINTER: + left = CExpr_ConvertToCondition(left); + break; + default: + CError_Error(144); + left = nullnode(); + } + switch (right->rtype->type) { + case TYPEINT: + case TYPEFLOAT: + case TYPEPOINTER: + case TYPEARRAY: + break; + case TYPEENUM: + case TYPEMEMBERPOINTER: + right = CExpr_ConvertToCondition(right); + break; + default: + CError_Error(144); + right = nullnode(); + } + + if (isnotzero(left)) { + left->type = EINTCONST; + left->rtype = CParser_GetBoolType(); + CInt64_SetLong(&left->data.intval, 1); + return left; + } + + if (iszero(left)) { + if (iszero(right)) { + left->type = EINTCONST; + left->rtype = CParser_GetBoolType(); + CInt64_SetLong(&left->data.intval, 0); + return left; + } else if (isnotzero(right)) { + left->type = EINTCONST; + left->rtype = CParser_GetBoolType(); + CInt64_SetLong(&left->data.intval, 1); + return left; + } else { + left = makemonadicnode(right, ELOGNOT); + left->rtype = CParser_GetBoolType(); + return makemonadicnode(left, ELOGNOT); + } + } else { + if (isnotzero(right)) { + right->type = EINTCONST; + right->rtype = CParser_GetBoolType(); + CInt64_SetLong(&right->data.intval, 1); + } else if (iszero(right)) { + left = makemonadicnode(left, ELOGNOT); + left->rtype = CParser_GetBoolType(); + return makemonadicnode(left, ELOGNOT); + } + left = makediadicnode(left, right, ELOR); + left->rtype = CParser_GetBoolType(); + return left; + } +} + +ENode *CExpr_NewDyadicNode(ENode *left, ENodeType nt, ENode *right) { + switch (nt) { + default: +#line 5642 + CError_FATAL(); + case EADD: return CExpr_New_EADD_Node(left, right); + case ESUB: return CExpr_New_ESUB_Node(left, right); + case EMUL: return CExpr_New_EMUL_Node(left, right); + case EDIV: return CExpr_New_EDIV_Node(left, right, 1); + case EMODULO: return CExpr_New_EMODULO_Node(left, right, 1); + case EAND: return CExpr_New_EAND_Node(left, right); + case EXOR: return CExpr_New_EXOR_Node(left, right); + case EOR: return CExpr_New_EOR_Node(left, right); + case ESHL: return CExpr_New_ESHL_Node(left, right); + case ESHR: return CExpr_New_ESHR_Node(left, right); + case ELESS: return CExpr_New_ELESS_Node(left, right); + case EGREATER: return CExpr_New_EGREATER_Node(left, right); + case ELESSEQU: return CExpr_New_ELESSEQU_Node(left, right); + case EGREATEREQU: return CExpr_New_EGREATEREQU_Node(left, right); + case EEQU: return CExpr_New_EEQU_Node(left, right); + case ENOTEQU: return CExpr_New_ENOTEQU_Node(left, right); + case ELAND: return CExpr_New_ELAND_Node(left, right); + case ELOR: return CExpr_New_ELOR_Node(left, right); + } +} + +typedef struct DyadicInfo { + ENodeType t; + UInt8 prec; +} DyadicInfo; + +static Boolean CExpr_GetDyadicInfo(short token, DyadicInfo *info) { + switch (token) { + case '*': + info->t = EMUL; + info->prec = 20; + return 1; + case '/': + info->t = EDIV; + info->prec = 20; + return 1; + case '%': + info->t = EMODULO; + info->prec = 20; + return 1; + case '+': + info->t = EADD; + info->prec = 19; + return 1; + case '-': + info->t = ESUB; + info->prec = 19; + return 1; + case TK_SHL: + info->t = ESHL; + info->prec = 18; + return 1; + case TK_SHR: + info->t = ESHR; + info->prec = 18; + return 1; + case '<': + info->t = ELESS; + info->prec = 17; + return 1; + case TK_LESS_EQUAL: + info->t = ELESSEQU; + info->prec = 17; + return 1; + case '>': + if (disallowgreaterthan) + return 0; + info->t = EGREATER; + info->prec = 17; + return 1; + case TK_GREATER_EQUAL: + info->t = EGREATEREQU; + info->prec = 17; + return 1; + case TK_LOGICAL_EQ: + info->t = EEQU; + info->prec = 16; + return 1; + case TK_LOGICAL_NE: + info->t = ENOTEQU; + info->prec = 16; + return 1; + case '&': + info->t = EAND; + info->prec = 15; + return 1; + case '^': + info->t = EXOR; + info->prec = 14; + return 1; + case '|': + info->t = EOR; + info->prec = 13; + return 1; + case TK_LOGICAL_AND: + info->t = ELAND; + info->prec = 12; + return 1; + case TK_LOGICAL_OR: + info->t = ELOR; + info->prec = 11; + return 1; + default: + return 0; + } +} + +static ENode *CExpr_ParseDyadicExpression(ENode *left, UInt8 prec, Boolean no_warning) { + ENode *right; + Boolean is_eland_or_elor; + Boolean save_dgt; + Boolean cont; + DyadicInfo left_info; + DyadicInfo right_info; + + save_dgt = disallowgreaterthan; + if (!left) { + disallowgreaterthan = 0; + left = pm_expression(); + disallowgreaterthan = save_dgt; + } + + do { + if (!CExpr_GetDyadicInfo(tk, &left_info)) + return left; + + switch (left_info.t) { + case ELAND: + CExpr_CheckUnwantedAssignment(left); + if (iszero(left)) + no_warning = 1; + is_eland_or_elor = 1; + break; + case ELOR: + CExpr_CheckUnwantedAssignment(left); + if (isnotzero(left)) + no_warning = 1; + is_eland_or_elor = 1; + break; + default: + is_eland_or_elor = 0; + } + + tk = lex(); + disallowgreaterthan = 0; + right = pm_expression(); + disallowgreaterthan = save_dgt; + inner_loop: + if (CExpr_GetDyadicInfo(tk, &right_info)) { + if (left_info.prec >= right_info.prec) { + cont = (prec >= right_info.prec); + } else { + right = CExpr_ParseDyadicExpression(right, left_info.prec, no_warning); + goto inner_loop; + } + } else { + cont = 1; + } + + if (is_eland_or_elor) + CExpr_CheckUnwantedAssignment(right); + + switch (left_info.t) { + case EDIV: + left = CExpr_New_EDIV_Node(left, right, no_warning); + break; + case EMODULO: + left = CExpr_New_EMODULO_Node(left, right, no_warning); + break; + default: + left = CExpr_NewDyadicNode(left, left_info.t, right); + } + } while (!cont); + + return left; +} + +static Boolean CExpr_IsBlockMoveType(Type *type) { + switch (type->type) { + case TYPESTRUCT: + case TYPECLASS: + return 1; + case TYPEMEMBERPOINTER: + return type->size != 4; + default: + return 0; + } +} + +ENode *CExpr_New_ECOND_Node(ENode *cond, ENode *expr1, ENode *expr2) { + ENode *result; + ENodeList *args; + short cost; + Conversion conv; + + cond = CExpr_ConvertToCondition(pointer_generation(cond)); + expr1 = pointer_generation(expr1); + expr2 = pointer_generation(expr2); + + if (!IS_TYPE_INT_OR_FLOAT(cond->rtype) && !IS_TYPE_POINTER_ONLY(cond->rtype)) { + CError_Error(144); + return nullnode(); + } + + cost = cond->cost + 1; + if (expr1->cost > expr2->cost) + cost += expr1->cost; + else + cost += expr2->cost; + if (expr2->cost > cost) + cost = expr2->cost; + if (cost > 200) + cost = 200; + + result = CExpr_NewENode(ECOND); + result->cost = cost; + result->rtype = expr1->rtype; + result->flags = expr1->flags | expr2->flags; + result->data.cond.cond = cond; + if (ENODE_IS(expr1, EFUNCCALL) && expr1->rtype == &stvoid && (expr1->flags & ENODE_FLAG_VOLATILE)) { + result->rtype = expr2->rtype; + result->flags = expr2->flags; + result->data.cond.expr1 = expr1; + result->data.cond.expr2 = expr2; + return result; + } + if (ENODE_IS(expr2, EFUNCCALL) && expr2->rtype == &stvoid && (expr2->flags & ENODE_FLAG_VOLATILE)) { + result->rtype = expr1->rtype; + result->flags = expr1->flags; + result->data.cond.expr1 = expr1; + result->data.cond.expr2 = expr2; + return result; + } + + if ( + ENODE_IS(expr1, EINDIRECT) && + ENODE_IS(expr2, EINDIRECT) && + is_typesame(expr1->rtype, expr2->rtype) && + ENODE_QUALS(expr1) == ENODE_QUALS(expr2) && + CExpr_IsBlockMoveType(expr1->rtype) && + !ENODE_IS(expr1->data.monadic, EBITFIELD) && + !ENODE_IS(expr2->data.monadic, EBITFIELD) + ) { + if (isnotzero(cond)) + return expr1; + if (iszero(cond)) + return expr2; + result->data.cond.expr1 = getnodeaddress(expr1, 0); + result->data.cond.expr2 = getnodeaddress(expr2, 0); + result->rtype = result->data.cond.expr1->rtype; + result = makemonadicnode(result, EINDIRECT); + result->rtype = TPTR_TARGET(result->rtype); + return result; + } + + if ((IS_TYPE_CLASS(expr1->rtype) || IS_TYPE_CLASS(expr2->rtype)) && !is_typesame(expr1->rtype, expr2->rtype)) { + if (!copts.old_argmatch) { + if (CExpr_CondOperatorMatch(expr1, expr2, &conv)) { +#line 6246 + CError_ASSERT(!conv.x0); + expr1 = conv.left; + expr2 = conv.right; + } else if (CExpr_CanImplicitlyConvert(expr1, expr2->rtype, ENODE_QUALS(expr2))) { + if (CExpr_CanImplicitlyConvert(expr2, expr1->rtype, ENODE_QUALS(expr1))) + CError_Error(188); + expr1 = CExpr_Convert(expr1, expr2->rtype, ENODE_QUALS(expr2), 0, 1); + } else if (CExpr_CanImplicitlyConvert(expr2, expr1->rtype, ENODE_QUALS(expr1))) { + expr2 = CExpr_Convert(expr2, expr1->rtype, ENODE_QUALS(expr1), 0, 1); + } else { + goto failed; + } + + result->rtype = expr1->rtype; + } else { + args = lalloc(sizeof(ENodeList)); + args->node = expr1; + args->next = lalloc(sizeof(ENodeList)); + args->next->node = expr2; + args->next->next = NULL; + + if (CExpr_CheckOperatorConversion(':', expr1, expr2, args, &conv)) { +#line 6274 + CError_ASSERT(!conv.x0); + expr1 = conv.left; + expr2 = conv.right; + } + + result->rtype = expr1->rtype; + } + } + + switch (expr1->rtype->type) { + case TYPEENUM: + if (expr1->rtype == expr2->rtype) + break; + expr1 = forceintegral(expr1); + case TYPEINT: + if (IS_TYPE_POINTER_ONLY(expr2->rtype) || IS_TYPE_MEMBERPOINTER(expr2->rtype)) { + expr1 = CExpr_Convert(expr1, expr2->rtype, ENODE_QUALS(expr2), 0, 1); + result->rtype = expr2->rtype; + break; + } + case TYPEFLOAT: + if (expr1->rtype != expr2->rtype) { + CExpr_ArithmeticConversion(&expr1, &expr2); + result->rtype = expr1->rtype; + } + break; + case TYPEPOINTER: + if (ENODE_IS(expr2, EINTCONST) && CInt64_IsZero(&expr2->data.intval)) { + expr2->rtype = TYPE(&stunsignedlong); + break; + } + if (IS_TYPE_POINTER_ONLY(expr2->rtype)) { + if (IS_TYPE_CLASS(TPTR_TARGET(expr1->rtype)) && IS_TYPE_CLASS(TPTR_TARGET(expr2->rtype))) { + if (TPTR_TARGET(expr1->rtype) != TPTR_TARGET(expr2->rtype)) { + if (CClass_IsBaseClass(TYPE_CLASS(TPTR_TARGET(expr1->rtype)), TYPE_CLASS(TPTR_TARGET(expr2->rtype)), NULL, 0, 1)) { + expr1 = CExpr_SafeClassPointerCast( + expr1, + TYPE_CLASS(TPTR_TARGET(expr1->rtype)), + TYPE_CLASS(TPTR_TARGET(expr2->rtype)), + 0, 1); + expr1->rtype = expr2->rtype; + } else if (CClass_IsBaseClass(TYPE_CLASS(TPTR_TARGET(expr2->rtype)), TYPE_CLASS(TPTR_TARGET(expr1->rtype)), NULL, 0, 1)) { + expr2 = CExpr_SafeClassPointerCast( + expr2, + TYPE_CLASS(TPTR_TARGET(expr2->rtype)), + TYPE_CLASS(TPTR_TARGET(expr1->rtype)), + 0, 1); + expr2->rtype = expr1->rtype; + } else { + goto failed; + } + } + result->rtype = expr1->rtype; + break; + } + if (TPTR_TARGET(expr2->rtype) == &stvoid) + result->rtype = expr2->rtype; + } + if (!is_typeequal(expr1->rtype, expr2->rtype)) { + if (!copts.objective_c) + goto failed; + if (!CObjC_IsCompatibleType(expr1->rtype, expr2->rtype)) + goto failed; + expr1->rtype = expr2->rtype = CObjC_GetObjCType_id(1); + } + break; + case TYPEVOID: + if (!is_typeequal(expr1->rtype, expr2->rtype)) + goto failed; + break; + case TYPESTRUCT: + case TYPECLASS: + if (!is_typeequal(expr1->rtype, expr2->rtype)) + goto failed; + result->rtype = expr1->rtype; + break; + case TYPEMEMBERPOINTER: + if (IS_TYPE_MEMBERPOINTER(expr2->rtype) && TYPE_MEMBER_POINTER(expr1->rtype)->ty2 == TYPE_MEMBER_POINTER(expr2->rtype)->ty2) { + expr2 = CExpr_Convert(expr2, expr1->rtype, ENODE_QUALS(expr1), 0, 1); + } else if (CExpr_CanImplicitlyConvert(expr1, expr2->rtype, ENODE_QUALS(expr2))) { + if (CExpr_CanImplicitlyConvert(expr2, expr1->rtype, ENODE_QUALS(expr1))) + CError_Error(188); + expr1 = CExpr_Convert(expr1, expr2->rtype, ENODE_QUALS(expr2), 0, 1); + } else if (CExpr_CanImplicitlyConvert(expr2, expr1->rtype, ENODE_QUALS(expr1))) { + expr2 = CExpr_Convert(expr2, expr1->rtype, ENODE_QUALS(expr1), 0, 1); + } else { + goto failed; + } + result->rtype = expr1->rtype; + break; + default: + failed: + CError_Error(245, expr1->rtype, ENODE_QUALS(expr1), expr2->rtype, ENODE_QUALS(expr2)); + return nullnode(); + } + + result->data.cond.expr1 = expr1; + result->data.cond.expr2 = expr2; + if (isnotzero(cond)) + result = expr1; + else if (iszero(cond)) + result = expr2; + return result; +} + +static ENode *conditional_expression(void) { + ENode *cond; + ENode *expr1; + ENode *expr2; + ENode *result; + Boolean is_templdep_cond; + + is_templdep_cond = 0; + cond = CExpr_ParseDyadicExpression(NULL, 0, 0); + if (tk != '?') + return cond; + + cond = pointer_generation(cond); + if (!IS_TYPE_TEMPLDEPEXPR(cond->rtype)) { + cond = CExpr_ConvertToCondition(cond); + if (!IS_TYPE_INT_OR_FLOAT(cond->rtype) && !IS_TYPE_POINTER_ONLY(cond->rtype)) { + CError_Error(144); + return nullnode(); + } + } else { + is_templdep_cond = 1; + } + + tk = lex(); + expr1 = expression(); + if (tk != ':') + CError_ErrorSkip(141); + else + tk = lex(); + + expr2 = (copts.cplusplus && !copts.ARM_conform) ? assignment_expression() : conditional_expression(); + + if (is_templdep_cond || IS_TYPE_TEMPLDEPEXPR(expr1->rtype) || IS_TYPE_TEMPLDEPEXPR(expr2->rtype)) { + result = CExpr_NewENode(ECOND); + result->rtype = &sttemplexpr; + result->data.cond.cond = cond; + result->data.cond.expr1 = expr1; + result->data.cond.expr2 = expr2; + return result; + } + + return CExpr_New_ECOND_Node(cond, expr1, expr2); +} + +static ENode *CExpr_MakeOpAssNode(ENode *left, ENode *right, ENodeType nt) { + if (left->rtype != right->rtype) { + switch (right->rtype->type) { + case TYPEINT: + case TYPEFLOAT: + break; + case TYPEENUM: + right->rtype = TYPE_ENUM(right->rtype)->enumtype; + break; + default: + right = CExpr_AssignmentPromotion(right, left->rtype, 0, 1); + } + if (IS_TYPE_FLOAT(left->rtype)) { + if (IS_TYPE_INT(right->rtype) || (IS_TYPE_FLOAT(right->rtype) && left->rtype->size >= right->rtype->size)) + right = CExpr_AssignmentPromotion(right, left->rtype, 0, 1); + } else if (IS_TYPE_INT(left->rtype)) { + if (IS_TYPE_INT(right->rtype) && (left->rtype->size > right->rtype->size || (left->rtype->size == right->rtype->size && is_unsigned(left->rtype) == is_unsigned(right->rtype)))) + right = CExpr_AssignmentPromotion(right, left->rtype, 0, 1); + } + } + + return makediadicnode(left, right, nt); +} + +static ENode *makeassignmentnode(ENode *left, ENodeType nt, short token) { + ENode *right; + ENode *tmp; + ENode *funcexpr; + ENodeList *args; + Conversion conv; + + tk = lex(); + right = assignment_expression(); + if (copts.cplusplus) { + if (copts.old_argmatch && !ENODE_IS(right, EMEMBER)) + right = pointer_generation(right); + if (CExpr_CheckOperator(token, left, right, &conv)) { + if (!conv.x0) { + if (nt == EASS) + goto continue_anyway; +#line 6531 + CError_FATAL(); + } + return conv.x0; + } + if (IS_TYPE_CLASS(left->rtype) && CClass_AssignmentOperator(TYPE_CLASS(left->rtype))) + CError_Error(144); + } +continue_anyway: + if (IS_TYPE_ARRAY(left->rtype)) { + if (copts.gcc_extensions && nt == EASS && is_typesame(left->rtype, right->rtype)) { + tmp = makediadicnode(left, right, nt); + tmp->flags = left->flags; + return tmp; + } + CError_Error(144); + return nullnode(); + } + + left = CExpr_LValue(pointer_generation(left), 1, 1); + if (nt != EASS) { + if (!IS_TYPE_INT(right->rtype)) { + if (!IS_TYPE_ENUM(right->rtype)) { + CError_Error(144); + return left; + } + right = forceintegral(right); + } + if (!IS_TYPE_INT(left->rtype)) { + if (copts.cplusplus) { + CError_Error(144); + return left; + } + left = forceintegral(left); + if (!IS_TYPE_INT(left->rtype)) { + CError_Error(144); + return left; + } + } + return CExpr_MakeOpAssNode(left, right, nt); + } + + if (IS_TYPE_CLASS(left->rtype) && TYPE_CLASS(left->rtype)->sominfo) { + CError_Error(285); + return left; + } + + if (copts.warn_implicitconv && ENODE_IS(left, EINDIRECT) && ENODE_IS(left->data.monadic, EBITFIELD) && !ENODE_IS(right, EINTCONST)) { + copts.warn_implicitconv = 0; + right = CExpr_AssignmentPromotion(right, left->rtype, left->flags, 1); + copts.warn_implicitconv = 1; + } else { + right = CExpr_AssignmentPromotion(right, left->rtype, left->flags, 1); + } + + tmp = right; + if (IS_TYPE_FLOAT(right->rtype) && ENODE_IS(right, ETYPCON) && right->rtype->size == right->data.monadic->rtype->size) + tmp = right->data.monadic; + + if ( + ENODE_IS(left, EINDIRECT) && + ENODE_IS(left->data.monadic, EOBJREF) && + ENODE_IS(tmp, EINDIRECT) && + (ENODE_IS(funcexpr = right->data.monadic, EFUNCCALL) || ENODE_IS(funcexpr, EFUNCCALLP)) && + left->rtype == funcexpr->data.funccall.functype->functype && + CMach_GetFunctionResultClass(funcexpr->data.funccall.functype) == 1 && + (args = funcexpr->data.funccall.args) + ) { + switch (CABI_GetStructResultArgumentIndex(funcexpr->data.funccall.functype)) { + case 0: + break; + case 1: + if ((args = args->next)) + break; +#line 6625 + CError_FATAL(); + default: +#line 6626 + CError_FATAL(); + } + if (ENODE_IS(args->node, ETEMP)) { + if (!(IS_TYPE_CLASS(left->rtype) && CClass_Destructor(TYPE_CLASS(left->rtype)))) { + args->node = getnodeaddress(left, 0); + return right; + } + } + } + + right = makediadicnode(left, right, nt); + right->flags = left->flags; + return right; +} + +static ENode *makepassignmentnode(ENode *left, ENodeType nt, short token) { + ENode *right; + Boolean is_array; + Conversion conv; + + is_array = IS_TYPE_ARRAY(left->rtype); + left = pointer_generation(left); + if (copts.cplusplus) { + tk = lex(); + right = pointer_generation(assignment_expression()); + if (CExpr_CheckOperator(token, left, right, &conv)) { +#line 6669 + CError_ASSERT(conv.x0); + return conv.x0; + } + left = CExpr_LValue(left, 1, 1); + } else { + left = CExpr_LValue(left, 1, 1); + tk = lex(); + right = pointer_generation(assignment_expression()); + } + + if (is_array) + CError_Error(144); + + switch (left->rtype->type) { + case TYPEINT: + case TYPEFLOAT: + case TYPEPOINTER: + break; + case TYPEENUM: + if (copts.cplusplus) { + CError_Error(144); + return left; + } + left = forceintegral(left); + break; + default: + CError_Error(144); + return left; + } + + if (IS_TYPE_ENUM(right->rtype)) + right = forceintegral(right); + + if (iszero(right)) + return left; + + if (IS_TYPE_POINTER_ONLY(left->rtype)) { + if (IS_TYPE_INT(right->rtype)) { + if (nt == ESUBASS) { + left = psub(left, right); + if (ENODE_IS(left, ESUB)) + left->type = ESUBASS; + return left; + } else { + left = padd(left, right); + if (ENODE_IS(left, EADD)) + left->type = EADDASS; + return left; + } + } + CError_Error(144); + return left; + } else { + return CExpr_MakeOpAssNode(left, right, nt); + } +} + +static ENode *makemulassignmentnode(ENode *left, ENodeType nt, short token) { + ENode *right; + Boolean is_array; + Conversion conv; + + is_array = IS_TYPE_ARRAY(left->rtype); + left = pointer_generation(left); + if (copts.cplusplus) { + tk = lex(); + right = pointer_generation(assignment_expression()); + if (CExpr_CheckOperator(token, left, right, &conv)) { +#line 6753 + CError_ASSERT(conv.x0); + return conv.x0; + } + if (!IS_TYPE_INT(left->rtype) && !(IS_TYPE_FLOAT(left->rtype) && nt != EMODASS)) { + CError_Error(144); + return nullnode(); + } + left = CExpr_LValue(left, 1, 1); + } else { + if (IS_TYPE_ENUM(left->rtype)) + left = forceintegral(left); + if (!IS_TYPE_INT(left->rtype) && !(IS_TYPE_FLOAT(left->rtype) && nt != EMODASS)) { + CError_Error(144); + return nullnode(); + } + + left = CExpr_LValue(left, 1, 1); + tk = lex(); + right = pointer_generation(assignment_expression()); + } + + if (is_array) + CError_Error(144); + + if (IS_TYPE_ENUM(right->rtype)) + right = forceintegral(right); + + if (IS_TYPE_INT(left->rtype) && IS_TYPE_FLOAT(right->rtype) && nt == EMODASS) { + CError_Error(144); + return nullnode(); + } + + return CExpr_MakeOpAssNode(left, right, nt); +} + +static ENode *CExpr_TransformOpAssign(ENode *expr) { + switch (expr->type) { + case EMULASS: + case EDIVASS: + case EMODASS: + case EADDASS: + case ESUBASS: + case ESHLASS: + case ESHRASS: + case EANDASS: + case EXORASS: + case EORASS: + if (expr->rtype == TYPE(&stbool)) { + expr = CIRTrans_TransformOpAss(expr); + if (ENODE_IS(expr, EASS)) { + expr->data.diadic.right = makemonadicnode(expr->data.diadic.right, ELOGNOT); + expr->data.diadic.right->rtype = TYPE(&stbool); + expr->data.diadic.right = makemonadicnode(expr->data.diadic.right, ELOGNOT); + } + } + } + + return expr; +} + +ENode *assignment_expression(void) { + ENode *expr; + + if (tk == TK_THROW) + return CExcept_ScanThrowExpression(); + + expr = conditional_expression(); + switch (tk) { + case '=': + return makeassignmentnode(expr, EASS, tk); + case TK_ADD_ASSIGN: + return CExpr_TransformOpAssign(makepassignmentnode(expr, EADDASS, tk)); + case TK_SUB_ASSIGN: + return CExpr_TransformOpAssign(makepassignmentnode(expr, ESUBASS, tk)); + case TK_MULT_ASSIGN: + expr = makemulassignmentnode(expr, EMULASS, tk); + if (ENODE_IS(expr, EMULASS) && CExpr_IsOne(expr->data.diadic.right)) + return expr->data.diadic.left; + return CExpr_TransformOpAssign(expr); + case TK_DIV_ASSIGN: + expr = makemulassignmentnode(expr, EDIVASS, tk); + if (ENODE_IS(expr, EDIVASS)) { + if (iszero(expr->data.diadic.right) && !IS_TYPE_FLOAT(expr->rtype)) { + CError_Warning(139); + return expr->data.diadic.left; + } + if (CExpr_IsOne(expr->data.diadic.right)) + return expr->data.diadic.left; + } + return CExpr_TransformOpAssign(expr); + case TK_MOD_ASSIGN: + expr = makemulassignmentnode(expr, EMODASS, tk); + if (ENODE_IS(expr, EMODASS)) { + if (iszero(expr->data.diadic.right)) { + CError_Warning(139); + return expr->data.diadic.left; + } + } + return CExpr_TransformOpAssign(expr); + case TK_SHL_ASSIGN: + expr = makeassignmentnode(expr, ESHLASS, tk); + if (ENODE_IS(expr, ESHLASS) && iszero(expr->data.diadic.right)) + return expr->data.diadic.left; + return CExpr_TransformOpAssign(expr); + case TK_SHR_ASSIGN: + expr = makeassignmentnode(expr, ESHRASS, tk); + if (ENODE_IS(expr, ESHRASS) && iszero(expr->data.diadic.right)) + return expr->data.diadic.left; + return CExpr_TransformOpAssign(expr); + case TK_AND_ASSIGN: + expr = makeassignmentnode(expr, EANDASS, tk); + if (ENODE_IS(expr, EANDASS) && CExpr_AllBitsSet(expr->data.diadic.right)) + return expr->data.diadic.left; + return expr; + case TK_XOR_ASSIGN: + expr = makeassignmentnode(expr, EXORASS, tk); + if (ENODE_IS(expr, EXORASS) && iszero(expr->data.diadic.right)) + return expr->data.diadic.left; + return CExpr_TransformOpAssign(expr); + case TK_OR_ASSIGN: + expr = makeassignmentnode(expr, EORASS, tk); + if (ENODE_IS(expr, EORASS) && iszero(expr->data.diadic.right)) + return expr->data.diadic.left; + return CExpr_TransformOpAssign(expr); + default: + return expr; + } +} + +ENode *conv_assignment_expression(void) { + return pointer_generation(assignment_expression()); +} + +static Boolean CExpr_HasSideEffect(ENode *expr) { + switch (expr->type) { + case EMONMIN: + case EBINNOT: + case ELOGNOT: + case EMUL: + case EDIV: + case EMODULO: + case EADD: + case ESUB: + case ESHL: + case ESHR: + case ELESS: + case EGREATER: + case ELESSEQU: + case EGREATEREQU: + case EEQU: + case ENOTEQU: + case EAND: + case EXOR: + case EOR: + case ELAND: + case ELOR: + case EROTL: + case EROTR: + case EBITFIELD: + case EINTCONST: + case EFLOATCONST: + case ESTRINGCONST: + case EOBJREF: + case ETEMP: + case EARGOBJ: + case ELOCOBJ: + case EOBJLIST: + case EMEMBER: + case EVECTOR128CONST: + return 0; + case ETYPCON: + return IS_TYPE_VOID(expr->rtype); + case EINDIRECT: + switch (expr->data.monadic->type) { + case EFUNCCALL: + case EFUNCCALLP: + return 1; + default: + return 0; + } + case ECOMMA: + return CInline_ExpressionHasSideEffect(expr->data.diadic.right); + case ECOND: + return CInline_ExpressionHasSideEffect(expr->data.cond.expr1) || CInline_ExpressionHasSideEffect(expr->data.cond.expr2); + case EPOSTINC: + case EPOSTDEC: + case EPREINC: + case EPREDEC: + case EFORCELOAD: + case EASS: + case EMULASS: + case EDIVASS: + case EMODASS: + case EADDASS: + case ESUBASS: + case ESHLASS: + case ESHRASS: + case EANDASS: + case EXORASS: + case EORASS: + case EFUNCCALL: + case EFUNCCALLP: + case EMFPOINTER: + case ENULLCHECK: + case EPRECOMP: + case ELABEL: + case ENEWEXCEPTION: + case ENEWEXCEPTIONARRAY: + case EMYSTERY67: + case EINSTRUCTION: + return 1; + default: +#line 7056 + CError_FATAL(); + return 0; + } +} + +void CExpr_CheckUnusedExpression(ENode *expr) { + ENode *scan; + ENodeList *arg; + + if (copts.warn_possunwant) { + scan = expr; + while (ENODE_IS(scan, ETYPCON)) + scan = scan->data.monadic; + if (ENODE_IS(scan, EEQU)) { + CError_Warning(208); + return; + } + } + + if (copts.warn_no_side_effect) { + if (!CExpr_HasSideEffect(expr)) { + CError_Warning(369); + return; + } + } + + if (copts.warn_resultnotused) { + scan = expr; + if (IS_TYPE_VOID(expr->rtype)) + return; + if (ENODE_IS(expr, EINDIRECT)) + scan = expr->data.monadic; + + switch (scan->type) { + case EFUNCCALL: + case EFUNCCALLP: + if (ENODE_IS(scan->data.funccall.funcref, EOBJREF) && scan->data.funccall.funcref->data.objref->name == asop_name_node) + return; + if (CMach_GetFunctionResultClass(scan->data.funccall.functype) == 1 && (arg = scan->data.funccall.args)) { + switch (CABI_GetStructResultArgumentIndex(scan->data.funccall.functype)) { + case 0: + break; + case 1: + if ((arg = arg->next)) + break; +#line 7110 + CError_FATAL(); + default: +#line 7111 + CError_FATAL(); + } + + if (!ENODE_IS(arg->node, ETEMP)) + return; + } + CError_Warning(370); + } + } +} + +ENode *s_expression(void) { + ENode *left; + ENode *right; + Conversion conv; + + left = assignment_expression(); + while (tk == ',') { + left = pointer_generation(left); + tk = lex(); + right = pointer_generation(assignment_expression()); + + if (copts.cplusplus && CExpr_CheckOperator(',', left, right, &conv)) { +#line 7143 + CError_ASSERT((left = conv.x0)); + } else { + CExpr_CheckUnusedExpression(left); + left = makecommaexpression(left, right); + left->rtype = right->rtype; + } + } + + return left; +} + +ENode *expression(void) { + return pointer_generation(s_expression()); +} + +CInt64 CExpr_IntegralConstExprType(Type **tint) { + ENode *expr; + + expr = pointer_generation(conditional_expression()); + if (ENODE_IS(expr, EINTCONST)) { + switch (expr->rtype->type) { + case TYPEINT: + *tint = expr->rtype; + return expr->data.intval; + case TYPEENUM: + *tint = TYPE_ENUM(expr->rtype)->enumtype; + return expr->data.intval; + } + } + + CError_Error(124); + *tint = TYPE(&stchar); + return cint64_zero; +} + +ENode *CExpr_IntegralConstOrDepExpr(void) { + ENode *expr; + + expr = pointer_generation(conditional_expression()); + if (ENODE_IS(expr, EINTCONST)) { + switch (expr->rtype->type) { + case TYPEINT: + return expr; + case TYPEENUM: + expr->rtype = TYPE_ENUM(expr->rtype)->enumtype; + return expr; + default: +#line 7209 + CError_FATAL(); + } + } + + if (CTemplTool_IsTemplateArgumentDependentExpression(expr)) + return expr; + + CError_Error(124); + expr = nullnode(); + expr->rtype = TYPE(&stchar); + return expr; +} + +CInt64 CExpr_IntegralConstExpr(void) { + Type *throwaway; + return CExpr_IntegralConstExprType(&throwaway); +} + +void CExpr_CheckUnwantedAssignment(ENode *expr) { + if (copts.warn_possunwant) { + if (ENODE_IS(expr, EASS) && !(expr->flags & ENODE_FLAG_80)) + CError_Warning(207); + } +} + +Boolean CExpr_ParseAsmExpr(Object **objptr, CInt64 *valptr) { + ENode *expr; + + if (objptr) + *objptr = NULL; + *valptr = cint64_zero; + + expr = pointer_generation(assignment_expression()); + if (ENODE_IS(expr, EINTCONST)) { + *valptr = expr->data.intval; + return 1; + } + + if (objptr) { + switch (expr->type) { + case EINDIRECT: + if (CInit_RelocInitCheck(expr->data.monadic, objptr, valptr, 1)) + return 1; + break; + case EOBJREF: + *objptr = expr->data.objref; + while ((*objptr)->datatype == DALIAS) + *objptr = (*objptr)->u.alias.object; + return 1; + case EMEMBER: + if (expr->data.emember->list->object->otype == OT_OBJECT) { + if (expr->data.emember->list->next && expr->data.emember->list->next->object->otype == OT_OBJECT) + CError_Error(199); + *objptr = OBJECT(expr->data.emember->list->object); + while ((*objptr)->datatype == DALIAS) + *objptr = (*objptr)->u.alias.object; + return 1; + } + break; + case EOBJLIST: + CError_Error(199); + return 0; + } + } + + CError_Error(155); + return 0; +} diff --git a/compiler_and_linker/unsorted/CExpr2.c b/compiler_and_linker/unsorted/CExpr2.c index 6679bce..47268ac 100644 --- a/compiler_and_linker/unsorted/CExpr2.c +++ b/compiler_and_linker/unsorted/CExpr2.c @@ -2,18 +2,22 @@ #include "compiler/CABI.h" #include "compiler/CClass.h" #include "compiler/CDecl.h" +#include "compiler/CInit.h" #include "compiler/CInt64.h" #include "compiler/CError.h" #include "compiler/CFunc.h" #include "compiler/CInline.h" #include "compiler/CMachine.h" +#include "compiler/CMangler.h" #include "compiler/CParser.h" +#include "compiler/CPrepTokenizer.h" #include "compiler/CScope.h" #include "compiler/CodeGen.h" #include "compiler/CompilerTools.h" #include "compiler/enode.h" #include "compiler/objects.h" #include "compiler/scopes.h" +#include "compiler/templates.h" #ifdef __MWERKS__ #undef va_start @@ -25,9 +29,18 @@ #endif // TODO MOVE ME +extern ENode *CObjC_New(TypeClass *tclass); +extern Boolean CObjC_IsType_id(Type *type); +extern ENode *CObjC_Delete(TypeClass *tclass, ENode *expr); +extern ENode *CSOM_New(TypeClass *tclass); +extern ENode *CSOM_Delete(TypeClass *tclass, ENode *expr); extern ENode *CSOM_EnvCheck(ENode *, ENodeList *); +extern ENode *CSOM_MethodAccess(BClassList *, Object *, Boolean); extern Boolean CTemplTool_IsTemplateArgumentDependentExpression(ENode *expr); extern ENode *CTemplTool_DeduceDefaultArg(Object *func, ENode *expr); +extern Boolean CTempl_CanDeduceFunc(Object *func, TypeFunc *tfunc, TemplArg *templargs); +extern void CTempl_FuncMatch(NameSpaceObjectList *nsol, TemplArg *templargs, ENodeList *argexprs, Match13 *match, ENode *expr); +extern TemplFuncInstance *CTempl_DeduceFunc(Object *func, TypeFunc *tfunc, TemplArg *templargs, Object *anotherobj, Boolean flag); extern Boolean CObjC_IsCompatibleType(Type *a, Type *b); ENode *assign_node; @@ -43,10 +56,9 @@ static CExprReplaceCB cexpr_rsearch_callback; static Type *cexpr_left_conversion_type; static Type *cexpr_right_conversion_type; -// data objects, need to figure out the types -static void *diadic_arg1; -static void *diadic_arg2; -static void *mon_arg; +static FuncArg mon_arg = {NULL, NULL, NULL, NULL, 0, 0, 0, 0}; +static FuncArg diadic_arg2 = {NULL, NULL, NULL, NULL, 0, 0, 0, 0}; +static FuncArg diadic_arg1 = {&diadic_arg1, NULL, NULL, NULL, 0, 0, 0, 0}; static void CExpr_RecSearchExprTree(ENode *expr) { ENodeList *list; @@ -1147,9 +1159,9 @@ void CExpr_MatchCV(Type *t1, UInt32 q1, Type *t2, UInt32 q2, Match13 *match) { while (IS_TYPE_POINTER_ONLY(t2) && IS_TYPE_POINTER_ONLY(t1)) { if (r8) { if ((TYPE_POINTER(t1)->qual & Q_CONST) != (TYPE_POINTER(t2)->qual & Q_CONST)) - match->xC--; + match->anotherm5.x8--; if ((TYPE_POINTER(t1)->qual & Q_VOLATILE) != (TYPE_POINTER(t2)->qual & Q_VOLATILE)) - match->xC--; + match->anotherm5.x8--; } t2 = TYPE_POINTER(t2)->target; t1 = TYPE_POINTER(t1)->target; @@ -1157,9 +1169,9 @@ void CExpr_MatchCV(Type *t1, UInt32 q1, Type *t2, UInt32 q2, Match13 *match) { } if ((q1 & Q_CONST) != (q2 & Q_CONST)) - match->xC--; + match->anotherm5.x8--; if ((q1 & Q_VOLATILE) != (q2 & Q_VOLATILE)) - match->xC--; + match->anotherm5.x8--; } Boolean CExpr_MatchAssign(Type *type, UInt32 qual, ENode *expr, Match13 *match) { @@ -1167,14 +1179,14 @@ Boolean CExpr_MatchAssign(Type *type, UInt32 qual, ENode *expr, Match13 *match) case CheckResult0: return 0; case CheckResult1: - match->x4++; + match->anotherm5.x0++; break; case CheckResult2: - match->x6++; + match->anotherm5.x2++; break; case CheckResult3: - match->x8++; - match->xA += assign_value; + match->anotherm5.x4++; + match->anotherm5.x6 += assign_value; break; case CheckResult4: match->xE++; @@ -1216,7 +1228,35 @@ static short CExpr_StdMatchCompare(Match5 *a, Match5 *b, Boolean flag) { } static short CExpr2_MemberPointerConversion(Type *type, ENode *expr, Boolean flag1) { - // returns CheckResult + ENode *newnode; + short depth; + + newnode = lalloc(sizeof(ENode)); + *newnode = *expr; + if (!IS_TYPE_MEMBERPOINTER(newnode->rtype)) { + newnode = CExpr_MemberPointerConversion(newnode, type, flag1); + if (iscpp_typeequal(newnode->rtype, type)) { + if (flag1) + assign_node = newnode; + return CheckResult3; + } + } + + if (IS_TYPE_MEMBERPOINTER(newnode->rtype)) { +#line 1656 + CError_ASSERT(IS_TYPE_CLASS(TYPE_MEMBER_POINTER(type)->ty2)); +#line 1657 + CError_ASSERT(IS_TYPE_CLASS(TYPE_MEMBER_POINTER(newnode->rtype)->ty2)); + + if (CClass_IsBaseClass(TYPE_CLASS(TYPE_MEMBER_POINTER(type)->ty2), TYPE_CLASS(TYPE_MEMBER_POINTER(newnode->rtype)->ty2), &depth, 0, 0)) { + assign_value = 1000 - depth; + if (flag1) + assign_node = PointerToMemberCast(newnode, TYPE_MEMBER_POINTER(newnode->rtype), TYPE_MEMBER_POINTER(type), 1); + return CheckResult3; + } + } + + return CheckResult0; } ENode *CExpr_ClassPointerCast(BClassList *cls, ENode *origexpr, Boolean nullcheckflag) { @@ -1347,6 +1387,75 @@ ENode *CExpr_GetClassAccessNode(BClassList *a, BClassList *b, ENode *expr, Objec } static short std_assign_check_overload(NameSpaceObjectList *list, TemplArg *templargs, Type *type, Boolean flag1) { + Object *obj; + Object *used_obj; + Boolean found_non_template_func; + Boolean is_ambig; + TemplFuncInstance *instance; + ENode *expr; + Object *cmp1; + Object *cmp2; + + if (!IS_TYPE_POINTER_ONLY(type) || !IS_TYPE_FUNC(TYPE_POINTER(type)->target)) + return CheckResult0; + + used_obj = NULL; + type = TYPE_POINTER(type)->target; + found_non_template_func = 0; + is_ambig = 0; + for (; list; list = list->next) { + obj = OBJECT(list->object); + if (obj->otype != OT_OBJECT) + continue; + + if (IS_TYPE_FUNC(obj->type) && (TYPE_FUNC(obj->type)->flags & FUNC_FLAGS_100000)) { + if (!found_non_template_func && CTempl_CanDeduceFunc(obj, TYPE_FUNC(type), templargs)) { + instance = CTempl_DeduceFunc(obj, TYPE_FUNC(type), templargs, NULL, 0); +#line 1861 + CError_ASSERT(instance); + if (is_typesame(instance->object->type, type)) { + if (used_obj && used_obj != instance->object) + is_ambig = 1; + else + used_obj = instance->object; + } + } + } else { + if (is_typesame(obj->type, type)) { + if (used_obj && found_non_template_func) { + cmp1 = obj; + if (obj->datatype == DALIAS) + cmp1 = obj->u.alias.object; + cmp2 = used_obj; + if (used_obj->datatype == DALIAS) + cmp2 = used_obj->u.alias.object; + if (cmp1 != cmp2) + is_ambig = 1; + } else { + is_ambig = 0; + used_obj = obj; + } + found_non_template_func = 1; + } + } + } + + if (used_obj) { + if (flag1) { + if (is_ambig) + CError_Error(CErrorStr199); + expr = CExpr_MakeObjRefNode(used_obj, 1); + assign_node = expr; + expr->rtype = CDecl_NewPointerType(used_obj->type); + expr->flags = obj->qual & ENODE_FLAG_QUALS; + used_obj->flags |= OBJECT_FLAGS_UNUSED; + if (used_obj->datatype == DINLINEFUNC) + CError_Error(CErrorStr175); + } + return CheckResult1; + } else { + return CheckResult0; + } } ENode *CExpr_ConvertToBool(ENode *expr, Boolean flag) { @@ -1702,7 +1811,225 @@ restart: return NULL; } -void user_assign_check() {} +short user_assign_check(ENode *expr, Type *type, UInt32 qual, Boolean flag1, Boolean flag2, Boolean flag3) { + Object *r26; + ENode *r25; + Boolean r24; + Boolean r23; + Boolean r22; + Type *r18b; + short r18; + TypeFunc *r17; + Object *r17b; + NameSpaceObjectList *r16b; + Object *r16; + Object *r15; + ENode *r15b; + ENode *r14; + short r14b; + TypeFunc *r14c; + ENodeList *r14d; + TypeMethod *r13; + ENodeList *r13b; + short result; + FuncArg *arg; + ConversionIterator iter; + Match5 stdmatch; + Match5 match_8C; + Match5 match_98; + BClassList path; + UInt16 chk; + Boolean is_const, is_volatile; + +#line 2378 + CError_ASSERT(copts.old_argmatch); + + memclrw(&stdmatch, sizeof(Match5)); + r24 = 0; + r22 = 0; + r23 = 0; + + if (!type->size) + CDecl_CompleteType(type); + if (!expr->rtype->size) + CDecl_CompleteType(expr->rtype); + + if (IS_TYPE_CLASS(expr->rtype)) { + r18 = 0; + CExpr_ConversionIteratorInit(&iter, TYPE_CLASS(expr->rtype)); + while ((r16 = CExpr_ConversionIteratorNext(&iter))) { + r17 = TYPE_FUNC(r16->type); + r14 = CExpr_NewENode(ETEMP); + r14->rtype = r17->functype; + if (IS_TYPE_REFERENCE(r14->rtype)) { + r14->rtype = TYPE_POINTER(r14->rtype)->target; + if (!CParser_IsConst(r14->rtype, r17->qual)) { + r14 = makemonadicnode(r14, EINDIRECT); + r14->data.monadic->rtype = TYPE(&void_ptr); + r14 = makemonadicnode(r14, EINDIRECT); + r14->data.monadic->rtype = TYPE(&void_ptr); + } + } + if ((result = std_assign_check(r14, type, 0, flag3))) { + CExpr_CalcStdAssign(result, &match_98, r17->functype, r17->qual, type, qual, 1); +#line 2419 + CError_ASSERT(r17->args && IS_TYPE_POINTER_ONLY(r17->args->type)); + chk = expr->flags; + if (!(is_const = (r17->args->qual & Q_CONST)) && (chk & Q_CONST) != 0) + continue; + if (!(is_volatile = (r17->args->qual & Q_VOLATILE)) && (chk & Q_VOLATILE) != 0) + continue; + //if (((r17->args->qual & Q_CONST) == 0 && (chk & Q_CONST) != 0) || ((r17->args->qual & Q_VOLATILE) == 0 && (chk & Q_VOLATILE) != 0)) + // continue; + + r14b = 0; + if (is_const == (expr->flags & Q_CONST)) + r14b++; + if (is_volatile == (expr->flags & Q_VOLATILE)) + r14b++; + switch (CExpr_StdMatchCompare(&match_98, &stdmatch, 1)) { + case -1: + continue; + case 0: + if (r26 == r16) + continue; + if (r14b < r18) + continue; + if (r14b != r18) + break; + r22 = 1; + continue; + } + r26 = r16; + stdmatch = match_98; + r24 = 1; + r22 = 0; + r18 = r14b; + } + } + } + + if (IS_TYPE_CLASS(type) && (r16b = CClass_Constructor(TYPE_CLASS(type)))) { + memclrw(&match_8C, sizeof(Match5)); + for (; r16b; r16b = r16b->next) { + r17b = OBJECT(r16b->object); + if (r17b->otype != OT_OBJECT) + continue; + r14c = TYPE_FUNC(r17b->type); + if (!IS_TYPE_FUNC(r14c)) + continue; + if (!flag2 && (r14c->qual & Q_EXPLICIT)) + continue; + if (!r14c->args) + continue; + if (!(arg = r14c->args->next)) + continue; + if ((TYPE_CLASS(type)->flags & CLASS_FLAGS_20) && !(arg = arg->next)) + continue; + if (arg == &elipsis) + continue; + if (arg->next && !arg->next->dexpr && arg->next != &elipsis) + continue; + + r18b = arg->type; + if (IS_TYPE_REFERENCE(r18b)) { + r18b = TYPE_POINTER(r18b)->target; + if (!CParser_IsConst(r18b, arg->qual) && !CExpr_IsLValue(expr)) + continue; + } + + if ((result = std_assign_check(expr, r18b, 0, flag3))) { + CExpr_CalcStdAssign(result, &match_98, r14c->functype, r14c->qual, type, qual, 0); + switch (CExpr_StdMatchCompare(&match_98, &match_8C, 1)) { + case -1: + case 0: + continue; + } + r25 = expr; + match_8C = match_98; + r23 = 1; + r15 = r17b; + } + } + + if (r23) { + if (r24) { + switch (CExpr_StdMatchCompare(&stdmatch, &match_8C, 1)) { + case -1: + stdmatch = match_8C; + r24 = 0; + break; + case 0: + r22 = 1; + break; + } + } else { + stdmatch = match_8C; + } + } + } + + if (r22 && flag1) + CError_Error(CErrorStr199); + + if (r24 || r23) { + if (flag1) { + if (r24) { + r13 = TYPE_METHOD(r26->type); +#line 2537 + CError_ASSERT(r13->flags & FUNC_FLAGS_METHOD); + r15b = create_objectrefnode(r26); + r26->flags |= OBJECT_FLAGS_UNUSED; + r14d = lalloc(sizeof(ENodeList)); + r14d->next = NULL; + expr = getnodeaddress(expr, 0); + r14d->node = CExpr_AssignmentPromotion(expr, CDecl_NewPointerType(TYPE(r13->theclass)), expr->flags, 0); + + expr = lalloc(sizeof(ENode)); + expr->type = EFUNCCALL; + expr->cost = 4; + expr->rtype = r13->functype; + expr->flags = r13->qual & ENODE_FLAG_QUALS; + expr->data.funccall.funcref = r15b; + expr->data.funccall.args = r14d; + expr->data.funccall.functype = TYPE_FUNC(r26->type); + assign_node = checkreference(CExpr_AdjustFunctionCall(expr)); + if (assign_node->rtype != type) + assign_node = CExpr_AssignmentPromotion(assign_node, type, qual, 1); + if (!IS_TYPE_REFERENCE(r13->functype)) + temp_reference_init = 1; + } else { + r13b = lalloc(sizeof(ENodeList)); + r13b->next = NULL; + r13b->node = r25; + if (TYPE_CLASS(type)->flags & CLASS_FLAGS_20) { + r13b->next = lalloc(sizeof(ENodeList)); + r13b->next->node = r25; + r13b->next->next = NULL; + r13b->node = intconstnode(TYPE(&stsignedshort), 1); + } + path.next = NULL; + path.type = type; + assign_node = makemonadicnode(create_temp_node(type), EINDIRECT); + assign_node->rtype = type; + assign_node = CExpr_GenericFuncCall(&path, assign_node, 0, r15, NULL, NULL, r13b, 0, 0, 1); + if (ENODE_IS2(assign_node, EFUNCCALL, EFUNCCALLP)) { + assign_node->rtype = CDecl_NewPointerType(type); + assign_node = makemonadicnode(assign_node, EINDIRECT); + assign_node->rtype = type; + } + temp_reference_init = 1; + } + } + + user_std_match = stdmatch; + return CheckResult4; + } else { + if (flag1) + CError_Error(CErrorStr244, expr->rtype, expr->flags & ENODE_FLAG_QUALS, type, qual); + return CheckResult0; + } +} ENode *CExpr_ConvertToCondition(ENode *expr) { switch (expr->rtype->type) { @@ -1723,16 +2050,332 @@ ENode *CExpr_ConvertToCondition(ENode *expr) { } } -void CExpr_ConvertToIntegral() {} -void CExpr_CheckArithmConversion() {} -void get_address_of_temp_copy() {} +ENode *CExpr_ConvertToIntegral(ENode *expr) { + ConversionIterator iter; + Type *found; + Object *obj; + + switch (expr->rtype->type) { + case TYPEINT: + case TYPEENUM: + return integralpromote(expr); + case TYPECLASS: + CDecl_CompleteType(expr->rtype); + found = NULL; + CExpr_ConversionIteratorInit(&iter, TYPE_CLASS(expr->rtype)); + while ((obj = CExpr_ConversionIteratorNext(&iter))) { + if (IS_TYPE_INT_OR_ENUM(TYPE_FUNC(obj->type)->functype)) { + if (found) { + CError_Error(CErrorStr199); + break; + } + found = TYPE_FUNC(obj->type)->functype; + } + } + if (found) + return integralpromote(CExpr_Convert(expr, found, 0, 0, 1)); + break; + } + + CError_Error(CErrorStr376, expr->rtype, expr->flags & ENODE_FLAG_QUALS); + return nullnode(); +} + +void CExpr_CheckArithmConversion(ENode *expr, Type *type) { + CInt64 val; + + if (expr->rtype == type) + return; + if (expr->rtype == TYPE(&stbool)) + return; + + if (IS_TYPE_INT(expr->rtype)) { + if (IS_TYPE_FLOAT(type)) + return; +#line 2772 + CError_ASSERT(IS_TYPE_INT(type)); + + if (type->size > expr->rtype->size) + return; + if (type->size == expr->rtype->size && is_unsigned(type) == is_unsigned(expr->rtype)) + return; + + switch (expr->type) { + case EINTCONST: + if (!CInt64_IsNegative(&expr->data.intval) || is_unsigned(expr->rtype) || !is_unsigned(type)) { + val = CExpr_IntConstConvert(type, expr->rtype, expr->data.intval); + val = CExpr_IntConstConvert(expr->rtype, type, val); + if (CInt64_Equal(val, expr->data.intval)) + return; + } + break; + case ELOGNOT: + case ELESS: + case EGREATER: + case ELESSEQU: + case EGREATEREQU: + case EEQU: + case ENOTEQU: + case ELAND: + case ELOR: + return; + } + } else { + if (IS_TYPE_FLOAT(type) && type->size >= expr->rtype->size) + return; + } + + CError_Warning(CErrorStr317, expr->rtype, 0, type, 0); +} + +ENode *get_address_of_temp_copy(ENode *expr, Boolean flag) { + char buf[64]; + ENode *result; + Object *obj; + Type *innertype; + + if (flag) { + if (ENODE_IS2(expr, EINTCONST, EFLOATCONST)) { + obj = CParser_NewCompilerDefDataObject(); + obj->type = expr->rtype; + obj->name = CParser_GetUniqueName(); + obj->sclass = TK_STATIC; + if (ENODE_IS(expr, EINTCONST)) { + innertype = expr->rtype; + switch (innertype->type) { + case TYPEINT: + break; + case TYPEENUM: + innertype = TYPE_ENUM(innertype)->enumtype; + break; + case TYPEPOINTER: + innertype = TYPE(&stunsignedlong); + break; + default: +#line 2857 + CError_FATAL(); + } + CMach_InitIntMem(innertype, expr->data.intval, buf); + } else { + CMach_InitFloatMem(expr->rtype, expr->data.floatval, buf); + } + CInit_DeclareData(obj, buf, NULL, obj->type->size); + return create_objectrefnode(obj); + } + + if (cinit_tempnodefunc == NULL) + result = CExpr_NewETEMPNode(expr->rtype, 1); + else + result = cinit_tempnodefunc(expr->rtype, 0); + result = makemonadicnode(result, EINDIRECT); + result->rtype = TYPE_POINTER(result->rtype)->target; + return makecommaexpression(makediadicnode(result, expr, EASS), result->data.monadic); + } else { + result = nullnode(); + CInt64_SetLong(&result->data.intval, -1); + result->rtype = CDecl_NewPointerType(expr->rtype); + return result; + } +} short assign_check(ENode *expr, Type *type, UInt32 qual, Boolean flag1, Boolean flag2, Boolean flag3) { + Type *type2; + Boolean r30; + Boolean r29; + short result; + + assign_value = 1000; + r30 = 0; + r29 = 0; + temp_reference_init = 0; + + type2 = type; + if (IS_TYPE_REFERENCE(type) && !IS_TYPE_FUNC(TYPE_POINTER(type)->target)) { + type2 = TYPE_POINTER(type)->target; + r30 = 1; + } + + assign_node = expr; + if (IS_TYPE_ARRAY(type2)) { + r29 = 1; + type2 = CDecl_NewPointerType(TYPE_POINTER(type2)->target); + } + + if (!type2->size) { + CDecl_CompleteType(type2); + if (!type2->size && !r30) { + if (flag1) { + if (IS_TYPE_CLASS(type2)) + CError_Error(CErrorStr136, type2, 0); + else + CError_Error(CErrorStr244, expr->rtype, expr->flags & ENODE_FLAG_QUALS, type2, qual); + } + return CheckResult0; + } + } + + if (copts.warn_implicitconv && flag1 && !flag2) { + if (IS_TYPE_INT_OR_FLOAT(type2) && IS_TYPE_INT_OR_FLOAT(expr->rtype)) + CExpr_CheckArithmConversion(expr, type2); + } + + result = std_assign_check(expr, type2, flag1, flag3); + if (!result) { + if (IS_TYPE_CLASS(expr->rtype) || IS_TYPE_CLASS(type2)) { + result = user_assign_check(expr, type2, qual, flag1, flag2, flag3); + } else if (flag1) { + CError_Error(CErrorStr244, expr->rtype, expr->flags & ENODE_FLAG_QUALS, type2, qual); + } + } + + if (r30 && result) { + if (flag1) { + if (!ENODE_IS(assign_node, EINDIRECT)) { + if (!r29) { + assign_node = CExpr_LValue(assign_node, 0, 0); + if (!ENODE_IS(assign_node, EINDIRECT)) { + assign_node = get_address_of_temp_copy(assign_node, 1); + temp_reference_init = 1; + } else { + assign_node = getnodeaddress(assign_node, 0); + } + } + } else { + if (!CExpr_IsLValue(assign_node)) + temp_reference_init = 1; + if (!r29) + assign_node = getnodeaddress(assign_node, 0); + } + } else { + if (!r29 && !CExpr_IsLValue(assign_node) && !CParser_IsConst(TYPE_POINTER(type)->target, qual)) { + result = CheckResult0; + } + } + } + + return result; +} + +Boolean CExpr_MatchCompare(Object *obj, Match13 *a, Match13 *b) { + Object *tmp; + ObjectList *list; + + switch (CExpr_StdMatchCompare(&b->anotherm5, &a->anotherm5, 0)) { + case -1: + return 0; + case 0: + if (a->xE > b->xE) + return 0; + if (a->xE != b->xE) + break; + switch (CExpr_StdMatchCompare(&b->match5, &a->match5, 1)) { + case -1: + return 0; + case 0: + if (a->anotherm5.x8 > b->anotherm5.x8) + return 0; + if (a->anotherm5.x8 == b->anotherm5.x8 && (tmp = a->obj)) { + if (tmp->datatype == obj->datatype) { + add_it: + list = lalloc(sizeof(ObjectList)); + list->next = a->list; + a->list = list; + list->object = obj; + return 0; + } + if (obj->datatype == DALIAS) + return 0; + if (tmp->datatype != DALIAS) + goto add_it; + } + } + } + + *a = *b; + a->obj = obj; + return 1; } -void CExpr_MatchCompare() {} -static void MatchOverloadFunc() {} -void CExpr_GetFuncMatchArgs() {} +static void MatchOverloadFunc(Object *obj, FuncArg *args, ENodeList *argexprs, Match13 *match) { + Match13 match2; + + if (IS_TYPE_FUNC(obj->type) && !(TYPE_FUNC(obj->type)->flags & FUNC_FLAGS_100000)) { + memclrw(&match2, sizeof(Match13)); + while (1) { + if (!args || args->type == &stvoid) { + if (!argexprs) + break; + return; + } + + if (args == &elipsis) + break; + if (args == &oldstyle) + break; + + if (!argexprs) { + if (args->dexpr) + break; + return; + } + + if (!CExpr_MatchAssign(args->type, args->qual, argexprs->node, &match2)) + return; + + argexprs = argexprs->next; + args = args->next; + } + + CExpr_MatchCompare(obj, match, &match2); + } +} + +Boolean CExpr_GetFuncMatchArgs(Object *obj, ENodeList *argexprs, ENode *expr, FuncMatchArgs *result) { + ENode *intexpr; + + if (!(TYPE_FUNC(obj->type)->flags & FUNC_FLAGS_METHOD)) { + result->exprs = argexprs; + result->args = TYPE_FUNC(obj->type)->args; + return 1; + } + + if (TYPE_METHOD(obj->type)->x26) { + result->exprs = argexprs; + result->args = TYPE_FUNC(obj->type)->args; + return 1; + } + + if (TYPE_FUNC(obj->type)->flags & FUNC_FLAGS_1000) { + result->exprs = argexprs; + result->args = TYPE_FUNC(obj->type)->args->next; + return 1; + } + + if (expr) { + intexpr = lalloc(sizeof(ENode)); + intexpr->type = EINTCONST; + intexpr->cost = 0; + intexpr->flags = expr->flags; + intexpr->rtype = CDecl_NewPointerType(expr->rtype); + intexpr->data.intval = cint64_zero; + + result->exprs = lalloc(sizeof(ENodeList)); + result->exprs->next = argexprs; + result->exprs->node = intexpr; + + if (obj->datatype == DALIAS) { + result->args = lalloc(sizeof(FuncArg)); + *result->args = *TYPE_FUNC(obj->type)->args; + result->args->type = CDecl_NewPointerType(expr->rtype); + } else { + result->args = TYPE_FUNC(obj->type)->args; + } + + return 1; + } + + return 0; +} static NameSpaceObjectList *CExpr_CopyNameSpaceObjectList(NameSpaceObjectList *list) { NameSpaceObjectList *first; @@ -1753,7 +2396,45 @@ static NameSpaceObjectList *CExpr_CopyNameSpaceObjectList(NameSpaceObjectList *l return first; } -static void CExpr_MatchArgList() {} +static void CExpr_MatchArgList(NameSpaceObjectList *list, TemplArg *templargs, ENodeList *argexprs, Match13 *match, ENode *expr, Boolean flag) { + NameSpaceObjectList *copied_list; + NameSpaceObjectList *scan_list; + Object *obj; + ENodeList *scan_expr; + Boolean is_template; + FuncMatchArgs fma; + + if (!copts.old_argmatch) { + CExpr_FuncArgMatch(CExpr_CopyNameSpaceObjectList(list), templargs, argexprs, match, expr, flag); + return; + } + + copied_list = CExpr_CopyNameSpaceObjectList(list); + + for (scan_expr = argexprs; scan_expr; scan_expr = scan_expr->next) + CDecl_CompleteType(scan_expr->node->rtype); + + scan_list = copied_list; + is_template = 0; + for (; scan_list; scan_list = scan_list->next) { + obj = OBJECT(scan_list->object); + if (obj->otype != OT_OBJECT) + continue; + if (IS_TYPE_FUNC(obj->type) && (!flag || !(obj->qual & Q_EXPLICIT))) { + if (!(TYPE_FUNC(obj->type)->flags & FUNC_FLAGS_100000)) { + if (CExpr_GetFuncMatchArgs(obj, argexprs, expr, &fma)) + MatchOverloadFunc(obj, fma.args, fma.exprs, match); + } else { + is_template = 1; + } + } + } + + if (is_template) { + if (!match->obj || match->anotherm5.x2 || match->anotherm5.x4 || match->xE) + CTempl_FuncMatch(copied_list, templargs, argexprs, match, expr); + } +} ENode *CExpr_GetDefaultArgument(ENode *funcexpr, FuncArg *arg) { ENode *tmp; @@ -1860,24 +2541,870 @@ ENode *CExpr_VarArgPromotion(ENode *expr, Boolean flag) { return expr; } -void CExpr_GenericFuncCall() {} -void CExpr_GenericPtmfCall() {} -static void CExpr_ConvertEMember() {} -void CExpr_MakeFunctionCall() {} -static void accept_conversion_type() {} -static void CExpr_OperatorConversion() {} -static void wild_conversion_check() {} -static void monadic_conversion_check() {} -static void is_legal_type_combination() {} -static void match_class_type_conversion() {} -static void match_type_class_conversion() {} -static void match_class_class_conversion() {} -void CExpr_CheckOperatorConversion() {} -void CExpr_CheckOperator() {} +ENode *CExpr_GenericFuncCall(BClassList *path, ENode *funcexpr, Boolean flag1, Object *obj, NameSpaceObjectList *nsol, TemplArg *templargs, ENodeList *nodes, Boolean flag2, Boolean flag3, Boolean flag4) { + TypeFunc *tfunc; + AccessType access; + FuncArg *scan_arg; + BClassList *buildpath; + ENode *objexpr; + ENodeList *scan_expr; + BClassList *pathcopy; + Boolean had_alias; + NameSpaceObjectList my_list; + Match13 match; + + memclrw(&match, sizeof(Match13)); + + if (!obj || IS_TEMPL_FUNC(obj->type)) { + if (!funcexpr && cscope_currentfunc && cscope_currentclass && cscope_is_member_func) { + funcexpr = CClass_CreateThisSelfExpr(); + if (funcexpr) { + funcexpr = makemonadicnode(funcexpr, EINDIRECT); + funcexpr->rtype = TYPE(cscope_currentclass); + } + } + + if (obj) { + my_list.next = NULL; + my_list.object = OBJ_BASE(obj); + nsol = &my_list; + } + + CExpr_MatchArgList(nsol, templargs, nodes, &match, funcexpr, flag2); + if (!match.obj) { + CError_ErrorFuncCall(CErrorStr248, nsol, nodes); + return nullnode(); + } + if (match.list) + CError_OverloadedFunctionError(match.obj, match.list); + obj = match.obj; + } + + objexpr = create_objectrefnode(obj); + tfunc = TYPE_FUNC(obj->type); + if (!IS_TYPE_FUNC(tfunc)) { + CError_Error(CErrorStr161); + return nullnode(); + } + + if (IS_TYPEFUNC_METHOD(tfunc) && !TYPE_METHOD(tfunc)->x26) { + had_alias = 0; + buildpath = NULL; + access = obj->access; + while (obj->datatype == DALIAS) { + buildpath = buildpath ? CClass_AppendPath(buildpath, CClass_GetPathCopy(obj->u.alias.member, 0)) : CClass_GetPathCopy(obj->u.alias.member, 0); + obj = obj->u.alias.object; + objexpr = create_objectrefnode(obj); + had_alias = 1; + } + if (flag3) + CError_Error(CErrorStr188); + + if (TYPE_METHOD(tfunc)->theclass->sominfo && (!(obj->qual & Q_INLINE) || (obj->datatype == DVFUNC && !flag1))) { + pathcopy = CClass_GetPathCopy(path, 0); + funcexpr = CExpr_GetClassAccessNode(path, buildpath, funcexpr, obj, access, flag4); + if (!funcexpr) + return nullnode(); + objexpr = CSOM_MethodAccess(pathcopy, obj, flag1); + } else { + if (obj->datatype == DVFUNC) { + if (flag1 || (!copts._59 && !had_alias && funcexpr && CExpr_IsStaticType(funcexpr))) + objexpr->flags |= ENODE_FLAG_80; + } + funcexpr = CExpr_GetClassAccessNode(path, buildpath, funcexpr, obj, access, flag4); + if (!funcexpr) + return nullnode(); + } + + if ( + (tfunc->flags & FUNC_FLAGS_8) && + cscope_currentfunc && + (TYPE_FUNC(cscope_currentfunc->type)->flags & (FUNC_FLAGS_1000 | FUNC_FLAGS_2000)) && + cscope_currentclass == TYPE_METHOD(tfunc)->theclass && + ENODE_IS(funcexpr, EINDIRECT) && + ENODE_IS(funcexpr->data.monadic, EINDIRECT) && + ENODE_IS(funcexpr->data.monadic->data.monadic, EOBJREF) && + funcexpr->data.monadic->data.monadic->data.objref->name == this_name_node && + !(objexpr->flags & ENODE_FLAG_80) + ) + CError_Warning(CErrorStr195); + + scan_expr = lalloc(sizeof(ENodeList)); + scan_expr->next = nodes; + scan_expr->node = funcexpr->data.monadic; + if (ENODE_IS(scan_expr->node, EOBJREF)) + scan_expr->node->data.objref->flags |= OBJECT_FLAGS_2; + + if (((funcexpr->flags & Q_CONST) && !(tfunc->args->qual & Q_CONST)) || ((funcexpr->flags & Q_VOLATILE) && !(tfunc->args->qual & Q_VOLATILE))) { + if (!(tfunc->flags & (FUNC_FLAGS_1000 | FUNC_FLAGS_2000))) + CError_Error(CErrorStr236); + } + + nodes = scan_expr; + scan_expr = scan_expr->next; + scan_arg = tfunc->args->next; + } else { + if (flag4 && obj->access != ACCESSPROTECTED) + CClass_CheckObjectAccess(path, obj); + + scan_arg = tfunc->args; + scan_expr = nodes; + if (tfunc->flags & FUNC_FLAGS_METHOD) { +#line 3599 + CError_ASSERT(TYPE_METHOD(tfunc)->theclass->sominfo == NULL); + } + } + + while (scan_expr) { + if (scan_arg && scan_arg != &elipsis && scan_arg != &oldstyle) { + scan_expr->node = argumentpromotion(scan_expr->node, scan_arg->type, scan_arg->qual, 1); + scan_arg = scan_arg->next; + } else { + if (!scan_arg) { + my_list.next = NULL; + my_list.object = OBJ_BASE(obj); + CError_ErrorFuncCall(CErrorStr248, &my_list, nodes); + } + scan_expr->node = CExpr_VarArgPromotion(scan_expr->node, scan_arg == &elipsis); + } + scan_expr = scan_expr->next; + } + + if (scan_arg) { + if (scan_arg != &elipsis && scan_arg != &oldstyle) { + if (!scan_arg->dexpr) { + my_list.next = NULL; + my_list.object = OBJ_BASE(obj); + CError_ErrorFuncCall(CErrorStr248, &my_list, nodes); + scan_arg = NULL; + } + } else { + scan_arg = NULL; + } + } + + return CExpr_GenericCall(objexpr, nodes, tfunc, scan_arg); +} + +ENode *CExpr_GenericPtmfCall(Object *obj, TypeFunc *tfunc, ENodeList *arg_exprs) { + ENodeList *scan_expr; + FuncArg *arg; + + scan_expr = arg_exprs; + arg = tfunc->args; + while (scan_expr) { + if (!arg) { + CError_Error(CErrorStr162); + return nullnode(); + } + + if (arg != &elipsis && arg != &oldstyle) { + scan_expr->node = argumentpromotion(scan_expr->node, arg->type, arg->qual, 1); + arg = arg->next; + } else { + scan_expr->node = CExpr_VarArgPromotion(scan_expr->node, arg == &elipsis); + } + scan_expr = scan_expr->next; + } + + if (arg) { + if (arg != &elipsis && arg != &oldstyle) { + if (!arg->dexpr) { + CError_Error(CErrorStr162); + arg = NULL; + } + } else { + arg = NULL; + } + } + + return CExpr_GenericCall(create_objectrefnode(obj), arg_exprs, tfunc, arg); +} + +static ENode *CExpr_ConvertEMember(ENode *expr) { + ENode *result; + + if (expr->data.emember->list->next || expr->data.emember->templargs) { + result = CExpr_NewENode(EOBJLIST); + result->rtype = OBJECT(expr->data.emember->list->object)->type; + result->data.objlist.list = expr->data.emember->list; + result->data.objlist.templargs = expr->data.emember->templargs; + return result; + } + + if (expr->data.emember->list->object->otype != OT_OBJECT) + return NULL; + return CExpr_MakeObjRefNode(OBJECT(expr->data.emember->list->object), 1); +} + +ENode *CExpr_MakeFunctionCall(ENode *funcexpr, ENodeList *arg_exprs) { + ENode *expr; + TypeFunc *tfunc; + BClassList *save_path; + ENode *save_expr; + Boolean save_1D; + Boolean save_isambig; + + FuncArg *scan_arg; + ENodeList *scan_expr; + Boolean has_varargs; + + if (ENODE_IS(funcexpr, EOBJLIST) && funcexpr->data.objlist.name) { + funcexpr->data.objlist.list = CScope_ArgumentDependentNameLookup( + funcexpr->data.objlist.list, + funcexpr->data.objlist.name, + arg_exprs, 0); + if (!funcexpr->data.objlist.list) { + CError_Error(CErrorStr140, CError_GetNameString(NULL, funcexpr->data.objlist.name)); + return nullnode(); + } + + if ( + funcexpr->data.objlist.list->object->otype == OT_OBJECT && + (TYPE_FUNC(OBJECT(funcexpr->data.objlist.list->object)->type)->flags & FUNC_FLAGS_200) && + (expr = CodeGen_HandleIntrinsicCall(OBJECT(funcexpr->data.objlist.list->object), arg_exprs))) + return expr; + + return CExpr_GenericFuncCall( + NULL, NULL, 0, NULL, + funcexpr->data.objlist.list, + funcexpr->data.objlist.templargs, + arg_exprs, 0, 0, 1); + } + + if (ENODE_IS(funcexpr, EMEMBER)) { + save_path = funcexpr->data.emember->path; + save_expr = funcexpr->data.emember->expr; + save_1D = funcexpr->data.emember->pr_1D; + save_isambig = funcexpr->data.emember->isambig; + funcexpr = CExpr_ConvertEMember(funcexpr); + if (!funcexpr) { + CError_Error(CErrorStr161); + return nullnode(); + } + } else { + save_path = NULL; + save_expr = NULL; + save_1D = 0; + save_isambig = 0; + } + + if (ENODE_IS(funcexpr, EOBJREF) && IS_TYPE_FUNC(funcexpr->data.objref->type) && (TYPE_FUNC(funcexpr->data.objref->type)->flags & FUNC_FLAGS_200)) { + if (!(expr = CodeGen_HandleIntrinsicCall(funcexpr->data.objref, arg_exprs))) { + expr = CExpr_GenericFuncCall( + save_path, save_expr, save_1D, funcexpr->data.objref, + NULL, NULL, + arg_exprs, 0, save_isambig, 1); + } + return expr; + } + + if (ENODE_IS(funcexpr, EOBJLIST)) { + return CExpr_GenericFuncCall( + save_path, save_expr, save_1D, NULL, + funcexpr->data.objlist.list, funcexpr->data.objlist.templargs, + arg_exprs, 0, save_isambig, 1); + } + + if (!IS_TYPE_POINTER_ONLY(funcexpr->rtype) || !IS_TYPE_FUNC((tfunc = TYPE_FUNC(TYPE_POINTER(funcexpr->rtype)->target)))) { + CError_Error(CErrorStr161); + return nullnode(); + } + + if (ENODE_IS(funcexpr, EOBJREF)) { + return CExpr_GenericFuncCall( + save_path, save_expr, save_1D, funcexpr->data.objref, + NULL, NULL, arg_exprs, 0, save_isambig, 1); + } + + scan_expr = arg_exprs; // r25 + scan_arg = tfunc->args; // r26 + has_varargs = 0; + while (scan_expr) { + if (!has_varargs) { + if (!scan_arg) { + CError_Error(CErrorStr162); + return nullnode(); + } + if (scan_arg == &elipsis || scan_arg == &oldstyle) { + scan_expr->node = CExpr_VarArgPromotion(scan_expr->node, scan_arg == &elipsis); + has_varargs = 1; + } else { + scan_expr->node = argumentpromotion(scan_expr->node, scan_arg->type, scan_arg->qual, 1); + scan_arg = scan_arg->next; + } + } else { + scan_expr->node = CExpr_VarArgPromotion(scan_expr->node, 0); + } + scan_expr = scan_expr->next; + } + + if (!has_varargs && scan_arg && scan_arg != &elipsis && scan_arg != &oldstyle) { + do { + if (!scan_arg->dexpr) { + CError_Error(CErrorStr162); + return nullnode(); + } + + if (arg_exprs) { + scan_expr = arg_exprs; + while (scan_expr->next) + scan_expr = scan_expr->next; + scan_expr->next = lalloc(sizeof(ENodeList)); + scan_expr = scan_expr->next; + } else { + scan_expr = lalloc(sizeof(ENodeList)); + arg_exprs = scan_expr; + } + + scan_expr->next = NULL; + scan_expr->node = CExpr_GetDefaultArgument(funcexpr, scan_arg); + } while ((scan_arg = scan_arg->next) && scan_arg != &elipsis && scan_arg != &oldstyle); + } + + expr = CExpr_NewENode(EFUNCCALL); + expr->cost = 4; + expr->rtype = tfunc->functype; + expr->flags = tfunc->qual & ENODE_FLAG_QUALS; + expr->data.funccall.funcref = funcexpr; + expr->data.funccall.args = arg_exprs; + expr->data.funccall.functype = tfunc; + return CExpr_AdjustFunctionCall(expr); +} + +static Boolean accept_conversion_type(Type *type, short mode) { + switch (mode) { + case 0: + return IS_TYPE_INT(type); + case 1: + return IS_TYPE_INT_OR_FLOAT(type); + case 2: + return IS_TYPE_INT_OR_FLOAT(type) || IS_TYPE_POINTER_ONLY(type); + case 3: + return IS_TYPE_POINTER_ONLY(type); + default: +#line 3912 + CError_FATAL(); + return 0; + } +} + +static ENode *CExpr_OperatorConversion(ENode *expr, Type *type, UInt32 qual) { + if (IS_TYPE_CLASS(expr->rtype) && type) { + if (user_assign_check(expr, type, qual, 1, 0, 1)) + return assign_node; + CError_Error(CErrorStr144); + } + return expr; +} + +static Boolean wild_conversion_check(ENode *left, ENode *right, Conversion *conv) { + ConversionIterator iter; + Object *obj; + + Type *check; + Type *left_type; + Type *right_type; + + left_type = right_type = NULL; + if (IS_TYPE_CLASS(left->rtype)) { + CExpr_ConversionIteratorInit(&iter, TYPE_CLASS(left->rtype)); + while ((obj = CExpr_ConversionIteratorNext(&iter))) { + check = TYPE_FUNC(obj->type)->functype; + if (accept_conversion_type(check, 2)) { + while ((obj = CExpr_ConversionIteratorNext(&iter))) { + if (accept_conversion_type(TYPE_FUNC(obj->type)->functype, 2)) + CError_Error(CErrorStr199); + } + left_type = check; + goto found_left; + } + } + return 0; + } +found_left: + if (IS_TYPE_CLASS(right->rtype)) { + CExpr_ConversionIteratorInit(&iter, TYPE_CLASS(right->rtype)); + while ((obj = CExpr_ConversionIteratorNext(&iter))) { + check = TYPE_FUNC(obj->type)->functype; + if (accept_conversion_type(check, 2)) { + while ((obj = CExpr_ConversionIteratorNext(&iter))) { + if (accept_conversion_type(TYPE_FUNC(obj->type)->functype, 2)) + CError_Error(CErrorStr199); + } + right_type = check; + goto found_right; + } + } + return 0; + } +found_right: + conv->x0 = NULL; + conv->left = CExpr_OperatorConversion(left, left_type, 0); + conv->right = CExpr_OperatorConversion(right, right_type, 0); + return 1; +} + +static Boolean monadic_conversion_check(ENode *expr, short which, Conversion *conv) { + ConversionIterator iter; + Object *obj; + Type *check; + + if (!IS_TYPE_CLASS(expr->rtype)) + return 0; + + if (which == 4) + which = 2; + else if (which == 5) + which = 1; + + CExpr_ConversionIteratorInit(&iter, TYPE_CLASS(expr->rtype)); + while ((obj = CExpr_ConversionIteratorNext(&iter))) { + check = TYPE_FUNC(obj->type)->functype; + if (accept_conversion_type(check, which)) { + while ((obj = CExpr_ConversionIteratorNext(&iter))) { + if (accept_conversion_type(TYPE_FUNC(obj->type)->functype, which)) + CError_Error(CErrorStr199); + } + + conv->x0 = NULL; + conv->left = CExpr_OperatorConversion(expr, check, 0); + conv->right = NULL; + return 1; + } + } + + return 0; +} + +static Boolean is_legal_type_combination(Type *left, Type *right, short mode) { + int left_type; + int right_type; + + if (IS_TYPE_ENUM(left)) + left = TYPE_ENUM(left)->enumtype; + if (IS_TYPE_ENUM(right)) + right = TYPE_ENUM(right)->enumtype; + + if (IS_TYPE_REFERENCE(left)) + left = TYPE_POINTER(left)->target; + if (IS_TYPE_REFERENCE(right)) + right = TYPE_POINTER(right)->target; + + left_type = left->type; // r7 + right_type = right->type; // r8 + switch (mode) { + case 3: + if (left_type != TYPEPOINTER || right_type != TYPEPOINTER) + return 0; + use_cpp_typeequal: + diadic_arg1.type = left; + diadic_arg2.type = right; + return iscpp_typeequal(left, right); + case 7: + if ((left_type == TYPEPOINTER && right_type == TYPEINT) || (left_type == TYPEINT && right_type == TYPEPOINTER)) { + diadic_arg1.type = left; + diadic_arg2.type = right; + return 1; + } + return 0; + case 6: + if ((left_type == TYPEPOINTER && right_type == TYPEINT) || (left_type == TYPEINT && right_type == TYPEPOINTER)) { + diadic_arg1.type = left; + diadic_arg2.type = right; + return 1; + } + case 2: + if (left_type == TYPEPOINTER || right_type == TYPEPOINTER) + goto use_cpp_typeequal; + case 1: + mode1: + if (left_type == TYPEFLOAT || right_type == TYPEFLOAT) { + if (left_type == TYPEFLOAT) { + if (right_type == TYPEFLOAT) { + if (TYPE_INTEGRAL(right)->integral > TYPE_INTEGRAL(left)->integral) + left = right; + diadic_arg2.type = left; + diadic_arg1.type = left; + return 1; + } + if (right_type != TYPEINT) + return 0; + diadic_arg2.type = left; + diadic_arg1.type = left; + return 1; + } + if (left_type != TYPEINT) + return 0; + diadic_arg2.type = right; + diadic_arg1.type = right; + return 1; + } + case 0: + if (left_type != TYPEINT || right_type != TYPEINT) + return 0; + if (TYPE_INTEGRAL(right)->integral > TYPE_INTEGRAL(left)->integral) + left = right; + if (TYPE_INTEGRAL(left)->integral < IT_INT) + left = TYPE(&stsignedint); + diadic_arg2.type = left; + diadic_arg1.type = left; + return 1; + case 4: + if (left_type == TYPEPOINTER) { + if (right_type != TYPEINT) + return 0; + diadic_arg1.type = left; + diadic_arg2.type = right; + return 1; + } + if (right_type == TYPEPOINTER) { + if (left_type != TYPEINT) + return 0; + diadic_arg1.type = left; + diadic_arg2.type = right; + return 1; + } + goto mode1; + case 5: + if (left_type != TYPEPOINTER) + goto mode1; + if (right_type == TYPEPOINTER) + goto use_cpp_typeequal; + if (right_type != TYPEINT) + return 0; + diadic_arg1.type = left; + diadic_arg2.type = right; + return 1; + default: +#line 4132 + CError_FATAL(); + return 0; + } +} + +static void match_class_type_conversion(Match13 *match, ENode *left, ENode *right, ENodeList *list, short which) { + ConversionIterator iter; + Object *obj; + + if (which == 6) { + if (!ENODE_IS(right, EINTCONST) || !CInt64_IsZero(&right->data.intval) || !IS_TYPE_INT(right->rtype)) + which = 2; + } + + CExpr_ConversionIteratorInit(&iter, TYPE_CLASS(left->rtype)); + while ((obj = CExpr_ConversionIteratorNext(&iter))) { + if (is_legal_type_combination(TYPE_FUNC(obj->type)->functype, right->rtype, which)) { + MatchOverloadFunc(obj, &diadic_arg1, list, match); + if (match->obj == obj) { + cexpr_left_conversion_type = diadic_arg1.type; + cexpr_right_conversion_type = diadic_arg2.type; + } + } + } +} + +static void match_type_class_conversion(Match13 *match, ENode *left, ENode *right, ENodeList *list, short which) { + ConversionIterator iter; + Object *obj; + + if (which == 6) { + if (!ENODE_IS(left, EINTCONST) || !CInt64_IsZero(&left->data.intval) || !IS_TYPE_INT(left->rtype)) + which = 2; + } + + CExpr_ConversionIteratorInit(&iter, TYPE_CLASS(right->rtype)); + while ((obj = CExpr_ConversionIteratorNext(&iter))) { + if (is_legal_type_combination(left->rtype, TYPE_FUNC(obj->type)->functype, which)) { + MatchOverloadFunc(obj, &diadic_arg1, list, match); + if (match->obj == obj) { + cexpr_left_conversion_type = diadic_arg1.type; + cexpr_right_conversion_type = diadic_arg2.type; + } + } + } +} + +static void match_class_class_conversion(Match13 *match, ENode *left, ENode *right, ENodeList *list, short which) { + ConversionIterator iter_left; + ConversionIterator iter_right; + Object *obj_left; + Object *obj_right; + + if (which == 6) + which = 2; + + CExpr_ConversionIteratorInit(&iter_left, TYPE_CLASS(left->rtype)); + while ((obj_left = CExpr_ConversionIteratorNext(&iter_left))) { + CExpr_ConversionIteratorInit(&iter_right, TYPE_CLASS(right->rtype)); + while ((obj_right = CExpr_ConversionIteratorNext(&iter_right))) { + if (is_legal_type_combination(TYPE_FUNC(obj_left->type)->functype, TYPE_FUNC(obj_right->type)->functype, which)) { + MatchOverloadFunc(obj_left, &diadic_arg1, list, match); + if (match->obj == obj_left) { + cexpr_left_conversion_type = diadic_arg1.type; + cexpr_right_conversion_type = diadic_arg2.type; + } + } + } + } +} + +Boolean CExpr_CheckOperatorConversion(short token, ENode *left, ENode *right, ENodeList *list, Conversion *conv) { + Match13 match; + short which; + + switch (token) { + case '*': + if (!right) { + which = 3; + break; + } + case '/': + which = 1; + break; + case '&': + if (!right) + return 0; + case '%': + case '^': + case '|': + case '~': + case TK_SHL: + case TK_SHR: + which = 0; + break; + case '[': + which = 7; + break; + case '+': + which = 4; + break; + case '-': + which = 5; + break; + case '!': + case ':': + case '<': + case '>': + case TK_LESS_EQUAL: + case TK_GREATER_EQUAL: + which = 2; + break; + case TK_LOGICAL_EQ: + case TK_LOGICAL_NE: + which = 6; + break; + case TK_LOGICAL_OR: + case TK_LOGICAL_AND: + return wild_conversion_check(left, right, conv); + default: + return 0; + } + + if (!right) + return monadic_conversion_check(left, which, conv); + + cexpr_left_conversion_type = cexpr_right_conversion_type = NULL; + memclrw(&match, sizeof(Match13)); + + if (IS_TYPE_CLASS(left->rtype)) { + if (IS_TYPE_CLASS(right->rtype)) + match_class_class_conversion(&match, left, right, list, which); + else + match_class_type_conversion(&match, left, right, list, which); + } else { + if (IS_TYPE_CLASS(right->rtype)) + match_type_class_conversion(&match, left, right, list, which); + else + return 0; + } + + if (!match.obj) + return 0; + if (match.list) + CError_OverloadedFunctionError(match.obj, match.list); + + conv->x0 = NULL; + conv->left = CExpr_OperatorConversion(left, cexpr_left_conversion_type, 0); + conv->right = CExpr_OperatorConversion(right, cexpr_right_conversion_type, 0); + return 1; +} + +Boolean CExpr_CheckOperator(short token, ENode *left, ENode *right, Conversion *conv) { + Match13 match; + CScopeParseResult pr; + CScopeParseResult pr2; + ENode *expr; + Object *obj; + ENodeList *nodes; + HashNameNode *name; + BClassList *path; + EMemberInfo *member; + Object *prev_obj; + NameSpaceObjectList mylist_A8; + NameSpaceObjectList mylist_B0; + + if (!copts.old_argmatch) { + if (token == '(') { + CDecl_CompleteType(left->rtype); + if (IS_TYPE_CLASS(left->rtype) && CScope_FindClassMemberObject(TYPE_CLASS(left->rtype), &pr, + CMangler_OperatorName(token))) { + if (pr.nsol_14 || (pr.obj_10 && pr.obj_10->otype == OT_OBJECT && IS_TYPE_FUNC(OBJECT(pr.obj_10)->type))) { + member = lalloc(sizeof(EMemberInfo)); + memclrw(member, sizeof(EMemberInfo)); + member->path = pr.bcl_18; + member->expr = left; + member->pr_1D = pr.x1D; + if (!pr.nsol_14) { + member->list = galloc(sizeof(NameSpaceObjectList)); + member->list->next = NULL; + member->list->object = pr.obj_10; + } else { + member->list = pr.nsol_14; + } + expr = CExpr_NewENode(EMEMBER); + expr->rtype = &stvoid; + expr->data.emember = member; + tk = lex(); + conv->x0 = checkreference(CExpr_MakeFunctionCall(expr, CExpr_ScanExpressionList(1))); + conv->left = NULL; + conv->right = NULL; + tk = lex(); + return 1; + } else { +#line 4371 + CError_FATAL(); + } + } + return 0; + } else { + return CExpr_OperatorMatch(token, left, right, conv); + } + } + + if (!IS_TYPE_CLASS(left->rtype)) { + if (!IS_TYPE_ENUM(left->rtype)) { + if (!right) + return 0; + if (!IS_TYPE_CLASS(right->rtype) && !IS_TYPE_ENUM(right->rtype)) + return 0; + } + } else { + CDecl_CompleteType(left->rtype); + } + + memclrw(&match, sizeof(Match13)); + name = CMangler_OperatorName(token); + if (token == '(') { + if (IS_TYPE_CLASS(left->rtype) && CScope_FindClassMemberObject(TYPE_CLASS(left->rtype), &pr2, name)) { + if (pr2.nsol_14 || (pr2.obj_10 && pr2.obj_10->otype == OT_OBJECT && IS_TYPE_FUNC(OBJECT(pr2.obj_10)->type))) { + member = lalloc(sizeof(EMemberInfo)); + memclrw(member, sizeof(EMemberInfo)); + member->path = pr2.bcl_18; + member->expr = left; + member->pr_1D = pr2.x1D; + if (!pr2.nsol_14) { + member->list = galloc(sizeof(NameSpaceObjectList)); + member->list->next = NULL; + member->list->object = pr2.obj_10; + } else { + member->list = pr2.nsol_14; + } + expr = CExpr_NewENode(EMEMBER); + expr->rtype = &stvoid; + expr->data.emember = member; + tk = lex(); + conv->x0 = checkreference(CExpr_MakeFunctionCall(expr, CExpr_ScanExpressionList(1))); + conv->left = NULL; + conv->right = NULL; + tk = lex(); + return 1; + } else { +#line 4439 + CError_FATAL(); + } + } + return 0; + } + + nodes = lalloc(sizeof(ENodeList)); + nodes->node = left; + if (right) { + nodes->next = lalloc(sizeof(ENodeList)); + nodes->next->node = right; + nodes->next->next = NULL; + } else { + nodes->next = NULL; + } + + obj = NULL; + if (IS_TYPE_CLASS(left->rtype) && CScope_FindClassMemberObject(TYPE_CLASS(left->rtype), &pr2, name)) { + if (pr2.obj_10) { + mylist_B0.next = NULL; + mylist_B0.object = pr2.obj_10; + pr2.nsol_14 = &mylist_B0; + } else { +#line 4470 + CError_ASSERT(pr2.nsol_14); + } + + if (token != '=' || (pr2.bcl_18->type == left->rtype && pr2.bcl_18->next == NULL)) { + prev_obj = match.obj; + CExpr_MatchArgList(pr2.nsol_14, NULL, nodes->next, &match, left, 0); + if (prev_obj != match.obj) { + obj = match.obj; + path = pr2.bcl_18; + } + } + } + + if (CScope_FindNonClassObject(cscope_current, &pr2, name)) { + if (pr2.obj_10) { + mylist_A8.next = NULL; + mylist_A8.object = pr2.obj_10; + pr2.nsol_14 = &mylist_A8; + } + } else { + pr2.nsol_14 = NULL; + } + + if (copts.arg_dep_lookup) + pr2.nsol_14 = CScope_ArgumentDependentNameLookup(pr2.nsol_14, name, nodes, 1); + if (pr2.nsol_14) + CExpr_MatchArgList(pr2.nsol_14, NULL, nodes, &match, NULL, 0); + + if (!match.obj) { + if (!IS_TYPE_CLASS(left->rtype) && (!right || !IS_TYPE_CLASS(right->rtype))) + return 0; + return CExpr_CheckOperatorConversion(token, left, right, nodes, conv); + } + + if (!(token == '&' && !right) && (token != ',')) { + if (!IS_TYPE_CLASS(left->rtype) && (!right || !IS_TYPE_CLASS(right->rtype)) && match.xE) + return 0; + if (right && match.xE == 2 && CExpr_CheckOperatorConversion(token, left, right, nodes, conv)) + return 1; + } + + if (match.list) + CError_OverloadedFunctionError(match.obj, match.list); + + if (match.obj == obj) { + conv->x0 = CExpr_GenericFuncCall(path, nodes->node, 0, match.obj, NULL, NULL, nodes->next, 0, 0, 1); + } else { + conv->x0 = CExpr_GenericFuncCall(NULL, NULL, 0, match.obj, NULL, NULL, nodes, 0, 0, 1); + } + + conv->x0 = checkreference(conv->x0); + conv->left = NULL; + conv->right = NULL; + return 1; +} ENode *CExpr_ConstructObject(TypeClass *tclass, ENode *addr_expr, ENodeList *args, Boolean flag1, Boolean flag2, Boolean flag3, Boolean flag4, Boolean flag5) { ENode *expr; - Object *ctor; + NameSpaceObjectList *ctorlist; + BClassList path; #line 4595 CError_ASSERT(IS_TYPE_POINTER_ONLY(addr_expr->rtype)); @@ -1894,14 +3421,23 @@ ENode *CExpr_ConstructObject(TypeClass *tclass, ENode *addr_expr, ENodeList *arg return expr; } - if ((ctor = CClass_Constructor(tclass))) { + if ((ctorlist = CClass_Constructor(tclass))) { if (tclass->flags & CLASS_FLAGS_20) { ENodeList *list = lalloc(sizeof(ENodeList)); list->next = args; args = list; list->node = intconstnode(TYPE(&stsignedshort), flag2 != 0); } - // TODO: 12CE80 call to genericfunccall + path.next = NULL; + path.type = TYPE(tclass); + expr = CExpr_GenericFuncCall(&path, addr_expr, 0, NULL, ctorlist, NULL, args, !flag5, 0, flag4); + if (ENODE_IS2(expr, EFUNCCALL, EFUNCCALLP)) + expr->rtype = CDecl_NewPointerType(TYPE(tclass)); + if (flag1) { + expr = makemonadicnode(expr, EINDIRECT); + expr->rtype = TYPE(tclass); + } + return expr; } else { if (args) { if (!args->next && ENODE_IS(addr_expr, EINDIRECT)) { @@ -1916,19 +3452,796 @@ ENode *CExpr_ConstructObject(TypeClass *tclass, ENode *addr_expr, ENodeList *arg } } -static void CExpr_DeleteFuncCall() {} -static void CExpr_CopyPlacementNewArg() {} -static void CExpr_PlacementDeleteCall() {} -static void scan_type_name() {} -static void cv_qualifier_list() {} -static void scan_new_declarator() {} -static void scan_new_type_name() {} -static void CExpr_NewAlloc() {} -static void CExpr_NewExceptionSafeAlloc() {} -static void CExpr_NewExceptionSafeInit() {} -static void CExpr_NewArray() {} -static void CExpr_NewSimpleClass() {} -static void CExpr_NewClass() {} -void scannew() {} -static void CExpr_DeleteArray() {} -void scandelete() {} +static ENode *CExpr_DeleteFuncCall(Object *obj, ENode *arg, Type *type, Boolean include_size) { + ENode *expr; + ENodeList *list; + + expr = lalloc(sizeof(ENode)); + expr->type = EFUNCCALL; + expr->cost = 4; + expr->flags = 0; + expr->rtype = &stvoid; + expr->data.funccall.funcref = create_objectrefnode(obj); + expr->data.funccall.functype = TYPE_FUNC(obj->type); + obj->flags |= OBJECT_FLAGS_UNUSED; + + list = lalloc(sizeof(ENodeList)); + list->node = arg; + expr->data.funccall.args = list; + + if (include_size) { + list->next = lalloc(sizeof(ENodeList)); + list->next->node = nullnode(); + CInt64_SetLong(&list->next->node->data.intval, type->size); + list->next->node->rtype = CABI_GetSizeTType(); + list->next->next = NULL; + } else { + list->next = NULL; + } + + return expr; +} + +static ENode *CExpr_CopyPlacementNewArg(ENodeList *list) { + switch (list->node->type) { + case EINDIRECT: + if (!ENODE_IS(list->node->data.monadic, EOBJREF)) + break; + if (list->node->data.monadic->data.objref->datatype != DLOCAL && !is_const_object(list->node->data.monadic->data.objref)) + break; + case EINTCONST: + case EFLOATCONST: + case ESTRINGCONST: + case EOBJREF: + case EARGOBJ: + case ELOCOBJ: + case EOBJLIST: + case EVECTOR128CONST: + return CInline_CopyExpression(list->node, CopyMode0); + } + + switch (list->node->rtype->type) { + default: +#line 4726 + CError_FATAL(); + case TYPEINT: + case TYPEFLOAT: + case TYPEENUM: + case TYPESTRUCT: + case TYPECLASS: + case TYPEMEMBERPOINTER: + case TYPEPOINTER: + case TYPEOBJCID: + return CExpr_GetETEMPCopy(list->node); + } +} + +static ENode *CExpr_PlacementDeleteCall(Type *type, ENode *expr, Object *obj, Boolean flag1, Boolean flag2) { + ENodeList *list; + Object *funcobj; + ENode *result; + ENodeList *inputarg; + Boolean outflag; + +#line 4752 + CError_ASSERT(ENODE_IS(expr, EFUNCCALL) && ENODE_IS(expr->data.funccall.funcref, EOBJREF)); + + funcobj = expr->data.funccall.funcref->data.objref; +#line 4756 + CError_ASSERT(IS_TYPE_FUNC(funcobj->type) && TYPE_FUNC(funcobj->type)->args && TYPE_FUNC(funcobj->type)->args->next); + + funcobj = CParser_FindDeallocationObject(type, TYPE_FUNC(funcobj->type)->args->next, flag1, flag2, &outflag); + if (!funcobj) + return NULL; + + result = CExpr_NewENode(EFUNCCALL); + result->type = EFUNCCALL; + result->cost = 4; + result->rtype = &stvoid; + result->data.funccall.funcref = create_objectrefnode(funcobj); + result->data.funccall.functype = TYPE_FUNC(funcobj->type); + funcobj->flags |= OBJECT_FLAGS_UNUSED; + + list = lalloc(sizeof(ENodeList)); + list->node = create_objectnode(obj); + result->data.funccall.args = list; + +#line 4780 + CError_ASSERT((inputarg = expr->data.funccall.args) && (inputarg = inputarg->next)); + + do { + list->next = lalloc(sizeof(ENodeList)); + list = list->next; + list->node = CExpr_CopyPlacementNewArg(inputarg); + inputarg = inputarg->next; + } while (inputarg); + list->next = NULL; + + return result; +} + +static Type *scan_type_name(UInt32 *qual) { + DeclInfo di; + memclrw(&di, sizeof(DeclInfo)); + + CParser_GetDeclSpecs(&di, 0); + di.x46 = 1; + scandeclarator(&di); + + if (di.name) + CError_Error(CErrorStr146); + + firstarrayexpr = di.x24; + *qual = di.qual; + return di.thetype; +} + +static UInt32 cv_qualifier_list(void) { + UInt32 qual; + + qual = 0; + tk = lex(); + while (tk >= TK_CONST && tk <= TK_ASM) { + switch (tk) { + case TK_CONST: + if (qual & Q_CONST) + CError_Error(CErrorStr121); + qual |= Q_CONST; + break; + case TK_VOLATILE: + if (qual & Q_VOLATILE) + CError_Error(CErrorStr121); + qual |= Q_VOLATILE; + break; + default: + CError_Error(CErrorStr121); + } + + tk = lex(); + } + + return qual; +} + +static void scan_new_declarator(DeclInfo *di, Boolean flag) { + CScopeParseResult pr; + SInt32 size; + ENode *expr; + + switch (tk) { + case '*': + makethetypepointer(di, cv_qualifier_list()); + if (tk != '[') + scan_new_declarator(di, flag); + break; + case TK_IDENTIFIER: + case TK_COLON_COLON: + if (CScope_ParseQualifiedNameSpace(&pr, 1, 0) && pr.nspace_0 && pr.nspace_0->theclass && tk == '*') { + makememberpointertype(di, pr.nspace_0->theclass, cv_qualifier_list()); + if (tk != '[') + scan_new_declarator(di, flag); + } else { + CError_Error(CErrorStr121); + } + break; + } + + if (tk == '[') { + tk = lex(); + expr = expression(); + + if (IS_TYPE_ENUM(expr->rtype)) + expr->rtype = TYPE_ENUM(expr->rtype)->enumtype; + if (!IS_TYPE_INT(expr->rtype)) + CError_Error(CErrorStr146); + + if (tk != ']') + CError_Error(CErrorStr125); + else + tk = lex(); + + if (tk == '[') + scan_new_declarator(di, 0); + + if (CanCreateObject(di->thetype) && IsCompleteType(di->thetype)) { + di->thetype = CDecl_NewArrayType(di->thetype, 0); + if (!ENODE_IS(expr, EINTCONST)) { + size = 1; + if (!flag) + CError_Error(CErrorStr124); + else + firstarrayexpr = expr; + } else { + size = CInt64_GetULong(&expr->data.intval); + } + TYPE_POINTER(di->thetype)->size = size * TYPE_POINTER(di->thetype)->target->size; + } else { + CError_Error(CErrorStr129); + } + } +} + +static Type *scan_new_type_name(UInt32 *qual) { + DeclInfo di; + memclrw(&di, sizeof(DeclInfo)); + + di.x4F = 1; + CParser_GetDeclSpecs(&di, 0); + scan_new_declarator(&di, 1); + + *qual = di.qual; + return di.thetype; +} + +static ENode *CExpr_NewAlloc(Type *type, ENodeList *args, Boolean flag1, Boolean flag2) { + NameSpaceObjectList *list; + Object *obj; + Boolean found; + HashNameNode *name; + CScopeParseResult pr; + + found = 0; + if (!flag1 && IS_TYPE_CLASS(type)) { + list = NULL; + obj = NULL; + name = (flag2 && copts.array_new_delete) ? newa_fobj->name : newp_fobj->name; + if (CScope_FindClassMemberObject(TYPE_CLASS(type), &pr, name)) { + list = pr.nsol_14; + obj = OBJECT(pr.obj_10); +#line 4935 + CError_ASSERT(list || obj); + found = 1; + } else if (TYPE_CLASS(type)->flags & CLASS_FLAGS_1) { +#line 4942 + CError_ASSERT(!flag2); + obj = newh_func; + found = 1; + } + } + + if (!found) { + if (flag2 && copts.array_new_delete) + list = &newa_fobj->first; + else + list = &newp_fobj->first; + obj = NULL; + } + + return CExpr_GenericFuncCall(NULL, NULL, 0, obj, list, NULL, args, 0, 0, 1); +} + +static ENode *CExpr_NewExceptionSafeAlloc(Type *type, ENode *node, ENodeList *args, Boolean flag1, Boolean flag2, Object **objptr) { + Object *obj; + ENode *result; + ENode *catchexpr; + Object *deletefunc; + Boolean include_size; + + if (!cscope_currentfunc || !copts.delete_exception || !copts.exceptions) + return NULL; + + obj = create_temp_object(TYPE(&void_ptr)); + *objptr = obj; + deletefunc = NULL; + catchexpr = NULL; + include_size = 0; + if (args) + catchexpr = CExpr_PlacementDeleteCall(type, node, obj, flag1, flag2); + if (!args) + deletefunc = CParser_FindDeallocationObject(type, NULL, flag1, flag2, &include_size); + + if (!deletefunc && !catchexpr) + return NULL; + + result = lalloc(sizeof(ENode)); + *result = *node; + node = makediadicnode(create_objectnode(obj), node, EASS); + if (!catchexpr && !include_size) { + result->type = ENEWEXCEPTION; + result->data.newexception.initexpr = node; + result->data.newexception.tryexpr = NULL; + result->data.newexception.pointertemp = obj; + result->data.newexception.deletefunc = deletefunc; + } else { + if (!catchexpr) + catchexpr = CExpr_DeleteFuncCall(deletefunc, create_objectnode(obj), type, include_size); + result->type = EMYSTERY67; + result->data.itc.initexpr = node; + result->data.itc.tryexpr = NULL; + result->data.itc.result = create_objectnode(obj); + result->data.itc.catchexpr = catchexpr; + } + + return result; +} + +static ENode *CExpr_NewExceptionSafeInit(ENode *expr, ENode *tryexpr) { + switch (expr->type) { + case ENEWEXCEPTION: + expr->data.newexception.tryexpr = tryexpr; + break; + case EMYSTERY67: + expr->data.itc.tryexpr = tryexpr; + break; + default: +#line 5056 + CError_FATAL(); + } + return expr; +} + +static ENode *CExpr_NewArray(Type *type, UInt32 qual, ENodeList *nodelist, Boolean flag) { + Type *tptr; + Type *sizetype; + Type *innertype; + ENodeList *newlist; + ENode *result; + Object *ctor; + Object *dtor; + ENode *ass; + ENode *etemp; + ENode *mul; + SInt32 count; + ENode *newalloc; + ENode *newESalloc; + Object *tempobj; + ENode *callexpr; + + tptr = CDecl_NewPointerType(TYPE_POINTER(type)->target); + sizetype = CABI_GetSizeTType(); + innertype = TYPE_POINTER(type)->target; + while (IS_TYPE_ARRAY(innertype)) + innertype = TYPE_POINTER(innertype)->target; + + if (!CanAllocObject(innertype) || !IsCompleteType(innertype)) + return nullnode(); + + newlist = lalloc(sizeof(ENodeList)); + newlist->next = nodelist; + if (tk == '(') { + tk = lex(); + if (CExpr_ScanExpressionList(1)) + CError_Error(CErrorStr174); + if (tk == ')') + tk = lex(); + else + CError_Error(CErrorStr115); + } + + if (!IS_TYPE_CLASS(innertype) || CClass_IsPODClass(TYPE_CLASS(innertype))) { + newlist->node = intconstnode(sizetype, type->size); + if (firstarrayexpr) { + newlist->node = makediadicnode(newlist->node, promote(firstarrayexpr, sizetype), EMUL); + optimizecomm(newlist->node); + } + result = CExpr_NewAlloc(innertype, newlist, flag, 1); + result->rtype = tptr; + result->flags |= (qual & ENODE_FLAG_QUALS); + return result; + } + + ctor = NULL; + if (CClass_Constructor(TYPE_CLASS(innertype))) { + ctor = CClass_DefaultConstructor(TYPE_CLASS(innertype)); + if (ctor) { + ctor->flags |= OBJECT_FLAGS_UNUSED; + } else { + ctor = CClass_DummyDefaultConstructor(TYPE_CLASS(innertype)); + if (!ctor) + CError_Error(CErrorStr203); + } + } + + dtor = CClass_Destructor(TYPE_CLASS(innertype)); + if (dtor) + dtor = CABI_GetDestructorObject(dtor, 1); + + ass = NULL; + if (firstarrayexpr) { + etemp = CExpr_NewETEMPNode(sizetype, 1); + mul = promote(firstarrayexpr, sizetype); + if (innertype->size) + count = type->size / innertype->size; + else + count = 0; + if (count > 1) { + mul = makediadicnode(mul, intconstnode(sizetype, count), EMUL); + optimizecomm(mul); + } + ass = makediadicnode(CExpr_DerefETEMPCopy(etemp), mul, EASS); + mul = makediadicnode(CExpr_DerefETEMPCopy(etemp), intconstnode(sizetype, innertype->size), EMUL); + optimizecomm(mul); + mul = makediadicnode(mul, intconstnode(sizetype, 16), EADD); + optimizecomm(mul); + newlist->node = mul; + etemp = CExpr_DerefETEMPCopy(etemp); + } else { + newlist->node = intconstnode(sizetype, type->size + 16); + if (innertype->size) + count = type->size / innertype->size; + else + count = 0; + etemp = intconstnode(sizetype, count); + } + + newalloc = CExpr_NewAlloc(innertype, newlist, flag, 1); + newalloc->rtype = tptr; + newESalloc = CExpr_NewExceptionSafeAlloc(innertype, newalloc, nodelist, 1, flag, &tempobj); + if (newESalloc) { + callexpr = CExpr_FuncCallSix( + cnar_func, + create_objectnode(tempobj), + ctor ? create_objectrefnode(ctor) : nullnode(), + dtor ? create_objectrefnode(dtor) : nullnode(), + intconstnode(sizetype, innertype->size), + etemp, + NULL + ); + result = CExpr_NewExceptionSafeInit(newESalloc, makediadicnode(create_objectnode(tempobj), callexpr, EASS)); + } else { + result = CExpr_FuncCallSix( + cnar_func, + newalloc, + ctor ? create_objectrefnode(ctor) : nullnode(), + dtor ? create_objectrefnode(dtor) : nullnode(), + intconstnode(sizetype, innertype->size), + etemp, + NULL + ); + } + + if (ass) + result = makecommaexpression(ass, result); + result->rtype = tptr; + result->flags |= (qual & ENODE_FLAG_QUALS); + return result; +} + +static ENode *CExpr_NewSimpleClass(TypeClass *tclass, ENode *expr, ENodeList *args) { + ENode *precomp; + ENode *nullcheck; + + precomp = lalloc(sizeof(ENode)); + *precomp = *expr; + precomp->type = EPRECOMP; + precomp->data.precompid = CParser_GetUniqueID(); + + nullcheck = lalloc(sizeof(ENode)); + *nullcheck = *expr; + nullcheck->type = ENULLCHECK; + nullcheck->cost = 4; + nullcheck->data.nullcheck.nullcheckexpr = expr; + nullcheck->data.nullcheck.condexpr = CExpr_ConstructObject(tclass, precomp, args, 0, 1, 1, 1, 1); + nullcheck->data.nullcheck.precompid = precomp->data.precompid; + return nullcheck; +} + +static ENode *CExpr_NewClass(TypeClass *tclass, ENode *expr, ENodeList *args1, ENodeList *args2, Boolean flag) { + Object *objptr; + ENode *newESalloc; + + if (!args2 && !flag && CABI_ConstructorCallsNew(tclass)) { + expr = nullnode(); + expr->rtype = CDecl_NewPointerType(TYPE(tclass)); + return CExpr_ConstructObject(tclass, expr, args1, 0, 1, 1, 1, 1); + } else { + newESalloc = CExpr_NewExceptionSafeAlloc(TYPE(tclass), expr, args2, 0, flag, &objptr); + if (newESalloc) { + return CExpr_NewExceptionSafeInit( + newESalloc, + CExpr_ConstructObject(tclass, create_objectnode(objptr), args1, 0, 1, 1, 1, 1)); + } else { + return CExpr_NewSimpleClass(tclass, expr, args1); + } + } +} + +ENode *scannew(Boolean flag) { + Type *type; // r27 + UInt32 qual; + ENodeList *args; // r28 + Boolean placement_flag; // r26 + ENodeList *newargs; // r26 + ENode *expr; // r26 + ENodeList *args2; // r29 + Object *tempobj; + ENode *newESalloc; // r28 + ENode *tempobj_expr; // r25 + ENode *etemp_expr; // r28 + ENode *indirect_expr; // r25 + ENode *ass; // r25 + ENode *cond; // r27 + + type = NULL; + args = NULL; + firstarrayexpr = NULL; + if ((tk = lex()) == '(') { + tk = lex(); + placement_flag = isdeclaration(1, 1, 1, ')'); + if (!placement_flag) + args = CExpr_ScanExpressionList(1); + if (placement_flag) + type = scan_type_name(&qual); + if (tk != ')') + CError_Error(CErrorStr115); + else + tk = lex(); + } + + if (!type) { + if (tk == '(') { + tk = lex(); + type = scan_type_name(&qual); + if (tk != ')') + CError_Error(CErrorStr115); + else + tk = lex(); + } else { + type = scan_new_type_name(&qual); + } + } + + if (IS_TYPE_ARRAY(type)) + return CExpr_NewArray(type, qual, args, flag); + + if (IS_TYPE_CLASS(type)) { + if (TYPE_CLASS(type)->sominfo) + return CSOM_New(TYPE_CLASS(type)); + if (TYPE_CLASS(type)->objcinfo) + return CObjC_New(TYPE_CLASS(type)); + } + + if (!IsCompleteType(type) || !CanAllocObject(type)) + return nullnode(); + + newargs = lalloc(sizeof(ENodeList)); + newargs->next = args; + newargs->node = intconstnode(CABI_GetSizeTType(), type->size); + + expr = CExpr_NewAlloc(type, newargs, flag, 0); + expr->rtype = CDecl_NewPointerType(type); + expr->flags |= (qual & ENODE_FLAG_QUALS); + + if (tk == '(') { + tk = lex(); + args2 = CExpr_ScanExpressionList(1); + if (!args2 && !IS_TYPE_CLASS(type)) { + args2 = lalloc(sizeof(ENodeList)); + memclrw(args2, sizeof(ENodeList)); + args2->node = do_typecast(nullnode(), type, 0); + } + if (tk == ')') + tk = lex(); + else + CError_Error(CErrorStr115); + } else { + args2 = NULL; + } + + if (ENODE_IS(expr, EINTCONST)) + return expr; + + if (IS_TYPE_CLASS(type) && CClass_Constructor(TYPE_CLASS(type))) + return CExpr_NewClass(TYPE_CLASS(type), expr, args2, args, flag); + + if (args2) { + if (args2->next) { + CError_Error(CErrorStr174); + return nullnode(); + } + + newESalloc = CExpr_NewExceptionSafeAlloc(type, expr, args, 0, flag, &tempobj); + if (newESalloc) { + tempobj_expr = makemonadicnode(create_objectnode(tempobj), EINDIRECT); + tempobj_expr->rtype = type; + tempobj_expr->flags = args2->node->flags & ENODE_FLAG_QUALS; + return CExpr_NewExceptionSafeInit( + newESalloc, + makediadicnode(tempobj_expr, CExpr_AssignmentPromotion(args2->node, type, newESalloc->flags, 1), EASS) + ); + } else { + etemp_expr = CExpr_GetETEMPCopy(expr); + indirect_expr = makemonadicnode(etemp_expr, EINDIRECT); + indirect_expr->rtype = type; + indirect_expr->flags = args2->node->flags & ENODE_FLAG_QUALS; + ass = makediadicnode(indirect_expr, CExpr_AssignmentPromotion(args2->node, type, indirect_expr->flags, 1), EASS); + cond = CExpr_NewENode(ECOND); + cond->cost = 4; + cond->rtype = &stvoid; + cond->data.cond.cond = expr; + cond->data.cond.expr1 = ass; + cond->data.cond.expr2 = nullnode(); + cond = makecommaexpression(cond, etemp_expr); + cond->rtype = etemp_expr->rtype; + cond->flags = etemp_expr->flags; + return cond; + } + } else { + return expr; + } +} + +static ENode *CExpr_DeleteArray(ENode *expr, Type *type, Boolean flag) { + Object *obj; + Object *dtor; + Boolean outflag; + ENode *precomp; + SInt32 precompid; + ENode *tmp; + ENode *result; + + obj = CParser_FindDeallocationObject(type, NULL, 1, flag, &outflag); + + if (!IS_TYPE_CLASS(type) || CClass_IsPODClass(TYPE_CLASS(type))) + return CExpr_DeleteFuncCall(obj, expr, type, outflag); + + dtor = CClass_Destructor(TYPE_CLASS(type)); + if (dtor || outflag) { + if (obj->nspace == cscope_root && !outflag) { + return funccallexpr(dnar_func, expr, dtor ? create_objectrefnode(dtor) : nullnode(), NULL, NULL); + } + return funccallexpr( + dnar3_func, + expr, + dtor ? create_objectrefnode(dtor) : nullnode(), + create_objectrefnode(obj), + intconstnode(TYPE(&stsignedshort), outflag)); + } + + precomp = lalloc(sizeof(ENode)); + *precomp = *expr; + precomp->type = EPRECOMP; + precomp->data.precompid = precompid = CParser_GetUniqueID(); + tmp = CExpr_DeleteFuncCall(obj, makediadicnode(precomp, intconstnode(CABI_GetSizeTType(), 16), ESUB), type, 0); + + result = CExpr_NewENode(ENULLCHECK); + result->rtype = &stvoid; + result->cost = 4; + result->data.nullcheck.nullcheckexpr = expr; + result->data.nullcheck.condexpr = tmp; + result->data.nullcheck.precompid = precompid; + + return result; +} + +ENode *scandelete(Boolean flag) { + Boolean is_array; // r24 + ENode *expr; // r25 + Type *conv_type; // r22 + UInt32 conv_qual; // r23 + Type *innertype; // r23 + Type *t; + Object *obj; + Object *dtor; // r24 + ENode *result_expr; // r24??? + ENode *precomp_orig; // r31 + SInt32 precompid; // r30 + Boolean is_virtual; // r23 + ENode *nc; + ConversionIterator iter; + Boolean outflag; + BClassList path; + + if ((tk = lex()) == '[') { + if ((tk = lex()) != ']') + CError_Error(CErrorStr125); + else + tk = lex(); + is_array = 1; + } else { + is_array = 0; + } + + expr = cast_expression(); + if (!IS_TYPE_POINTER_ONLY(expr->rtype)) { + if (IS_TYPE_CLASS(expr->rtype)) { + conv_type = NULL; + CExpr_ConversionIteratorInit(&iter, TYPE_CLASS(expr->rtype)); + while ((obj = CExpr_ConversionIteratorNext(&iter))) { + if (IS_TYPE_POINTER_ONLY(TYPE_FUNC(obj->type)->functype)) { + if (conv_type) { + CError_Error(CErrorStr199); + break; + } + conv_type = TYPE_FUNC(obj->type)->functype; + conv_qual = TYPE_FUNC(obj->type)->qual; + } + } + if (conv_type) { + if (!copts.old_argmatch) { + expr = CExpr_Convert(expr, conv_type, conv_qual, 1, 1); + } else { + if (user_assign_check(expr, conv_type, conv_qual, 1, 0, 1)) + expr = assign_node; + } + } + } + if (!IS_TYPE_POINTER_ONLY(expr->rtype)) { + CError_Error(CErrorStr146); + return nullnode(); + } + } + + innertype = TYPE_POINTER(expr->rtype)->target; + if (innertype->size == 0) + CDecl_CompleteType(innertype); + + if (IS_TYPE_ARRAY(innertype) && !is_array) + CError_Error(CErrorStr146); + + if (is_array) { + t = innertype; + while (IS_TYPE_ARRAY(t)) + t = TYPE_POINTER(t)->target; + return CExpr_DeleteArray(expr, t, flag); + } + + if (copts.objective_c && CObjC_IsType_id(expr->rtype)) + return CObjC_Delete(NULL, expr); + + if (!IS_TYPE_CLASS(innertype)) { + obj = CParser_FindDeallocationObject(innertype, NULL, 0, flag, &outflag); + CClass_CheckObjectAccess(NULL, obj); + return CExpr_DeleteFuncCall(obj, expr, innertype, outflag); + } + + if (TYPE_CLASS(innertype)->sominfo) + return CSOM_Delete(TYPE_CLASS(innertype), expr); + + if (TYPE_CLASS(innertype)->objcinfo) + return CObjC_Delete(TYPE_CLASS(innertype), expr); + + if (!(TYPE_CLASS(innertype)->flags & CLASS_FLAGS_2) && copts.pedantic) + CError_Warning(CErrorStr136, innertype, 0); + + obj = CParser_FindDeallocationObject(innertype, NULL, 0, flag, &outflag); + CClass_CheckObjectAccess(NULL, obj); + dtor = CClass_Destructor(TYPE_CLASS(innertype)); + if (!dtor) + return CExpr_DeleteFuncCall(obj, expr, innertype, outflag); + + path.next = NULL; + path.type = innertype; + CClass_CheckObjectAccess(&path, dtor); + + result_expr = lalloc(sizeof(ENode)); + result_expr->type = EFUNCCALL; + result_expr->cost = 4; + result_expr->flags = 0; + result_expr->rtype = &stvoid; + if (dtor->datatype == DVFUNC) { + precomp_orig = expr; + expr = lalloc(sizeof(ENode)); + *expr = *precomp_orig; + expr->type = EPRECOMP; + expr->data.precompid = precompid = CParser_GetUniqueID(); + is_virtual = 1; + } else { + is_virtual = 0; + } + + if (!flag) { + result_expr = CABI_DestroyObject(dtor, expr, 2, 0, 1); + } else { +#line 5650 + CError_ASSERT(!outflag); + result_expr = CABI_DestroyObject(dtor, expr, 2, 0, 0); + result_expr->rtype = TYPE(&void_ptr); + result_expr = funccallexpr(obj, result_expr, NULL, NULL, NULL); + obj->flags |= OBJECT_FLAGS_UNUSED; + } + + if (is_virtual) { + nc = lalloc(sizeof(ENode)); + nc->type = ENULLCHECK; + nc->rtype = &stvoid; + nc->cost = 4; + nc->flags = 0; + nc->data.nullcheck.nullcheckexpr = precomp_orig; + nc->data.nullcheck.condexpr = result_expr; + nc->data.nullcheck.precompid = precompid; + return nc; + } else { + return result_expr; + } +} diff --git a/compiler_and_linker/unsorted/CIRTransform.c b/compiler_and_linker/unsorted/CIRTransform.c new file mode 100644 index 0000000..e69de29 --- /dev/null +++ b/compiler_and_linker/unsorted/CIRTransform.c diff --git a/compiler_and_linker/unsorted/CInline.c b/compiler_and_linker/unsorted/CInline.c index bd2e46c..1f11b61 100644 --- a/compiler_and_linker/unsorted/CInline.c +++ b/compiler_and_linker/unsorted/CInline.c @@ -84,7 +84,7 @@ static void CInline_ForceReverseSearch(ENode *) {} static ENode *CInline_ForceReverseEvaluation(ENode *expr) {} static void CInline_ExportCheck(ENode *expr) {} static void CInline_Expand(Statement *stmt) {} -SInt32 CInline_GetStatementNumber(Statement *first, Statement *stmt) {} +SInt16 CInline_GetStatementNumber(Statement *first, Statement *stmt) {} static CI_Switch *CInline_PackSwitch(Statement *s1, Statement *s2) {} static Boolean CInline_CanInline(Object *obj, Statement *stmt) {} static ExceptionAction *CInline_PackActions(Statement *s1, Statement *s2) {} diff --git a/compiler_and_linker/unsorted/CMachine.c b/compiler_and_linker/unsorted/CMachine.c index fd4aafc..0c1ac0d 100644 --- a/compiler_and_linker/unsorted/CMachine.c +++ b/compiler_and_linker/unsorted/CMachine.c @@ -1337,7 +1337,7 @@ Boolean CMach_PassResultInHiddenArg(Type *type) { } } -const char *CMach_GetCPU() { +char *CMach_GetCPU() { switch (copts.cpu) { case CPU_PPC401: return "__PPC401__"; case CPU_PPC403: return "__PPC403__"; diff --git a/compiler_and_linker/unsorted/CObjC.c b/compiler_and_linker/unsorted/CObjC.c new file mode 100644 index 0000000..e69de29 --- /dev/null +++ b/compiler_and_linker/unsorted/CObjC.c diff --git a/compiler_and_linker/unsorted/CObjCModern.c b/compiler_and_linker/unsorted/CObjCModern.c new file mode 100644 index 0000000..e69de29 --- /dev/null +++ b/compiler_and_linker/unsorted/CObjCModern.c diff --git a/compiler_and_linker/unsorted/COptimizer.c b/compiler_and_linker/unsorted/COptimizer.c new file mode 100644 index 0000000..38b203f --- /dev/null +++ b/compiler_and_linker/unsorted/COptimizer.c @@ -0,0 +1,1781 @@ +#include "compiler/COptimizer.h" +#include "compiler/CompilerTools.h" +#include "compiler/CClass.h" +#include "compiler/CDecl.h" +#include "compiler/CError.h" +#include "compiler/CExpr.h" +#include "compiler/CFunc.h" +#include "compiler/CInt64.h" +#include "compiler/CMachine.h" +#include "compiler/CParser.h" +#include "compiler/InlineAsm.h" +#include "compiler/enode.h" +#include "compiler/objects.h" +#include "compiler/CodeGen.h" +#include "compiler/Switch.h" +#include "compiler/Exceptions.h" +#include "compiler/IrOptimizer.h" +#include "cos.h" + +COptBlock *basicblocks; +Boolean copt_isleaffunction; +static Boolean stmtchanged; +static COptBlock *currentblock; +static ENode *mexpr; +static short setbytes; +static COptCSE *csenodes[MAXEXPR]; +static COptCSEList *cselist; +static short extravars; +static Boolean cse_found; +static Boolean cse_invals; +static Boolean static_for_inlines; +static short replaces; +static ENode *objrefnode; +static int objrefnodes; + +static short bitmasks[] = { + 1, 2, 4, 8, 0x10, 0x20, 0x40, 0x80, + 0x100, 0x200, 0x400, 0x800, 0x1000, 0x2000, 0x4000, 0x8000 +}; + +// forward decls +static COptCSE *cse_expression(ENode *expr); + +static COptCSE *cse_new(ENode *expr) { + COptCSE *cse = oalloc(sizeof(COptCSE)); + cse->expr = expr; + cse->replaced = NULL; + cse->block = currentblock; + cse->mexpr = mexpr; + cse->left = NULL; + cse->right = NULL; + cse->x1C = 1; + return cse; +} + +static COptCSE *cse_append(COptCSE *cse, ENode *expr) { + COptCSEList *list = oalloc(sizeof(COptCSEList)); + list->next = cselist; + cselist = list; + list->cse = cse; + list->expr = expr; + return cse; +} + +static void cse_cleanup(void) { + COptCSEList *scanlist; + COptCSEList *prevlist; + COptCSE *scan; + COptCSE *prev; + short op; + + scanlist = cselist; + while (scanlist && !scanlist->cse) + scanlist = scanlist->next; + cselist = scanlist; + + if (scanlist) { + do { + prevlist = scanlist; + do { + scanlist = scanlist->next; + } while (scanlist && !scanlist->cse); + prevlist->next = scanlist; + } while (scanlist); + } + + for (op = 0; op < MAXEXPR; op++) { + scan = csenodes[op]; + while (scan && scan->x1C < 0) + scan = scan->next; + csenodes[op] = scan; + + if (scan) { + do { + prev = scan; + do { + scan = scan->next; + } while (scan && scan->x1C < 0); + prev->next = scan; + } while (scan); + } + } +} + +static void cse_inval(COptCSE *cse) { + COptCSEList *scanlist; + COptCSE *scan; + short op; + + if (cse) { + for (scanlist = cselist; scanlist; scanlist = scanlist->next) { + if (scanlist->cse == cse) { + scanlist->cse = NULL; + scanlist->expr = NULL; + } + } + + cse->x1C = -1; + cse->left = NULL; + cse->right = NULL; + + for (op = 0; op < MAXEXPR; op++) { + for (scan = csenodes[op]; scan; scan = scan->next) { + if (scan->left == cse || scan->right == cse) + cse_inval(scan); + } + } + } +} + +static void cse_update_usages(COptCSE *cse, short amount) { + cse->x1C /= amount; + if (cse->left) + cse_update_usages(cse->left, amount); + if (cse->right) + cse_update_usages(cse->right, amount); +} + +static void cse_replace(ENode *expr, COptCSE *cse) { + COptCSEList *list; + + for (list = cselist; list; list = list->next) { + if (list->cse == cse) { + *list->expr = *expr; + replaces++; + list->cse = NULL; + list->expr = NULL; + } + } +} + +static short cse_objectcost(Object *obj) { + if (obj->datatype == DLOCAL && !obj->u.var.info->noregister) + return 0; + return 1; +} + +static void cse_treereplacemexpr(COptCSE *cse, ENode *from, ENode *to) { + if (cse->mexpr == from) + cse->mexpr = to; + if (cse->left) + cse_treereplacemexpr(cse->left, from, to); + if (cse->right) + cse_treereplacemexpr(cse->right, from, to); +} + +static Boolean cse_issubcse(COptCSE *a, COptCSE *b) { + if (a == b) + return 1; + if (b->left && cse_issubcse(a, b->left)) + return 1; + if (b->right && cse_issubcse(a, b->right)) + return 1; + + return 0; +} + +static short cse_cost(COptCSE *cse) { + short cost; + + if (cse) { + while (ENODE_IS(cse->expr, ETYPCON) && cse->expr->rtype->type == cse->expr->data.monadic->rtype->type && cse->expr->rtype->size == cse->expr->data.monadic->rtype->size) + cse = cse->left; + + if (ENODE_IS_INDIRECT_TO(cse->expr, EOBJREF)) + return cse_objectcost(cse->expr->data.monadic->data.objref); + + cost = 1; + if (!copts.optimize_for_size) { + if (ENODE_IS3(cse->expr, EMUL, EDIV, EMODULO)) + cost = 2; + } + //cost = (!copts.optimize_for_size && ENODE_IS3(cse->expr, EMUL, EDIV, EMODULO)) ? 2 : 1; + return cse_cost(cse->left) + cse_cost(cse->right) + cost; + //return + // ((!copts.optimize_for_size && ENODE_IS3(cse->expr, EMUL, EDIV, EMODULO)) ? 2 : 1) + + // cse_cost(cse->left) + + // cse_cost(cse->right); + } + + return 0; +} + +static void cse_remove(void) { + short op; // r27 + COptCSE *cse; // r25 + COptCSE *best_cse; // r28 + int best_cost; // r30 + Object *obj; // r31 + Boolean did_replacement; // r24 + VarInfo *vi; // r27 + ObjectList *objlist; + ENode *expr1; + ENode *expr2; + ENode *expr3; + ENode *expr4; + ENode *mexprsave; + COptCSEList *list; + short cost; + + while (1) { + op = 0; + best_cse = NULL; + best_cost = 0; + did_replacement = 0; + + for (; op < MAXEXPR; op++) { + switch (op) { + case EINTCONST: + case EFLOATCONST: + case EOBJREF: + case EVECTOR128CONST: + break; + default: + for (cse = csenodes[op]; cse; cse = cse->next) { + if (cse->x1C > 1 && (cost = cse_cost(cse)) > 4) { + if (cse->replaced) { + replaces = 0; + cse_replace(cse->replaced, cse); +#line 348 + CError_ASSERT(replaces >= 1); + cse_found = 1; + did_replacement = 1; + cse_update_usages(cse, cse->x1C); + } else { + if ((cse->x1C * cost) > best_cost) { + best_cse = cse; + best_cost = cse->x1C * cost; + } + } + } + } + break; + } + } + + if (did_replacement) + continue; + if (!best_cse || extravars >= 256) + return; + + obj = lalloc(sizeof(Object)); + memclrw(obj, sizeof(Object)); + obj->name = CParser_GetUniqueName(); + obj->type = cse->expr->rtype; + obj->datatype = DLOCAL; + vi = CodeGen_GetNewVarInfo(); + obj->u.var.info = vi; + + objlist = lalloc(sizeof(ObjectList)); + objlist->object = obj; + objlist->next = locals; + locals = objlist; + + vi->used = 1; + vi->usage = cse->x1C + 1; + + expr1 = lalloc(sizeof(ENode)); + expr1->type = EOBJREF; + expr1->cost = 0; + expr1->flags = 0; + expr1->data.objref = obj; + expr1->rtype = CDecl_NewPointerType(obj->type); + + expr2 = lalloc(sizeof(ENode)); + expr2->type = EINDIRECT; + expr2->cost = 1; + expr2->flags = 0; + expr2->data.monadic = expr1; + expr2->rtype = obj->type; + + expr3 = lalloc(sizeof(ENode)); + expr3->type = EASS; + expr3->cost = -1; + expr3->flags = 0; + expr3->rtype = obj->type; + expr3->data.diadic.left = expr2; + expr3->data.diadic.right = lalloc(sizeof(ENode)); + + *expr3->data.diadic.right = *cse->expr; + cse->expr = expr3->data.diadic.right; + + replaces = 0; + cse_replace(expr2, cse); + cse->replaced = expr2; + + if (replaces < 2) { +#line 390 + CError_FATAL(); + } else { + cse_found = 1; + } + + expr4 = lalloc(sizeof(ENode)); + *expr4 = *cse->mexpr; + + cse->mexpr->type = ECOMMA; + cse->mexpr->data.diadic.left = expr3; + cse->mexpr->data.diadic.right = expr4; + + cse_update_usages(cse, cse->x1C); + extravars++; + + mexprsave = cse->mexpr; + if (mexpr == mexprsave) + mexpr = expr4; + + for (list = cselist; list; list = list->next) { + if (list->cse && !cse_issubcse(list->cse, cse)) { + if (list->cse->mexpr == mexprsave) + list->cse->mexpr = expr4; + if (list->cse->expr == mexprsave) + list->cse->expr = expr4; + if (list->expr == mexprsave) + list->expr = expr4; + } + } + } +} + +static COptCSE *cse_intconst(ENode *expr) { + COptCSE *cse = csenodes[EINTCONST]; + + for (; cse; cse = cse->next) { + if (expr->rtype == cse->expr->rtype) + if (CInt64_Equal(cse->expr->data.intval, expr->data.intval)) + return cse; + } + + cse = cse_new(expr); + cse->next = csenodes[EINTCONST]; + csenodes[EINTCONST] = cse; + return cse; +} + +static COptCSE *cse_floatconst(ENode *expr) { + COptCSE *cse = csenodes[EFLOATCONST]; + Float val = expr->data.floatval; + + for (; cse; cse = cse->next) { + if (CMach_CalcFloatDiadicBool(cse->expr->rtype, cse->expr->data.floatval, TK_LOGICAL_EQ, val)) + if (expr->rtype == cse->expr->rtype) + return cse; + } + + cse = cse_new(expr); + cse->next = csenodes[EFLOATCONST]; + csenodes[EFLOATCONST] = cse; + return cse; +} + +static COptCSE *cse_vectorconst(ENode *expr) { + COptCSE *cse = csenodes[EVECTOR128CONST]; + MWVector128 val = expr->data.vector128val; + + for (; cse; cse = cse->next) { + if (CMach_CalcVectorDiadicBool(cse->expr->rtype, &cse->expr->data.vector128val, TK_LOGICAL_EQ, &val)) + if (expr->rtype == cse->expr->rtype) + return cse; + } + + cse = cse_new(expr); + cse->next = csenodes[EVECTOR128CONST]; + csenodes[EVECTOR128CONST] = cse; + return cse; +} + +static COptCSE *cse_objref(ENode *expr) { + COptCSE *cse = csenodes[EOBJREF]; + Object *obj = expr->data.objref; + + for (; cse; cse = cse->next) { + if (cse->expr->data.objref == obj) + return cse; + } + + cse = cse_new(expr); + cse->next = csenodes[EOBJREF]; + csenodes[EOBJREF] = cse; + return cse; +} + +static COptCSE *cse_add_monadic_node(ENode *outer, COptCSE *innercse) { + COptCSE *cse; + + if (!innercse) + return NULL; + + for (cse = csenodes[outer->type]; cse; cse = cse->next) { + if (cse->left == innercse && cse->expr->rtype == outer->rtype) { +#line 524 + CError_ASSERT(cse->expr != outer); + cse->x1C++; + return cse; + } + } + + cse = cse_new(outer); + cse->next = csenodes[outer->type]; + csenodes[outer->type] = cse; + cse->left = innercse; + return cse; +} + +static COptCSE *cse_add_typecon_node(ENode *outer, COptCSE *innercse) { + COptCSE *cse; + + if (!innercse) + return NULL; + + for (cse = csenodes[outer->type]; cse; cse = cse->next) { + if (cse->left == innercse && cse->expr->rtype == outer->rtype) { +#line 552 + CError_ASSERT(cse->expr != outer); + cse->x1C++; + return cse; + } + } + + cse = cse_new(outer); + cse->next = csenodes[outer->type]; + csenodes[outer->type] = cse; + cse->left = innercse; + return cse; +} + +static COptCSE *cse_add_diadic_node(ENode *outer, COptCSE *leftcse, COptCSE *rightcse) { + COptCSE *cse; + + if (!leftcse || !rightcse) + return NULL; + + for (cse = csenodes[outer->type]; cse; cse = cse->next) { + if (cse->left == leftcse && cse->right == rightcse) { +#line 581 + CError_ASSERT(cse->expr != outer); + cse->x1C++; + return cse; + } + } + + cse = cse_new(outer); + cse->next = csenodes[outer->type]; + csenodes[outer->type] = cse; + cse->left = leftcse; + cse->right = rightcse; + return cse; +} + +static COptCSE *cse_add_commdiadic_node(ENode *outer, COptCSE *leftcse, COptCSE *rightcse) { + COptCSE *cse; + + if (!leftcse || !rightcse) + return NULL; + + for (cse = csenodes[outer->type]; cse; cse = cse->next) { + if ((cse->left == leftcse && cse->right == rightcse) || (cse->left == rightcse && cse->right == leftcse)) { +#line 612 + CError_ASSERT(cse->expr != outer); + cse->x1C++; + return cse; + } + } + + cse = cse_new(outer); + cse->next = csenodes[outer->type]; + csenodes[outer->type] = cse; + cse->left = leftcse; + cse->right = rightcse; + return cse; +} + +static void sfind_objref(ENode *expr) { + while (1) { + switch (expr->type) { + case ETYPCON: + expr = expr->data.monadic; + break; + case EOBJREF: + objrefnode = expr; + objrefnodes++; + return; + case EADD: + case ESUB: + sfind_objref(expr->data.diadic.left); + expr = expr->data.diadic.right; + break; + default: + return; + } + } +} + +static ENode *find_objref_node(ENode *expr) { + objrefnode = NULL; + objrefnodes = 0; + sfind_objref(expr); + if (objrefnodes == 1) + return objrefnode; + else + return NULL; +} + +static void cse_mem_modify(void) { + COptCSE *cse; + + for (cse = csenodes[EINDIRECT]; cse; cse = cse->next) { + if (ENODE_IS(cse->expr->data.monadic, EOBJREF)) { + Object *obj = cse->expr->data.monadic->data.objref; +#line 672 + CError_ASSERT(obj->datatype != DALIAS); + if (obj->datatype == DLOCAL && !obj->u.var.info->noregister) + continue; + } + + cse_inval(cse); + } +} + +static void cse_modify_expression(ENode *expr) { + if (!expr) { + short op; + + cse_remove(); + for (op = 0; op < MAXEXPR; op++) + csenodes[op] = NULL; + + cselist = NULL; + freeoheap(); + } else { + ENode *objnode; + Object *obj; + COptCSE *cse; + + cse_invals = 1; + if (ENODE_IS(expr, EINDIRECT) && (objnode = find_objref_node(expr->data.monadic))) { + do { + obj = objnode->data.objref; + cse_remove(); + for (cse = csenodes[EINDIRECT]; cse; cse = cse->next) { + if ((objnode = find_objref_node(cse->expr->data.monadic)) && obj == objnode->data.objref) + cse_inval(cse); + } + + objnode = find_objref_node(expr->data.monadic); + if (!objnode) { + cse_mem_modify(); + break; + } + } while (obj != objnode->data.objref); + } else { + cse_remove(); + cse_mem_modify(); + } + } +} + +static void cse_pascalcall(ENode *expr) { + ENodeList *list; + + for (list = expr->data.funccall.args; list; list = list->next) + cse_expression(list->node); + + if (ENODE_IS(expr, EFUNCCALLP)) + cse_expression(expr->data.funccall.funcref); + + cse_remove(); + cse_mem_modify(); +} + +static Boolean cse_pusharg(ENodeList *exprs, FuncArg *args) { + Boolean result; + + if (!exprs) + return 1; + + if (args && args != &elipsis && args != &oldstyle) + args = args->next; + if (exprs->next) + result = cse_pusharg(exprs->next, args); + + cse_expression(exprs->node); + return result; +} + +static void cse_ccall(ENode *expr) { + if (cse_pusharg(expr->data.funccall.args, expr->data.funccall.functype->args)) { + if (ENODE_IS(expr, EFUNCCALL)) + cse_expression(expr->data.funccall.funcref); + + cse_remove(); + cse_mem_modify(); + } else { + cse_modify_expression(NULL); + } +} + +static COptCSE *cse_expression(ENode *expr) { + ENode *save; + COptCSE *tmp; + ENodeType nt = expr->type; + + switch (nt) { + case EFUNCCALL: + cse_ccall(expr); + return NULL; + case EFUNCCALLP: + cse_pascalcall(expr); + return NULL; + case EPOSTINC: + case EPOSTDEC: + case EPREINC: + case EPREDEC: + save = mexpr; + mexpr = expr; +#line 816 + CError_ASSERT(ENODE_IS(expr->data.monadic, EINDIRECT)); + + cse_expression(expr->data.monadic->data.monadic); + cse_modify_expression(expr->data.monadic); + mexpr = save; + return NULL; + + case EINDIRECT: + case EMONMIN: + case EBINNOT: + case ELOGNOT: + case EFORCELOAD: + return cse_append(cse_add_monadic_node(expr, cse_expression(expr->data.monadic)), expr); + + case ETYPCON: + return cse_append(cse_add_typecon_node(expr, cse_expression(expr->data.monadic)), expr); + + case EMUL: + case EMULV: + case EADDV: + case EADD: + case EEQU: + case ENOTEQU: + case EAND: + case EXOR: + case EOR: + tmp = cse_expression(expr->data.diadic.left); + if (expr->type == nt) + return cse_append(cse_add_commdiadic_node(expr, tmp, cse_expression(expr->data.diadic.right)), expr); + else + return NULL; + + case EDIV: + case EMODULO: + case ESUBV: + case ESUB: + case ESHL: + case ESHR: + case ELESS: + case EGREATER: + case ELESSEQU: + case EGREATEREQU: + case EPMODULO: + case EROTL: + case EROTR: + case EBTST: + tmp = cse_expression(expr->data.diadic.left); + if (expr->type == nt) + return cse_append(cse_add_diadic_node(expr, tmp, cse_expression(expr->data.diadic.right)), expr); + else + return NULL; + + case EASS: + case EMULASS: + case EDIVASS: + case EMODASS: + case EADDASS: + case ESUBASS: + case ESHLASS: + case ESHRASS: + case EANDASS: + case EXORASS: + case EORASS: +#line 887 + CError_ASSERT(ENODE_IS(expr->data.diadic.left, EINDIRECT)); + save = mexpr; + mexpr = expr; + cse_expression(expr->data.diadic.right); + if (expr->type == nt) { + cse_expression(expr->data.diadic.left->data.monadic); + cse_modify_expression(expr->data.diadic.left); + mexpr = save; + return NULL; + } else { + cse_modify_expression(NULL); + return NULL; + } + + case ECOMMA: + cse_expression(expr->data.diadic.left); + save = mexpr; + mexpr = expr->data.diadic.right; + tmp = cse_expression(expr->data.diadic.right); + mexpr = save; + return tmp; + + case EINTCONST: + return cse_intconst(expr); + case EFLOATCONST: + return cse_floatconst(expr); + case EVECTOR128CONST: + return cse_vectorconst(expr); + case EOBJREF: + return cse_objref(expr); + + case EBITFIELD: + cse_modify_expression(NULL); + return NULL; + + case ECOND: + cse_expression(expr->data.cond.cond); + cse_modify_expression(NULL); + return NULL; + + case ENULLCHECK: + cse_expression(expr->data.nullcheck.nullcheckexpr); + cse_modify_expression(NULL); + return NULL; + + case ELAND: + case ELOR: + cse_expression(expr->data.diadic.left); + cse_modify_expression(NULL); + return NULL; + + case ESTRINGCONST: + case ELABEL: + return NULL; + + case EPRECOMP: +#line 948 + CError_FATAL(); + + default: +#line 951 + CError_FATAL(); + return NULL; + } +} + +static void cse_block(COptBlock *block) { + Statement *stmt; + COptBlock *check; + COptBlockList *scan; + COptBlock *best; + short i; + SInt32 counter; + UInt32 starttime; + + starttime = COS_GetTicks(); + counter = 0; + + while (1) { + cse_invals = 0; + currentblock = block; + block->x1E = 1; + + for (stmt = block->stmt, i = block->x1C; i > 0; stmt = stmt->next, i--) { + switch (stmt->type) { + case ST_EXPRESSION: + case ST_SWITCH: + case ST_IFGOTO: + case ST_IFNGOTO: + mexpr = stmt->expr; + cse_expression(mexpr); + break; + case ST_RETURN: + mexpr = stmt->expr; + if (mexpr) + cse_expression(mexpr); + break; + } + } + + i = 0; + for (scan = block->blocks2; scan; scan = scan->next) { + check = scan->block; + if (!check->x1E && check->blocks && !check->blocks->next && check->blocks->block == block) { + best = check; + i++; + } + } + + if (i != 1) + break; + + block = best; + if (COS_GetTicks() > (starttime + 60)) { + if (counter++ & 1) { + if (CWDisplayLines(cparamblkptr->context, lines)) + CError_UserBreak(); + } else { + if (CWDisplayLines(cparamblkptr->context, lines + 1)) + CError_UserBreak(); + } + starttime = COS_GetTicks(); + } + + if (cse_invals) + cse_cleanup(); + } + + cse_remove(); +} + +static void CSE(void) { + COptBlock *block; + + for (block = basicblocks->next; block; block = block->next) + block->x1E = 0; + + for (block = basicblocks->next; block; block = block->next) { + if (!block->x1E) { + short op; + + for (op = 0; op < MAXEXPR; op++) + csenodes[op] = NULL; + + cselist = NULL; + cse_found = 0; + cse_block(block); + freeoheap(); + } + } +} + +static short TestSetBit(short *set, short bit) { + return set[bit >> 4] & bitmasks[bit & 15]; +} + +static void SetSetBit(short *set, short bit) { + set[bit >> 4] |= bitmasks[bit & 15]; +} + +UInt32 RegAllocMask(short var) { + COptBlock *block; + UInt32 mask = 0; + + for (block = basicblocks; block; block = block->next) { + if (TestSetBit(block->set1, var) || TestSetBit(block->set2, var)) + mask |= block->allocmask; + } + + return mask; +} + +void MarkRegAllocMask(short var, short bit, Boolean flag) { + COptBlock *block; + UInt32 mask = 1 << bit; + + if (flag) { + for (block = basicblocks; block; block = block->next) { + if (TestSetBit(block->set1, var) || TestSetBit(block->set2, var)) + block->allocmask |= mask; + } + } else { + for (block = basicblocks; block; block = block->next) { + block->allocmask |= mask; + } + } +} + +static COptBlock *newblock(void) { + COptBlock *block; + short i; + short max; + + block = lalloc(sizeof(COptBlock) + (setbytes * 2)); + block->x1E = 0; + block->next = NULL; + block->blocks = NULL; + block->blocks2 = NULL; + block->allocmask = 0; + block->set1 = (short *) (((long) block) + sizeof(COptBlock)); + block->set2 = (short *) (((long) block) + setbytes + sizeof(COptBlock)); + + for (i = 0, max = setbytes / 2; i < max; i++) { + block->set1[i] = 0; + block->set2[i] = 0; + } +} + +static void MarkFollow(COptBlock *block) { + COptBlockList *list; + +restart: + block->x1E = 1; + if ((list = block->blocks2)) { + while (1) { + if (!list->block->x1E) { + if (!list->next) { + block = list->block; + goto restart; + } + MarkFollow(list->block); + list = list->next; + } else { + list = list->next; + if (!list) + break; + } + } + } +} + +static Boolean CheckInit(short var) { + Boolean result; + COptBlock *block; + + result = 1; + for (block = basicblocks; block; block = block->next) { + if (!block->x1E && TestSetBit(block->set2, var)) + MarkFollow(block); + } + + for (block = basicblocks; block; block = block->next) { + if (!block->x1E) { + if (TestSetBit(block->set1, var)) + result = 0; + } else { + block->x1E = 0; + } + } + + return result; +} + +static void CheckVarInit(void) { + COptBlock *block; + VarInfo *vi; + ObjectList *list; + + for (block = basicblocks; block; block = block->next) + block->x1E = 0; + + for (list = locals; list; list = list->next) { + if (list->object->datatype == DLOCAL && !IsTempName(list->object->name) && !is_volatile_object(list->object)) { + vi = list->object->u.var.info; + if (vi->used && !CheckInit(vi->varnumber)) { + if (!IS_TYPE_CLASS(list->object->type) || !CClass_IsEmpty(TYPE_CLASS(list->object->type))) { + CError_SetErrorToken(&vi->deftoken); + CError_Warning(CErrorStr185, list->object->name->name); + } + } + } + } +} + +static void AddVar(Object *obj, Boolean whichSet) { + VarInfo *vi; + + if (obj->datatype == DLOCAL) { + vi = obj->u.var.info; + if (!whichSet) { + SetSetBit(currentblock->set1, vi->varnumber); + } else { + if (!TestSetBit(currentblock->set1, vi->varnumber)) + SetSetBit(currentblock->set2, vi->varnumber); + } + } +} + +static void CheckExpr(ENode *expr) { + ENodeList *list; + + while (1) { + switch (expr->type) { + case EINDIRECT: + if (ENODE_IS(expr->data.monadic, EOBJREF)) { + AddVar(expr->data.monadic->data.objref, 0); + return; + } + expr = expr->data.monadic; + break; + case EOBJREF: + AddVar(expr->data.objref, 1); + return; + case EFUNCCALL: + case EFUNCCALLP: + CheckExpr(expr->data.funccall.funcref); + for (list = expr->data.funccall.args; list; list = list->next) + CheckExpr(list->node); + return; + case ECOND: + CheckExpr(expr->data.cond.cond); + CheckExpr(expr->data.cond.expr1); + CheckExpr(expr->data.cond.expr2); + return; + case EASS: + if (ENODE_IS_INDIRECT_TO(expr->data.diadic.left, EOBJREF)) { + CheckExpr(expr->data.diadic.right); + AddVar(expr->data.diadic.left->data.monadic->data.objref, 1); + return; + } + case EMUL: + case EMULV: + case EDIV: + case EMODULO: + case EADDV: + case ESUBV: + case EADD: + case ESUB: + case ESHL: + case ESHR: + case ELESS: + case EGREATER: + case ELESSEQU: + case EGREATEREQU: + case EEQU: + case ENOTEQU: + case EAND: + case EXOR: + case EOR: + case ELAND: + case ELOR: + case EMULASS: + case EDIVASS: + case EMODASS: + case EADDASS: + case ESUBASS: + case ESHLASS: + case ESHRASS: + case EANDASS: + case EXORASS: + case EORASS: + case ECOMMA: + case EPMODULO: + case EROTL: + case EROTR: + case EBCLR: + case EBTST: + case EBSET: + CheckExpr(expr->data.diadic.left); + expr = expr->data.diadic.right; + break; + case EPOSTINC: + case EPOSTDEC: + case EPREINC: + case EPREDEC: + case EMONMIN: + case EBINNOT: + case ELOGNOT: + case EFORCELOAD: + case ETYPCON: + case EBITFIELD: + expr = expr->data.monadic; + break; + case ENULLCHECK: + CheckExpr(expr->data.nullcheck.nullcheckexpr); + expr = expr->data.nullcheck.condexpr; + break; + case EINTCONST: + case EFLOATCONST: + case ESTRINGCONST: + case EPRECOMP: + case ELABEL: + case EVECTOR128CONST: + return; + default: +#line 1332 + CError_FATAL(); + } + } +} + +static short CheckPath(COptBlock *block, short var) { + COptBlockList *list; + + if (block->x1E) + return TestSetBit(block->set1, var); + + block->x1E = 1; + if (TestSetBit(block->set1, var)) + return -1; + if (TestSetBit(block->set2, var)) + return 0; + + for (list = block->blocks2; list; list = list->next) { + if (CheckPath(list->block, var)) { + SetSetBit(block->set1, var); + return -1; + } + } + + return 0; +} + +static void MarkPre(COptBlock *block, short var) { + COptBlockList *list; + +restart: + block->x1E = 1; + for (list = block->blocks; list; list = list->next) { + if (!list->block->x1E) { + if (!TestSetBit(list->block->set2, var)) { + SetSetBit(list->block->set1, var); + if (!list->next) { + block = list->block; + goto restart; + } + MarkPre(list->block, var); + } else { + list->block->x1E = 1; + } + } + } +} + +static void CheckVarUsage(void) { + short local; + COptBlock *block; + short counter; + + for (currentblock = basicblocks; currentblock; currentblock = currentblock->next) { + Statement *stmt = currentblock->stmt; + if (currentblock->x1C > 0 && stmt->type == ST_LABEL && (stmt->flags & StmtFlag_1)) { + short i; + for (i = 0; i < localcount; i++) + SetSetBit(currentblock->set2, i); + } + + for (counter = currentblock->x1C; counter > 0; counter--) { + if (stmt->type >= ST_EXPRESSION && stmt->type <= ST_GOTOEXPR && stmt->expr) + CheckExpr(stmt->expr); + stmt = stmt->next; + } + } + + for (local = 0; local < localcount; local++) { + for (block = basicblocks; block; block = block->next) { + if (!block->x1E && TestSetBit(block->set1, local)) + MarkPre(block, local); + } + for (block = basicblocks; block; block = block->next) { + block->x1E = 0; + } + } +} + +static void SplitCommaExpressions(void) { + COptBlock *block; + Statement *stmt; + ENode *expr; + Statement *stmtcopy; + short counter; + Boolean flag; + + block = basicblocks->next; + while (block) { + stmt = block->stmt; + counter = block->x1C; + flag = 1; + while (counter > 0) { + if (stmt->type >= ST_EXPRESSION && stmt->type <= ST_GOTOEXPR) { + if ((expr = stmt->expr) && ENODE_IS(expr, ECOMMA)) { + stmtcopy = lalloc(sizeof(Statement)); + *stmtcopy = *stmt; + stmt->next = stmtcopy; + stmt->type = ST_EXPRESSION; + stmt->expr = expr->data.diadic.left; + stmtcopy->expr = expr->data.diadic.right; + block->x1C++; + flag = 0; + break; + } + } + + stmt = stmt->next; + counter--; + } + + if (flag) + block = block->next; + } +} + +static void BasicBlockAnalyze(Statement *stmt) { + COptBlock *block; + ObjectList *objlist; + COptBlockList *scan; + COptBlockList *list; + CLabel *label; + COptBlock *iblock; + COptBlock *oblock; + SwitchCase *swcase; + + setbytes = 2 * ((localcount - 1) / 16) + 2; + if (copts.global_optimizer) { + setbytes += 32; + extravars = 0; + } + + block = newblock(); + basicblocks = block; + block->stmt = NULL; + block->x1C = 0; + + if (stmt) { + list = lalloc(sizeof(COptBlockList)); + list->next = NULL; + block->blocks2 = list; + list->block = (COptBlock *) stmt; + } + + for (objlist = arguments; objlist; objlist = objlist->next) { + SetSetBit(block->set2, objlist->object->u.var.info->varnumber); + } + + while (stmt) { + int counter; + + block->next = newblock(); + block = block->next; + block->stmt = stmt; + counter = 1; + + innerLoop: + switch (stmt->type) { + case ST_ASM: + label = InlineAsm_GetReferencedLabel(stmt); + if (!label) + goto jumpahead; + list = lalloc(sizeof(COptBlockList)); + list->next = block->blocks2; + block->blocks2 = list; + list->block = (COptBlock *) label->stmt; + if (stmt->next) { + list = lalloc(sizeof(COptBlockList)); + list->next = block->blocks2; + block->blocks2 = list; + list->block = (COptBlock *) stmt->next; + } + stmt = stmt->next; + block->x1C = counter; + continue; + case ST_NOP: + case ST_GOTO: + case ST_ENTRY: + if (stmt->next && stmt->next->type != ST_LABEL) { + stmt = stmt->next; + counter++; + goto innerLoop; + } + break; + case ST_EXPRESSION: + case ST_BEGINCATCH: + case ST_ENDCATCH: + case ST_ENDCATCHDTOR: + jumpahead: + if (stmt->next && stmt->next->type == ST_GOTO) { + stmt = stmt->next; + counter++; + goto innerLoop; + } + break; + } + + switch (stmt->type) { + case ST_SWITCH: + label = ((SwitchInfo *) stmt->label)->defaultlabel; + if (label != cleanreturnlabel) { + list = lalloc(sizeof(COptBlockList)); + list->next = block->blocks2; + block->blocks2 = list; + list->block = (COptBlock *) label->stmt; + } + for (swcase = ((SwitchInfo *) stmt->label)->cases; swcase; swcase = swcase->next) { + label = swcase->label; + if (label != cleanreturnlabel) { + list = lalloc(sizeof(COptBlockList)); + list->next = block->blocks2; + block->blocks2 = list; + list->block = (COptBlock *) label->stmt; + } + } + break; + case ST_RETURN: + case ST_EXIT: + case ST_GOTOEXPR: + break; + case ST_GOTO: + case ST_IFGOTO: + case ST_IFNGOTO: + case ST_OVF: + label = stmt->label; + if (label != cleanreturnlabel) { + list = lalloc(sizeof(COptBlockList)); + list->next = block->blocks2; + block->blocks2 = list; + list->block = (COptBlock *) label->stmt; + } + if (stmt->type == ST_GOTO) + break; + default: + if (stmt->next) { + list = lalloc(sizeof(COptBlockList)); + list->next = block->blocks2; + block->blocks2 = list; + list->block = (COptBlock *) stmt->next; + } + break; + } + + stmt = stmt->next; + block->x1C = counter; + } + + for (oblock = basicblocks; oblock; oblock = oblock->next) { + for (scan = oblock->blocks2; scan; scan = scan->next) { + stmt = (Statement *) scan->block; + for (iblock = basicblocks->next; iblock; iblock = iblock->next) { + if (iblock->stmt == stmt) { + scan->block = iblock; + list = lalloc(sizeof(COptBlockList)); + list->next = iblock->blocks; + iblock->blocks = list; + list->block = oblock; + break; + } + } + +#line 1602 + CError_ASSERT(iblock); + } + } + + SplitCommaExpressions(); + CheckVarUsage(); +} + +static CLabel *finallabel(CLabel *label, Statement *stmt) { + Statement *scan; + + for (scan = label->stmt; scan; scan = scan->next) { + if (scan->type > ST_LABEL) { + if (scan == stmt) + return label; + if (scan->type == ST_GOTO) { + if (scan->label != label) + stmtchanged = 1; + return scan->label; + } + return label; + } + } +} + +static void optimizegoto(Statement *stmt) { + Statement *scan; + + for (scan = stmt->next; scan; scan = scan->next) { + if (stmt->label->stmt == scan) { + stmt->type = ST_NOP; + stmtchanged = 1; + return; + } + if (scan->type > ST_LABEL) + break; + } + + stmt->label = finallabel(stmt->label, stmt); +} + +static void removeif(Statement *stmt, Boolean flag) { + if (((stmt->type == ST_IFGOTO) && flag) || ((stmt->type == ST_IFNGOTO) && !flag)) { + Statement *copy = lalloc(sizeof(Statement)); + *copy = *stmt; + copy->type = ST_GOTO; + stmt->next = copy; + } + stmt->type = ST_EXPRESSION; + stmtchanged = 1; +} + +static void optimizeif(Statement *stmt) { +} + +static void optimizeswitch(Statement *stmt) { + SwitchInfo *info; + SwitchCase *swcase; + + info = (SwitchInfo *) stmt->label; +#line 1746 + CError_ASSERT(info && info->cases && info->defaultlabel); + + info->defaultlabel = finallabel(info->defaultlabel, stmt); + for (swcase = info->cases; swcase; swcase = swcase->next) + swcase->label = finallabel(swcase->label, stmt); + + if (ENODE_IS(stmt->expr, EINTCONST)) { + for (swcase = info->cases; swcase; swcase = swcase->next) { + if (CInt64_GreaterEqual(swcase->min, stmt->expr->data.intval) && CInt64_LessEqual(swcase->max, stmt->expr->data.intval)) + break; + } + + stmt->type = ST_GOTO; + stmt->label = swcase ? swcase->label : info->defaultlabel; + } +} + +static void removeunusedlabels(Statement *stmt) { + Statement *scan; + CLabel *label; + SwitchCase *swcase; + ExceptionAction *action; + + for (scan = stmt; scan; scan = scan->next) + scan->marked = 0; + + for (scan = stmt; scan; scan = scan->next) { + switch (scan->type) { + case ST_GOTO: + case ST_IFGOTO: + case ST_IFNGOTO: + case ST_OVF: + if (scan->label->stmt) + scan->label->stmt->marked = 1; + break; + case ST_SWITCH: + ((SwitchInfo *) scan->label)->defaultlabel->stmt->marked = 1; + for (swcase = ((SwitchInfo *) scan->label)->cases; swcase; swcase = swcase->next) + swcase->label->stmt->marked = 1; + break; + case ST_ASM: + if ((label = InlineAsm_GetReferencedLabel(scan))) + label->stmt->marked = 1; + if ((label = InlineAsm_GetReferencedLabel2(scan))) + label->stmt->marked = 1; + break; + case ST_BEGINLOOP: + ((LoopInfo *) scan->expr)->stmt->marked = 1; + break; + case ST_ENDLOOP: + if (scan->next->type == ST_GOTO && scan->next->next->type == ST_LABEL) + scan->next->next->marked = 1; + break; + default: + for (action = scan->dobjstack; action; action = action->prev) { + if (action->type == EAT_CATCHBLOCK) { + action->data.catch_block.catch_label->stmt->marked = 1; + action->data.catch_block.catch_label->stmt->flags |= StmtFlag_1; + } else if (action->type == EAT_SPECIFICATION) { + action->data.specification.unexp_label->stmt->marked = 1; + action->data.specification.unexp_label->stmt->flags |= StmtFlag_1; + } + } + } + } + + for (scan = stmt; scan; scan = scan->next) { + if (scan->type == ST_LABEL && !scan->marked && !(scan->flags & StmtFlag_1)) { + scan->type = ST_NOP; + stmtchanged = 1; + } + } +} + +static void optimizebranches(Statement *stmt) { + removeunusedlabels(stmt); + while (stmt) { + switch (stmt->type) { + case ST_GOTO: + optimizegoto(stmt); + break; + case ST_IFGOTO: + case ST_IFNGOTO: + optimizeif(stmt); + break; + case ST_SWITCH: + optimizeswitch(stmt); + break; + } + stmt = stmt->next; + } +} + +void SetVarUsage(Object *obj, Boolean noregister) { + VarInfo *vi; +#line 1875 + CError_ASSERT(obj->datatype != DALIAS); + + if (obj->datatype == DLOCAL || obj->datatype == DNONLAZYPTR) { + vi = obj->u.var.info; + vi->used = 1; + if (!copts.global_optimizer) { + if (copts.optimize_for_size) + vi->usage++; + else + vi->usage += curstmtvalue; + } + + if (noregister) + vi->noregister = 1; + } +} + +static void checkexpression(ENode *expr) { + ENodeList *list; + + while (1) { + switch (expr->type) { + case EOBJREF: + SetVarUsage(expr->data.objref, 1); + return; + case EINDIRECT: + if (ENODE_IS(expr->data.monadic, EOBJREF)) { + SetVarUsage(expr->data.monadic->data.objref, 0); + return; + } + expr = expr->data.monadic; + break; + case EFUNCCALL: + case EFUNCCALLP: + copt_isleaffunction = 0; + checkexpression(expr->data.funccall.funcref); + for (list = expr->data.funccall.args; list; list = list->next) + checkexpression(list->node); + return; + case ECOND: + case ECONDASS: + checkexpression(expr->data.cond.cond); + checkexpression(expr->data.cond.expr1); + checkexpression(expr->data.cond.expr2); + return; + case EMUL: + case EMULV: + case EDIV: + case EMODULO: + case EADDV: + case ESUBV: + case EADD: + case ESUB: + case ESHL: + case ESHR: + case ELESS: + case EGREATER: + case ELESSEQU: + case EGREATEREQU: + case EEQU: + case ENOTEQU: + case EAND: + case EXOR: + case EOR: + case ELAND: + case ELOR: + case EASS: + case EMULASS: + case EDIVASS: + case EMODASS: + case EADDASS: + case ESUBASS: + case ESHLASS: + case ESHRASS: + case EANDASS: + case EXORASS: + case EORASS: + case ECOMMA: + case EPMODULO: + case EROTL: + case EROTR: + case EBCLR: + case EBTST: + case EBSET: + checkexpression(expr->data.diadic.left); + expr = expr->data.diadic.right; + break; + case EPOSTINC: + case EPOSTDEC: + case EPREINC: + case EPREDEC: + case EMONMIN: + case EBINNOT: + case ELOGNOT: + case EFORCELOAD: + case ETYPCON: + case EBITFIELD: + expr = expr->data.monadic; + break; + case ENULLCHECK: + checkexpression(expr->data.nullcheck.nullcheckexpr); + expr = expr->data.nullcheck.condexpr; + break; + case EINTCONST: + case EFLOATCONST: + case EPRECOMP: + case ELABEL: + case EVECTOR128CONST: + return; + case ESTRINGCONST: + return; + default: +#line 1998 + CError_FATAL(); + } + } +} + +static void checklocalusage(Statement *stmt) { + Statement *scan; + + for (scan = stmt; scan; scan = scan->next) { + if (scan->type >= ST_EXPRESSION && scan->type <= ST_GOTOEXPR && scan->expr) { + curstmtvalue = scan->value; + checkexpression(scan->expr); + } else if (scan->type == ST_ASM) { + curstmtvalue = scan->value; + InlineAsm_CheckLocalUsage(scan); + } + } +} + +static void colorcode(Statement *stmt) { + CLabel *label; + SwitchCase *swcase; + + while (stmt && !stmt->marked) { + stmt->marked = 1; + switch (stmt->type) { + case ST_GOTOEXPR: + return; + case ST_IFGOTO: + case ST_IFNGOTO: + case ST_OVF: + colorcode(stmt->label->stmt); + break; + case ST_GOTO: + case ST_EXIT: + stmt = stmt->label->stmt; + continue; + case ST_RETURN: + return; + case ST_SWITCH: + for (swcase = ((SwitchInfo *) stmt->label)->cases; swcase; swcase = swcase->next) + colorcode(swcase->label->stmt); + stmt = ((SwitchInfo *) stmt->label)->defaultlabel->stmt; + continue; + case ST_ASM: + if ((label = InlineAsm_GetReferencedLabel(stmt))) + colorcode(label->stmt); + if ((label = InlineAsm_GetReferencedLabel2(stmt))) + colorcode(label->stmt); + break; + case ST_ENDLOOP: + if (stmt->next && stmt->next->type == ST_GOTO) { + stmt = stmt->next; + stmt->marked = 1; + } + break; + case ST_NOP: + case ST_LABEL: + case ST_EXPRESSION: + case ST_ENTRY: + case ST_BEGINCATCH: + case ST_ENDCATCH: + case ST_ENDCATCHDTOR: + case ST_BEGINLOOP: + break; + default: +#line 2096 + CError_FATAL(); + } + stmt = stmt->next; + } +} + +static void removeunusedcode(Statement *stmt) { + Statement *scan; + + for (scan = stmt; scan; scan = scan->next) + scan->marked = 0; + + colorcode(stmt); + for (scan = stmt; scan; scan = scan->next) { + if (!scan->marked && (scan->flags & StmtFlag_1)) + colorcode(scan); + } + + for (scan = stmt; scan; scan = scan->next) { + if (!scan->marked && scan->type != ST_NOP) { + scan->type = ST_NOP; + stmtchanged = 1; + } + } +} + +static void COpt_ReturnCheck(Object *obj, Statement *stmt) { + if ((copts.pedantic || copts.cplusplus) && obj && TYPE_FUNC(obj->type)->functype != &stvoid) { + while (stmt) { + if (!stmt->next && stmt->type != ST_GOTO && stmt->type != ST_RETURN) { + CError_Warning(CErrorStr184); + break; + } + + if (stmt->type == ST_RETURN && !stmt->expr && !(stmt->flags & StmtFlag_8)) { + CError_Warning(CErrorStr184); + break; + } + + stmt = stmt->next; + } + } +} + +static void COpt_Optimize(Object *obj, Statement *stmt) { + Statement **ptr; + + do { + stmtchanged = 0; + optimizebranches(stmt->next); + removeunusedcode(stmt->next); + } while (stmtchanged); + + ptr = &stmt->next; + while (*ptr) { + if ((*ptr)->type == ST_NOP) + *ptr = (*ptr)->next; + else + ptr = &(*ptr)->next; + } +} + +static void COpt_ELABELCallBack(ENode *expr) { +#line 2195 + CError_ASSERT(expr->data.label->stmt && expr->data.label->stmt->type == ST_LABEL); + expr->data.label->stmt->flags |= StmtFlag_1; +} + +void COpt_SimpleOptimizer(Object *obj, Statement *stmt) { + Statement *scan; + + for (scan = stmt; scan; scan = scan->next) { + if ((scan->type >= ST_EXPRESSION && scan->type <= ST_GOTOEXPR) && scan->expr) + CExpr_SearchExprTree(scan->expr, COpt_ELABELCallBack, 1, ELABEL); + } + + static_for_inlines = 1; + cleanreturnlabel = NULL; + COpt_Optimize(obj, stmt); + COpt_ReturnCheck(obj, stmt); +} + +Statement *COpt_Optimizer(Object *obj, Statement *stmt) { + copt_isleaffunction = 1; + if (copts.global_optimizer) + stmt = IRO_Optimizer(obj, stmt); + + static_for_inlines = 0; + COpt_Optimize(obj, stmt); + + if (obj && !(obj->qual & Q_INLINE)) + COpt_ReturnCheck(obj, stmt); + + checklocalusage(stmt->next); + return stmt; +} diff --git a/compiler_and_linker/unsorted/CPreprocess.c b/compiler_and_linker/unsorted/CPreprocess.c new file mode 100644 index 0000000..e69de29 --- /dev/null +++ b/compiler_and_linker/unsorted/CPreprocess.c diff --git a/compiler_and_linker/unsorted/CRTTI.c b/compiler_and_linker/unsorted/CRTTI.c new file mode 100644 index 0000000..e69de29 --- /dev/null +++ b/compiler_and_linker/unsorted/CRTTI.c diff --git a/compiler_and_linker/unsorted/CSOM.c b/compiler_and_linker/unsorted/CSOM.c new file mode 100644 index 0000000..e69de29 --- /dev/null +++ b/compiler_and_linker/unsorted/CSOM.c diff --git a/compiler_and_linker/unsorted/CTemplateClass.c b/compiler_and_linker/unsorted/CTemplateClass.c new file mode 100644 index 0000000..e69de29 --- /dev/null +++ b/compiler_and_linker/unsorted/CTemplateClass.c diff --git a/compiler_and_linker/unsorted/CTemplateFunc.c b/compiler_and_linker/unsorted/CTemplateFunc.c new file mode 100644 index 0000000..e69de29 --- /dev/null +++ b/compiler_and_linker/unsorted/CTemplateFunc.c diff --git a/compiler_and_linker/unsorted/CTemplateNew.c b/compiler_and_linker/unsorted/CTemplateNew.c new file mode 100644 index 0000000..e69de29 --- /dev/null +++ b/compiler_and_linker/unsorted/CTemplateNew.c diff --git a/compiler_and_linker/unsorted/CTemplateTools.c b/compiler_and_linker/unsorted/CTemplateTools.c new file mode 100644 index 0000000..e69de29 --- /dev/null +++ b/compiler_and_linker/unsorted/CTemplateTools.c diff --git a/compiler_and_linker/unsorted/CodeGen.c b/compiler_and_linker/unsorted/CodeGen.c index 0867270..d87d80f 100644 --- a/compiler_and_linker/unsorted/CodeGen.c +++ b/compiler_and_linker/unsorted/CodeGen.c @@ -1,13 +1,63 @@ -#include "compiler.h" +#include "compiler/CodeGen.h" +#include "compiler/CCompiler.h" +#include "compiler/CDecl.h" #include "compiler/CError.h" +#include "compiler/CExpr.h" +#include "compiler/CFunc.h" +#include "compiler/CInt64.h" +#include "compiler/CMachine.h" +#include "compiler/CMangler.h" +#include "compiler/CParser.h" +#include "compiler/CPrep.h" +#include "compiler/CPrepTokenizer.h" +#include "compiler/InstrSelection.h" +#include "compiler/Operands.h" #include "compiler/PCode.h" #include "compiler/PCodeInfo.h" #include "compiler/PCodeUtilities.h" +#include "compiler/RegisterInfo.h" +#include "compiler/StackFrame.h" +#include "compiler/TOC.h" +#include "compiler/CompilerTools.h" #include "compiler/enode.h" #include "compiler/objects.h" +#include "compiler/scopes.h" #include "compiler/tokens.h" #include "compiler/types.h" +// TODO: MOVE ME +extern void Intrinsics_SetupRuntimeObjects(void); +extern void Intrinsics_ReInitRuntimeObjects(Boolean); +extern Boolean Intrinsics_IsPublicRuntimeObject(Object *); +extern ENode *Intrinsics_HandleIntrinsicCall(Object *func, ENodeList *arg_exprs); +extern void PPCError_Error(int, ...); +extern void PPCError_Warning(int, ...); +extern void PPCError_Message(char *, ...); +extern void globallyoptimizepcode(Object *); +extern void pclistblocks(char *, char *); +extern void pclistblocks_start_scheduler(char *, char *); +extern void pclistblocks_end_scheduler(); +extern void scheduleinstructions(Boolean); +extern void peepholemergeblocks(Object *, Boolean); +extern void peepholeoptimizeforward(Object *); +extern void peepholeoptimizepcode(Object *); +extern void colorinstructions(Object *); +extern void removecommonsubexpressions(Object *, Boolean); +extern int removedcommonsubexpressions; +extern SInt32 assemblefunction(Object *, void *); +extern void dumpswitchtables(Object *); +extern void ObjGen_DeclareInitFunction(Object *); +extern void *switchtables; +extern void initializeexceptiontables(); +extern void dumpexceptiontables(Object *, SInt32); +extern void switchstatement(ENode *, CLabel *); +extern void DumpIR(Statement **, Object *); +extern void InlineAsm_TranslateIRtoPCode(Statement *stmt); +typedef struct WeirdInlineAsmThing { + UInt8 x0, x1, x2; +} WeirdInlineAsmThing; +extern Statement **COpt_Optimizer(Object *, Statement **); + static Macro powcM; static Macro __powcM; static Macro ppc_cpu; @@ -29,8 +79,8 @@ static Macro dynM; static Macro ppcM; Object *gFunction; static ObjectList *temps; -PCodeLabel *returnlabel; -PCodeLabel *cleanreturnlabel; +CLabel *returnlabel; +CLabel *cleanreturnlabel; Boolean needs_cleanup; Statement *current_statement; int has_catch_blocks; @@ -60,7 +110,7 @@ Object *rt_cvt_sll_dbl; Object *rt_cvt_ull_flt; Object *rt_cvt_sll_flt; Object *rt_cvt_dbl_usll; -static void *saveheaperror; +static heaperror_t saveheaperror; enum { GPRLimit = 10, @@ -68,6 +118,9 @@ enum { VRLimit = 13 }; +// forward decls +static void CodeGen_heaperror(void); + VarInfo *CodeGen_GetNewVarInfo(void) { VarInfo *vi; @@ -601,10 +654,11 @@ static void load_TOC_pointers(void) { Object *obj; ObjectList *list; PCode *pc; + Operand opnd; if (uses_globals && pic_base_reg) { pic_base_pcodelabel = makepclabel(); - pc = makepcode(PC_BC, 20, 7, 3); + pc = makepcode(PC_BC, 20, 7, 3, pic_base_pcodelabel); pcsetlinkbit(pc); pcsetsideeffects(pc); appendpcode(pclastblock, pc); @@ -614,24 +668,52 @@ static void load_TOC_pointers(void) { emitpcode(PC_MFLR, pic_base_reg); } - // TODO: depends on Operands + memclrw(&opnd, sizeof(Operand)); for (list = toclist; list; list = list->next) { - + obj = list->object; + if ((vi = Registers_GetVarInfo(obj)) && (vi->flags & VarInfoFlag2)) { + switch (obj->datatype) { + case DNONLAZYPTR: + symbol_operand(&opnd, obj); + opnd.optype = OpndType_IndirectSymbol; + if (opnd.optype) + Coerce_to_register(&opnd, TYPE(&void_ptr), vi->reg); + if (opnd.reg != vi->reg) + emitpcode(PC_MR, vi->reg, opnd.reg); + break; + default: +#line 1206 + CError_FATAL(); + } + } } } -static Boolean has_vararglist(Object *funcobj) { +static int has_vararglist(Object *funcobj) { FuncArg *arg; arg = TYPE_FUNC(funcobj->type)->args; while (arg && arg != &elipsis) arg = arg->next; - return arg == &elipsis; + return (arg == &elipsis); } -void assign_labels() { - // TODO +void assign_labels(Statement *stmt) { + Statement *last; + + last = NULL; + while (stmt) { + if (stmt->type == ST_LABEL && !stmt->label->pclabel) { + if (last && last->type == ST_LABEL) + stmt->label->pclabel = last->label->pclabel; + else + stmt->label->pclabel = makepclabel(); + } + + last = stmt; + stmt = stmt->next; + } } static Boolean islaststatement(Statement *stmt) { @@ -642,7 +724,7 @@ static Boolean islaststatement(Statement *stmt) { return 1; } -static void newstatement(SInt32 sourceoffset, UInt16 value, int flag) { +static void newstatement(SInt32 sourceoffset, SInt32 value, int flag) { PCodeBlock *block = pclastblock; pcloopweight = value; @@ -657,41 +739,1685 @@ static void newstatement(SInt32 sourceoffset, UInt16 value, int flag) { } static void expressionstatement(ENode *expr) { + Operand opnd; + + memclrw(&opnd, sizeof(Operand)); + cgdispatch[expr->type](expr, 0, 0, &opnd); + + if (ENODE_IS(expr, EINDIRECT) && (opnd.flags & OpndFlags_Volatile)) { + if (TYPE_FITS_IN_REGISTER_2(expr->rtype)) { + if (opnd.optype != OpndType_GPR) + Coerce_to_register(&opnd, expr->rtype, 0); + } else if (IS_TYPE_FLOAT(expr->rtype)) { + if (opnd.optype != OpndType_FPR) + Coerce_to_fp_register(&opnd, expr->rtype, 0); + } else if (IS_TYPE_VECTOR(expr->rtype)) { + if (opnd.optype != OpndType_VR) + Coerce_to_v_register(&opnd, expr->rtype, 0); + } + } +} + +static void labelstatement(CLabel *label) { + if (!label->pclabel) + label->pclabel = makepclabel(); + if (!label->pclabel->resolved) + branch_label(label->pclabel); + free_temporaries(); +} + +static void gotostatement(CLabel *label) { + if (!label->pclabel) + label->pclabel = makepclabel(); + branch_always(label->pclabel); + free_temporaries(); +} + +static void gotoexpression(ENode *expr) { + Operand opnd; + CodeLabelList *list; + + memclrw(&opnd, sizeof(Operand)); + cgdispatch[expr->type](expr, 0, 0, &opnd); + + if (opnd.optype != OpndType_GPR) + Coerce_to_register(&opnd, TYPE(&void_ptr), 0); +#line 1397 + CError_ASSERT(opnd.optype == OpndType_GPR); + + for (list = codelabellist; list; list = list->next) + pcbranch(pclastblock, list->label->pclabel); + + emitpcode(PC_MTCTR, opnd.reg); + branch_indirect(NULL); +} + +static void conditionalstatement(ENode *cond, CLabel *label, short truthy) { + Operand opnd; + memclrw(&opnd, sizeof(Operand)); + + cond = evaluate_and_skip_comma(cond); + if (!label->pclabel) + label->pclabel = makepclabel(); + + if (TYPE_IS_8BYTES(cond->data.diadic.right->rtype) || TYPE_IS_8BYTES(cond->data.diadic.left->rtype)) + I8_gen_condition(cond, &opnd, 0); + else + gen_condition(cond, &opnd); + + branch_conditional(opnd.reg, opnd.regOffset, truthy, label->pclabel); + free_temporaries(); +} + +static void returnstatement(ENode *expr, Boolean dont_branch) { + Operand opnd; + Type *type; + memclrw(&opnd, sizeof(Operand)); + + if (expr) { + type = expr->rtype; + if (TYPE_FITS_IN_REGISTER(type)) { + if (TYPE_IS_8BYTES(type)) { + cgdispatch[expr->type](expr, low_reg, high_reg, &opnd); + coerce_to_register_pair(&opnd, type, low_reg, high_reg); + } else { + cgdispatch[expr->type](expr, 3, 0, &opnd); + if (opnd.optype != OpndType_GPR) + Coerce_to_register(&opnd, type, 3); + if (opnd.reg != 3) + emitpcode(PC_MR, 3, opnd.reg); + } + } else if (IS_TYPE_FLOAT(type)) { + cgdispatch[expr->type](expr, 1, 0, &opnd); + if (opnd.optype != OpndType_FPR) + Coerce_to_fp_register(&opnd, type, 1); + if (opnd.reg != 1) + emitpcode(PC_FMR, 1, opnd.reg); + } else if (IS_TYPE_VECTOR(type)) { + cgdispatch[expr->type](expr, 2, 0, &opnd); + if (opnd.optype != OpndType_VR) + Coerce_to_v_register(&opnd, type, 2); + if (opnd.reg != 2) + emitpcode(PC_VMR, 2, opnd.reg); + } else { + cgdispatch[expr->type](expr, 0, 0, &opnd); + } + } + + if (!dont_branch) { + if (!returnlabel->pclabel) + returnlabel->pclabel = makepclabel(); + branch_always(returnlabel->pclabel); + free_temporaries(); + } +} + +static void capturestackpointer(Object *obj) { + branch_label(makepclabel()); +#line 1568 + CError_ASSERT(obj->datatype == DLOCAL); + + load_store_register(PC_STW, 1, local_base_register(obj), obj, 20); + branch_label(makepclabel()); +} + +static void resetstackpointer(Object *obj) { + PCode *pc; + +#line 1595 + CError_ASSERT(obj->datatype == DLOCAL); + + branch_label(makepclabel()); + + load_store_register(PC_LWZ, 0, 1, NULL, 0); + + pc = makepcode(PC_LWZ, 1, local_base_register(obj), obj, 20); + pcsetsideeffects(pc); + appendpcode(pclastblock, pc); + + load_store_register(PC_STW, 0, 1, NULL, 0); + + branch_label(makepclabel()); +} + +static void callprofiler(char *name) { + UInt32 masks[RegClassMax] = {0, 0, 0, 0, 0}; + load_store_register(PC_LWZ, 3, 1, NULL, 0); + load_store_register(PC_LWZ, 3, 3, NULL, 8); + masks[RegClass_GPR] |= (1 << 3); + branch_subroutine(rt_profile_entry, 1, masks); +} + +static void exitprofiler(void) { +} + +void CodeGen_Generator(Statement **statements, Object *func, UInt8 mysteryFlag, Boolean callOnModuleBind) { + Statement *stmt; + Boolean has_varargs; + PCodeBlock *tmp; + Object *obj; + SInt32 size; + + CodeGen_InitialSanityCheck(); + if (!saveheaperror) { + saveheaperror = getheaperror(); + setheaperror(CodeGen_heaperror); + } + + if (cparamblkptr->isPrecompiling == 1) + CError_Error(180); + + if (!func) { + func = createstaticinitobject(); + } else if (func && func->name) { + PrintProgressFunction(func->name->name); + } + + gFunction = func; + has_varargs = has_vararglist(func); + init_endian(); + init_stack_globals(func); + assign_arguments_to_memory(func, mysteryFlag, has_varargs); + + needs_cleanup = 0; + disable_optimizer = 0; + has_catch_blocks = 0; + current_statement = NULL; + current_linenumber = 0; + precomputedoperands = NULL; + switchtables = NULL; + temps = NULL; + initializeexceptiontables(); + returnlabel = cleanreturnlabel = newlabel(); + + if (copts.debuglisting) + DumpIR(statements, func); + + statements = COpt_Optimizer(func, statements); + if (copts.debuglisting) + DumpIR(statements, func); + + resetTOCvarinfo(); + init_registers(); + expandTOCreferences(statements); + if (copts.debuglisting) + DumpIR(statements, func); + + if (copts.profile) { + makes_call = 1; + requires_frame = 1; + } + + initpcode(); + + pclabel(prologue = makepcblock(), makepclabel()); + prologue->flags |= fPCBlockFlag1; + + pclabel(tmp = makepcblock(), makepclabel()); + pcbranch(prologue, tmp->labels); + + init_frame_sizes(has_varargs); + allocate_locals(); + process_arguments(move_assigned_argument, has_varargs); + + if (copts.schedule_mode || copts.altivec_model) + branch_label(makepclabel()); + + load_TOC_pointers(); + + if (copts.profile) + callprofiler(CMangler_GetLinkName(func)->name); + + assign_labels(*statements); + open_temp_registers(); + + for (stmt = *statements; stmt; stmt = stmt->next) { + current_statement = stmt; + current_linenumber = stmt->sourceoffset; + switch (stmt->type) { + case ST_NOP: + break; + case ST_EXPRESSION: + newstatement(stmt->sourceoffset, stmt->value, (stmt->flags & StmtFlag_10) != 0); + expressionstatement(stmt->expr); + break; + case ST_LABEL: + labelstatement(stmt->label); + break; + case ST_IFGOTO: + newstatement(stmt->sourceoffset, stmt->value, (stmt->flags & StmtFlag_10) != 0); + conditionalstatement(stmt->expr, stmt->label, 1); + break; + case ST_IFNGOTO: + newstatement(stmt->sourceoffset, stmt->value, (stmt->flags & StmtFlag_10) != 0); + conditionalstatement(stmt->expr, stmt->label, 0); + break; + case ST_GOTOEXPR: + newstatement(stmt->sourceoffset, stmt->value, (stmt->flags & StmtFlag_10) != 0); + gotoexpression(stmt->expr); + break; + case ST_GOTO: + newstatement(stmt->sourceoffset, stmt->value, (stmt->flags & StmtFlag_10) != 0); + gotostatement(stmt->label); + break; + case ST_RETURN: + newstatement(stmt->sourceoffset, stmt->value, (stmt->flags & StmtFlag_10) != 0); + returnstatement(stmt->expr, islaststatement(stmt)); + break; + case ST_SWITCH: + newstatement(stmt->sourceoffset, stmt->value, (stmt->flags & StmtFlag_10) != 0); + switchstatement(stmt->expr, stmt->label); + break; + case ST_BEGINCATCH: + capturestackpointer(stmt->expr->data.objref); + break; + case ST_ENDCATCHDTOR: +#line 2056 + CError_ASSERT(stmt->expr->data.objref->datatype == DLOCAL); + obj = stmt->expr->data.objref; + add_immediate(3, local_base_register(obj), obj, 0); + { + UInt32 masks[RegClassMax] = {0, 0, 0, 0, 0}; + masks[RegClass_GPR] |= 1 << 3; + branch_subroutine(Xecth_func, 1, masks); + } + case ST_ENDCATCH: + resetstackpointer(stmt->expr->data.objref); + break; + case ST_ASM: + if (stmt->expr) { + // ... will need to understand inline ASM properly for this ... + if (((WeirdInlineAsmThing *) stmt->expr)->x2 & 1) { +#line 2076 + CError_FATAL(); + } else { + branch_label(makepclabel()); + InlineAsm_TranslateIRtoPCode(stmt); + } + } + break; + case ST_BEGINLOOP: +#line 2086 + CError_FATAL(); + break; + case ST_ENDLOOP: +#line 2090 + CError_FATAL(); + break; + default: +#line 2094 + CError_FATAL(); + } + check_temp_registers(); + } + + close_temp_registers(); + labelstatement(returnlabel); + + current_statement = NULL; + + epilogue = pclastblock; + pclastblock->flags |= fPCBlockFlag2; + + pccomputepredecessors(); + deleteunreachableblocks(); + + if (copts.report_heap_info > 0) + CodeGen_reportheapinfo(0, CMangler_GetLinkName(func)->name, "before optimization"); + + if (copts.optimizationlevel > 0 && !disable_optimizer) + globallyoptimizepcode(func); + else + pclistblocks(CMangler_GetLinkName(func)->name, "INITIAL CODE"); + + if (copts.schedule_mode == 2) { + if (copts.peephole) + peepholemergeblocks(func, 0); + if (copts.debuglisting) + pclistblocks_start_scheduler(CMangler_GetLinkName(func)->name, "BEFORE SCHEDULING"); + scheduleinstructions(0); + if (copts.debuglisting) + pclistblocks_end_scheduler(); + if (copts.debuglisting) + pclistblocks(CMangler_GetLinkName(func)->name, "AFTER INSTRUCTION SCHEDULING"); + } + + if (copts.peephole) { + if (copts.schedule_mode == 0 && copts.optimizationlevel > 1) + peepholemergeblocks(func, 0); + peepholeoptimizeforward(func); + if (copts.debuglisting) + pclistblocks(CMangler_GetLinkName(func)->name, "AFTER PEEPHOLE FORWARD"); + } + + allocate_temporaries(); + colorinstructions(func); + if (copts.debuglisting) + pclistblocks(CMangler_GetLinkName(func)->name, "AFTER REGISTER COLORING"); + + if (copts.optimizationlevel > 1 && !disable_optimizer) { + removecommonsubexpressions(func, 1); + if (removedcommonsubexpressions && copts.debuglisting) + pclistblocks(CMangler_GetLinkName(func)->name, "AFTER VALUE NUMBERING (POST COLORING)"); + } + + compute_frame_sizes(); + generate_prologue(prologue, has_varargs); + if (copts.profile) + exitprofiler(); + generate_epilogue(epilogue, 1); + + if (copts.debuglisting) + pclistblocks(CMangler_GetLinkName(func)->name, "AFTER GENERATING EPILOGUE, PROLOGUE"); + + if (copts.peephole) { + if (copts.schedule_mode) { + peepholemergeblocks(func, 1); + if (copts.debuglisting) + pclistblocks(CMangler_GetLinkName(func)->name, "AFTER MERGING EPILOGUE, PROLOGUE"); + } + peepholeoptimizepcode(func); + if (copts.debuglisting) + pclistblocks(CMangler_GetLinkName(func)->name, "AFTER PEEPHOLE OPTIMIZATION"); + } + + if (copts.schedule_mode) { + if (copts.debuglisting) + pclistblocks_start_scheduler(CMangler_GetLinkName(func)->name, "BEFORE SCHEDULING"); + scheduleinstructions(1); + if (copts.debuglisting) + pclistblocks_end_scheduler(); + if (copts.debuglisting) + pclistblocks(CMangler_GetLinkName(func)->name, "FINAL CODE AFTER INSTRUCTION SCHEDULING"); + } else { + if (copts.debuglisting) + pclistblocks(CMangler_GetLinkName(func)->name, "FINAL CODE"); + } + + size = assemblefunction(func, NULL); + dumpswitchtables(func); + dumpcodelabels(func); + if (callOnModuleBind) + ObjGen_DeclareInitFunction(func); + + pic_base_pcodelabel = NULL; + pic_base_reg = 0; + if (copts.exceptions && requires_frame) + dumpexceptiontables(func, size); + + if (copts.report_heap_info > 0) + CodeGen_reportheapinfo(0, CMangler_GetLinkName(func)->name, "finished"); + + if (saveheaperror) + setheaperror(saveheaperror); +} + +enum { + reg3 = 3, + reg4 = 4 +}; + +void CodeGen_GenVDispatchThunk(Object *thunkobj, Object *obj, SInt32 a, SInt32 b, SInt32 c) { + Boolean save_debug; + Boolean save_peephole; + Boolean save_traceback; + char reg; + + save_debug = copts.isGeneratingDebugInfo; + save_peephole = copts.peephole; + save_traceback = copts.traceback; + + CodeGen_InitialSanityCheck(); +#line 2270 + CError_ASSERT(b == 0); + + initpcode(); + makepcblock(); + + if (a) { + reg = CMach_PassResultInHiddenArg(TYPE_FUNC(obj->type)->functype) ? reg4 : reg3; + + if (c >= 0) { + if (!FITS_IN_SHORT(c)) { + emitpcode(PC_ADDIS, 11, 0, 0, HIGH_PART(c)); + if (c) + emitpcode(PC_ADDI, 11, 11, 0, LOW_PART(c)); + } else { + emitpcode(PC_ADDI, 11, 0, 0, c); + } + emitpcode(PC_LWZX, 11, reg, 11); + emitpcode(PC_ADD, reg, reg, 11); + } + + if (!FITS_IN_SHORT(a)) { + emitpcode(PC_ADDIS, reg, reg, 0, HIGH_PART(a)); + if (a) + emitpcode(PC_ADDI, reg, reg, 0, LOW_PART(a)); + } else { + emitpcode(PC_ADDI, reg, reg, 0, a); + } + } + + emitpcode(PC_B, 0, obj); + + copts.isGeneratingDebugInfo = 0; + copts.peephole = 0; + copts.traceback = 0; + assemblefunction(thunkobj, NULL); + copts.isGeneratingDebugInfo = save_debug; + copts.peephole = save_peephole; + copts.traceback = save_traceback; +} + +void CodeGen_SetupRuntimeObjects(void) { + setupaddressing(); + dyld_stub_binding_helper = CParser_NewRTFunc(&stvoid, NULL, 2, 0); + rt_cvt_fp2unsigned = CParser_NewRTFunc(&stvoid, NULL, 2, 0); + rt_profile_entry = CParser_NewRTFunc(&stvoid, NULL, 2, 0); + rt_profile_exit = CParser_NewRTFunc(&stvoid, NULL, 2, 0); + rt_div2i = CParser_NewRTFunc(&stvoid, NULL, 2, 0); + rt_div2u = CParser_NewRTFunc(&stvoid, NULL, 2, 0); + rt_mod2i = CParser_NewRTFunc(&stvoid, NULL, 2, 0); + rt_mod2u = CParser_NewRTFunc(&stvoid, NULL, 2, 0); + rt_shr2i = CParser_NewRTFunc(&stvoid, NULL, 2, 0); + rt_shr2u = CParser_NewRTFunc(&stvoid, NULL, 2, 0); + rt_shl2i = CParser_NewRTFunc(&stvoid, NULL, 2, 0); + rt_cvt_ull_dbl = CParser_NewRTFunc(&stvoid, NULL, 2, 0); + rt_cvt_sll_dbl = CParser_NewRTFunc(&stvoid, NULL, 2, 0); + rt_cvt_ull_flt = CParser_NewRTFunc(&stvoid, NULL, 2, 0); + rt_cvt_sll_flt = CParser_NewRTFunc(&stvoid, NULL, 2, 0); + rt_cvt_dbl_usll = CParser_NewRTFunc(&stvoid, NULL, 2, 0); + Intrinsics_SetupRuntimeObjects(); } -static void labelstatement() {} -static void gotostatement() {} -static void gotoexpression() {} -static void conditionalstatement() {} -static void returnstatement() {} -static void capturestackpointer() {} -static void resetstackpointer() {} -static void callprofiler() {} -static void exitprofiler() {} -void CodeGen_Generator() {} -void CodeGen_GenVDispatchThunk() {} -void CodeGen_SetupRuntimeObjects() {} -Boolean CodeGen_ReInitRuntimeObjects(Boolean is_precompiler) {} -Boolean CodeGen_IsPublicRuntimeObject(Object *obj) {} -void CodeGen_SOMStub() {} -void CodeGen_ParseDeclSpec() {} -static void CodeGen_EOLCheck() {} -static void schedule_for() {} -static void pragma_scheduling() {} -static void CodeGen_ParseLongIntegerORonORoff() {} -void CodeGen_ParsePragma(HashNameNode *name) {} -void CodeGen_UpdateObject(Object *object) {} -void CodeGen_UpdateBackEndOptions() {} -void CodeGen_objc_method_self_offset() {} -void CodeGen_objc_method_sel_offset() {} -void CodeGen_objc_method_arg_offset() {} -void CodeGen_objc_method_args_size() {} -void CodeGen_HandleIntrinsicCall() {} -void CodeGen_HandleTypeCast() {} -void CodeGen_AssignCheck() {} -void CodeGen_CollapseVectorExpression() {} -void CodeGen_InsertSpecialMacros() {} -char *CodeGen_ExpandSpecialMacro(Macro *macro) {} -void CodeGen_reportheapinfo() {} -static void CodeGen_heaperror() {} -void CodeGen_InitialSanityCheck() {} +Boolean CodeGen_ReInitRuntimeObjects(Boolean is_precompiler) { + dyld_stub_binding_helper->name = GetHashNameNodeExport("dyld_stub_binding_helper"); + dyld_stub_binding_helper->u.func.linkname = dyld_stub_binding_helper->name; + + rt_cvt_fp2unsigned->name = GetHashNameNodeExport("__cvt_fp2unsigned"); + + rt_profile_entry->name = GetHashNameNodeExport("mcount"); + rt_profile_entry->u.func.linkname = rt_profile_entry->name; + + rt_profile_exit->name = GetHashNameNodeExport("profile_exit"); + + rt_div2i->name = GetHashNameNodeExport("__div2i"); + rt_div2u->name = GetHashNameNodeExport("__div2u"); + rt_mod2i->name = GetHashNameNodeExport("__mod2i"); + rt_mod2u->name = GetHashNameNodeExport("__mod2u"); + rt_shr2i->name = GetHashNameNodeExport("__shr2i"); + rt_shr2u->name = GetHashNameNodeExport("__shr2u"); + rt_shl2i->name = GetHashNameNodeExport("__shl2i"); + + rt_cvt_ull_dbl->name = GetHashNameNodeExport("__cvt_ull_dbl"); + rt_cvt_sll_dbl->name = GetHashNameNodeExport("__cvt_sll_dbl"); + rt_cvt_ull_flt->name = GetHashNameNodeExport("__cvt_ull_flt"); + rt_cvt_sll_flt->name = GetHashNameNodeExport("__cvt_sll_flt"); + rt_cvt_dbl_usll->name = GetHashNameNodeExport("__cvt_dbl_usll"); + + CMach_ReInitRuntimeObjects(); + Intrinsics_ReInitRuntimeObjects(is_precompiler); +} + +Boolean CodeGen_IsPublicRuntimeObject(Object *obj) { + return Intrinsics_IsPublicRuntimeObject(obj); +} + +void CodeGen_SOMStub(Object *a, Object *b, Object *c, SInt32 offset) { + Boolean save_debug; + Boolean save_peephole; + Boolean save_traceback; + Object *tmp; + Operand opnd; + + save_debug = copts.isGeneratingDebugInfo; + save_peephole = copts.peephole; + save_traceback = copts.traceback; + + CodeGen_InitialSanityCheck(); + memclrw(&opnd, sizeof(Operand)); +#line 2528 + CError_ASSERT(offset <= 0x7FFF); + + initpcode(); + makepcblock(); + + tmp = createIndirect(c, 1, 1); + if (tmp) { + opnd.optype = OpndType_Symbol; + opnd.object = tmp; + indirect(&opnd, NULL); + } else { + opnd.optype = OpndType_Symbol; + opnd.object = c; + } + + if (opnd.optype != OpndType_GPR) + Coerce_to_register(&opnd, TYPE(&void_ptr), 12); + + if (opnd.optype != OpndType_GPR) { +#line 2562 + CError_FATAL(); + } else if (opnd.reg != 12) { + emitpcode(PC_MR, 12, opnd.reg); + } + + load_store_register(PC_LWZ, 12, 12, NULL, (short) offset); + emitpcode(PC_B, 0, b); + + copts.isGeneratingDebugInfo = 0; + copts.peephole = 0; + copts.traceback = 0; + assemblefunction(a, NULL); + copts.isGeneratingDebugInfo = save_debug; + copts.peephole = save_peephole; + copts.traceback = save_traceback; +} + +void CodeGen_ParseDeclSpec(HashNameNode *identifier, DeclInfo *declinfo) { + if (!strcmp(identifier->name, "private_extern")) { + declinfo->storageclass = TK_EXTERN; + declinfo->exportflags = EXPORT_FLAGS_INTERNAL; + } else { + CError_Error(176); + } +} + +static void CodeGen_EOLCheck(void) { + short t; + + if (plex() != TK_NEG7) { + CPrep_Error(113); + do { + t = plex(); + } while (t != TK_NEG7 && t != 0); + } +} + +static void schedule_for(int what) { + CPrep_PushOption(OPT_OFFSET(schedule_cpu), what); + if (copts.schedule_mode == 0) + CPrep_PushOption(OPT_OFFSET(schedule_mode), 2); +} + +static void pragma_scheduling(void) { + Boolean *flag; + int cpu; + + tk = plex(); + if (tk == TK_IDENTIFIER) { + flag = &copts.altivec_model; + if (!strcmp(tkidentifier->name, "vger")) { + schedule_for(10); + return; + } else if (!strcmp(tkidentifier->name, "altivec")) { + schedule_for(7); + return; + } else if (!strcmp(tkidentifier->name, "reset")) { + CPrep_PopOption(OPT_OFFSET(schedule_cpu)); + CPrep_PopOption(OPT_OFFSET(schedule_mode)); + return; + } else if (!strcmp(tkidentifier->name, "off")) { + CPrep_PushOption(OPT_OFFSET(schedule_mode), 0); + return; + } else if (!strcmp(tkidentifier->name, "once")) { + CPrep_PushOption(OPT_OFFSET(schedule_mode), 1); + return; + } else if (!strcmp(tkidentifier->name, "twice")) { + CPrep_PushOption(OPT_OFFSET(schedule_mode), 2); + return; + } else if (!strcmp(tkidentifier->name, "on")) { + CPrep_PushOption(OPT_OFFSET(schedule_mode), 2); + return; + } else if (!*flag) { + if (!strcmp(tkidentifier->name, "603e")) { + schedule_for(5); + return; + } else if (!strcmp(tkidentifier->name, "604e")) { + schedule_for(6); + return; + } else if (!strcmp(tkidentifier->name, "PPC603e")) { + schedule_for(5); + return; + } else if (!strcmp(tkidentifier->name, "PPC604e")) { + schedule_for(6); + return; + } + } else { + PPCError_Error(115); + return; + } + CPrep_Error(186); + return; + } + + if (tk == TK_INTCONST) { + switch (CInt64_GetULong(&tkintconst)) { + case 601: + cpu = 1; + break; + case 603: + cpu = 2; + break; + case 604: + cpu = 3; + break; + case 750: + cpu = 4; + break; + case 7400: + cpu = 7; + break; + case 7450: + cpu = 10; + break; + case 8240: + case 8260: + cpu = 5; + break; + case 801: + case 821: + case 823: + case 850: + case 860: + cpu = 9; + break; + default: + CPrep_Error(186); + return; + } + schedule_for(cpu); + return; + } + + if (copts.warn_illpragma) + CPrep_Warning(186); +} + +static SInt32 CodeGen_ParseLongIntegerORonORoff(void) { + SInt32 result; + short t; + + result = 0; + t = plex(); + if (t == TK_INTCONST) { + if (!tkintconst.hi) + result = CInt64_GetULong(&tkintconst); + else + CPrep_Error(154); + CodeGen_EOLCheck(); + } else if (t == TK_IDENTIFIER) { + if (!strcmp(tkidentifier->name, "on")) { + CodeGen_EOLCheck(); + return 1; + } + if (!strcmp(tkidentifier->name, "off")) { + CodeGen_EOLCheck(); + return 0; + } + if (copts.warn_illpragma) + CPrep_Warning(186); + return 0; + } else { + if (copts.warn_illpragma) + CPrep_Warning(186); + } + + return result; +} + +void CodeGen_ParsePragma(HashNameNode *name) { + short t; + SInt32 value; + char *str; + NameSpace *nspace; + NameSpaceObjectList *list; + + if (!strcmp(name->name, "debuglisting")) { + copts.debuglisting = CodeGen_ParseLongIntegerORonORoff(); + return; + } + + if (!strcmp(name->name, "report_heap_info")) { + t = plex(); + if (t == TK_INTCONST) { + copts.report_heap_info = CInt64_GetULong(&tkintconst); + if (copts.report_heap_info < 0) { + copts.report_heap_info = 0; + CError_Error(186); + } + } else if (t == TK_IDENTIFIER) { + if (!strcmp(tkidentifier->name, "off")) { + copts.report_heap_info = 0; + } else if (!strcmp(tkidentifier->name, "on")) { + copts.report_heap_info = 1; + } else { + CError_Error(186); + return; + } + } else { + CError_Error(186); + } + CodeGen_EOLCheck(); + return; + } + + if (!strcmp(name->name, "scheduling")) { + pragma_scheduling(); + CodeGen_EOLCheck(); + return; + } + + if (!strcmp(name->name, "ppc_unroll_speculative")) { + if (plex() == TK_IDENTIFIER) { + if (!strcmp(tkidentifier->name, "off")) { + copts.ppc_unroll_speculative = 0; + } else if (!strcmp(tkidentifier->name, "on")) { + copts.ppc_unroll_speculative = 1; + } else { + CError_Error(186); + return; + } + } else { + CError_Error(186); + } + CodeGen_EOLCheck(); + return; + } + + if (!strcmp(name->name, "ppc_unroll_instructions_limit")) { + t = plex(); + if (t == TK_INTCONST) { + copts.ppc_unroll_instructions_limit = CInt64_GetULong(&tkintconst); + if (copts.ppc_unroll_instructions_limit < 0) { + copts.ppc_unroll_instructions_limit = 0; + CError_Error(186); + } + } else if (t == TK_IDENTIFIER) { + if (!strcmp(tkidentifier->name, "off")) { + copts.ppc_unroll_instructions_limit = 0; + } else if (!strcmp(tkidentifier->name, "on")) { + copts.ppc_unroll_instructions_limit = 70; + } else { + CError_Error(186); + return; + } + } else { + CError_Error(186); + } + CodeGen_EOLCheck(); + return; + } + + if (!strcmp(name->name, "gen_fsel")) { + t = plex(); + if (t == TK_INTCONST) { + value = CInt64_GetULong(&tkintconst); + if (value < 0) { + copts.gen_fsel = 0; + CError_Error(186); + } else if (value > 255) { + copts.gen_fsel = 255; + CError_Error(186); + } else { + copts.gen_fsel = value; + } + } else if (t == TK_IDENTIFIER) { + if (!strcmp(tkidentifier->name, "off")) { + copts.gen_fsel = 0; + } else if (!strcmp(tkidentifier->name, "on")) { + copts.gen_fsel = 10; + } else if (!strcmp(tkidentifier->name, "always")) { + copts.gen_fsel = 255; + } else { + CError_Error(186); + return; + } + } else { + CError_Error(186); + } + CodeGen_EOLCheck(); + return; + } + + if (!strcmp(name->name, "ppc_unroll_factor_limit")) { + t = plex(); + if (t == TK_INTCONST) { + copts.ppc_unroll_factor_limit = CInt64_GetULong(&tkintconst); + if (copts.ppc_unroll_factor_limit < 0) { + copts.ppc_unroll_factor_limit = 0; + CError_Error(186); + } + } else if (t == TK_IDENTIFIER) { + if (!strcmp(tkidentifier->name, "off")) { + copts.ppc_unroll_factor_limit = 0; + } else if (!strcmp(tkidentifier->name, "on")) { + copts.ppc_unroll_factor_limit = 10; + } else { + CError_Error(186); + return; + } + } else { + CError_Error(186); + } + CodeGen_EOLCheck(); + return; + } + + if (!strcmp(name->name, "altivec_model")) { + if (plex() == TK_IDENTIFIER) { + if (!strcmp(tkidentifier->name, "off")) { + copts.altivec_model = 0; + } else if (!strcmp(tkidentifier->name, "on")) { + copts.altivec_model = 1; + } else { + CError_Error(186); + return; + } + } else { + CError_Error(186); + } + CodeGen_EOLCheck(); + return; + } + + if (!strcmp(name->name, "altivec_vrsave")) { + if (plex() == TK_IDENTIFIER) { + if (!strcmp(tkidentifier->name, "off")) { + CPrep_PushOption(OPT_OFFSET(altivec_vrsave), 0); + } else if (!strcmp(tkidentifier->name, "on")) { + CPrep_PushOption(OPT_OFFSET(altivec_vrsave), 1); + } else if (!strcmp(tkidentifier->name, "allon")) { + CPrep_PushOption(OPT_OFFSET(altivec_vrsave), 2); + } else if (!strcmp(tkidentifier->name, "reset")) { + CPrep_PopOption(OPT_OFFSET(altivec_vrsave)); + } else { + CError_Error(186); + return; + } + } else { + CError_Error(186); + } + CodeGen_EOLCheck(); + return; + } + + if (!strcmp(name->name, "function_align")) { + t = plex(); + if (t == TK_INTCONST) { + value = CInt64_GetULong(&tkintconst); + switch (value) { + case 4: + case 8: + case 16: + case 32: + case 64: + case 128: + CPrep_PushOption(OPT_OFFSET(code_alignment), value); + break; + default: + PPCError_Warning(161); + CodeGen_EOLCheck(); + return; + } + } else if (t == TK_IDENTIFIER && !strcmp(tkidentifier->name, "reset")) { + CPrep_PopOption(OPT_OFFSET(code_alignment)); + } else { + PPCError_Warning(161); + } + CodeGen_EOLCheck(); + return; + } + + if (!strcmp(name->name, "processor")) { + if (cscope_currentfunc) { + PPCError_Warning(156, "pragma processor"); + return; + } + t = plex(); + if (t == TK_INTCONST) { + switch (CInt64_GetULong(&tkintconst)) { + case 401: + copts.cpu = 0; + break; + case 403: + copts.cpu = 1; + break; + case 505: + copts.cpu = 2; + break; + case 509: + copts.cpu = 3; + break; + case 555: + copts.cpu = 4; + break; + case 556: + copts.cpu = 25; + break; + case 565: + copts.cpu = 26; + break; + case 601: + copts.cpu = 5; + break; + case 602: + copts.cpu = 6; + break; + case 8240: + copts.cpu = 18; + break; + case 8260: + copts.cpu = 19; + break; + case 603: + copts.cpu = 7; + break; + case 604: + copts.cpu = 9; + break; + case 740: + copts.cpu = 11; + break; + case 750: + copts.cpu = 12; + break; + case 801: + copts.cpu = 13; + break; + case 821: + copts.cpu = 14; + break; + case 823: + copts.cpu = 15; + break; + case 850: + copts.cpu = 16; + break; + case 860: + copts.cpu = 17; + break; + case 7400: + copts.cpu = 21; + break; + default: + PPCError_Warning(208); + CodeGen_EOLCheck(); + return; + } + } else if (t == TK_IDENTIFIER) { + if (!strcmp(tkidentifier->name, "generic")) + copts.cpu = 20; + else if (!strcmp(tkidentifier->name, "603e")) + copts.cpu = 8; + else if (!strcmp(tkidentifier->name, "604e")) + copts.cpu = 10; + else if (!strcmp(tkidentifier->name, "PPC603e")) + copts.cpu = 8; + else if (!strcmp(tkidentifier->name, "PPC604e")) + copts.cpu = 10; + else + PPCError_Warning(208); + } else { + PPCError_Warning(208); + } + + if ((str = CMach_GetCPU())) + CPrep_InsertSpecialMacro(&ppc_cpu, str); + + CodeGen_EOLCheck(); + return; + } + + if (!strcmp(name->name, "min_struct_alignment")) { + t = plex(); + if (t == TK_INTCONST) { + value = CInt64_GetULong(&tkintconst); + switch (value) { + case 4: + case 8: + case 16: + case 32: + case 64: + case 128: + CPrep_PushOption(OPT_OFFSET(some_alignment), value); + break; + default: + PPCError_Warning(191); + CodeGen_EOLCheck(); + return; + } + } else if (t == TK_IDENTIFIER) { + if (!strcmp(tkidentifier->name, "reset")) + CPrep_PopOption(OPT_OFFSET(some_alignment)); + else if (!strcmp(tkidentifier->name, "on")) + CPrep_PushOption(OPT_OFFSET(some_alignment), 4); + else if (!strcmp(tkidentifier->name, "off")) + CPrep_PushOption(OPT_OFFSET(some_alignment), 1); + } else { + PPCError_Warning(161); + } + + CodeGen_EOLCheck(); + return; + } + + if (!strcmp(name->name, "tvectors")) { + if (plex() == TK_IDENTIFIER) { + if (!strcmp(tkidentifier->name, "off")) { + no_descriptors = 1; + } else if (!strcmp(tkidentifier->name, "on")) { + no_descriptors = 0; + } else { + CError_Error(186); + return; + } + } else { + CError_Error(186); + } + + CodeGen_EOLCheck(); + return; + } + + if (!strcmp(name->name, "dynamic")) { + if (plex() == TK_IDENTIFIER) { + if (!strcmp(tkidentifier->name, "off")) { + copts.codegen_dynamic = 0; + copts.codegen_pic = 0; + } else if (!strcmp(tkidentifier->name, "on")) { + copts.codegen_dynamic = 1; + } else { + CError_Error(186); + return; + } + } else { + CError_Error(186); + } + + CodeGen_EOLCheck(); + return; + } + + if (!strcmp(name->name, "pic")) { + if (plex() == TK_IDENTIFIER) { + if (!strcmp(tkidentifier->name, "off")) { + copts.codegen_pic = 0; + } else if (!strcmp(tkidentifier->name, "on")) { + copts.codegen_pic = 1; + if (!copts.codegen_dynamic) { + PPCError_Error(189); + copts.codegen_pic = 0; + } + } else { + CError_Error(186); + return; + } + } else { + CError_Error(186); + } + + CodeGen_EOLCheck(); + return; + } + + if (!strcmp(name->name, "implicit_templates")) { + if (plex() == TK_IDENTIFIER) { + if (!strcmp(tkidentifier->name, "off")) { + copts.no_implicit_templates = 1; + } else if (!strcmp(tkidentifier->name, "on")) { + copts.no_implicit_templates = 0; + } else { + CError_Error(186); + return; + } + } else { + CError_Error(186); + } + + CodeGen_EOLCheck(); + return; + } + + if (!strcmp(name->name, "common")) { + if (plex() == TK_IDENTIFIER) { + if (!strcmp(tkidentifier->name, "off")) { + copts.no_common = 1; + } else if (!strcmp(tkidentifier->name, "on")) { + copts.no_common = 0; + } else { + CError_Error(186); + return; + } + } else { + CError_Error(186); + } + + CodeGen_EOLCheck(); + return; + } + + if (!strcmp(name->name, "CALL_ON_MODULE_BIND")) { + if (plex() == TK_IDENTIFIER) { + for (nspace = cscope_current; nspace; nspace = nspace->parent) { + list = CScope_GetLocalObject(nspace, tkidentifier); + if (list && list->object->otype == OT_OBJECT && OBJECT(list->object)->datatype == DFUNC) { + ObjGen_DeclareInitFunction(OBJECT(list->object)); + break; + } + } + } else { + CError_Error(186); + } + + CodeGen_EOLCheck(); + return; + } + + if (copts.warn_illpragma) + CPrep_Warning(186); + + if (plex() != TK_NEG7) { + do { + t = plex(); + } while (t != TK_NEG7 && t != 0); + } +} + +void CodeGen_UpdateObject(Object *object) { + if (object->datatype == DDATA && object->section == SECT_DEFAULT && object == rt_ptmf_null) + object->sclass = TK_EXTERN; +} + +void CodeGen_UpdateBackEndOptions(void) { + copts.global_optimizer = 1; +} + +void CodeGen_objc_method_self_offset() { + // TODO objc +} + +void CodeGen_objc_method_sel_offset() { + // TODO objc +} + +void CodeGen_objc_method_arg_offset() { + // TODO objc +} + +void CodeGen_objc_method_args_size() { + // TODO objc +} + +ENode *CodeGen_HandleIntrinsicCall(Object *func, ENodeList *arg_exprs) { + return Intrinsics_HandleIntrinsicCall(func, arg_exprs); +} + +ENode *CodeGen_HandleTypeCast(ENode *expr, Type *type, UInt32 qual) { + short flags; + + if (copts.altivec_model) { + flags = qual & ENODE_FLAG_QUALS; + if (IS_TYPE_STRUCT(type) && IS_TYPE_STRUCT(expr->rtype) && expr->flags == flags) { + switch (TYPE_STRUCT(type)->stype) { + case STRUCT_TYPE_4: + case STRUCT_TYPE_5: + case STRUCT_TYPE_6: + case STRUCT_TYPE_7: + case STRUCT_TYPE_8: + case STRUCT_TYPE_9: + case STRUCT_TYPE_A: + case STRUCT_TYPE_B: + case STRUCT_TYPE_C: + case STRUCT_TYPE_D: + case STRUCT_TYPE_E: + expr = makemonadicnode(expr, ETYPCON); + expr->rtype = type; + expr->flags = flags; + return expr; + } + } + } + + return NULL; +} + +short CodeGen_AssignCheck(ENode *expr, Type *type, Boolean flag1, Boolean flag2) { + short result; + Type *exprtype = expr->rtype; + + if (copts.altivec_model && IS_TYPE_VECTOR(type) && IS_TYPE_VECTOR(exprtype) && TYPE_STRUCT(type)->stype == TYPE_STRUCT(exprtype)->stype) + result = CheckResult3; + else + result = CheckResult0; + return result; +} + +Boolean CodeGen_CollapseVectorExpression(ENode *expr, MWVector128 *vec, Type *type) { + // this function is a mess and needs lots of fixing + Boolean result; + //int count; + int i; + ENode *escan; + + result = 0; + for (i = 0; i < 4; i++) + vec->ul[i] = 0; + + if (ENODE_IS(expr, ECOMMA)) { + i = 0; + escan = expr; + while (ENODE_IS(escan, ECOMMA)) { + i++; + escan = escan->data.diadic.left; + } + switch (TYPE_STRUCT(type)->stype) { + case STRUCT_TYPE_4: + case STRUCT_TYPE_5: + case STRUCT_TYPE_6: + if (i < 15) { + PPCError_Error(110, type, 0); + } else if (i > 15) { + PPCError_Error(111, type, 0); + } else { + escan = expr; + i = 15; + while (ENODE_IS(escan, ECOMMA)) { + CInt64 v; + expr = escan->data.diadic.right; + v = expr->data.intval; + if (!ENODE_IS(expr, EINTCONST)) { + PPCError_Error(112); + break; + } + + if (copts.pedantic) { + if (TYPE_STRUCT(type)->stype == STRUCT_TYPE_4) { + if (!CInt64_IsInURange(v, 1)) + PPCError_Warning(113, type, 0); + } else { + if (!CInt64_IsInRange(v, 1)) + PPCError_Warning(113, type, 0); + } + } + + vec->uc[i--] = (UInt8) v.lo; + escan = escan->data.diadic.left; + } + + if (ENODE_IS(escan, EINTCONST)) { + CInt64 v = escan->data.intval; + if (copts.pedantic) { + if (TYPE_STRUCT(type)->stype == STRUCT_TYPE_4) { + if (!CInt64_IsInURange(v, 1)) + PPCError_Warning(113, type, 0); + } else { + if (!CInt64_IsInRange(v, 1)) + PPCError_Warning(113, type, 0); + } + } + vec->uc[0] = (UInt8) v.lo; + } else { + PPCError_Error(112); + break; + } + result = 1; + } + break; + + case STRUCT_TYPE_7: + case STRUCT_TYPE_8: + case STRUCT_TYPE_9: + case STRUCT_TYPE_E: + if (i < 7) { + PPCError_Error(110, type, 0); + } else if (i > 7) { + PPCError_Error(111, type, 0); + } else { + escan = expr; + i = 7; + while (ENODE_IS(escan, ECOMMA)) { + ENode *e = escan->data.diadic.right; + CInt64 v = e->data.intval; + if (!ENODE_IS(e, EINTCONST)) { + PPCError_Error(112); + break; + } + + if (copts.pedantic) { + if (TYPE_STRUCT(type)->stype == STRUCT_TYPE_7 || TYPE_STRUCT(type)->stype == STRUCT_TYPE_E) { + if (!CInt64_IsInURange(v, 2)) + PPCError_Warning(113, type, 0); + } else { + if (!CInt64_IsInRange(v, 2)) + PPCError_Warning(113, type, 0); + } + } + + vec->us[i--] = (UInt16) e->data.intval.lo; + escan = escan->data.diadic.left; + } + + if (ENODE_IS(escan, EINTCONST)) { + CInt64 v = escan->data.intval; + if (copts.pedantic) { + if (TYPE_STRUCT(type)->stype == STRUCT_TYPE_7 || TYPE_STRUCT(type)->stype == STRUCT_TYPE_E) { + if (!CInt64_IsInURange(v, 2)) + PPCError_Warning(113, type, 0); + } else { + if (!CInt64_IsInRange(v, 2)) + PPCError_Warning(113, type, 0); + } + } + vec->us[0] = (UInt16) v.lo; + } else { + PPCError_Error(112); + break; + } + result = 1; + } + break; + + case STRUCT_TYPE_A: + case STRUCT_TYPE_B: + case STRUCT_TYPE_C: + if (i < 3) { + PPCError_Error(110, type, 0); + } else if (i > 3) { + PPCError_Error(111, type, 0); + } else { + escan = expr; + i = 3; + while (ENODE_IS(escan, ECOMMA)) { + CInt64 v; + expr = escan->data.diadic.right; + v = expr->data.intval; + if (!ENODE_IS(expr, EINTCONST)) { + PPCError_Error(112); + break; + } + + if (copts.pedantic) { + if (TYPE_STRUCT(type)->stype == STRUCT_TYPE_A) { + if (!CInt64_IsInURange(v, 4)) + PPCError_Warning(113, type, 0); + } else { + if (!CInt64_IsInRange(v, 4)) + PPCError_Warning(113, type, 0); + } + } + + vec->ul[i--] = expr->data.intval.lo; + escan = escan->data.diadic.left; + } + + if (ENODE_IS(escan, EINTCONST)) { + CInt64 v = escan->data.intval; + if (copts.pedantic) { + if (TYPE_STRUCT(type)->stype == STRUCT_TYPE_A) { + if (!CInt64_IsInURange(v, 4)) + PPCError_Warning(113, type, 0); + } else { + if (!CInt64_IsInRange(v, 4)) + PPCError_Warning(113, type, 0); + } + } + vec->ul[0] = v.lo; + } else { + PPCError_Error(112); + break; + } + result = 1; + } + break; + + case STRUCT_TYPE_D: + if (i < 3) { + PPCError_Error(110, type, 0); + } else if (i > 3) { + PPCError_Error(111, type, 0); + } else { + Float fv; + escan = expr; + i = 3; + while (ENODE_IS(escan, ECOMMA)) { + expr = escan->data.diadic.right; + if (ENODE_IS(expr, EFLOATCONST)) { + fv = expr->data.floatval; + } else if (ENODE_IS(escan->data.diadic.right, EINTCONST)) { + fv = CMach_CalcFloatConvertFromInt(expr->rtype, + expr->data.intval); + } else { + PPCError_Error(112); + break; + } + + CMach_InitFloatMem(TYPE(&stfloat), fv, &vec->f[i]); + i--; + escan = escan->data.diadic.left; + } + + if (ENODE_IS(escan, EFLOATCONST)) { + fv = escan->data.floatval; + } else if (ENODE_IS(escan, EINTCONST)) { + fv = CMach_CalcFloatConvertFromInt(escan->rtype, escan->data.intval); + } else { + PPCError_Error(112); + break; + } + + CMach_InitFloatMem(TYPE(&stfloat), fv, &vec->f[0]); + result = 1; + } + break; + } + } else if (ENODE_IS(expr, EINTCONST)) { + int i = 0; + switch (TYPE_STRUCT(type)->stype) { + case STRUCT_TYPE_4: + case STRUCT_TYPE_5: + case STRUCT_TYPE_6: + { + CInt64 v = expr->data.intval; + if (copts.pedantic) { + if (TYPE_STRUCT(type)->stype == STRUCT_TYPE_4) { + if (!CInt64_IsInURange(v, 1)) + PPCError_Warning(113, type, 0); + } else { + if (!CInt64_IsInRange(v, 1)) + PPCError_Warning(113, type, 0); + } + } + while (i < 16) + vec->uc[i++] = (UInt8) v.lo; + result = 1; + break; + } + case STRUCT_TYPE_7: + case STRUCT_TYPE_8: + case STRUCT_TYPE_9: + case STRUCT_TYPE_E: + { + CInt64 v = expr->data.intval; + if (copts.pedantic) { + if (TYPE_STRUCT(type)->stype == STRUCT_TYPE_7 || TYPE_STRUCT(type)->stype == STRUCT_TYPE_E) { + if (!CInt64_IsInURange(v, 2)) + PPCError_Warning(113, type, 0); + } else { + if (!CInt64_IsInRange(v, 2)) + PPCError_Warning(113, type, 0); + } + } + while (i < 8) + vec->us[i++] = (UInt16) v.lo; + result = 1; + break; + } + case STRUCT_TYPE_A: + case STRUCT_TYPE_B: + case STRUCT_TYPE_C: + { + CInt64 v = expr->data.intval; + if (copts.pedantic) { + if (TYPE_STRUCT(type)->stype == STRUCT_TYPE_A) { + if (!CInt64_IsInURange(v, 4)) + PPCError_Warning(113, type, 0); + } else { + if (!CInt64_IsInRange(v, 4)) + PPCError_Warning(113, type, 0); + } + } + while (i < 4) + vec->ul[i++] = v.lo; + result = 1; + break; + } + case STRUCT_TYPE_D: + { + Float fv; + if (!CInt64_IsInRange(expr->data.intval, 4)) { + PPCError_Error(112); + break; + } + fv = CMach_CalcFloatConvertFromInt(expr->rtype, expr->data.intval); + for (; i < 4; i++) + CMach_InitFloatMem(TYPE(&stfloat), fv, &vec->f[i]); + result = 1; + break; + } + default: + PPCError_Error(112); + } + } else if (ENODE_IS(expr, EFLOATCONST)) { + switch (TYPE_STRUCT(type)->stype) { + default: + PPCError_Error(112); + break; + case STRUCT_TYPE_D: + { + Float fv; + i = 0; + fv = expr->data.floatval; + CMach_InitFloatMem(TYPE(&stfloat), fv, &vec->f[0]); + while (i < 4) + CMach_InitFloatMem(TYPE(&stfloat), fv, &vec->f[i++]); + result = 1; + break; + } + } + } else if (ENODE_IS2(expr, EINDIRECT, EFUNCCALL)) { + if (!IS_TYPE_STRUCT(expr->rtype)) + PPCError_Error(112); + } else if (!ENODE_IS(expr, EVECTOR128CONST)) { + PPCError_Error(112); + } + + return result; +} + +void CodeGen_InsertSpecialMacros(void) { + char *str; + + CPrep_InsertSpecialMacro(&vecM, "__VEC__"); + CPrep_InsertSpecialMacro(&altivecM, "__ALTIVEC__"); + CPrep_InsertSpecialMacro(&powcM, "powerc"); + CPrep_InsertSpecialMacro(&__powcM, "__powerc"); + CPrep_InsertSpecialMacro(&hostM, "__POWERPC__"); + CPrep_InsertSpecialMacro(&_ppc_M, "__ppc__"); + + CPrep_InsertSpecialMacro(&bendM, "__BIG_ENDIAN__"); + + if ((str = CMach_GetCPU())) + CPrep_InsertSpecialMacro(&ppc_cpu, str); + + CPrep_InsertSpecialMacro(&profM, "__profile__"); + CPrep_InsertSpecialMacro(&longI, "__fourbyteints__"); + CPrep_InsertSpecialMacro(&IEEED, "__IEEEdoubles__"); + CPrep_InsertSpecialMacro(&macM2, "__MACOS__"); + CPrep_InsertSpecialMacro(&appleM, "__APPLE__"); + CPrep_InsertSpecialMacro(&_machM, "__MACH__"); + CPrep_InsertSpecialMacro(&archM, "__ARCHITECTURE__"); + + if (copts.optimizationlevel > 0) + CPrep_InsertSpecialMacro(&optM, "__OPTIMIZE__"); + + if (copts.codegen_dynamic) + CPrep_InsertSpecialMacro(&dynM, "__DYNAMIC__"); + if (!copts.codegen_dynamic) + CPrep_InsertSpecialMacro(&dynM, "__STATIC__"); + + if (copts.oldalignment && copts.align_mode == AlignMode2_PPC) + CPrep_InsertSpecialMacro(&alignM, "__NATURAL_ALIGNMENT__"); + + if (!copts.ANSI_strict) + CPrep_InsertSpecialMacro(&ppcM, "ppc"); +} + +char *CodeGen_ExpandSpecialMacro(Macro *macro) { + if (macro == &vecM) return "10205"; + if (macro == &altivecM) return "100000000"; + if (macro == &powcM) return "1"; + if (macro == &__powcM) return "1"; + if (macro == &hostM) return "1"; + if (macro == &bendM) return "1"; + if (macro == &_ppc_M) return "1"; + if (CMach_GetCPU() && macro == &ppc_cpu) return "1"; + if (macro == &profM) return copts.profile ? "1" : "0"; + if (macro == &longI) return "1"; + if (macro == &IEEED) return "1"; + if (macro == &macM2) return "1"; + if (macro == &appleM) return "1"; + if (macro == &alignM) return "1"; + + if (macro == &optM) { + switch (copts.optimizationlevel) { + case 1: return "1"; + case 2: return "2"; + case 3: return "3"; + case 4: return "4"; + case 0: return "0"; + default: return "9"; + } + } + + if (macro == &_machM) return "1"; + if (macro == &archM) return "ppc"; + if (macro == &dynM) return "1"; + if (!copts.ANSI_strict && macro == &ppcM) return "1"; + if (macro == &_ppc_M) return "1"; + +#line 4801 + CError_FATAL(); + return "0"; +} + +void CodeGen_reportheapinfo(Boolean release_flag, char *name, char *text) { + HeapInfo o; + HeapInfo all; + + CTool_GetHeapInfo(&o, 3); + CTool_GetHeapInfo(&all, 5); + + if (release_flag) + releaseoheap(); + + PPCError_Message( + "%n:%u HEAP STATUS\n" + " optimizer: %i blocks, used: %i, free: %i, total: %i, largest free: %i\n" + " all: %i blocks, used: %i, free: %i, total: %i, largest free: %i", + name, text, + o.blocks, o.total_size - o.total_free, o.total_free, o.total_size, o.largest_free_block, + all.blocks, all.total_size - all.total_free, all.total_free, all.total_size, all.largest_free_block + ); +} + +static void CodeGen_heaperror(void) { + CodeGen_reportheapinfo(1, "?", "out of memory"); + if (saveheaperror) { + setheaperror(saveheaperror); + saveheaperror(); + } +} + +void CodeGen_InitialSanityCheck(void) { +} diff --git a/compiler_and_linker/unsorted/CodeGenOptPPC.c b/compiler_and_linker/unsorted/CodeGenOptPPC.c new file mode 100644 index 0000000..5723395 --- /dev/null +++ b/compiler_and_linker/unsorted/CodeGenOptPPC.c @@ -0,0 +1,17 @@ +#include "compiler/CodeGenOptPPC.h" +#include "compiler/InstrSelection.h" + +void CodeGen_InitCompiler(void) { + init_cgdispatch(); +} + +void CodeGen_TermCompiler(void) { + +} + +void CodeGen_InitBackEndOptions(void) { + // TODO +} + +void Test_Version_Numbers(void) { +} diff --git a/compiler_and_linker/unsorted/CodeMotion.c b/compiler_and_linker/unsorted/CodeMotion.c new file mode 100644 index 0000000..e69de29 --- /dev/null +++ b/compiler_and_linker/unsorted/CodeMotion.c diff --git a/compiler_and_linker/unsorted/Coloring.c b/compiler_and_linker/unsorted/Coloring.c new file mode 100644 index 0000000..e69de29 --- /dev/null +++ b/compiler_and_linker/unsorted/Coloring.c diff --git a/compiler_and_linker/unsorted/ConstantPropagation.c b/compiler_and_linker/unsorted/ConstantPropagation.c new file mode 100644 index 0000000..e69de29 --- /dev/null +++ b/compiler_and_linker/unsorted/ConstantPropagation.c diff --git a/compiler_and_linker/unsorted/CopyPropagation.c b/compiler_and_linker/unsorted/CopyPropagation.c new file mode 100644 index 0000000..e69de29 --- /dev/null +++ b/compiler_and_linker/unsorted/CopyPropagation.c diff --git a/compiler_and_linker/unsorted/Exceptions.c b/compiler_and_linker/unsorted/Exceptions.c new file mode 100644 index 0000000..e69de29 --- /dev/null +++ b/compiler_and_linker/unsorted/Exceptions.c diff --git a/compiler_and_linker/unsorted/FuncLevelAsmPPC.c b/compiler_and_linker/unsorted/FuncLevelAsmPPC.c new file mode 100644 index 0000000..d054191 --- /dev/null +++ b/compiler_and_linker/unsorted/FuncLevelAsmPPC.c @@ -0,0 +1,22 @@ +#include "compiler/FuncLevelAsmPPC.h" + +void setup_assembly_argument(Object *obj, short i) { +} + +void assign_local_addresses() { +} + +static void FuncAsm_PreScanDirectives() { +} + +static void FuncAsm_AddEntryPoint() { +} + +void Assembler() { +} + +void SetupAssembler() { +} + +void CleanupAssembler() { +} diff --git a/compiler_and_linker/unsorted/FunctionCalls.c b/compiler_and_linker/unsorted/FunctionCalls.c new file mode 100644 index 0000000..e69de29 --- /dev/null +++ b/compiler_and_linker/unsorted/FunctionCalls.c diff --git a/compiler_and_linker/unsorted/GCCInlineAsm.c b/compiler_and_linker/unsorted/GCCInlineAsm.c new file mode 100644 index 0000000..9bceb19 --- /dev/null +++ b/compiler_and_linker/unsorted/GCCInlineAsm.c @@ -0,0 +1,33 @@ +#include "compiler/GCCInlineAsm.h" + +Statement *first_ST_ASM; + +void InlineAsm_SkipComment() { +} + +static void gcc_parse_attribute() { +} + +static void gcc_parse_name() { +} + +static void gcc_parse_expression() { +} + +static void gcc_parse_input() { +} + +static void gcc_parse_output() { +} + +static void gcc_parse_killed() { +} + +static void gcc_replace_arg_st_asm() { +} + +static void gcc_replace_arg() { +} + +void InlineAsm_gcc_parse(void) { +} diff --git a/compiler_and_linker/unsorted/GenStabs.c b/compiler_and_linker/unsorted/GenStabs.c new file mode 100644 index 0000000..e69de29 --- /dev/null +++ b/compiler_and_linker/unsorted/GenStabs.c diff --git a/compiler_and_linker/unsorted/GlobalOptimizer.c b/compiler_and_linker/unsorted/GlobalOptimizer.c new file mode 100644 index 0000000..e69de29 --- /dev/null +++ b/compiler_and_linker/unsorted/GlobalOptimizer.c diff --git a/compiler_and_linker/unsorted/IROUseDef.c b/compiler_and_linker/unsorted/IROUseDef.c new file mode 100644 index 0000000..e69de29 --- /dev/null +++ b/compiler_and_linker/unsorted/IROUseDef.c diff --git a/compiler_and_linker/unsorted/InlineAsm.c b/compiler_and_linker/unsorted/InlineAsm.c new file mode 100644 index 0000000..ae73d91 --- /dev/null +++ b/compiler_and_linker/unsorted/InlineAsm.c @@ -0,0 +1,681 @@ +#include "compiler/InlineAsm.h" +#include "compiler/InlineAsmPPC.h" +#include "compiler/GCCInlineAsm.h" +#include "compiler/CompilerTools.h" +#include "compiler/CError.h" +#include "compiler/CExpr.h" +#include "compiler/CFunc.h" +#include "compiler/CInit.h" +#include "compiler/CInline.h" +#include "compiler/CInt64.h" +#include "compiler/CMachine.h" +#include "compiler/COptimizer.h" +#include "compiler/CParser.h" +#include "compiler/CPrep.h" +#include "compiler/CPrepTokenizer.h" +#include "compiler/CScope.h" +#include "compiler/PCode.h" +#include "compiler/Registers.h" +#include "compiler/objects.h" +#include "compiler/scopes.h" +#include "compiler/types.h" + +int allow_array_expressions = 1; + +int backtracking; +jmp_buf backtrack; +jmp_buf InlineAsm_assemblererror; +static int ASMstmtnb; + +void AssemblerError(void) { + longjmp(InlineAsm_assemblererror, 1); +} + +void InlineAsm_SyntaxError(short code) { + if (backtracking) + longjmp(backtrack, 1); + + if (tk == TK_NEG7 || tk == ';') + code = CErrorStr112; + CError_Error(code); +} + +CLabel *InlineAsm_LookupLabel(HashNameNode *name) { + CLabel *label; + + for (label = Labels; label; label = label->next) { + if (name == label->name) + break; + } + + return label; +} + +CLabel *InlineAsm_DeclareLabel(HashNameNode *name) { + CLabel *label = newlabel(); + label->name = name; + label->next = Labels; + Labels = label; + return label; +} + +static void InlineAsm_DefineLabel(HashNameNode *name) { + CLabel *label; + Statement *stmt; + + label = InlineAsm_LookupLabel(name); + if (!label) { + label = InlineAsm_DeclareLabel(name); + } else { + if (label->stmt) + CError_Error(CErrorStr171, name->name); + } + + stmt = CFunc_AppendStatement(ST_LABEL); + stmt->label = label; + label->stmt = stmt; +} + +Boolean InlineAsm_LookupSymbolOrTag(HashNameNode *name, IALookupResult *result, Boolean allow_tag) { + ObjBase *obj; + NameSpace *nspace; + NameSpaceObjectList *list; + + result->name = name; + result->object = NULL; + result->label = NULL; + result->type = NULL; + result->has_value = 0; + + if ((result->label = InlineAsm_LookupLabel(name))) + return 1; + + for (nspace = cscope_current; nspace; nspace = nspace->parent) { + if ((list = CScope_FindName(nspace, name))) { + obj = list->object; + switch (obj->otype) { + case OT_ENUMCONST: + result->has_value = 1; + result->value = OBJ_ENUM_CONST(list->object)->val.lo; + return 1; + case OT_OBJECT: + if (OBJECT(obj)->datatype == DABSOLUTE) { + result->has_value = 1; + result->value = OBJECT(obj)->u.address; + } else { + if (OBJECT(obj)->datatype == DDATA && (OBJECT(obj)->qual & Q_10000)) + CInit_ExportConst(OBJECT(obj)); + result->object = OBJECT(obj); + } + return 1; + case OT_TYPE: + result->type = OBJ_TYPE(obj)->type; + return 1; + case OT_TYPETAG: + if (allow_tag) { + result->type = OBJ_TYPE_TAG(obj)->type; + return 1; + } + case OT_NAMESPACE: + case OT_MEMBERVAR: + return 0; + default: +#line 245 + CError_FATAL(); + } + } + } + + return 0; +} + +Boolean InlineAsm_LookupSymbol(HashNameNode *name, IALookupResult *result) { + return InlineAsm_LookupSymbolOrTag(name, result, 0); +} + +static ObjMemberVar *isclassmember(TypeClass *tclass, HashNameNode *name) { + NameSpaceObjectList *list; + + list = CScope_FindName(tclass->nspace, name); + return (list && list->object->otype == OT_MEMBERVAR) ? OBJ_MEMBER_VAR(list->object) : NULL; +} + +SInt32 InlineAsm_StructMemberOffset(Type *type) { + StructMember *member; + ObjMemberVar *ivar; + SInt32 offset = 0; + + do { + if (IS_TYPE_STRUCT(type)) { + tk = lex(); + if (tk != TK_IDENTIFIER) + InlineAsm_SyntaxError(CErrorStr107); + member = ismember(TYPE_STRUCT(type), tkidentifier); + if (!member) + CError_Error(CErrorStr150, tkidentifier->name); + offset += member->offset; + type = member->type; + tk = lex(); + } else if (IS_TYPE_CLASS(type)) { + tk = lex(); + if (tk != TK_IDENTIFIER) + InlineAsm_SyntaxError(CErrorStr107); + ivar = isclassmember(TYPE_CLASS(type), tkidentifier); + if (!ivar) + CError_Error(CErrorStr150, tkidentifier->name); + offset += ivar->offset; + type = ivar->type; + tk = lex(); + } else { + CError_Error(CErrorStr149); + } + } while (tk == '.'); + + return offset; +} + +SInt32 InlineAsm_StructArrayMemberOffset(Type *type) { + StructMember *member; + ObjMemberVar *ivar; + SInt32 offset = 0; + + do { + if (tk == '.') { + if (IS_TYPE_STRUCT(type)) { + tk = lex(); + if (tk != TK_IDENTIFIER) + InlineAsm_SyntaxError(CErrorStr107); + member = ismember(TYPE_STRUCT(type), tkidentifier); + if (!member) + CError_Error(CErrorStr150, tkidentifier->name); + offset += member->offset; + type = member->type; + tk = lex(); + } else if (IS_TYPE_CLASS(type)) { + tk = lex(); + if (tk != TK_IDENTIFIER) + InlineAsm_SyntaxError(CErrorStr107); + ivar = isclassmember(TYPE_CLASS(type), tkidentifier); + if (!ivar) + CError_Error(CErrorStr150, tkidentifier->name); + offset += ivar->offset; + type = ivar->type; + tk = lex(); + } else { + CError_Error(CErrorStr149); + } + } else { + if (IS_TYPE_ARRAY(type)) { + type = TPTR_TARGET(type); + tk = lex(); + offset += type->size * InlineAsm_ConstantExpression(); + if (tk != ']') + InlineAsm_SyntaxError(125); + tk = lex(); + } else { + CError_Error(CErrorStr148); + } + } + } while (tk == '.' || tk == '['); + + return offset; +} + +SInt32 InlineAsm_StructPointerMemberOffset(Type *type) { + StructMember *member; + ObjMemberVar *ivar; + SInt32 offset; + + tk = lex(); + if (tk != TK_IDENTIFIER) + InlineAsm_SyntaxError(107); + + if (IS_TYPE_STRUCT(type)) { + member = ismember(TYPE_STRUCT(type), tkidentifier); + if (!member) + CError_Error(CErrorStr150, tkidentifier->name); + offset = member->offset; + type = member->type; + } else { + ivar = isclassmember(TYPE_CLASS(type), tkidentifier); + if (!ivar) + CError_Error(CErrorStr150, tkidentifier->name); + offset = ivar->offset; + type = ivar->type; + } + + tk = lex(); + if (tk == '.' || tk == '[') + offset += InlineAsm_StructArrayMemberOffset(type); + + return offset; +} + +static SInt32 DiadicOperator(SInt32 left, short op, SInt32 right) { + CInt64 left64; + CInt64 right64; + CInt64_SetLong(&left64, left); + CInt64_SetLong(&right64, right); + right64 = CMach_CalcIntDiadic(TYPE(&stsignedint), left64, op, right64); + return CInt64_GetULong(&right64); +} + +static SInt32 PrimaryExpression(void) { + IALookupResult result; + SInt32 value; + + switch (tk) { + case TK_IDENTIFIER: + if (InlineAsm_LookupSymbol(tkidentifier, &result)) { + if (result.has_value) { + tk = lex(); + return result.value; + } + + if (result.type && (IS_TYPE_STRUCT(result.type) || IS_TYPE_CLASS(result.type))) { + tk = lex(); + if (tk != '.') + InlineAsm_SyntaxError(120); + if (allow_array_expressions) + return InlineAsm_StructArrayMemberOffset(result.type); + else + return InlineAsm_StructMemberOffset(result.type); + } else { + InlineAsm_SyntaxError(124); + } + } else { + InlineAsm_SyntaxError(124); + } + break; + case TK_INTCONST: + value = tkintconst.lo; + tk = lex(); + return value; + case TK_SIZEOF: + return scansizeof(); + case '+': + tk = lex(); + return PrimaryExpression(); + case '-': + tk = lex(); + return -PrimaryExpression(); + case '!': + tk = lex(); + return PrimaryExpression() == 0; + case '~': + tk = lex(); + return ~PrimaryExpression(); + case '(': + tk = lex(); + value = InlineAsm_ConstantExpression(); + if (tk != ')') + InlineAsm_SyntaxError(115); + tk = lex(); + return value; + default: + InlineAsm_SyntaxError(120); + } + + return 0; +} + +static SInt32 ConstantExpressionTail(SInt32 value) { + SInt32 right; + short left_token; + short right_prec; + + while (1) { + left_token = tk; + tk = lex(); + right = PrimaryExpression(); + + right_prec = GetPrec(tk); + if (right_prec == 0) + return DiadicOperator(value, left_token, right); + + if (GetPrec(left_token) >= right_prec) { + value = DiadicOperator(value, left_token, right); + } else { + value = DiadicOperator(value, left_token, ConstantExpressionTail(right)); + if (GetPrec(tk) == 0) + return value; + } + } +} + +SInt32 InlineAsm_ConstantExpression(void) { + SInt32 value = PrimaryExpression(); + + if (GetPrec(tk) == 0) + return value; + else + return ConstantExpressionTail(value); +} + +HashNameNode *MakeLocalLabel(CInt64 num) { + char buf[80]; + sprintf(buf, "@%i_%i", ASMstmtnb, CInt64_GetULong(&num)); + return GetHashNameNodeExport(buf); +} + +static void ScanOptionalLabel() { + if (tk == TK_INTCONST) { + if (lookahead() == ':') { + InlineAsm_DefineLabel(MakeLocalLabel(tkintconst)); + tk = lex(); + tk = lex(); + } + } else { + if (tkidentifier->name[0] == '@') { + InlineAsm_DefineLabel(tkidentifier); + tk = lex(); + if (tk == ':') + tk = lex(); + } else { + HashNameNode *name = tkidentifier; + short t = lookahead(); + tkidentifier = name; + if (t == ':') { + InlineAsm_DefineLabel(name); + tk = lex(); + tk = lex(); + } + } + } +} + +static void ScanStatements(volatile short endToken, UInt8 mode) { + if (setjmp(InlineAsm_assemblererror)) { + while (tk != TK_NEG7 && tk != endToken && tk != '}' && tk) + tk = lex(); + if (tk == ';' || tk == TK_NEG7) + tk = lex(); + } else { + InlineAsm_Initialize(mode); + InlineAsm_gccmode = 0; + if (setjmp(InlineAsm_assemblererror)) { + while (tk != ';' && tk != TK_NEG7 && tk != endToken && tk != '}' && tk) + tk = lex(); + if (tk == ';' || tk == TK_NEG7) + tk = lex(); + } + + while (tk && tk != endToken) { + backtracking = 0; + sourceoffset = CPrep_GetFileOffsetInfo(&cparser_fileoffset); + if (tk == '"') { + if (InlineAsm_gccmode) { + tk = lex(); + InlineAsm_gcc_parse(); + } else { + InlineAsm_gccmode = 1; + copts.cplusplus = 0; + copts.asmpoundcomment = 1; + tk = lex(); + } + } + + if (tk == '.') { + InlineAsm_ScanAssemblyDirective(); + } else if (tk == TK_IDENTIFIER) { + ScanOptionalLabel(); + if (tk == TK_IDENTIFIER) + InlineAsm_ScanAssemblyInstruction(); + } else if (tk == TK_INTCONST) { + ScanOptionalLabel(); + if (tk == TK_IDENTIFIER) + InlineAsm_ScanAssemblyInstruction(); + } + + if (InlineAsm_gccmode && tk == '"') { + tk = lex(); + InlineAsm_gcc_parse(); + } + + if (tk == ';' || tk == TK_NEG7) { + CPrep_TokenStreamFlush(); + tk = lex(); + } else if (tk != endToken) { + if (endToken == ')') + CError_Error(CErrorStr115); + else + CError_Error(CErrorStr113); + } + } + } +} + +void InlineAsm_ScanStatements(volatile short endToken) { + ScanStatements(endToken, 0); +} + +void InlineAsm_ScanFunction(volatile short endToken) { + ScanStatements(endToken, 1); +} + +void InlineAsm_Assemble(void) { + short token = (tk == '(') ? ')' : '}'; + char save_pc = copts.asmpoundcomment; + char save_cpp = copts.cplusplus; + + cprep_nostring = 1; + CFunc_AppendStatement(ST_NOP); + first_ST_ASM = curstmt; + ASMstmtnb++; + + cprep_eoltokens = 1; + in_assembler = 1; + tk = lex(); + InlineAsm_ScanStatements(token); + in_assembler = 0; + cprep_eoltokens = 0; + cprep_nostring = 0; + + copts.asmpoundcomment = save_pc; + copts.cplusplus = save_cpp; +} + +void InlineAsm_PackAsmStatement(Statement *stmt, Statement *first, void **output, SInt32 *outsize) { + InlineAsm *src; + InlineAsm *dest; + IAOperand *op; + SInt32 i; + SInt32 size; + + src = (InlineAsm *) stmt->expr; + size = sizeof(InlineAsm) + sizeof(IAOperand) * src->argcount; + dest = galloc(size); + memcpy(dest, src, size); + + for (i = 0, op = dest->args; i < dest->argcount; i++, op++) { + switch (op->type) { + case IAOpnd_0: + break; + case IAOpnd_Reg: + case IAOpnd_4: + op->u.reg.object = (Object *) CInline_GetLocalID(op->u.reg.object); + break; + case IAOpnd_Lab: + op->u.lab.label = (CLabel *) CInline_GetStatementNumber(first, op->u.lab.label->stmt); + break; + case IAOpnd_LabDiff: + op->u.labdiff.label1 = (CLabel *) CInline_GetStatementNumber(first, op->u.labdiff.label1->stmt); + op->u.labdiff.label2 = (CLabel *) CInline_GetStatementNumber(first, op->u.labdiff.label2->stmt); + break; + } + } + + *output = dest; + *outsize = size; +} + +void InlineAsm_UnpackAsmStatement(Statement *stmt, CLabel **labelArray, Boolean flag, void *data, SInt32 size) { + InlineAsm *ia; + IAOperand *op; + SInt32 i; + + ia = galloc(size); + memcpy(ia, data, size); + + for (i = 0, op = ia->args; i < ia->argcount; i++, op++) { + switch (op->type) { + case IAOpnd_0: + break; + case IAOpnd_Reg: + case IAOpnd_4: + op->u.reg.object = CInline_GetLocalObj((SInt32) op->u.reg.object, flag); + break; + case IAOpnd_Lab: + op->u.lab.label = labelArray[(SInt16) op->u.lab.label]; + break; + case IAOpnd_LabDiff: + op->u.labdiff.label1 = labelArray[(SInt16) op->u.labdiff.label1]; + op->u.labdiff.label2 = labelArray[(SInt16) op->u.labdiff.label2]; + break; + } + } + + stmt->expr = (ENode *) ia; +} + +void InlineAsm_CheckLocalUsage(Statement *stmt) { + InlineAsm *ia = (InlineAsm *) stmt->expr; + IAOperand *op; + SInt32 i; + + for (i = 0, op = ia->args; i < ia->argcount; i++, op++) { + switch (op->type) { + case IAOpnd_Reg: + if (op->u.reg.object) + SetVarUsage(op->u.reg.object, 0); + break; + case IAOpnd_4: + SetVarUsage(op->u.obj.obj, 1); + break; + } + } +} + +CLabel *InlineAsm_GetReferencedLabel(Statement *stmt) { + InlineAsm *ia = (InlineAsm *) stmt->expr; + IAOperand *op; + SInt32 i; + + for (i = 0, op = ia->args; i < ia->argcount; i++, op++) { + if (op->type == IAOpnd_Lab) + return op->u.lab.label; + if (op->type == IAOpnd_LabDiff) + return op->u.labdiff.label1; + } + + return NULL; +} + +CLabel *InlineAsm_GetReferencedLabel2(Statement *stmt) { + InlineAsm *ia = (InlineAsm *) stmt->expr; + IAOperand *op; + SInt32 i; + + for (i = 0, op = ia->args; i < ia->argcount; i++, op++) { + if (op->type == IAOpnd_LabDiff) + return op->u.labdiff.label2; + } + + return NULL; +} + +Object *InlineAsm_GetObjectOffset(InlineAsm *ia, SInt32 index, SInt32 *offset) { + IAOperand *op; + SInt32 i; + SInt32 counter; + + for (i = 0, counter = 0, op = ia->args; i < ia->argcount; i++, op++) { + if (op->type == IAOpnd_3) { + if (counter++ == index) { + *offset = ((SInt32) &op->u.obj.obj) - ((SInt32) ia); + return op->u.obj.obj; + } + } + } + + return NULL; +} + +char *InlineAsm_DumpStatement(Statement *stmt) { + static char buffer[1024]; + InlineAsm *ia; + IAOperand *arg; + int i; + char ch; + SInt32 offset; + + ia = (InlineAsm *) stmt->expr; + + strcpy(buffer, "\""); + strcat(buffer, InlineAsm_GetMnemonic(ia)); + strcat(buffer, "\""); + + for (i = 0, arg = ia->args; i < ia->argcount; i++, arg++) { + char argbuf[1024]; + + switch (arg->type) { + case IAOpnd_Imm: + sprintf(argbuf, " imm(%ld)", arg->u.imm.value); + break; + case IAOpnd_Reg: + ch = ' '; + if (arg->u.reg.effect & EffectWrite) { + if (arg->u.reg.effect & EffectRead) + ch = '+'; + else + ch = '='; + } else { + if (!(arg->u.reg.effect & EffectRead)) + ch = '0'; + } + + if (arg->u.reg.object) { + sprintf(argbuf, + "%creg(%s)", + ch, + arg->u.reg.object->name->name); + } else { + sprintf(argbuf, + "%creg(%s%d)", + ch, + register_class_name[arg->u.reg.rclass], + arg->u.reg.num); + } + break; + + case IAOpnd_3: + case IAOpnd_4: + if (arg->u.obj.offset > 0) + sprintf(argbuf, " obj(%s+%ld)", arg->u.obj.obj->name->name, arg->u.obj.offset); + else if (arg->u.obj.offset < 0) + sprintf(argbuf, " obj(%s-%ld)", arg->u.obj.obj->name->name, -arg->u.obj.offset); + else + sprintf(argbuf, " obj(%s)", arg->u.obj.obj->name->name); + break; + + case IAOpnd_Lab: + sprintf(argbuf, " lab(%s)", arg->u.lab.label->uniquename->name); + break; + + case IAOpnd_LabDiff: + offset = !arg->negated ? 0 : arg->u.labdiff.offset; + sprintf(argbuf, + " labdiff(%s-%s%c%d)", + arg->u.labdiff.label1->uniquename->name, + arg->u.labdiff.label2->uniquename->name, + (arg->negated == 1) ? '-' : '+', + offset + ); + break; + } + + strcat(buffer, argbuf); + } + + return buffer; +} diff --git a/compiler_and_linker/unsorted/InlineAsmMnemonicsPPC.c b/compiler_and_linker/unsorted/InlineAsmMnemonicsPPC.c new file mode 100644 index 0000000..07d7d2c --- /dev/null +++ b/compiler_and_linker/unsorted/InlineAsmMnemonicsPPC.c @@ -0,0 +1,1036 @@ +#include "compiler/InlineAsmMnemonicsPPC.h" +#include "compiler/InlineAsm.h" +#include "compiler/CompilerTools.h" + +static IAMnemonic mnemonics[] = { + "abs", 0x000001A7, "=r,r", 0x00000001, 0x7C0002D0, + "abs.", 0x000001A7, "=r,r;=Z", 0x00000001, 0x7C0002D1, + "abso", 0x000001A7, "=r,r;+X", 0x00000001, 0x7C0006D0, + "abso.", 0x000001A7, "=r,r;+X=Z", 0x00000001, 0x7C0006D1, + "add", 0x0000003C, "=r,r,r", 0x000FFFFF, 0x7C000214, + "add.", 0x0000003C, "=r,r,r;=Z", 0x000FFFFF, 0x7C000215, + "addo", 0x0000003C, "=r,r,r;+X", 0x000FFFFF, 0x7C000614, + "addo.", 0x0000003C, "=r,r,r;+X=Z", 0x000FFFFF, 0x7C000615, + "addc", 0x0000003D, "=r,r,r;+X", 0x000FFFFF, 0x7C000014, + "addc.", 0x0000003D, "=r,r,r;+X=Z", 0x000FFFFF, 0x7C000015, + "addco", 0x0000003D, "=r,r,r;+X", 0x000FFFFF, 0x7C000414, + "addco.", 0x0000003D, "=r,r,r;+X=Z", 0x000FFFFF, 0x7C000415, + "adde", 0x0000003E, "=r,r,r;+X", 0x000FFFFF, 0x7C000114, + "adde.", 0x0000003E, "=r,r,r;+X=Z", 0x000FFFFF, 0x7C000115, + "addeo", 0x0000003E, "=r,r,r;+X", 0x000FFFFF, 0x7C000514, + "addeo.", 0x0000003E, "=r,r,r;+X=Z", 0x000FFFFF, 0x7C000515, + "addi", 0x0000003F, "=r,b,m;p", 0x000FFFFF, 0x38000000, + "addic", 0x00000040, "=r,r,i;+X", 0x000FFFFF, 0x30000000, + "addic.", 0x00000041, "=r,r,i;+X=Z", 0x000FFFFF, 0x34000000, + "addis", 0x00000042, "=r,b,M", 0x000FFFFF, 0x3C000000, + "addme", 0x00000043, "=r,r;+X", 0x000FFFFF, 0x7C0001D4, + "addme.", 0x00000043, "=r,r;+X=Z", 0x000FFFFF, 0x7C0001D5, + "addmeo", 0x00000043, "=r,r;+X", 0x000FFFFF, 0x7C0005D4, + "addmeo.", 0x00000043, "=r,r;+X=Z", 0x000FFFFF, 0x7C0005D5, + "addze", 0x00000044, "=r,r;+X", 0x000FFFFF, 0x7C000194, + "addze.", 0x00000044, "=r,r;+X=Z", 0x000FFFFF, 0x7C000195, + "addzeo", 0x00000044, "=r,r;+X", 0x000FFFFF, 0x7C000594, + "addzeo.", 0x00000044, "=r,r;+X=Z", 0x000FFFFF, 0x7C000595, + "and", 0x0000005C, "=r,r,r", 0x000FFFFF, 0x7C000038, + "and.", 0x0000005C, "=r,r,r;=Z", 0x000FFFFF, 0x7C000039, + "andc", 0x00000062, "=r,r,r", 0x000FFFFF, 0x7C000078, + "andc.", 0x00000062, "=r,r,r;=Z", 0x000FFFFF, 0x7C000079, + "andi.", 0x00000056, "=r,r,x;=Z", 0x000FFFFF, 0x70000000, + "andis.", 0x00000057, "=r,r,x;=Z", 0x000FFFFF, 0x74000000, + "b", 0x00000000, "l;p", 0x000FFFFF, 0x48000000, + "ba", 0x00000000, "l;p", 0x000FFFFF, 0x48000002, + "bc", 0x00000002, "B,Q,l;p", 0x000FFFFF, 0x40000000, + "bca", 0x00000002, "B,Q,l;p", 0x000FFFFF, 0x40000002, + "bcla", 0x00000002, "B,Q,l;=L", 0x000FFFFF, 0x40000003, + "bcctr", 0x00000004, "B,Q;Cp", 0x000FFFFF, 0x4C000420, + "bcctrl", 0x00000004, "B,Q;C=L", 0x000FFFFF, 0x4C000421, + "bcl", 0x00000002, "B,Q,l;=L", 0x000FFFFF, 0x40000001, + "bclr", 0x00000003, "B,Q;L", 0x000FFFFF, 0x4C000020, + "bclrl", 0x00000003, "B,Q;+L", 0x000FFFFF, 0x4C000021, + "bl", 0x00000001, "l;=L", 0x000FFFFF, 0x48000001, + "bla", 0x00000001, "l;=L", 0x000FFFFF, 0x48000003, + "clcs", 0x000001A8, "=r,r", 0x00000001, 0x7C000426, + "cmp", 0x00000053, "=?c,Or,r", 0x000FFFFF, 0x7C000000, + "cmpi", 0x00000052, "=?c,Or,i", 0x000FFFFF, 0x2C000000, + "cmpl", 0x00000055, "=?c,Or,r", 0x000FFFFF, 0x7C000040, + "cmpli", 0x00000054, "=?c,Or,u", 0x000FFFFF, 0x28000000, + "cntlzw", 0x00000066, "=r,r", 0x000FFFFF, 0x7C000034, + "cntlzw.", 0x00000066, "=r,r;=Z", 0x000FFFFF, 0x7C000035, + "crand", 0x0000006E, "=Q,Q,Q", 0x000FFFFF, 0x4C000202, + "crandc", 0x0000006F, "=Q,Q,Q", 0x000FFFFF, 0x4C000102, + "creqv", 0x00000070, "=Q,Q,Q", 0x000FFFFF, 0x4C000242, + "crnand", 0x00000071, "=Q,Q,Q", 0x000FFFFF, 0x4C0001C2, + "crnor", 0x00000072, "=Q,Q,Q", 0x000FFFFF, 0x4C000042, + "cror", 0x00000073, "=Q,Q,Q", 0x000FFFFF, 0x4C000382, + "crorc", 0x00000074, "=Q,Q,Q", 0x000FFFFF, 0x4C000342, + "crxor", 0x00000075, "=Q,Q,Q", 0x000FFFFF, 0x4C000182, + "dcbf", 0x00000037, "b,r", 0x080FFFFF, 0x7C0000AC, + "dcbst", 0x00000038, "b,r", 0x080FFFFF, 0x7C00006C, + "dcbt", 0x00000039, "b,r", 0x080FFFFF, 0x7C00022C, + "dcbtst", 0x0000003A, "b,r", 0x080FFFFF, 0x7C0001EC, + "dcba", 0x000000EB, "b,r", 0x00004000, 0x7C0005EC, + "dcbz", 0x0000003B, "b,r", 0x080FFFFF, 0x7C0007EC, + "dccci", 0x000000DE, "b,r", 0x000007C0, 0x7C00038C, + "dcread", 0x000000DF, "=r,(b,r)", 0x000007C0, 0x7C0003CC, + "dcbi", 0x000000C3, "b,r", 0x080FFFFF, 0x7C0003AC, + "icbi", 0x000000C4, "b,r", 0x000FEFFF, 0x7C0007AC, + "icbt", 0x000000E0, "b,r", 0x000007C0, 0x7C00020C, + "iccci", 0x000000E1, "b,r", 0x000007C0, 0x7C00078C, + "icread", 0x000000E2, "b,r", 0x000007C0, 0x7C0007CC, + "div", 0x000001A2, "=r,r,r", 0x00000001, 0x7C000296, + "div.", 0x000001A2, "=r,r,r;=Z", 0x00000001, 0x7C000297, + "divo", 0x000001A2, "=r,r,r;+X", 0x00000001, 0x7C000696, + "divo.", 0x000001A2, "=r,r,r;+X=Z", 0x00000001, 0x7C000697, + "divs", 0x000001A3, "=r,r,r", 0x00000001, 0x7C0002D6, + "divs.", 0x000001A3, "=r,r,r;=Z", 0x00000001, 0x7C0002D7, + "divso", 0x000001A3, "=r,r,r;+X", 0x00000001, 0x7C0006D6, + "divso.", 0x000001A3, "=r,r,r;+X=Z", 0x00000001, 0x7C0006D7, + "divw", 0x00000045, "=r,r,r", 0x000FFFFF, 0x7C0003D6, + "divw.", 0x00000045, "=r,r,r;=Z", 0x000FFFFF, 0x7C0003D7, + "divwo", 0x00000045, "=r,r,r;+X", 0x000FFFFF, 0x7C0007D6, + "divwo.", 0x00000045, "=r,r,r;+X=Z", 0x000FFFFF, 0x7C0007D7, + "divwu", 0x00000046, "=r,r,r", 0x000FFFFF, 0x7C000396, + "divwu.", 0x00000046, "=r,r,r;=Z", 0x000FFFFF, 0x7C000397, + "divwuo", 0x00000046, "=r,r,r;+X", 0x000FFFFF, 0x7C000796, + "divwuo.", 0x00000046, "=r,r,r;+X=Z", 0x000FFFFF, 0x7C000797, + "doz", 0x000001A4, "=r,r,r", 0x00000001, 0x7C000210, + "doz.", 0x000001A4, "=r,r,r;=Z", 0x00000001, 0x7C000211, + "dozo", 0x000001A4, "=r,r,r;+X", 0x00000001, 0x7C000610, + "dozo.", 0x000001A4, "=r,r,r;+X=Z", 0x00000001, 0x7C000611, + "dozi", 0x000001A9, "=r,r,x", 0x00000001, 0x24000000, + "dsa", 0x000000DC, "", 0x00000002, 0x7C0004E8, + "esa", 0x000000DD, "", 0x00000002, 0x7C0004A8, + "eciwx", 0x000000C1, "=r,(b,r)", 0x020FFFFF, 0x7C00026C, + "ecowx", 0x000000C2, "r,(b,r)", 0x020FFFFF, 0x7C00036C, + "eieio", 0x00000085, "", 0x000FFFFF, 0x7C0006AC, + "eqv", 0x00000061, "=r,r,r", 0x000FFFFF, 0x7C000238, + "eqv.", 0x00000061, "=r,r,r;=Z", 0x000FFFFF, 0x7C000239, + "extsb", 0x00000064, "=r,r", 0x000FFFFF, 0x7C000774, + "extsb.", 0x00000064, "=r,r;=Z", 0x000FFFFF, 0x7C000775, + "extsh", 0x00000065, "=r,r", 0x000FFFFF, 0x7C000734, + "extsh.", 0x00000065, "=r,r;=Z", 0x000FFFFF, 0x7C000735, + "fabs", 0x0000009F, "=f,f", 0x800FFFFF, 0xFC000210, + "fabs.", 0x0000009F, "=f,f;=Z", 0x800FFFFF, 0xFC000211, + "fadd", 0x000000A2, "=f,f,f", 0x800FFFFF, 0xFC00002A, + "fadd.", 0x000000A2, "=f,f,f;=Z", 0x800FFFFF, 0xFC00002B, + "fadds", 0x000000A3, "=f,f,f", 0x800FFFFF, 0xEC00002A, + "fadds.", 0x000000A3, "=f,f,f;=Z", 0x800FFFFF, 0xEC00002B, + "fcmpo", 0x000000B9, "=?c,f,f", 0x800FFFFF, 0xFC000040, + "fcmpu", 0x000000B8, "=?c,f,f", 0x800FFFFF, 0xFC000000, + "fctiw", 0x000000B6, "=f,f", 0x800FFFFF, 0xFC00001C, + "fctiw.", 0x000000B6, "=f,f;=Z", 0x800FFFFF, 0xFC00001D, + "fctiwz", 0x000000B7, "=f,f", 0x800FFFFF, 0xFC00001E, + "fctiwz.", 0x000000B7, "=f,f;=Z", 0x800FFFFF, 0xFC00001F, + "fdiv", 0x000000A8, "=f,f,f", 0x800FFFFF, 0xFC000024, + "fdiv.", 0x000000A8, "=f,f,f;=Z", 0x800FFFFF, 0xFC000025, + "fdivs", 0x000000A9, "=f,f,f", 0x800FFFFF, 0xEC000024, + "fdivs.", 0x000000A9, "=f,f,f;=Z", 0x800FFFFF, 0xEC000025, + "fmadd", 0x000000AA, "=f,f,f,f", 0x800FFFFF, 0xFC00003A, + "fmadd.", 0x000000AA, "=f,f,f,f;=Z", 0x800FFFFF, 0xFC00003B, + "fmadds", 0x000000AB, "=f,f,f,f", 0x800FFFFF, 0xEC00003A, + "fmadds.", 0x000000AB, "=f,f,f,f;=Z", 0x800FFFFF, 0xEC00003B, + "fmr", 0x0000009E, "=f,f", 0x800FFFFF, 0xFC000090, + "fmr.", 0x0000009E, "=f,f;=Z", 0x800FFFFF, 0xFC000091, + "fmsub", 0x000000AC, "=f,f,f,f", 0x800FFFFF, 0xFC000038, + "fmsub.", 0x000000AC, "=f,f,f,f;=Z", 0x800FFFFF, 0xFC000039, + "fmsubs", 0x000000AD, "=f,f,f,f", 0x800FFFFF, 0xEC000038, + "fmsubs.", 0x000000AD, "=f,f,f,f;=Z", 0x800FFFFF, 0xEC000039, + "fmul", 0x000000A6, "=f,f,f", 0x800FFFFF, 0xFC000032, + "fmul.", 0x000000A6, "=f,f,f;=Z", 0x800FFFFF, 0xFC000033, + "fmuls", 0x000000A7, "=f,f,f", 0x800FFFFF, 0xEC000032, + "fmuls.", 0x000000A7, "=f,f,f;=Z", 0x800FFFFF, 0xEC000033, + "fnabs", 0x000000A1, "=f,f", 0x800FFFFF, 0xFC000110, + "fnabs.", 0x000000A1, "=f,f;=Z", 0x800FFFFF, 0xFC000111, + "fneg", 0x000000A0, "=f,f", 0x800FFFFF, 0xFC000050, + "fneg.", 0x000000A0, "=f,f;=Z", 0x800FFFFF, 0xFC000051, + "fnmadd", 0x000000AE, "=f,f,f,f", 0x800FFFFF, 0xFC00003E, + "fnmadd.", 0x000000AE, "=f,f,f,f;=Z", 0x800FFFFF, 0xFC00003F, + "fnmadds", 0x000000AF, "=f,f,f,f", 0x800FFFFF, 0xEC00003E, + "fnmadds.", 0x000000AF, "=f,f,f,f;=Z", 0x800FFFFF, 0xEC00003F, + "fnmsub", 0x000000B0, "=f,f,f,f", 0x800FFFFF, 0xFC00003C, + "fnmsub.", 0x000000B0, "=f,f,f,f;=Z", 0x800FFFFF, 0xFC00003D, + "fnmsubs", 0x000000B1, "=f,f,f,f", 0x800FFFFF, 0xEC00003C, + "fnmsubs.", 0x000000B1, "=f,f,f,f;=Z", 0x800FFFFF, 0xEC00003D, + "fres", 0x000000B2, "=f,f", 0x808FFFFF, 0xEC000030, + "fres.", 0x000000B2, "=f,f;=Z", 0x808FFFFF, 0xEC000031, + "frsp", 0x000000B5, "=f,f", 0x800FFFFF, 0xFC000018, + "frsp.", 0x000000B5, "=f,f;=Z", 0x800FFFFF, 0xFC000019, + "frsqrte", 0x000000B3, "=f,f", 0x808FFFFF, 0xFC000034, + "frsqrte.", 0x000000B3, "=f,f;=Z", 0x808FFFFF, 0xFC000035, + "fsel", 0x000000B4, "=f,f,f,f", 0x808FFFFF, 0xFC00002E, + "fsel.", 0x000000B4, "=f,f,f,f;=Z", 0x808FFFFF, 0xFC00002F, + "fsqrt", 0x000000D0, "=f,f", 0x80000000, 0xFC00002C, + "fsqrt.", 0x000000D0, "=f,f;=Z", 0x80000000, 0xFC00002D, + "fsqrts", 0x000000D1, "=f,f", 0x80000000, 0xEC00002C, + "fsqrts.", 0x000000D1, "=f,f;=Z", 0x80000000, 0xEC00002D, + "fsub", 0x000000A4, "=f,f,f", 0x800FFFFF, 0xFC000028, + "fsub.", 0x000000A4, "=f,f,f;=Z", 0x800FFFFF, 0xFC000029, + "fsubs", 0x000000A5, "=f,f,f", 0x800FFFFF, 0xEC000028, + "fsubs.", 0x000000A5, "=f,f,f;=Z", 0x800FFFFF, 0xEC000029, + "isync", 0x00000086, "", 0x000FFFFF, 0x4C00012C, + "lbz", 0x00000015, "=r,d(b)", 0x000FFFFF, 0x88000000, + "lbzu", 0x00000016, "=r,d(+b)", 0x000FFFFF, 0x8C000000, + "lbzx", 0x00000017, "=r,(b,r)", 0x000FFFFF, 0x7C0000AE, + "lbzux", 0x00000018, "=r,(+b,r)", 0x000FFFFF, 0x7C0000EE, + "lfd", 0x00000092, "=f,d(b)", 0x800FFFFF, 0xC8000000, + "lfdu", 0x00000093, "=f,d(+b)", 0x800FFFFF, 0xCC000000, + "lfdx", 0x00000094, "=f,(b,r)", 0x800FFFFF, 0x7C0004AE, + "lfdux", 0x00000095, "=f,(+b,r)", 0x800FFFFF, 0x7C0004EE, + "lfs", 0x0000008E, "=f,d(b)", 0x800FFFFF, 0xC0000000, + "lfsu", 0x0000008F, "=f,d(+b)", 0x800FFFFF, 0xC4000000, + "lfsx", 0x00000090, "=f,(b,r)", 0x800FFFFF, 0x7C00042E, + "lfsux", 0x00000091, "=f,(+b,r)", 0x800FFFFF, 0x7C00046E, + "lha", 0x0000001D, "=r,d(b)", 0x000FFFFF, 0xA8000000, + "lhau", 0x0000001E, "=r,d(+b)", 0x000FFFFF, 0xAC000000, + "lhaux", 0x00000020, "=r,(+b,r)", 0x000FFFFF, 0x7C0002EE, + "lhax", 0x0000001F, "=r,(b,r)", 0x000FFFFF, 0x7C0002AE, + "lhbrx", 0x00000021, "=r,(b,r)", 0x000FFFFF, 0x7C00062C, + "lhz", 0x00000019, "=r,d(b)", 0x000FFFFF, 0xA0000000, + "lhzu", 0x0000001A, "=r,d(+b)", 0x000FFFFF, 0xA4000000, + "lhzux", 0x0000001C, "=r,(+b,r)", 0x000FFFFF, 0x7C00026E, + "lhzx", 0x0000001B, "=r,(b,r)", 0x000FFFFF, 0x7C00022E, + "lmw", 0x00000027, "=r,d(b)", 0x000FFFFF, 0xB8000000, + "lscbx", 0x000001A1, "=r,(b,r)", 0x00000001, 0x7C00022A, + "lscbx.", 0x000001A1, "=r,(b,r);=Z", 0x00000001, 0x7C00022B, + "lswi", 0x000000BB, "=r,b,N", 0x000FFFFF, 0x7C0004AA, + "lswx", 0x000000BC, "=r,(b,r)", 0x000FFFFF, 0x7C00042A, + "lwarx", 0x000000BA, "=r,(b,r)", 0x000FFFFF, 0x7C000028, + "lwbrx", 0x00000026, "=r,(b,r)", 0x000FFFFF, 0x7C00042C, + "lwz", 0x00000022, "=r,d(b)", 0x000FFFFF, 0x80000000, + "lwzu", 0x00000023, "=r,d(+b)", 0x000FFFFF, 0x84000000, + "lwzux", 0x00000025, "=r,(+b,r)", 0x000FFFFF, 0x7C00006E, + "lwzx", 0x00000024, "=r,(b,r)", 0x000FFFFF, 0x7C00002E, + "maskg", 0x0000019F, "=r,r,r", 0x00000001, 0x7C00003A, + "maskg.", 0x0000019F, "=r,r,r;=Z", 0x00000001, 0x7C00003B, + "maskir", 0x000001A0, "=r,r,r", 0x00000001, 0x7C00043A, + "maskir.", 0x000001A0, "=r,r,r;=Z", 0x00000001, 0x7C00043B, + "mcrf", 0x00000076, "=c,c", 0x000FFFFF, 0x4C000000, + "mcrfs", 0x000000C5, "=c,x3", 0x800FFFFF, 0xFC000080, + "mcrxr", 0x000000C6, "=c;+X", 0x000FFFFF, 0x7C000400, + "mfcr", 0x00000082, "=r;Y", 0x000FFFFF, 0x7C000026, + "mfdcr", 0x000000E9, "=r,D", 0x000007C0, 0x7C000286, + "mffs", 0x00000083, "=f", 0x800FFFFF, 0xFC00048E, + "mffs.", 0x00000083, "=f;=Z", 0x800FFFFF, 0xFC00048F, + "mfmsr", 0x0000007D, "=r", 0x000FFFFF, 0x7C0000A6, + "mfrom", 0x000000DB, "=r,r", 0x00000002, 0x7C000212, + "mfspr", 0x0000007E, "=r,s", 0x000FFFFF, 0x7C0002A6, + "mfsr", 0x000000C8, "=r,u4", 0x010FFFFF, 0x7C0004A6, + "mfsrin", 0x000000CA, "=r,r", 0x010FFFFF, 0x7C000526, + "mtcrf", 0x0000007A, "x8,r;=Y", 0x000FFFFF, 0x7C000120, + "mtdcr", 0x000000EA, "D,r", 0x000007C0, 0x7C000386, + "mtfsb0", 0x000000CC, "u5", 0x000FFFFF, 0xFC00008C, + "mtfsb0.", 0x000000CC, "u5;=Z", 0x000FFFFF, 0xFC00008D, + "mtfsb1", 0x000000CD, "u5", 0x000FFFFF, 0xFC00004C, + "mtfsb1.", 0x000000CD, "u5;=Z", 0x000FFFFF, 0xFC00004D, + "mtfsf", 0x00000084, "x8,f", 0x800FFFFF, 0xFC00058E, + "mtfsf.", 0x00000084, "x8,f;=Z", 0x800FFFFF, 0xFC00058F, + "mtfsfi", 0x000000CE, "c,x4", 0x000FFFFF, 0xFC00010C, + "mtfsfi.", 0x000000CE, "c,x4;=Z", 0x000FFFFF, 0xFC00010D, + "mtmsr", 0x0000007B, "r", 0x000FFFFF, 0x7C000124, + "mtspr", 0x0000007C, "=s,r", 0x000FFFFF, 0x7C0003A6, + "mtsr", 0x000000C9, "u4,r", 0x010FFFFF, 0x7C0001A4, + "mtsrin", 0x000000CB, "r,r", 0x010FFFFF, 0x7C0001E4, + "mul", 0x000001A5, "=r,r,r", 0x00000001, 0x7C0000D6, + "mul.", 0x000001A5, "=r,r,r;=Z", 0x00000001, 0x7C0000D7, + "mulo", 0x000001A5, "=r,r,r;+X", 0x00000001, 0x7C0004D6, + "mulo.", 0x000001A5, "=r,r,r;+X=Z", 0x00000001, 0x7C0004D7, + "mulhw", 0x00000047, "=r,r,r", 0x000FFFFF, 0x7C000096, + "mulhw.", 0x00000047, "=r,r,r;=Z", 0x000FFFFF, 0x7C000097, + "mulhwu", 0x00000048, "=r,r,r", 0x000FFFFF, 0x7C000016, + "mulhwu.", 0x00000048, "=r,r,r;=Z", 0x000FFFFF, 0x7C000017, + "mulli", 0x00000049, "=r,r,i", 0x000FFFFF, 0x1C000000, + "mullw", 0x0000004A, "=r,r,r", 0x000FFFFF, 0x7C0001D6, + "mullw.", 0x0000004A, "=r,r,r;=Z", 0x000FFFFF, 0x7C0001D7, + "mullwo", 0x0000004A, "=r,r,r;+X", 0x000FFFFF, 0x7C0005D6, + "mullwo.", 0x0000004A, "=r,r,r;+X=Z", 0x000FFFFF, 0x7C0005D7, + "nabs", 0x000001A6, "=r,r", 0x00000001, 0x7C0003D0, + "nabs.", 0x000001A6, "=r,r;=Z", 0x00000001, 0x7C0003D1, + "nabso", 0x000001A6, "=r,r;+X", 0x00000001, 0x7C0007D0, + "nabso.", 0x000001A6, "=r,r;+X=Z", 0x00000001, 0x7C0007D1, + "nand", 0x0000005F, "=r,r,r", 0x000FFFFF, 0x7C0003B8, + "nand.", 0x0000005F, "=r,r,r;=Z", 0x000FFFFF, 0x7C0003B9, + "neg", 0x0000004B, "=r,r", 0x000FFFFF, 0x7C0000D0, + "neg.", 0x0000004B, "=r,r;=Z", 0x000FFFFF, 0x7C0000D1, + "nego", 0x0000004B, "=r,r;+X", 0x000FFFFF, 0x7C0004D0, + "nego.", 0x0000004B, "=r,r;+X=Z", 0x000FFFFF, 0x7C0004D1, + "nor", 0x00000060, "=r,r,r", 0x000FFFFF, 0x7C0000F8, + "nor.", 0x00000060, "=r,r,r;=Z", 0x000FFFFF, 0x7C0000F9, + "or", 0x0000005D, "=r,r,r;pp", 0x000FFFFF, 0x7C000378, + "or.", 0x0000005D, "=r,r,r;pp=Z", 0x000FFFFF, 0x7C000379, + "orc", 0x00000063, "=r,r,r", 0x000FFFFF, 0x7C000338, + "orc.", 0x00000063, "=r,r,r;=Z", 0x000FFFFF, 0x7C000339, + "ori", 0x00000058, "=r,r,m", 0x000FFFFF, 0x60000000, + "oris", 0x00000059, "=r,r,M", 0x000FFFFF, 0x64000000, + "rfci", 0x000000E3, "", 0x000007C0, 0x4C000066, + "rfi", 0x00000088, "", 0x000FFFFF, 0x4C000064, + "rlmi", 0x000001AA, "+r,r,r,u5,u5", 0x00000001, 0x58000000, + "rlmi.", 0x000001AA, "+r,r,r,u5,u5;=Z", 0x00000001, 0x58000001, + "rlwimi", 0x00000069, "+r,r,u5,u5,u5", 0x000FFFFF, 0x50000000, + "rlwimi.", 0x00000069, "+r,r,u5,u5,u5;=Z", 0x000FFFFF, 0x50000001, + "rlwinm", 0x00000067, "=r,r,u5,u5,u5", 0x000FFFFF, 0x54000000, + "rlwinm.", 0x00000067, "=r,r,u5,u5,u5;=Z", 0x000FFFFF, 0x54000001, + "rlwnm", 0x00000068, "=r,r,r,u5,u5", 0x000FFFFF, 0x5C000000, + "rlwnm.", 0x00000068, "=r,r,r,u5,u5;=Z", 0x000FFFFF, 0x5C000001, + "rrib", 0x000001AB, "=r,r,r", 0x00000001, 0x7C000432, + "rrib.", 0x000001AB, "=r,r,r;=Z", 0x00000001, 0x7C000433, + "sc", 0x000000CF, "", 0x000FFFFF, 0x44000002, + "sle", 0x00000190, "=r,r,r", 0x00000001, 0x7C000132, + "sle.", 0x00000190, "=r,r,r;=Z", 0x00000001, 0x7C000133, + "sleq", 0x00000191, "=r,r,r", 0x00000001, 0x7C0001B2, + "sleq.", 0x00000191, "=r,r,r;=Z", 0x00000001, 0x7C0001B3, + "sliq", 0x00000192, "=r,r,u5", 0x00000001, 0x7C000170, + "sliq.", 0x00000192, "=r,r,u5;=Z", 0x00000001, 0x7C000171, + "slliq", 0x00000193, "=r,r,u5", 0x00000001, 0x7C0001F0, + "slliq.", 0x00000193, "=r,r,u5;=Z", 0x00000001, 0x7C0001F1, + "sllq", 0x00000194, "=r,r,r", 0x00000001, 0x7C0001B0, + "sllq.", 0x00000194, "=r,r,r;=Z", 0x00000001, 0x7C0001B1, + "slq", 0x00000195, "=r,r,r", 0x00000001, 0x7C000130, + "slq.", 0x00000195, "=r,r,r;=Z", 0x00000001, 0x7C000131, + "slw", 0x0000006A, "=r,r,r", 0x000FFFFF, 0x7C000030, + "slw.", 0x0000006A, "=r,r,r;=Z", 0x000FFFFF, 0x7C000031, + "sraiq", 0x00000196, "=r,r,u5", 0x00000001, 0x7C000770, + "sraiq.", 0x00000196, "=r,r,u5;=Z", 0x00000001, 0x7C000771, + "sraq", 0x00000197, "=r,r,r", 0x00000001, 0x7C000730, + "sraq.", 0x00000197, "=r,r,r;=Z", 0x00000001, 0x7C000731, + "sraw", 0x0000006D, "=r,r,r;+X", 0x000FFFFF, 0x7C000630, + "sraw.", 0x0000006D, "=r,r,r;+X=Z", 0x000FFFFF, 0x7C000631, + "srawi", 0x0000006C, "=r,r,u5;+X", 0x000FFFFF, 0x7C000670, + "srawi.", 0x0000006C, "=r,r,u5;+X=Z", 0x000FFFFF, 0x7C000671, + "sre", 0x00000198, "=r,r,r", 0x00000001, 0x7C000532, + "sre.", 0x00000198, "=r,r,r;=Z", 0x00000001, 0x7C000533, + "srea", 0x00000199, "=r,r,r", 0x00000001, 0x7C000732, + "srea.", 0x00000199, "=r,r,r;=Z", 0x00000001, 0x7C000733, + "sreq", 0x0000019A, "=r,r,r", 0x00000001, 0x7C0005B2, + "sreq.", 0x0000019A, "=r,r,r;=Z", 0x00000001, 0x7C0005B3, + "sriq", 0x0000019B, "=r,r,u5", 0x00000001, 0x7C000570, + "sriq.", 0x0000019B, "=r,r,u5;=Z", 0x00000001, 0x7C000571, + "srliq", 0x0000019C, "=r,r,u5", 0x00000001, 0x7C0005F0, + "srliq.", 0x0000019C, "=r,r,u5;=Z", 0x00000001, 0x7C0005F1, + "srlq", 0x0000019D, "=r,r,r", 0x00000001, 0x7C0005B0, + "srlq.", 0x0000019D, "=r,r,r;=Z", 0x00000001, 0x7C0005B1, + "srq", 0x0000019E, "=r,r,r", 0x00000001, 0x7C000530, + "srq.", 0x0000019E, "=r,r,r;=Z", 0x00000001, 0x7C000531, + "srw", 0x0000006B, "=r,r,r", 0x000FFFFF, 0x7C000430, + "srw.", 0x0000006B, "=r,r,r;=Z", 0x000FFFFF, 0x7C000431, + "stb", 0x00000028, "r,d(b)", 0x000FFFFF, 0x98000000, + "stbu", 0x00000029, "r,d(+b)", 0x000FFFFF, 0x9C000000, + "stbux", 0x0000002B, "r,(+b,r)", 0x000FFFFF, 0x7C0001EE, + "stbx", 0x0000002A, "r,(b,r)", 0x000FFFFF, 0x7C0001AE, + "stfd", 0x0000009A, "f,d(b)", 0x800FFFFF, 0xD8000000, + "stfdu", 0x0000009B, "f,d(+b)", 0x800FFFFF, 0xDC000000, + "stfdux", 0x0000009D, "f,(+b,r)", 0x800FFFFF, 0x7C0005EE, + "stfdx", 0x0000009C, "f,(b,r)", 0x800FFFFF, 0x7C0005AE, + "stfiwx", 0x000000BD, "f,(b,r)", 0x800FFFFE, 0x7C0007AE, + "stfs", 0x00000096, "f,d(b)", 0x800FFFFF, 0xD0000000, + "stfsu", 0x00000097, "f,d(+b)", 0x800FFFFF, 0xD4000000, + "stfsux", 0x00000099, "f,(+b,r)", 0x800FFFFF, 0x7C00056E, + "stfsx", 0x00000098, "f,(b,r)", 0x800FFFFF, 0x7C00052E, + "sth", 0x0000002C, "r,d(b)", 0x000FFFFF, 0xB0000000, + "sthbrx", 0x00000030, "r,(b,r)", 0x000FFFFF, 0x7C00072C, + "sthu", 0x0000002D, "r,d(+b)", 0x000FFFFF, 0xB4000000, + "sthux", 0x0000002F, "r,(+b,r)", 0x000FFFFF, 0x7C00036E, + "sthx", 0x0000002E, "r,(b,r)", 0x000FFFFF, 0x7C00032E, + "stmw", 0x00000036, "r,d(b)", 0x000FFFFF, 0xBC000000, + "stswi", 0x000000BE, "r,b,N", 0x000FFFFF, 0x7C0005AA, + "stswx", 0x000000BF, "r,(b,r)", 0x000FFFFF, 0x7C00052A, + "stw", 0x00000031, "r,d(b)", 0x000FFFFF, 0x90000000, + "stwbrx", 0x00000035, "r,(b,r)", 0x000FFFFF, 0x7C00052C, + "stwcx.", 0x000000C0, "r,(b,r);=Z", 0x000FFFFF, 0x7C00012D, + "stwu", 0x00000032, "r,d(+b)", 0x000FFFFF, 0x94000000, + "stwux", 0x00000034, "r,(+b,r)", 0x000FFFFF, 0x7C00016E, + "stwx", 0x00000033, "r,(b,r)", 0x000FFFFF, 0x7C00012E, + "subf", 0x0000004C, "=r,r,r", 0x000FFFFF, 0x7C000050, + "subf.", 0x0000004C, "=r,r,r;=Z", 0x000FFFFF, 0x7C000051, + "subfo", 0x0000004C, "=r,r,r;+X", 0x000FFFFF, 0x7C000450, + "subfo.", 0x0000004C, "=r,r,r;+X=Z", 0x000FFFFF, 0x7C000451, + "subfc", 0x0000004D, "=r,r,r;+X", 0x000FFFFF, 0x7C000010, + "subfc.", 0x0000004D, "=r,r,r;+X=Z", 0x000FFFFF, 0x7C000011, + "subfco", 0x0000004D, "=r,r,r;+X", 0x000FFFFF, 0x7C000410, + "subfco.", 0x0000004D, "=r,r,r;+X=Z", 0x000FFFFF, 0x7C000411, + "subfe", 0x0000004E, "=r,r,r;+X", 0x000FFFFF, 0x7C000110, + "subfe.", 0x0000004E, "=r,r,r;+X=Z", 0x000FFFFF, 0x7C000111, + "subfeo", 0x0000004E, "=r,r,r;+X", 0x000FFFFF, 0x7C000510, + "subfeo.", 0x0000004E, "=r,r,r;+X=Z", 0x000FFFFF, 0x7C000511, + "subfic", 0x0000004F, "=r,r,i;+X", 0x000FFFFF, 0x20000000, + "subfme", 0x00000050, "=r,r;+X", 0x000FFFFF, 0x7C0001D0, + "subfme.", 0x00000050, "=r,r;+X=Z", 0x000FFFFF, 0x7C0001D1, + "subfmeo", 0x00000050, "=r,r;+X", 0x000FFFFF, 0x7C0005D0, + "subfmeo.", 0x00000050, "=r,r;+X=Z", 0x000FFFFF, 0x7C0005D1, + "subfze", 0x00000051, "=r,r;+X", 0x000FFFFF, 0x7C000190, + "subfze.", 0x00000051, "=r,r;+X=Z", 0x000FFFFF, 0x7C000191, + "subfzeo", 0x00000051, "=r,r;+X", 0x000FFFFF, 0x7C000590, + "subfzeo.", 0x00000051, "=r,r;+X=Z", 0x000FFFFF, 0x7C000591, + "sync", 0x00000087, "", 0x000FFFFF, 0x7C0004AC, + "tlbia", 0x000000D2, "", 0x00000230, 0x7C0002E4, + "tlbie", 0x000000D3, "r", 0x040FFFFF, 0x7C000264, + "tlbld", 0x000000D4, "r", 0x00010006, 0x7C0007A4, + "tlbli", 0x000000D5, "r", 0x00010006, 0x7C0007E4, + "tlbsync", 0x000000D6, "", 0x040FFFFE, 0x7C00046C, + "tlbre", 0x000000E4, "=r,r,u1", 0x00000200, 0x7C000764, + "tlbrehi", 0x000000E4, "=r,r;%0", 0x00000200, 0x7C000764, + "tlbrelo", 0x000000E4, "=r,r;%1", 0x00000200, 0x7C000F64, + "tlbsx", 0x000000E5, "=r,(b,r)", 0x00000200, 0x7C000724, + "tlbsx.", 0x000000E5, "=r,(b,r);=Z", 0x00000200, 0x7C000725, + "tlbwe", 0x000000E6, "r,b,u1", 0x00000200, 0x7C0007A4, + "tlbwehi", 0x000000E6, "r,b;%0", 0x00000200, 0x7C0007A4, + "tlbwelo", 0x000000E6, "r,b;%1", 0x00000200, 0x7C000FA4, + "tw", 0x000000D7, "u5,r,r", 0x000FFFFF, 0x7C000008, + "twi", 0x000000D9, "u5,r,m", 0x000FFFFF, 0x0C000000, + "wrtee", 0x000000E7, "r", 0x000007C0, 0x7C000106, + "wrteei", 0x000000E8, "u1", 0x000007C0, 0x7C000146, + "xor", 0x0000005E, "=r,r,r", 0x000FFFFF, 0x7C000278, + "xor.", 0x0000005E, "=r,r,r;=Z", 0x000FFFFF, 0x7C000279, + "xori", 0x0000005A, "=r,r,x", 0x000FFFFF, 0x68000000, + "xoris", 0x0000005B, "=r,r,x", 0x000FFFFF, 0x6C000000, + "cmpw", 0x00000053, "=?c,r,r", 0x000FFFFF, 0x7C000000, + "cmpwi", 0x00000052, "=?c,r,i", 0x000FFFFF, 0x2C000000, + "cmplw", 0x00000055, "=?c,r,r", 0x000FFFFF, 0x7C000040, + "cmplwi", 0x00000054, "=?c,r,u", 0x000FFFFF, 0x28000000, + "la", 0x0000003F, "=r,d(b)", 0x000FFFFF, 0x38000000, + "las", 0x00000042, "=r,d(b)", 0x000FFFFF, 0x3C000000, + "li", 0x00000089, "=r,n", 0x000FFFFF, 0x38000000, + "lis", 0x0000008A, "=r,M", 0x000FFFFF, 0x3C000000, + "mr", 0x0000008B, "=r,r;p", 0x000FFFFF, 0x7C000378, + "mr.", 0x0000008B, "=r,r;p=Z", 0x000FFFFF, 0x7C000379, + "nop", 0x0000008C, "", 0x000FFFFF, 0x60000000, + "not", 0x0000008D, "=r,r", 0x000FFFFF, 0x7C0000F8, + "not.", 0x0000008D, "=r,r;=Z", 0x000FFFFF, 0x7C0000F9, + "sub", 0x0000004C, "=r,r,r/", 0x000FFFFF, 0x7C000050, + "sub.", 0x0000004C, "=r,r,r/;=Z", 0x000FFFFF, 0x7C000051, + "subo", 0x0000004C, "=r,r,r/;+X", 0x000FFFFF, 0x7C000450, + "subo.", 0x0000004C, "=r,r,r/;+X=Z", 0x000FFFFF, 0x7C000451, + "subc", 0x0000004D, "=r,r,r/;+X", 0x000FFFFF, 0x7C000010, + "subc.", 0x0000004D, "=r,r,r/;+X=Z", 0x000FFFFF, 0x7C000011, + "subco", 0x0000004D, "=r,r,r/;+X", 0x000FFFFF, 0x7C000410, + "subco.", 0x0000004D, "=r,r,r/;+X=Z", 0x000FFFFF, 0x7C000411, + "subi", 0x0000003F, "=r,b,-i;p", 0x000FFFFF, 0x38000000, + "subic", 0x00000040, "=r,r,-i;+X", 0x000FFFFF, 0x30000000, + "subic.", 0x00000041, "=r,r,-i;+X=Z", 0x000FFFFF, 0x34000000, + "subis", 0x00000042, "=r,b,-i", 0x000FFFFF, 0x3C000000, + "bctr", 0x00000012, ";Cpp", 0x000FFFFF, 0x4E800420, + "bctrl", 0x00000013, ";C=L", 0x000FFFFF, 0x4E800421, + "bdnzf", 0x0000000D, "Q,l;Cp", 0x000FFFFF, 0x40000000, + "bdnzfl", 0x0000000D, "Q,l;C=L", 0x000FFFFF, 0x40000001, + "bdnzfa", 0x0000000D, "Q,l;Cp", 0x000FFFFF, 0x40000002, + "bdnzfla", 0x0000000D, "Q,l;C=L", 0x000FFFFF, 0x40000003, + "bdnzflr", 0x00000003, "%0Q;CL", 0x000FFFFF, 0x4C000020, + "bdnzflrl", 0x00000003, "%0Q;C+L", 0x000FFFFF, 0x4C000021, + "bdnz", 0x0000000B, "l;Cp", 0x000FFFFF, 0x42000000, + "bdnzl", 0x0000000B, "l;C=L", 0x000FFFFF, 0x42000001, + "bdnza", 0x0000000B, "l;Cp", 0x000FFFFF, 0x42000002, + "bdnzla", 0x0000000B, "l;C=L", 0x000FFFFF, 0x42000003, + "bdnzlr", 0x00000003, ";%16%0%0CL", 0x000FFFFF, 0x4E000020, + "bdnzlrl", 0x00000003, ";%16%0%0C+L", 0x000FFFFF, 0x4E000021, + "bdnzt", 0x0000000C, "Q,l;Cp", 0x000FFFFF, 0x41000000, + "bdnztl", 0x0000000C, "Q,l;C=L", 0x000FFFFF, 0x41000001, + "bdnzta", 0x0000000C, "Q,l;Cp", 0x000FFFFF, 0x41000002, + "bdnztla", 0x0000000C, "Q,l;C=L", 0x000FFFFF, 0x41000003, + "bdnztlr", 0x00000003, "%8Q;CL", 0x000FFFFF, 0x4D000020, + "bdnztlrl", 0x00000003, "%8Q;C+L", 0x000FFFFF, 0x4D000021, + "bdzf", 0x00000010, "Q,l;Cp", 0x000FFFFF, 0x40400000, + "bdzfl", 0x00000010, "Q,l;C=L", 0x000FFFFF, 0x40400001, + "bdzfa", 0x00000010, "Q,l;Cp", 0x000FFFFF, 0x40400002, + "bdzfla", 0x00000010, "Q,l;C=L", 0x000FFFFF, 0x40400003, + "bdzflr", 0x00000003, "%2Q;CL", 0x000FFFFF, 0x4C400020, + "bdzflrl", 0x00000003, "%2Q;C+L", 0x000FFFFF, 0x4C400021, + "bdz", 0x0000000E, "l;Cp", 0x000FFFFF, 0x42400000, + "bdzl", 0x0000000E, "l;C=L", 0x000FFFFF, 0x42400001, + "bdza", 0x0000000E, "l;Cp", 0x000FFFFF, 0x42400002, + "bdzla", 0x0000000E, "l;C=L", 0x000FFFFF, 0x42400003, + "bdzlr", 0x00000003, ";%18%0%0CL", 0x000FFFFF, 0x4E400020, + "bdzlrl", 0x00000003, ";%18%0%0C+L", 0x000FFFFF, 0x4E400021, + "bdzt", 0x0000000F, "Q,l;Cp", 0x000FFFFF, 0x41400000, + "bdztl", 0x0000000F, "Q,l;C=L", 0x000FFFFF, 0x41400001, + "bdzta", 0x0000000F, "Q,l;Cp", 0x000FFFFF, 0x41400002, + "bdztla", 0x0000000F, "Q,l;C=L", 0x000FFFFF, 0x41400003, + "bdztlr", 0x00000003, "%10Q;CL", 0x000FFFFF, 0x4D400020, + "bdztlrl", 0x00000003, "%10Q;C+L", 0x000FFFFF, 0x4D400021, + "bf", 0x00000008, "Q,l;p", 0x000FFFFF, 0x40800000, + "bfl", 0x00000008, "Q,l;=L", 0x000FFFFF, 0x40800001, + "bfa", 0x00000008, "Q,l;p", 0x000FFFFF, 0x40800002, + "bfla", 0x00000008, "Q,l;=L", 0x000FFFFF, 0x40800003, + "bfctr", 0x0000000A, "Q;Cp", 0x000FFFFF, 0x4C800420, + "bfctrl", 0x0000000A, "Q;C=L", 0x000FFFFF, 0x4C800421, + "bflr", 0x00000009, "Q;L", 0x000FFFFF, 0x4C800020, + "bflrl", 0x00000009, "Q;+L", 0x000FFFFF, 0x4C800021, + "blr", 0x00000011, ";L", 0x000FFFFF, 0x4E800020, + "blrl", 0x00000014, ";+L", 0x000FFFFF, 0x4E800021, + "bt", 0x00000005, "Q,l;p", 0x000FFFFF, 0x41800000, + "btl", 0x00000005, "Q,l;=L", 0x000FFFFF, 0x41800001, + "bta", 0x00000005, "Q,l;p", 0x000FFFFF, 0x41800002, + "btla", 0x00000005, "Q,l;=L", 0x000FFFFF, 0x41800003, + "btctr", 0x00000007, "Q;Cp", 0x000FFFFF, 0x4D800420, + "btctrl", 0x00000007, "Q;C=L", 0x000FFFFF, 0x4D800421, + "btlr", 0x00000006, "Q;L", 0x000FFFFF, 0x4D800020, + "btlrl", 0x00000006, "Q;+L", 0x000FFFFF, 0x4D800021, + "beq", 0x00000005, "?c,%2l;p", 0x000FFFFF, 0x41820000, + "beql", 0x00000005, "?c,%2l;=L", 0x000FFFFF, 0x41820001, + "beqa", 0x00000005, "?c,%2l;p", 0x000FFFFF, 0x41820002, + "beqla", 0x00000005, "?c,%2l;=L", 0x000FFFFF, 0x41820003, + "beqctr", 0x00000007, "?c;%2Cp", 0x000FFFFF, 0x4D820420, + "beqctrl", 0x00000007, "?c;%2C=L", 0x000FFFFF, 0x4D820421, + "beqlr", 0x00000006, "?c;%2L", 0x000FFFFF, 0x4D820020, + "beqlrl", 0x00000006, "?c;%2+L", 0x000FFFFF, 0x4D820021, + "bge", 0x00000008, "?c,%0l;p", 0x000FFFFF, 0x40800000, + "bgel", 0x00000008, "?c,%0l;=L", 0x000FFFFF, 0x40800001, + "bgea", 0x00000008, "?c,%0l;p", 0x000FFFFF, 0x40800002, + "bgela", 0x00000008, "?c,%0l;=L", 0x000FFFFF, 0x40800003, + "bgectr", 0x0000000A, "?c;%0Cp", 0x000FFFFF, 0x4C800420, + "bgectrl", 0x0000000A, "?c;%0C=L", 0x000FFFFF, 0x4C800421, + "bgelr", 0x00000009, "?c;%0L", 0x000FFFFF, 0x4C800020, + "bgelrl", 0x00000009, "?c;%0+L", 0x000FFFFF, 0x4C800021, + "bgt", 0x00000005, "?c,%1l;p", 0x000FFFFF, 0x41810000, + "bgtl", 0x00000005, "?c,%1l;=L", 0x000FFFFF, 0x41810001, + "bgta", 0x00000005, "?c,%1l;p", 0x000FFFFF, 0x41810002, + "bgtla", 0x00000005, "?c,%1l;=L", 0x000FFFFF, 0x41810003, + "bgtctr", 0x00000007, "?c;%1Cp", 0x000FFFFF, 0x4D810420, + "bgtctrl", 0x00000007, "?c;%1C=L", 0x000FFFFF, 0x4D810421, + "bgtlr", 0x00000006, "?c;%1L", 0x000FFFFF, 0x4D810020, + "bgtlrl", 0x00000006, "?c;%1+L", 0x000FFFFF, 0x4D810021, + "ble", 0x00000008, "?c,%1l;p", 0x000FFFFF, 0x40810000, + "blel", 0x00000008, "?c,%1l;=L", 0x000FFFFF, 0x40810001, + "blea", 0x00000008, "?c,%1l;p", 0x000FFFFF, 0x40810002, + "blela", 0x00000008, "?c,%1l;=L", 0x000FFFFF, 0x40810003, + "blectr", 0x0000000A, "?c;%1Cp", 0x000FFFFF, 0x4C810420, + "blectrl", 0x0000000A, "?c;%1C=L", 0x000FFFFF, 0x4C810421, + "blelr", 0x00000009, "?c;%1L", 0x000FFFFF, 0x4C810020, + "blelrl", 0x00000009, "?c;%1+L", 0x000FFFFF, 0x4C810021, + "blt", 0x00000005, "?c,%0l;p", 0x000FFFFF, 0x41800000, + "bltl", 0x00000005, "?c,%0l;=L", 0x000FFFFF, 0x41800001, + "blta", 0x00000005, "?c,%0l;p", 0x000FFFFF, 0x41800002, + "bltla", 0x00000005, "?c,%0l;=L", 0x000FFFFF, 0x41800003, + "bltctr", 0x00000007, "?c;%0Cp", 0x000FFFFF, 0x4D800420, + "bltctrl", 0x00000007, "?c;%0C=L", 0x000FFFFF, 0x4D800421, + "bltlr", 0x00000006, "?c;%0L", 0x000FFFFF, 0x4D800020, + "bltlrl", 0x00000006, "?c;%0+L", 0x000FFFFF, 0x4D800021, + "bne", 0x00000008, "?c,%2l;p", 0x000FFFFF, 0x40820000, + "bnel", 0x00000008, "?c,%2l;=L", 0x000FFFFF, 0x40820001, + "bnea", 0x00000008, "?c,%2l;p", 0x000FFFFF, 0x40820002, + "bnela", 0x00000008, "?c,%2l;=L", 0x000FFFFF, 0x40820003, + "bnectr", 0x0000000A, "?c;%2Cp", 0x000FFFFF, 0x4C820420, + "bnectrl", 0x0000000A, "?c;%2C=L", 0x000FFFFF, 0x4C820421, + "bnelr", 0x00000009, "?c;%2L", 0x000FFFFF, 0x4C820020, + "bnelrl", 0x00000009, "?c;%2+L", 0x000FFFFF, 0x4C820021, + "bng", 0x00000008, "?c,%1l;p", 0x000FFFFF, 0x40810000, + "bngl", 0x00000008, "?c,%1l;=L", 0x000FFFFF, 0x40810001, + "bnga", 0x00000008, "?c,%1l;p", 0x000FFFFF, 0x40810002, + "bngla", 0x00000008, "?c,%1l;=L", 0x000FFFFF, 0x40810003, + "bngctr", 0x0000000A, "?c;%1Cp", 0x000FFFFF, 0x4C810420, + "bngctrl", 0x0000000A, "?c;%1C=L", 0x000FFFFF, 0x4C810421, + "bnglr", 0x00000009, "?c;%1L", 0x000FFFFF, 0x4C810020, + "bnglrl", 0x00000009, "?c;%1+L", 0x000FFFFF, 0x4C810021, + "bnl", 0x00000008, "?c,%0l;p", 0x000FFFFF, 0x40800000, + "bnll", 0x00000008, "?c,%0l;=L", 0x000FFFFF, 0x40800001, + "bnla", 0x00000008, "?c,%0l;p", 0x000FFFFF, 0x40800002, + "bnlla", 0x00000008, "?c,%0l;=L", 0x000FFFFF, 0x40800003, + "bnlctr", 0x0000000A, "?c;%0Cp", 0x000FFFFF, 0x4C800420, + "bnlctrl", 0x0000000A, "?c;%0C=L", 0x000FFFFF, 0x4C800421, + "bnllr", 0x00000009, "?c;%0L", 0x000FFFFF, 0x4C800020, + "bnllrl", 0x00000009, "?c;%0+L", 0x000FFFFF, 0x4C800021, + "bns", 0x00000008, "?c,%3l;p", 0x000FFFFF, 0x40830000, + "bnsl", 0x00000008, "?c,%3l;=L", 0x000FFFFF, 0x40830001, + "bnsa", 0x00000008, "?c,%3l;p", 0x000FFFFF, 0x40830002, + "bnsla", 0x00000008, "?c,%3l;=L", 0x000FFFFF, 0x40830003, + "bnsctr", 0x0000000A, "?c;%3Cp", 0x000FFFFF, 0x4C830420, + "bnsctrl", 0x0000000A, "?c;%3C=L", 0x000FFFFF, 0x4C830421, + "bnslr", 0x00000009, "?c;%3L", 0x000FFFFF, 0x4C830020, + "bnslrl", 0x00000009, "?c;%3+L", 0x000FFFFF, 0x4C830021, + "bnu", 0x00000008, "?c,%3l;p", 0x000FFFFF, 0x40830000, + "bnul", 0x00000008, "?c,%3l;=L", 0x000FFFFF, 0x40830001, + "bnua", 0x00000008, "?c,%3l;p", 0x000FFFFF, 0x40830002, + "bnula", 0x00000008, "?c,%3l;=L", 0x000FFFFF, 0x40830003, + "bnuctr", 0x0000000A, "?c;%3Cp", 0x000FFFFF, 0x4C830420, + "bnuctrl", 0x0000000A, "?c;%3C=L", 0x000FFFFF, 0x4C830421, + "bnulr", 0x00000009, "?c;%3L", 0x000FFFFF, 0x4C830020, + "bnulrl", 0x00000009, "?c;%3+L", 0x000FFFFF, 0x4C830021, + "bso", 0x00000005, "?c,%3l;p", 0x000FFFFF, 0x41830000, + "bsol", 0x00000005, "?c,%3l;=L", 0x000FFFFF, 0x41830001, + "bsoa", 0x00000005, "?c,%3l;p", 0x000FFFFF, 0x41830002, + "bsola", 0x00000005, "?c,%3l;=L", 0x000FFFFF, 0x41830003, + "bsoctr", 0x00000007, "?c;%3Cp", 0x000FFFFF, 0x4D830420, + "bsoctrl", 0x00000007, "?c;%3C=L", 0x000FFFFF, 0x4D830421, + "bsolr", 0x00000006, "?c;%3L", 0x000FFFFF, 0x4D830020, + "bsolrl", 0x00000006, "?c;%3+L", 0x000FFFFF, 0x4D830021, + "bun", 0x00000005, "?c,%3l;p", 0x000FFFFF, 0x41830000, + "bunl", 0x00000005, "?c,%3l;=L", 0x000FFFFF, 0x41830001, + "buna", 0x00000005, "?c,%3l;p", 0x000FFFFF, 0x41830002, + "bunla", 0x00000005, "?c,%3l;=L", 0x000FFFFF, 0x41830003, + "bunctr", 0x00000007, "?c;%3Cp", 0x000FFFFF, 0x4D830420, + "bunctrl", 0x00000007, "?c;%3C=L", 0x000FFFFF, 0x4D830421, + "bunlr", 0x00000006, "?c;%3L", 0x000FFFFF, 0x4D830020, + "bunlrl", 0x00000006, "?c;%3+L", 0x000FFFFF, 0x4D830021, + "mfxer", 0x0000007F, "=r;X", 0x000FFFFF, 0x7C0102A6, + "mflr", 0x00000081, "=r;L", 0x000FFFFF, 0x7C0802A6, + "mfctr", 0x00000080, "=r;C", 0x000FFFFF, 0x7C0902A6, + "mftb", 0x000000C7, "=r?T", 0x100FFFFF, 0x7C0C42E6, + "mftbu", 0x000000C7, "=r;S285", 0x100FFFFF, 0x7C0D42E6, + "mttbl", 0x0000007C, "=S284r", 0x100FFFFF, 0x7C1C43A6, + "mttbu", 0x0000007C, "=S285r", 0x100FFFFF, 0x7C1D43A6, + "mtxer", 0x00000077, "r;=X", 0x000FFFFF, 0x7C0103A6, + "mtctr", 0x00000078, "r;=C", 0x000FFFFF, 0x7C0903A6, + "mtlr", 0x00000079, "r;=L", 0x000FFFFF, 0x7C0803A6, + "mfdec", 0x0000007E, "=r;S22", 0x000FF83F, 0x7C1602A6, + "mfmq", 0x0000007E, "=r;S0", 0x00000001, 0x7C0002A6, + "mfrtcl", 0x0000007E, "=r;S5", 0x00000001, 0x7C0502A6, + "mfrtcu", 0x0000007E, "=r;S4", 0x00000001, 0x7C0402A6, + "mfdar", 0x0000007E, "=r;S19", 0x000FF83F, 0x7C1302A6, + "mfdbatl", 0x0000007E, "=r,P*2|537", 0x000FFFFF, 0x7C1982A6, + "mfdbatu", 0x0000007E, "=r,P*2|536", 0x000FFFFF, 0x7C1882A6, + "mfdsisr", 0x0000007E, "=r;S18", 0x000FF83F, 0x7C1202A6, + "mfear", 0x0000007E, "=r;S282", 0x000FFFCF, 0x7C1A42A6, + "mfibatl", 0x0000007E, "=r,P*2|529", 0x000FFFFF, 0x7C1182A6, + "mfibatu", 0x0000007E, "=r,P*2|528", 0x000FFFFF, 0x7C1082A6, + "mfpvr", 0x0000007E, "=r;S287", 0x000FFFFF, 0x7C1F42A6, + "mfsdr1", 0x0000007E, "=r;S25", 0x000FE00F, 0x7C1902A6, + "mfsprg", 0x0000007E, "=r,P|272", 0x000FFFFF, 0x7C1042A6, + "mfsrr0", 0x0000007E, "=r;S26", 0x000FFFFF, 0x7C1A02A6, + "mfsrr1", 0x0000007E, "=r;S27", 0x000FFFFF, 0x7C1B02A6, + "mtcr", 0x0000007A, "%255r;Y", 0x000FFFFF, 0x7C0FF120, + "mtfs", 0x00000084, "%255f", 0x800FFFFF, 0xFDFE058E, + "mtfs.", 0x00000084, "%255f;=Z", 0x800FFFFF, 0xFDFE058F, + "mtmq", 0x0000007C, "=S0r", 0x00000001, 0x7C0003A6, + "mtdar", 0x0000007C, "=S19r", 0x000FF83F, 0x7C1303A6, + "mtdbatl", 0x0000007C, "=P*2|537,r", 0x000FFFFF, 0x7C1983A6, + "mtdbatu", 0x0000007C, "=P*2|536,r", 0x000FFFFF, 0x7C1883A6, + "mtdec", 0x0000007C, "=S22r", 0x000FF83F, 0x7C1603A6, + "mtdsisr", 0x0000007C, "=S18r", 0x000FF83F, 0x7C1203A6, + "mtear", 0x0000007C, "=S282r", 0x000FFFCF, 0x7C1A43A6, + "mtibatl", 0x0000007C, "=P*2|529,r", 0x000FFFFF, 0x7C1183A6, + "mtibatu", 0x0000007C, "=P*2|528,r", 0x000FFFFF, 0x7C1083A6, + "mtsdr1", 0x0000007C, "=S25r", 0x000FE00F, 0x7C1903A6, + "mtsprg", 0x0000007C, "=P|272,r", 0x000FFFFF, 0x7C1043A6, + "mtsrr0", 0x0000007C, "=S26r", 0x000FFFFF, 0x7C1A03A6, + "mtsrr1", 0x0000007C, "=S27r", 0x000FFFFF, 0x7C1B03A6, + "mfcdbcr", 0x0000007E, "=r;S983", 0x000007C0, 0x7C17F2A6, + "mfdac1", 0x0000007E, "=r;S1014", 0x000007C0, 0x7C16FAA6, + "mfdac2", 0x0000007E, "=r;S1015", 0x00000080, 0x7C17FAA6, + "mfdbcr", 0x0000007E, "=r;S1010", 0x000007C0, 0x7C12FAA6, + "mfdbsr", 0x0000007E, "=r;S1008", 0x000007C0, 0x7C10FAA6, + "mfdccr", 0x0000007E, "=r;S1018", 0x000007C0, 0x7C1AFAA6, + "mfdcwr", 0x0000007E, "=r;S954", 0x00000240, 0x7C1AEAA6, + "mfdear", 0x0000007E, "=r;S981", 0x000007C0, 0x7C15F2A6, + "mfesr", 0x0000007E, "=r;S980", 0x000007C0, 0x7C14F2A6, + "mfevpr", 0x0000007E, "=r;S982", 0x000007C0, 0x7C16F2A6, + "mfiac1", 0x0000007E, "=r;S1012", 0x000007C0, 0x7C14FAA6, + "mfiac2", 0x0000007E, "=r;S1013", 0x00000080, 0x7C15FAA6, + "mficcr", 0x0000007E, "=r;S1019", 0x000007C0, 0x7C1BFAA6, + "mficdbdr", 0x0000007E, "=r;S979", 0x000007C0, 0x7C13F2A6, + "mfpid", 0x0000007E, "=r;S945", 0x00000200, 0x7C11EAA6, + "mfpit", 0x0000007E, "=r;S987", 0x000007C0, 0x7C1BF2A6, + "mfpbl1", 0x0000007E, "=r;S1020", 0x00000080, 0x7C1CFAA6, + "mfpbl2", 0x0000007E, "=r;S1022", 0x00000080, 0x7C1EFAA6, + "mfpbu1", 0x0000007E, "=r;S1021", 0x00000080, 0x7C1DFAA6, + "mfpbu2", 0x0000007E, "=r;S1023", 0x00000080, 0x7C1FFAA6, + "mfsgr", 0x0000007E, "=r;S953", 0x00000240, 0x7C19EAA6, + "mfsler", 0x0000007E, "=r;S955", 0x00000040, 0x7C1BEAA6, + "mfsprg0", 0x0000007E, "=r;S272", 0x000FFFFF, 0x7C1042A6, + "mfsprg1", 0x0000007E, "=r;S273", 0x000FFFFF, 0x7C1142A6, + "mfsprg2", 0x0000007E, "=r;S274", 0x000FFFFF, 0x7C1242A6, + "mfsprg3", 0x0000007E, "=r;S275", 0x000FFFFF, 0x7C1342A6, + "mfsrr2", 0x0000007E, "=r;S990", 0x000007C0, 0x7C1EF2A6, + "mfsrr3", 0x0000007E, "=r;S991", 0x000007C0, 0x7C1FF2A6, + "mftbhi", 0x0000007E, "=r;S988", 0x000007C0, 0x7C1CF2A6, + "mftbhu", 0x0000007E, "=r;S972", 0x00000240, 0x7C0CF2A6, + "mftblo", 0x0000007E, "=r;S989", 0x000007C0, 0x7C1DF2A6, + "mftblu", 0x0000007E, "=r;S973", 0x00000240, 0x7C0DF2A6, + "mftcr", 0x0000007E, "=r;S986", 0x000007C0, 0x7C1AF2A6, + "mftsr", 0x0000007E, "=r;S984", 0x000007C0, 0x7C18F2A6, + "mfzpr", 0x0000007E, "=r;S944", 0x00000200, 0x7C10EAA6, + "mtcdbcr", 0x0000007C, "=S983r", 0x000007C0, 0x7C17F3A6, + "mtdac1", 0x0000007C, "=S1014r", 0x000007C0, 0x7C16FBA6, + "mtdac2", 0x0000007C, "=S1015r", 0x00000080, 0x7C17FBA6, + "mtdbcr", 0x0000007C, "=S1010r", 0x000007C0, 0x7C12FBA6, + "mtdbsr", 0x0000007C, "=S1008r", 0x000007C0, 0x7C10FBA6, + "mtdccr", 0x0000007C, "=S1018r", 0x000007C0, 0x7C1AFBA6, + "mtdcwr", 0x0000007C, "=S954r", 0x00000240, 0x7C1AEBA6, + "mtdear", 0x0000007C, "=S981r", 0x000007C0, 0x7C15F3A6, + "mtesr", 0x0000007C, "=S980r", 0x000007C0, 0x7C14F3A6, + "mtevpr", 0x0000007C, "=S982r", 0x000007C0, 0x7C16F3A6, + "mtiac1", 0x0000007C, "=S1012r", 0x000007C0, 0x7C14FBA6, + "mtiac2", 0x0000007C, "=S1013r", 0x00000080, 0x7C15FBA6, + "mticcr", 0x0000007C, "=S1019r", 0x000007C0, 0x7C1BFBA6, + "mticdbdr", 0x0000007C, "=S979r", 0x000007C0, 0x7C13F3A6, + "mtpid", 0x0000007C, "=S945r", 0x00000200, 0x7C11EBA6, + "mtpit", 0x0000007C, "=S987r", 0x000007C0, 0x7C1BF3A6, + "mtpbl1", 0x0000007C, "=S1020r", 0x00000080, 0x7C1CFBA6, + "mtpbl2", 0x0000007C, "=S1022r", 0x00000080, 0x7C1EFBA6, + "mtpbu1", 0x0000007C, "=S1021r", 0x00000080, 0x7C1DFBA6, + "mtpbu2", 0x0000007C, "=S1023r", 0x00000080, 0x7C1FFBA6, + "mtsgr", 0x0000007C, "=S953r", 0x00000240, 0x7C19EBA6, + "mtsler", 0x0000007C, "=S955r", 0x00000040, 0x7C1BEBA6, + "mtsprg0", 0x0000007C, "=S272r", 0x000FFFFF, 0x7C1043A6, + "mtsprg1", 0x0000007C, "=S273r", 0x000FFFFF, 0x7C1143A6, + "mtsprg2", 0x0000007C, "=S274r", 0x000FFFFF, 0x7C1243A6, + "mtsprg3", 0x0000007C, "=S275r", 0x000FFFFF, 0x7C1343A6, + "mtsrr2", 0x0000007C, "=S990r", 0x000007C0, 0x7C1EF3A6, + "mtsrr3", 0x0000007C, "=S991r", 0x000007C0, 0x7C1FF3A6, + "mttbhi", 0x0000007C, "=S988r", 0x000007C0, 0x7C1CF3A6, + "mttblo", 0x0000007C, "=S989r", 0x000007C0, 0x7C1DF3A6, + "mttcr", 0x0000007C, "=S986r", 0x000007C0, 0x7C1AF3A6, + "mttsr", 0x0000007C, "=S984r", 0x000007C0, 0x7C18F3A6, + "mtzpr", 0x0000007C, "=S944r", 0x00000200, 0x7C10EBA6, + "mfbear", 0x000000E9, "=r;%144", 0x000007C0, 0x7C102286, + "mfbesr", 0x000000E9, "=r;%145", 0x00000080, 0x7C112286, + "mfbesr0", 0x000000E9, "=r;%145", 0x00000040, 0x7C112286, + "mfbr0", 0x000000E9, "=r;%128", 0x00000080, 0x7C002286, + "mfbrcr0", 0x000000E9, "=r;%128", 0x00000040, 0x7C002286, + "mfbr1", 0x000000E9, "=r;%129", 0x00000080, 0x7C012286, + "mfbrcr1", 0x000000E9, "=r;%129", 0x00000040, 0x7C012286, + "mfbr2", 0x000000E9, "=r;%130", 0x00000080, 0x7C022286, + "mfbrcr2", 0x000000E9, "=r;%130", 0x00000040, 0x7C022286, + "mfbr3", 0x000000E9, "=r;%131", 0x00000080, 0x7C032286, + "mfbrcr3", 0x000000E9, "=r;%131", 0x00000040, 0x7C032286, + "mfbr4", 0x000000E9, "=r;%132", 0x00000080, 0x7C042286, + "mfbrcr4", 0x000000E9, "=r;%132", 0x00000040, 0x7C042286, + "mfbr5", 0x000000E9, "=r;%133", 0x00000080, 0x7C052286, + "mfbrcr5", 0x000000E9, "=r;%133", 0x00000040, 0x7C052286, + "mfbr6", 0x000000E9, "=r;%134", 0x00000080, 0x7C062286, + "mfbrcr6", 0x000000E9, "=r;%134", 0x00000040, 0x7C062286, + "mfbr7", 0x000000E9, "=r;%135", 0x00000080, 0x7C072286, + "mfbrcr7", 0x000000E9, "=r;%135", 0x00000040, 0x7C072286, + "mfdmacc0", 0x000000E9, "=r;%196", 0x00000080, 0x7C043286, + "mfdmacc1", 0x000000E9, "=r;%204", 0x00000080, 0x7C0C3286, + "mfdmacc2", 0x000000E9, "=r;%212", 0x00000080, 0x7C143286, + "mfdmacc3", 0x000000E9, "=r;%220", 0x00000080, 0x7C1C3286, + "mfdmacr0", 0x000000E9, "=r;%192", 0x00000080, 0x7C003286, + "mfdmacr1", 0x000000E9, "=r;%200", 0x00000080, 0x7C083286, + "mfdmacr2", 0x000000E9, "=r;%208", 0x00000300, 0x7C103286, + "mfdmacr3", 0x000000E9, "=r;%216", 0x00000300, 0x7C183286, + "mfdmact0", 0x000000E9, "=r;%193", 0x00000080, 0x7C013286, + "mfdmact1", 0x000000E9, "=r;%201", 0x00000080, 0x7C093286, + "mfdmact2", 0x000000E9, "=r;%209", 0x00000300, 0x7C113286, + "mfdmact3", 0x000000E9, "=r;%217", 0x00000300, 0x7C193286, + "mfdmada0", 0x000000E9, "=r;%194", 0x00000080, 0x7C023286, + "mfdmada1", 0x000000E9, "=r;%202", 0x00000080, 0x7C0A3286, + "mfdmada2", 0x000000E9, "=r;%210", 0x00000300, 0x7C123286, + "mfdmada3", 0x000000E9, "=r;%218", 0x00000300, 0x7C1A3286, + "mfdmasa0", 0x000000E9, "=r;%195", 0x00000080, 0x7C033286, + "mfdmasa1", 0x000000E9, "=r;%203", 0x00000080, 0x7C0B3286, + "mfdmasa2", 0x000000E9, "=r;%211", 0x00000300, 0x7C133286, + "mfdmasa3", 0x000000E9, "=r;%219", 0x00000300, 0x7C1B3286, + "mfdmasr", 0x000000E9, "=r;%224", 0x00000080, 0x7C003A86, + "mfexisr", 0x000000E9, "=r;%64", 0x00000080, 0x7C001286, + "mfexier", 0x000000E9, "=r;%66", 0x00000080, 0x7C021286, + "mfiocr", 0x000000E9, "=r;%160", 0x000007C0, 0x7C002A86, + "mfpmcr0", 0x000000E9, "=r;%161", 0x00000040, 0x7C012A86, + "mtbear", 0x000000EA, "%144r", 0x000007C0, 0x7C102386, + "mtbesr", 0x000000EA, "%145r", 0x00000080, 0x7C112386, + "mtbesr0", 0x000000EA, "%145r", 0x00000080, 0x7C112386, + "mtbr0", 0x000000EA, "%128r", 0x00000080, 0x7C002386, + "mtbrcr0", 0x000000EA, "%128r", 0x00000040, 0x7C002386, + "mtbr1", 0x000000EA, "%129r", 0x00000080, 0x7C012386, + "mtbrcr1", 0x000000EA, "%129r", 0x00000040, 0x7C012386, + "mtbr2", 0x000000EA, "%130r", 0x00000080, 0x7C022386, + "mtbrcr2", 0x000000EA, "%130r", 0x00000040, 0x7C022386, + "mtbr3", 0x000000EA, "%131r", 0x00000080, 0x7C032386, + "mtbrcr3", 0x000000EA, "%131r", 0x00000040, 0x7C032386, + "mtbr4", 0x000000EA, "%132r", 0x00000080, 0x7C042386, + "mtbrcr4", 0x000000EA, "%132r", 0x00000040, 0x7C042386, + "mtbr5", 0x000000EA, "%133r", 0x00000080, 0x7C052386, + "mtbrcr5", 0x000000EA, "%133r", 0x00000040, 0x7C052386, + "mtbr6", 0x000000EA, "%134r", 0x00000080, 0x7C062386, + "mtbrcr6", 0x000000EA, "%134r", 0x00000040, 0x7C062386, + "mtbr7", 0x000000EA, "%135r", 0x00000080, 0x7C072386, + "mtbrcr7", 0x000000EA, "%135r", 0x00000040, 0x7C072386, + "mtdmacc0", 0x000000EA, "%196r", 0x00000080, 0x7C043386, + "mtdmacc1", 0x000000EA, "%204r", 0x00000080, 0x7C0C3386, + "mtdmacc2", 0x000000EA, "%212r", 0x00000300, 0x7C143386, + "mtdmacc3", 0x000000EA, "%220r", 0x00000300, 0x7C1C3386, + "mtdmacr0", 0x000000EA, "%192r", 0x00000080, 0x7C003386, + "mtdmacr1", 0x000000EA, "%200r", 0x00000080, 0x7C083386, + "mtdmacr2", 0x000000EA, "%208r", 0x00000300, 0x7C103386, + "mtdmacr3", 0x000000EA, "%216r", 0x00000300, 0x7C183386, + "mtdmact0", 0x000000EA, "%193r", 0x00000080, 0x7C013386, + "mtdmact1", 0x000000EA, "%201r", 0x00000080, 0x7C093386, + "mtdmact2", 0x000000EA, "%209r", 0x00000300, 0x7C113386, + "mtdmact3", 0x000000EA, "%217r", 0x00000300, 0x7C193386, + "mtdmada0", 0x000000EA, "%194r", 0x00000080, 0x7C023386, + "mtdmada1", 0x000000EA, "%202r", 0x00000080, 0x7C0A3386, + "mtdmada2", 0x000000EA, "%210r", 0x00000300, 0x7C123386, + "mtdmada3", 0x000000EA, "%218r", 0x00000300, 0x7C1A3386, + "mtdmasa0", 0x000000EA, "%195r", 0x00000080, 0x7C033386, + "mtdmasa1", 0x000000EA, "%203r", 0x00000080, 0x7C0B3386, + "mtdmasa2", 0x000000EA, "%211r", 0x00000300, 0x7C133386, + "mtdmasa3", 0x000000EA, "%219r", 0x00000300, 0x7C1B3386, + "mtdmasr", 0x000000EA, "%224r", 0x00000080, 0x7C003B86, + "mtexisr", 0x000000EA, "%64r", 0x00000080, 0x7C001386, + "mtexier", 0x000000EA, "%66r", 0x00000080, 0x7C021386, + "mtiocr", 0x000000EA, "%160r", 0x000007C0, 0x7C002B86, + "mtpmcr0", 0x000000EA, "%161r", 0x00000040, 0x7C012B86, + "trap", 0x000000D8, "", 0x000FFFFF, 0x7FE00008, + "tweq", 0x000000D7, "%4r,r", 0x000FFFFF, 0x7C800008, + "tweqi", 0x000000D9, "%4r,i", 0x000FFFFF, 0x0C800000, + "twge", 0x000000D7, "%12r,r", 0x000FFFFF, 0x7D800008, + "twgei", 0x000000D9, "%12r,i", 0x000FFFFF, 0x0D800000, + "twgt", 0x000000D7, "%8r,r", 0x000FFFFF, 0x7D000008, + "twgti", 0x000000D9, "%8r,i", 0x000FFFFF, 0x0D000000, + "twle", 0x000000D7, "%20r,r", 0x000FFFFF, 0x7E800008, + "twlei", 0x000000D9, "%20r,i", 0x000FFFFF, 0x0E800000, + "twlge", 0x000000D7, "%5r,r", 0x000FFFFF, 0x7CA00008, + "twlgei", 0x000000D9, "%5r,i", 0x000FFFFF, 0x0CA00000, + "twlgt", 0x000000D7, "%1r,r", 0x000FFFFF, 0x7C200008, + "twlgti", 0x000000D9, "%1r,i", 0x000FFFFF, 0x0C200000, + "twlle", 0x000000D7, "%6r,r", 0x000FFFFF, 0x7CC00008, + "twllei", 0x000000D9, "%6r,i", 0x000FFFFF, 0x0CC00000, + "twllt", 0x000000D7, "%2r,r", 0x000FFFFF, 0x7C400008, + "twllti", 0x000000D9, "%2r,i", 0x000FFFFF, 0x0C400000, + "twlng", 0x000000D7, "%6r,r", 0x000FFFFF, 0x7CC00008, + "twlngi", 0x000000D9, "%6r,i", 0x000FFFFF, 0x0CC00000, + "twlnl", 0x000000D7, "%5r,r", 0x000FFFFF, 0x7CA00008, + "twlnli", 0x000000D9, "%5r,i", 0x000FFFFF, 0x0CA00000, + "twlt", 0x000000D7, "%16r,r", 0x000FFFFF, 0x7E000008, + "twlti", 0x000000D9, "%16r,i", 0x000FFFFF, 0x0E000000, + "twne", 0x000000D7, "%24r,r", 0x000FFFFF, 0x7F000008, + "twnei", 0x000000D9, "%24r,i", 0x000FFFFF, 0x0F000000, + "twng", 0x000000D7, "%20r,r", 0x000FFFFF, 0x7E800008, + "twngi", 0x000000D9, "%20r,i", 0x000FFFFF, 0x0E800000, + "twnl", 0x000000D7, "%12r,r", 0x000FFFFF, 0x7D800008, + "twnli", 0x000000D9, "%12r,i", 0x000FFFFF, 0x0D800000, + "rotlwi", 0x00000067, "=r,r,u5;%0;%31", 0x000FFFFF, 0x5400003E, + "rotlwi.", 0x00000067, "=r,r,u5;%0;%31;=Z", 0x000FFFFF, 0x5400003F, + "rotrwi", 0x00000067, "=r,r,u5<31;%0;%31", 0x000FFFFF, 0x5400003E, + "rotrwi.", 0x00000067, "=r,r,u5<31;%0;%31;=Z", 0x000FFFFF, 0x5400003F, + "clrlslwi", 0x00000067, "=r,r,u5&,u5>p/<31", 0x000FFFFF, 0x54000000, + "clrlslwi.", 0x00000067, "=r,r,u5&,u5>p/<31;=Z", 0x000FFFFF, 0x54000001, + "clrlwi", 0x00000067, "=r,r,u5;%0/%31", 0x000FFFFF, 0x5400003E, + "clrlwi.", 0x00000067, "=r,r,u5;%0/%31=Z", 0x000FFFFF, 0x5400003F, + "clrrwi", 0x00000067, "=r,r,u5;%0;%0/2<31", 0x000FFFFF, 0x54000000, + "clrrwi.", 0x00000067, "=r,r,u5;%0;%0/2<31=Z", 0x000FFFFF, 0x54000001, + "extlwi", 0x00000067, "=r,r,u5,u5/>1%0/", 0x000FFFFF, 0x54000000, + "extlwi.", 0x00000067, "=r,r,u5,u5/>1%0/;=Z", 0x000FFFFF, 0x54000001, + "extrwi", 0x00000067, "=r,r,u5,u5|p/<32;%31", 0x000FFFFF, 0x5400003E, + "extrwi.", 0x00000067, "=r,r,u5,u5|p/<32;%31;=Z", 0x000FFFFF, 0x5400003F, + "slwi", 0x00000067, "=r,r,u5&<31%0/", 0x000FFFFF, 0x54000000, + "slwi.", 0x00000067, "=r,r,u5&<31%0/;=Z", 0x000FFFFF, 0x54000001, + "srwi", 0x00000067, "=r,r,u5&<32/%31", 0x000FFFFF, 0x5400003E, + "srwi.", 0x00000067, "=r,r,u5&<32/%31;=Z", 0x000FFFFF, 0x5400003F, + "rotlw", 0x00000068, "=r,r,r;%0%31", 0x000FFFFF, 0x5C00003E, + "rotlw.", 0x00000068, "=r,r,r;%0%31=Z", 0x000FFFFF, 0x5C00003F, + "inslwi", 0x00000069, "+r,r,u5,u5&<32/2|p>1", 0x000FFFFF, 0x50000000, + "inslwi.", 0x00000069, "+r,r,u5,u5&<32/2|p>1;=Z", 0x000FFFFF, 0x50000001, + "insrwi", 0x00000069, "+r,r,u5,u5/|p&<32/2/>1", 0x000FFFFF, 0x50000000, + "insrwi.", 0x00000069, "+r,r,u5,u5/|p&<32/2/>1;=Z", 0x000FFFFF, 0x50000001, + "crset", 0x00000070, "=Q&2&2", 0x000FFFFF, 0x4C000242, + "crnot", 0x00000072, "=Q,Q&2", 0x000FFFFF, 0x4C000042, + "crmove", 0x00000073, "=Q,Q&2", 0x000FFFFF, 0x4C000382, + "crclr", 0x00000075, "=Q&2&2", 0x000FFFFF, 0x4C000182, + "opword", 0x000000DA, "w", 0x000FFFFF, 0x00000000, + "dss", 0x000000EC, "u2?u2", 0x400FFFFF, 0x7C00066C, + "dssall", 0x000000ED, "", 0x400FFFFF, 0x7E00066C, + "dst", 0x000000EE, "r,r,u2?u2", 0x400FFFFF, 0x7C0002AC, + "dstt", 0x000000EF, "r,r,u2", 0x400FFFFF, 0x7E0002AC, + "dstst", 0x000000F0, "r,r,u2?u2", 0x400FFFFF, 0x7C0002EC, + "dststt", 0x000000F1, "r,r,u2", 0x400FFFFF, 0x7E0002EC, + "lvebx", 0x000000F2, "=v,(b,r)", 0x400FFFFF, 0x7C00000E, + "lvehx", 0x000000F3, "=v,(b,r)", 0x400FFFFF, 0x7C00004E, + "lvewx", 0x000000F4, "=v,(b,r)", 0x400FFFFF, 0x7C00008E, + "lvsl", 0x000000F5, "=v,(b,r)", 0x400FFFFF, 0x7C00000C, + "lvsr", 0x000000F6, "=v,(b,r)", 0x400FFFFF, 0x7C00004C, + "lvx", 0x000000F7, "=v,(b,r)", 0x400FFFFF, 0x7C0000CE, + "lvxl", 0x000000F8, "=v,(b,r)", 0x400FFFFF, 0x7C0002CE, + "mfvscr", 0x000000FE, "=v", 0x400FFFFF, 0x10000C08, + "mtvscr", 0x000000FF, "v", 0x400FFFFF, 0x10000C88, + "stvebx", 0x000000F9, "v,(b,r)", 0x400FFFFF, 0x7C00010E, + "stvehx", 0x000000FA, "v,(b,r)", 0x400FFFFF, 0x7C00014E, + "stvewx", 0x000000FB, "v,(b,r)", 0x400FFFFF, 0x7C00018E, + "stvx", 0x000000FC, "v,(b,r)", 0x400FFFFF, 0x7C0001CE, + "stvxl", 0x000000FD, "v,(b,r)", 0x400FFFFF, 0x7C0003CE, + "vaddcuw", 0x00000100, "=v,v,v", 0x400FFFFF, 0x10000180, + "vaddfp", 0x00000101, "=v,v,v", 0x400FFFFF, 0x1000000A, + "vaddsbs", 0x00000102, "=v,v,v", 0x400FFFFF, 0x10000300, + "vaddshs", 0x00000103, "=v,v,v", 0x400FFFFF, 0x10000340, + "vaddsws", 0x00000104, "=v,v,v", 0x400FFFFF, 0x10000380, + "vaddubm", 0x00000105, "=v,v,v", 0x400FFFFF, 0x10000000, + "vaddubs", 0x00000106, "=v,v,v", 0x400FFFFF, 0x10000200, + "vadduhm", 0x00000107, "=v,v,v", 0x400FFFFF, 0x10000040, + "vadduhs", 0x00000108, "=v,v,v", 0x400FFFFF, 0x10000240, + "vadduwm", 0x00000109, "=v,v,v", 0x400FFFFF, 0x10000080, + "vadduws", 0x0000010A, "=v,v,v", 0x400FFFFF, 0x10000280, + "vand", 0x0000010B, "=v,v,v", 0x400FFFFF, 0x10000404, + "vandc", 0x0000010C, "=v,v,v", 0x400FFFFF, 0x10000444, + "vavgsb", 0x0000010D, "=v,v,v", 0x400FFFFF, 0x10000502, + "vavgsh", 0x0000010E, "=v,v,v", 0x400FFFFF, 0x10000542, + "vavgsw", 0x0000010F, "=v,v,v", 0x400FFFFF, 0x10000582, + "vavgub", 0x00000110, "=v,v,v", 0x400FFFFF, 0x10000402, + "vavguh", 0x00000111, "=v,v,v", 0x400FFFFF, 0x10000442, + "vavguw", 0x00000112, "=v,v,v", 0x400FFFFF, 0x10000482, + "vcfsx", 0x00000113, "=v,v,u5", 0x400FFFFF, 0x1000034A, + "vcfux", 0x00000114, "=v,v,u5", 0x400FFFFF, 0x1000030A, + "vcmpbfp", 0x00000115, "=v,v,v", 0x400FFFFF, 0x100003C6, + "vcmpbfp.", 0x00000115, "=v,v,v;=Z", 0x400FFFFF, 0x100007C6, + "vcmpeqfp", 0x00000116, "=v,v,v", 0x400FFFFF, 0x100000C6, + "vcmpeqfp.", 0x00000116, "=v,v,v;=Z", 0x400FFFFF, 0x100004C6, + "vcmpequb", 0x00000117, "=v,v,v", 0x400FFFFF, 0x10000006, + "vcmpequb.", 0x00000117, "=v,v,v;=Z", 0x400FFFFF, 0x10000406, + "vcmpequh", 0x00000118, "=v,v,v", 0x400FFFFF, 0x10000046, + "vcmpequh.", 0x00000118, "=v,v,v;=Z", 0x400FFFFF, 0x10000446, + "vcmpequw", 0x00000119, "=v,v,v", 0x400FFFFF, 0x10000086, + "vcmpequw.", 0x00000119, "=v,v,v;=Z", 0x400FFFFF, 0x10000486, + "vcmpgefp", 0x0000011A, "=v,v,v", 0x400FFFFF, 0x100001C6, + "vcmpgefp.", 0x0000011A, "=v,v,v;=Z", 0x400FFFFF, 0x100005C6, + "vcmpgtfp", 0x0000011B, "=v,v,v", 0x400FFFFF, 0x100002C6, + "vcmpgtfp.", 0x0000011B, "=v,v,v;=Z", 0x400FFFFF, 0x100006C6, + "vcmpgtsb", 0x0000011C, "=v,v,v", 0x400FFFFF, 0x10000306, + "vcmpgtsb.", 0x0000011C, "=v,v,v;=Z", 0x400FFFFF, 0x10000706, + "vcmpgtsh", 0x0000011D, "=v,v,v", 0x400FFFFF, 0x10000346, + "vcmpgtsh.", 0x0000011D, "=v,v,v;=Z", 0x400FFFFF, 0x10000746, + "vcmpgtsw", 0x0000011E, "=v,v,v", 0x400FFFFF, 0x10000386, + "vcmpgtsw.", 0x0000011E, "=v,v,v;=Z", 0x400FFFFF, 0x10000786, + "vcmpgtub", 0x0000011F, "=v,v,v", 0x400FFFFF, 0x10000206, + "vcmpgtub.", 0x0000011F, "=v,v,v;=Z", 0x400FFFFF, 0x10000606, + "vcmpgtuh", 0x00000120, "=v,v,v", 0x400FFFFF, 0x10000246, + "vcmpgtuh.", 0x00000120, "=v,v,v;=Z", 0x400FFFFF, 0x10000646, + "vcmpgtuw", 0x00000121, "=v,v,v", 0x400FFFFF, 0x10000286, + "vcmpgtuw.", 0x00000121, "=v,v,v;=Z", 0x400FFFFF, 0x10000686, + "vctsxs", 0x00000122, "=v,v,u5", 0x400FFFFF, 0x100003CA, + "vctuxs", 0x00000123, "=v,v,u5", 0x400FFFFF, 0x1000038A, + "vexptefp", 0x00000124, "=v,v", 0x400FFFFF, 0x1000018A, + "vlogefp", 0x00000125, "=v,v", 0x400FFFFF, 0x100001CA, + "vmaxfp", 0x00000126, "=v,v,v", 0x400FFFFF, 0x1000040A, + "vmaxsb", 0x00000127, "=v,v,v", 0x400FFFFF, 0x10000102, + "vmaxsh", 0x00000128, "=v,v,v", 0x400FFFFF, 0x10000142, + "vmaxsw", 0x00000129, "=v,v,v", 0x400FFFFF, 0x10000182, + "vmaxub", 0x0000012A, "=v,v,v", 0x400FFFFF, 0x10000002, + "vmaxuh", 0x0000012B, "=v,v,v", 0x400FFFFF, 0x10000042, + "vmaxuw", 0x0000012C, "=v,v,v", 0x400FFFFF, 0x10000082, + "vminfp", 0x0000012D, "=v,v,v", 0x400FFFFF, 0x1000044A, + "vminsb", 0x0000012E, "=v,v,v", 0x400FFFFF, 0x10000302, + "vminsh", 0x0000012F, "=v,v,v", 0x400FFFFF, 0x10000342, + "vminsw", 0x00000130, "=v,v,v", 0x400FFFFF, 0x10000382, + "vminub", 0x00000131, "=v,v,v", 0x400FFFFF, 0x10000202, + "vminuh", 0x00000132, "=v,v,v", 0x400FFFFF, 0x10000242, + "vminuw", 0x00000133, "=v,v,v", 0x400FFFFF, 0x10000282, + "vmrghb", 0x00000134, "=v,v,v", 0x400FFFFF, 0x1000000C, + "vmrghh", 0x00000135, "=v,v,v", 0x400FFFFF, 0x1000004C, + "vmrghw", 0x00000136, "=v,v,v", 0x400FFFFF, 0x1000008C, + "vmrglb", 0x00000137, "=v,v,v", 0x400FFFFF, 0x1000010C, + "vmrglh", 0x00000138, "=v,v,v", 0x400FFFFF, 0x1000014C, + "vmrglw", 0x00000139, "=v,v,v", 0x400FFFFF, 0x1000018C, + "vmulesb", 0x0000013A, "=v,v,v", 0x400FFFFF, 0x10000308, + "vmulesh", 0x0000013B, "=v,v,v", 0x400FFFFF, 0x10000348, + "vmuleub", 0x0000013C, "=v,v,v", 0x400FFFFF, 0x10000208, + "vmuleuh", 0x0000013D, "=v,v,v", 0x400FFFFF, 0x10000248, + "vmulosb", 0x0000013E, "=v,v,v", 0x400FFFFF, 0x10000108, + "vmulosh", 0x0000013F, "=v,v,v", 0x400FFFFF, 0x10000148, + "vmuloub", 0x00000140, "=v,v,v", 0x400FFFFF, 0x10000008, + "vmulouh", 0x00000141, "=v,v,v", 0x400FFFFF, 0x10000048, + "vnor", 0x00000142, "=v,v,v", 0x400FFFFF, 0x10000504, + "vnot", 0x00000142, "=v,v&", 0x400FFFFF, 0x10000504, + "vor", 0x00000143, "=v,v,v", 0x400FFFFF, 0x10000484, + "vpkpx", 0x00000144, "=v,v,v", 0x400FFFFF, 0x1000030E, + "vpkshss", 0x00000145, "=v,v,v", 0x400FFFFF, 0x1000018E, + "vpkshus", 0x00000146, "=v,v,v", 0x400FFFFF, 0x1000010E, + "vpkswss", 0x00000147, "=v,v,v", 0x400FFFFF, 0x100001CE, + "vpkswus", 0x00000148, "=v,v,v", 0x400FFFFF, 0x1000014E, + "vpkuhum", 0x00000149, "=v,v,v", 0x400FFFFF, 0x1000000E, + "vpkuhus", 0x0000014A, "=v,v,v", 0x400FFFFF, 0x1000008E, + "vpkuwum", 0x0000014B, "=v,v,v", 0x400FFFFF, 0x1000004E, + "vpkuwus", 0x0000014C, "=v,v,v", 0x400FFFFF, 0x100000CE, + "vrefp", 0x0000014D, "=v,v", 0x400FFFFF, 0x1000010A, + "vrfim", 0x0000014E, "=v,v", 0x400FFFFF, 0x100002CA, + "vrfin", 0x0000014F, "=v,v", 0x400FFFFF, 0x1000020A, + "vrfip", 0x00000150, "=v,v", 0x400FFFFF, 0x1000028A, + "vrfiz", 0x00000151, "=v,v", 0x400FFFFF, 0x1000024A, + "vrlb", 0x00000152, "=v,v,v", 0x400FFFFF, 0x10000004, + "vrlh", 0x00000153, "=v,v,v", 0x400FFFFF, 0x10000044, + "vrlw", 0x00000154, "=v,v,v", 0x400FFFFF, 0x10000084, + "vrsqrtefp", 0x00000155, "=v,v", 0x400FFFFF, 0x1000014A, + "vsl", 0x00000156, "=v,v,v", 0x400FFFFF, 0x100001C4, + "vslb", 0x00000157, "=v,v,v", 0x400FFFFF, 0x10000104, + "vslh", 0x00000158, "=v,v,v", 0x400FFFFF, 0x10000144, + "vslo", 0x00000159, "=v,v,v", 0x400FFFFF, 0x1000040C, + "vslw", 0x0000015A, "=v,v,v", 0x400FFFFF, 0x10000184, + "vspltb", 0x0000015B, "=v,v,u5", 0x400FFFFF, 0x1000020C, + "vsplth", 0x0000015C, "=v,v,u5", 0x400FFFFF, 0x1000024C, + "vspltw", 0x0000015D, "=v,v,u5", 0x400FFFFF, 0x1000028C, + "vspltisb", 0x0000015E, "=v,i5", 0x400FFFFF, 0x1000030C, + "vspltish", 0x0000015F, "=v,i5", 0x400FFFFF, 0x1000034C, + "vspltisw", 0x00000160, "=v,i5", 0x400FFFFF, 0x1000038C, + "vsr", 0x00000161, "=v,v,v", 0x400FFFFF, 0x100002C4, + "vsrab", 0x00000162, "=v,v,v", 0x400FFFFF, 0x10000304, + "vsrah", 0x00000163, "=v,v,v", 0x400FFFFF, 0x10000344, + "vsraw", 0x00000164, "=v,v,v", 0x400FFFFF, 0x10000384, + "vsrb", 0x00000165, "=v,v,v", 0x400FFFFF, 0x10000204, + "vsrh", 0x00000166, "=v,v,v", 0x400FFFFF, 0x10000244, + "vsro", 0x00000167, "=v,v,v", 0x400FFFFF, 0x1000044C, + "vsrw", 0x00000168, "=v,v,v", 0x400FFFFF, 0x10000284, + "vsubcuw", 0x00000169, "=v,v,v", 0x400FFFFF, 0x10000580, + "vsubfp", 0x0000016A, "=v,v,v", 0x400FFFFF, 0x1000004A, + "vsubsbs", 0x0000016B, "=v,v,v", 0x400FFFFF, 0x10000700, + "vsubshs", 0x0000016C, "=v,v,v", 0x400FFFFF, 0x10000740, + "vsubsws", 0x0000016D, "=v,v,v", 0x400FFFFF, 0x10000780, + "vsububm", 0x0000016E, "=v,v,v", 0x400FFFFF, 0x10000400, + "vsububs", 0x0000016F, "=v,v,v", 0x400FFFFF, 0x10000600, + "vsubuhm", 0x00000170, "=v,v,v", 0x400FFFFF, 0x10000440, + "vsubuhs", 0x00000171, "=v,v,v", 0x400FFFFF, 0x10000640, + "vsubuwm", 0x00000172, "=v,v,v", 0x400FFFFF, 0x10000480, + "vsubuws", 0x00000173, "=v,v,v", 0x400FFFFF, 0x10000680, + "vsumsws", 0x00000174, "=v,v,v", 0x400FFFFF, 0x10000788, + "vsum2sws", 0x00000175, "=v,v,v", 0x400FFFFF, 0x10000688, + "vsum4sbs", 0x00000176, "=v,v,v", 0x400FFFFF, 0x10000708, + "vsum4shs", 0x00000177, "=v,v,v", 0x400FFFFF, 0x10000648, + "vsum4ubs", 0x00000178, "=v,v,v", 0x400FFFFF, 0x10000608, + "vupkhpx", 0x00000179, "=v,v", 0x400FFFFF, 0x1000034E, + "vupkhsb", 0x0000017A, "=v,v", 0x400FFFFF, 0x1000020E, + "vupkhsh", 0x0000017B, "=v,v", 0x400FFFFF, 0x1000024E, + "vupklpx", 0x0000017C, "=v,v", 0x400FFFFF, 0x100003CE, + "vupklsb", 0x0000017D, "=v,v", 0x400FFFFF, 0x1000028E, + "vupklsh", 0x0000017E, "=v,v", 0x400FFFFF, 0x100002CE, + "vxor", 0x0000017F, "=v,v,v", 0x400FFFFF, 0x100004C4, + "vmaddfp", 0x00000180, "=v,v,v,v", 0x400FFFFF, 0x1000002E, + "vmhaddshs", 0x00000181, "=v,v,v,v", 0x400FFFFF, 0x10000020, + "vmhraddshs", 0x00000182, "=v,v,v,v", 0x400FFFFF, 0x10000021, + "vmladduhm", 0x00000183, "=v,v,v,v", 0x400FFFFF, 0x10000022, + "vmsummbm", 0x00000184, "=v,v,v,v", 0x400FFFFF, 0x10000025, + "vmsumshm", 0x00000185, "=v,v,v,v", 0x400FFFFF, 0x10000028, + "vmsumshs", 0x00000186, "=v,v,v,v", 0x400FFFFF, 0x10000029, + "vmsumubm", 0x00000187, "=v,v,v,v", 0x400FFFFF, 0x10000024, + "vmsumuhm", 0x00000188, "=v,v,v,v", 0x400FFFFF, 0x10000026, + "vmsumuhs", 0x00000189, "=v,v,v,v", 0x400FFFFF, 0x10000027, + "vnmsubfp", 0x0000018A, "=v,v,v,v", 0x400FFFFF, 0x1000002F, + "vperm", 0x0000018B, "=v,v,v,v", 0x400FFFFF, 0x1000002B, + "vsel", 0x0000018C, "=v,v,v,v", 0x400FFFFF, 0x1000002A, + "vsldoi", 0x0000018D, "=v,v,v,u4", 0x400FFFFF, 0x1000002C, + "vmr", 0x0000018E, "=v,v", 0x400FFFFF, 0x10000484, + "vmrp", 0x0000018F, "=v,v", 0x400FFFFF, 0x1000002C, + "mtvrsave", 0x0000007C, "=S256r", 0x400FFFFF, 0x7C0043A6, + "mfvrsave", 0x0000007E, "=r;S256", 0x400FFFFF, 0x7C0042A6, + NULL, 0, NULL, 0, 0 +}; + +typedef struct HashedMnemonic { + struct HashedMnemonic *next; + IAMnemonic *mnemonic; +} HashedMnemonic; + +HashedMnemonic *hashedmnemonics[1024]; + +void InlineAsm_InitializeMnemonicsPPC(void) { + SInt32 i; + IAMnemonic *mnemonic; + HashedMnemonic **ptr; + HashedMnemonic *entry; + + for (i = 0; i < 1024; i++) + hashedmnemonics[i] = NULL; + + for (mnemonic = mnemonics; mnemonic->name; mnemonic++) { + ptr = hashedmnemonics + (CHash(mnemonic->name) & 1023); + entry = lalloc(sizeof(HashedMnemonic)); + entry->mnemonic = mnemonic; + entry->next = *ptr; + *ptr = entry; + } +} + +IAMnemonic *InlineAsm_LookupMnemonicPPC(char *name) { + HashedMnemonic *entry; + + for (entry = hashedmnemonics[CHash(name) & 1023]; entry; entry = entry->next) { + IAMnemonic *mnemonic = entry->mnemonic; + if (!strcmp(mnemonic->name, name)) + return mnemonic; + } + + return NULL; +} diff --git a/compiler_and_linker/unsorted/InlineAsmPPC.c b/compiler_and_linker/unsorted/InlineAsmPPC.c new file mode 100644 index 0000000..ead84d7 --- /dev/null +++ b/compiler_and_linker/unsorted/InlineAsmPPC.c @@ -0,0 +1,2624 @@ +#include "compiler/InlineAsmPPC.h" +#include "compiler/CError.h" +#include "compiler/CInt64.h" +#include "compiler/CFunc.h" +#include "compiler/CMachine.h" +#include "compiler/CParser.h" +#include "compiler/CPrep.h" +#include "compiler/CPrepTokenizer.h" +#include "compiler/TOC.h" +#include "compiler/FuncLevelAsmPPC.h" +#include "compiler/InlineAsm.h" +#include "compiler/InlineAsmMnemonicsPPC.h" +#include "compiler/InlineAsmRegisters.h" +#include "compiler/InlineAsmRegistersPPC.h" +#include "compiler/CodeGen.h" +#include "compiler/CodeGenOptPPC.h" +#include "compiler/PPCError.h" +#include "compiler/RegisterInfo.h" +#include "compiler/objects.h" +#include "compiler/CExpr.h" +#include "compiler/PCode.h" +#include "compiler/PCodeUtilities.h" +#include "compiler/StackFrame.h" +#include "compiler/CompilerTools.h" + +// TODO: move me +extern int countexceptionactionregisters(ExceptionAction *); +extern void noteexceptionactionregisters(ExceptionAction *, PCodeArg *); +extern void *make_alias(Object *obj, SInt32 offset, SInt32 size); + +char asm_alloc_flags[10]; +unsigned char sm_section; +UInt32 cpu; +SInt32 fralloc_parameter_area_size; +Boolean user_responsible_for_frame; +Boolean supports_hardware_fpu; +UInt32 assembledinstructions; +UInt8 assembler_type; +char volatileasm; +Boolean InlineAsm_gccmode; +Boolean InlineAsm_labelref; +CLabel *pic_base_label; + +enum { + NO_REG = 0, + INVALID_PIC_REG = -2 +}; + +// forward decls +static SInt32 InlineAsm_ConstantExpressionPPC(SInt32 value); +static Object *isvariableoperand(void); +static Object *isregisterstructpointeroperand(void); +static void registeroperand(IAOperand *op, char rclass, short effect); +static void DiadicOperatorPPC(IAExpr *left, short token, IAExpr *right); +static void InlineAsm_ExpressionPPC(IAExpr *expr, SInt32 value); +static void savepicbase(short reg, HashNameNode *name); + +inline SInt32 ExtractValue(CInt64 value) { + return (SInt32) CInt64_GetULong(&value); +} + +static void IllegalObjectOperator(HashNameNode *name1, HashNameNode *name2, short token) { + char *opstr; + switch (token) { + case '*': opstr = "*"; break; + case '/': opstr = "/"; break; + case '%': opstr = "%"; break; + case '+': opstr = "+"; break; + case '-': opstr = "-"; break; + case TK_SHL: opstr = "<<"; break; + case TK_SHR: opstr = ">>"; break; + case '<': opstr = "<"; break; + case '>': opstr = ">"; break; + case TK_LESS_EQUAL: opstr = "<="; break; + case TK_GREATER_EQUAL: opstr = ">="; break; + case TK_LOGICAL_EQ: opstr = "=="; break; + case TK_LOGICAL_NE: opstr = "!="; break; + case '&': opstr = "&"; break; + case '^': opstr = "^"; break; + case '|': opstr = "|"; break; + case TK_LOGICAL_AND: opstr = "&&"; break; + case TK_LOGICAL_OR: opstr = "||"; break; + default: opstr = "???"; + } + + if (!name2) { + PPCError_Error(119, opstr, name1->name); + } else if (!name1) { + PPCError_Error(120, opstr, name2->name); + } else { + PPCError_Error(118, name1->name, opstr, name2->name); + } +} + +static void IllegalObjectInConst(IAExpr *expr) { + if (expr->xC) { + PPCError_Error(122, expr->xC->name->name); + } else if (expr->object) { + PPCError_Error(122, expr->object->name->name); + } else if (expr->label) { + PPCError_Error(166, expr->label->name->name); + } +} + +static void NotInRegisterError(char *name, char rclass) { + PPCError_Error(167, name, register_class_name[rclass]); +} + +static int isregisteroperand(char rclass) { + IARegister *reg; + + return (tk == TK_IDENTIFIER && (reg = InlineAsm_LookupRegisterPPCName(tkidentifier)) && reg->rclass == rclass); +} + +static SInt32 getcroperand(char rclass) { + SInt32 value; + IARegister *reg; + + value = 0; + if (tk == TK_IDENTIFIER && (reg = InlineAsm_LookupRegisterPPCName(tkidentifier)) && reg->rclass == rclass) { + value = reg->num; + } else { + PPCError_Error(167, tkidentifier->name); + } + + tk = lex(); + return value; +} + +static SInt32 getimmediateoperand(SInt32 minimum, SInt32 maximum) { + SInt32 value = InlineAsm_ConstantExpressionPPC(0); + if (value < minimum || value > maximum) + CError_Error(CErrorStr154); + return value; +} + +static void PrimaryExpressionPPC(IAExpr *expr, SInt32 value) { + Object *obj; + IALookupResult result; + IAExpr subexpr; + IAExprType type = IAExpr_0; + SInt32 v; + + switch (tk) { + case TK_IDENTIFIER: + if ((obj = isregisterstructpointeroperand())) { + tk = lex(); + InlineAsm_InitExpr5(expr, InlineAsm_StructPointerMemberOffset(TPTR_TARGET(obj->type))); + expr->object = obj; + return; + } + + if ((obj = isvariableoperand())) { + short reg; + InlineAsm_InitExpr5(expr, 0); + expr->xC = obj; + + if (obj->datatype == DLOCAL) + reg = 1; + else + reg = pic_base_reg; + + tk = lex(); + if (tk == '.' || tk == '[') { + InlineAsm_InitExpr5(&subexpr, InlineAsm_StructArrayMemberOffset(obj->type)); + DiadicOperatorPPC(expr, '+', &subexpr); + } + + if (tk == '+') { + tk = lex(); + InlineAsm_ExpressionPPC(&subexpr, value); + DiadicOperatorPPC(expr, '+', &subexpr); + } else if (tk == '-') { + tk = lex(); + InlineAsm_ExpressionPPC(&subexpr, value); + DiadicOperatorPPC(expr, '-', &subexpr); + } else if (!strcmp(tkidentifier->name, "@loword")) { + tk = lex(); + if (low_offset) { + InlineAsm_InitExpr5(&subexpr, low_offset); + DiadicOperatorPPC(expr, '+', &subexpr); + } + } else if (!strcmp(tkidentifier->name, "@hiword")) { + tk = lex(); + if (high_offset) { + InlineAsm_InitExpr5(&subexpr, high_offset); + DiadicOperatorPPC(expr, '+', &subexpr); + } + } + expr->reg = reg; + return; + } + + if (InlineAsm_LookupSymbolOrTag(tkidentifier, &result, 1)) { + if (result.has_value) { + tk = lex(); + InlineAsm_InitExpr5(expr, result.value); + return; + } + + if (result.type && (IS_TYPE_STRUCT(result.type) || IS_TYPE_CLASS(result.type))) { + tk = lex(); + if (tk != '.') + CError_Error(CErrorStr120); + + if (allow_array_expressions) { + InlineAsm_InitExpr5(expr, InlineAsm_StructArrayMemberOffset(result.type)); + return; + } + + InlineAsm_InitExpr5(expr, InlineAsm_StructMemberOffset(result.type)); + return; + } + + if (result.object && result.object->datatype == DABSOLUTE) { + tk = lex(); + InlineAsm_InitExpr5(expr, result.object->u.address); + return; + } + } else if (value) { + if (isregisteroperand(RegClass_CRFIELD)) { + InlineAsm_InitExpr5(expr, getcroperand(RegClass_CRFIELD)); + return; + } + if (isregisteroperand(RegClass_6)) { + InlineAsm_InitExpr5(expr, getcroperand(RegClass_6)); + return; + } + if (strlen(tkidentifier->name) == 6 && !strncmp(tkidentifier->name, "cr", 2) && tkidentifier->name[3] == '_') { + IARegister *reg; + char regname[4]; + regname[0] = tkidentifier->name[0]; + regname[1] = tkidentifier->name[1]; + regname[2] = tkidentifier->name[2]; + regname[3] = 0; + if ((reg = InlineAsm_LookupRegisterPPC(regname)) && reg->rclass == RegClass_CRFIELD) { + SInt32 v = reg->num * 4; + regname[0] = tkidentifier->name[4]; + regname[1] = tkidentifier->name[5]; + regname[2] = 0; + if ((reg = InlineAsm_LookupRegisterPPC(regname)) && reg->rclass == RegClass_6) { + tk = lex(); + InlineAsm_InitExpr5(expr, v + reg->num); + return; + } + } + } + } + + if (!strcmp("ha16", tkidentifier->name)) + type = IAExpr_8; + else if (!strcmp("hi16", tkidentifier->name)) + type = IAExpr_7; + else if (!strcmp("lo16", tkidentifier->name)) + type = IAExpr_6; + + if (type != IAExpr_0) { + tk = lex(); + if (tk == '(') { + SInt32 v; + tk = lex(); + PrimaryExpressionPPC(expr, value); + expr->type = type; + if (tk != ')') + CError_Error(CErrorStr115); + + tk = lex(); + if (InlineAsm_CheckExpr(expr)) { + expr->value = InlineAsm_GetExprValue(expr); + expr->type = IAExpr_5; + } + return; + } + + CError_Error(CErrorStr114); + } else { + if (!result.label) + result.label = InlineAsm_DeclareLabel(tkidentifier); + + InlineAsm_InitExpr5(expr, 0); + expr->flags |= IAFlag1; + expr->label = result.label; + tk = lex(); + return; + } + break; + + case TK_INTCONST: + v = CInt64_GetULong(&tkintconst); + tk = lex(); + InlineAsm_InitExpr5(expr, v); + return; + + case TK_SIZEOF: + InlineAsm_InitExpr5(expr, scansizeof()); + return; + + case '+': + tk = lex(); + PrimaryExpressionPPC(expr, value); + return; + + case '-': + tk = lex(); + PrimaryExpressionPPC(expr, value); + if (InlineAsm_CheckExpr(expr)) + expr->value = -expr->value; + else + CError_Error(CErrorStr124); + return; + + case '!': + tk = lex(); + PrimaryExpressionPPC(expr, value); + if (InlineAsm_CheckExpr(expr)) + expr->value = !expr->value; + else + CError_Error(CErrorStr124); + return; + + case '~': + tk = lex(); + PrimaryExpressionPPC(expr, value); + if (InlineAsm_CheckExpr(expr)) + expr->value = ~expr->value; + else + CError_Error(CErrorStr124); + return; + + case '(': + tk = lex(); + InlineAsm_ExpressionPPC(expr, value); + if (tk != ')') + CError_Error(CErrorStr115); + tk = lex(); + return; + + default: + CError_Error(CErrorStr120); + } + + InlineAsm_InitExpr5(expr, 0); +} + +static void DiadicOperatorPPC(IAExpr *left, short token, IAExpr *right) { + CInt64 leftval; + CInt64 rightval; + + CInt64_SetLong(&leftval, left->value); + CInt64_SetLong(&rightval, right->value); + rightval = CMach_CalcIntDiadic(TYPE(&stsignedint), leftval, token, rightval); + + if (left->xC) { + if (right->label) + PPCError_Error(124, left->xC->name->name, right->label->name->name); + + if (right->xC) { + if (left->x10) { + PPCError_Error(121, left->xC->name->name, left->x10->name->name, right->xC->name->name); + } else if (right->x10) { + PPCError_Error(121, left->xC->name->name, right->xC->name->name, right->x10->name->name); + } else if (token == '-') { + left->value = CInt64_GetULong(&rightval); + left->x10 = right->xC; + } else { + IllegalObjectOperator(left->xC->name, right->xC->name, token); + } + } else if (token == '-' || token == '+') { + left->value = CInt64_GetULong(&rightval); + } else { + IllegalObjectOperator(left->xC->name, NULL, token); + } + } else if (right->xC) { + if (right->label) + PPCError_Error(124, right->xC->name->name, right->label->name->name); + + if (token == '+') { + left->xC = right->xC; + left->x10 = right->x10; + left->value = CInt64_GetULong(&rightval); + } else { + IllegalObjectOperator(NULL, right->xC->name, token); + } + } else if (left->label) { + if (left->xC) + PPCError_Error(124, left->label->name->name, left->xC->name->name); + + if (right->label) { + if (left->x18) { + PPCError_Error(121, left->label->name->name, left->x18->name->name, right->label->name->name); + } else if (right->x18) { + PPCError_Error(121, left->label->name->name, right->label->name->name, right->x18->name->name); + } else if (token == '-') { + left->value = CInt64_GetULong(&rightval); + left->x18 = right->label; + } else { + IllegalObjectOperator(left->label->name, right->label->name, token); + } + } else if (token == '+' || token == '-') { + left->value = CInt64_GetULong(&rightval); + } else { + IllegalObjectOperator(NULL, left->label->name, token); + } + } else if (right->label) { + if (token == '+') { + left->label = right->label; + left->x18 = right->x18; + left->value = CInt64_GetULong(&rightval); + } else { + IllegalObjectOperator(NULL, right->label->name, token); + } + } else { + left->value = CInt64_GetULong(&rightval); + } + + left->flags |= right->flags; + if (left->type == IAOpnd_Lab) { + if (right->type != IAOpnd_Lab) + left->type = right->type; + } else { + if (right->type != IAOpnd_Lab && right->type != left->type) + PPCError_Error(126); + } +} + +static void ExpressionTailPPC(IAExpr *left, SInt32 value) { + IAExpr right; + short left_tk; + short right_prec; + + while (1) { + left_tk = tk; + tk = lex(); + + PrimaryExpressionPPC(&right, value); + right_prec = GetPrec(tk); + if (right_prec == 0) { + DiadicOperatorPPC(left, left_tk, &right); + break; + } + + if (GetPrec(left_tk) >= right_prec) { + DiadicOperatorPPC(left, left_tk, &right); + } else { + ExpressionTailPPC(&right, value); + DiadicOperatorPPC(left, left_tk, &right); + if (GetPrec(tk) == 0) + break; + } + } +} + +static void immediateoperand(IAOperand *op, SInt32 minval, SInt32 maxval) { + SInt32 value; + if (InlineAsm_gccmode && tk == '%') { + tk = lex(); + if (tk != TK_INTCONST) { + CError_Error(CErrorStr144); + } else { + CInt64 c = tkintconst; + value = CInt64_GetULong(&c); + if (value < 0) + CError_Error(CErrorStr144); + } + op->type = IAOpnd_7; + op->u.unk7.value = value; + op->u.unk7.unk1 = 1; + op->u.unk7.unk2 = 0; + op->u.unk7.unk3 = 0; + tk = lex(); + } else { + value = InlineAsm_ConstantExpressionPPC(0); + if (value < minval || value > maxval) + CError_Error(CErrorStr154); + op->type = IAOpnd_Imm; + op->u.imm.value = value; + } +} + +static SInt32 immediatevalue(IAOperand *op, SInt32 minval, SInt32 maxval) { + SInt32 value; + if (InlineAsm_gccmode && tk == '%') { + CError_Error(CErrorStr144); + return 0; + } else { + value = InlineAsm_ConstantExpressionPPC(0); + if (value < minval || value > maxval) + CError_Error(CErrorStr154); + op->type = IAOpnd_Imm; + op->u.imm.value = value; + return value; + } +} + +static void InlineAsm_ExpressionPPC(IAExpr *expr, SInt32 value) { + PrimaryExpressionPPC(expr, value); + if (GetPrec(tk)) + ExpressionTailPPC(expr, value); + if (GetPrec(tk)) + ExpressionTailPPC(expr, value); + + if (expr->type == IAExpr_5 && tk == TK_IDENTIFIER) { + if (!strcmp(tkidentifier->name, "@l")) { + expr->type = IAExpr_6; + tk = lex(); + } else if (!strcmp(tkidentifier->name, "@ha")) { + expr->type = IAExpr_8; + tk = lex(); + } else if (!strcmp(tkidentifier->name, "@h")) { + expr->type = IAExpr_7; + tk = lex(); + } + } +} + +static SInt32 InlineAsm_ConstantExpressionPPC(SInt32 value) { + IAExpr expr; + + InlineAsm_ExpressionPPC(&expr, value); + if (!InlineAsm_CheckExpr(&expr)) { + IllegalObjectInConst(&expr); + return 0; + } else { + return InlineAsm_GetExprValue(&expr); + } +} + +static SInt32 crbitoperand(void) { + SInt32 value = InlineAsm_ConstantExpressionPPC(1); + if (value < 0 || value > 31) + CError_Error(CErrorStr154); + return value; +} + +static void floatoperand(IAOperand *op, InlineAsm *ia, Type *type) { + Object *obj; + + obj = createfloatconstant(type, &tkfloatconst); + op[0].type = IAOpnd_Reg; + op[0].u.reg.rclass = RegClass_GPR; + op[0].u.reg.object = NULL; + op[0].u.reg.effect = EffectRead; + op[0].u.reg.num = pic_base_reg; + + ia->argcount++; + op[1].type = IAOpnd_4; + op[1].u.obj.obj = obj; + PPCError_Error(179); + op[1].u.obj.unk = IAExpr_2; + op[1].u.obj.offset = 0; + tk = lex(); +} + +static Object *isvariableoperand(void) { + IALookupResult result; + Object *obj; + + if (tk == TK_IDENTIFIER) { + InlineAsm_LookupSymbol(tkidentifier, &result); + if ((obj = result.object)) { + if (obj->datatype == DLOCAL) { + if (OBJECT_REG(obj)) + return NULL; + return obj; + } + + if (obj->datatype == DFUNC || obj->datatype == DVFUNC) + return obj; + + if (obj->datatype == DDATA) { + createIndirect(obj, 0, 0); + return obj; + } + } + } + + return NULL; +} + +static Object *isregisterstructpointeroperand(void) { + IALookupResult result; + Object *obj; + + if (tk != TK_IDENTIFIER) + return NULL; + + InlineAsm_LookupSymbol(tkidentifier, &result); + if ((obj = result.object)) { + if (obj->datatype != DLOCAL) + return NULL; + if (!OBJECT_REG(obj) && !is_register_object(obj)) + return NULL; + if (!IS_TYPE_POINTER(obj->type)) + return NULL; + if (!IS_TYPE_STRUCT(TPTR_TARGET(obj->type)) && !IS_TYPE_CLASS(TPTR_TARGET(obj->type))) + return NULL; + return obj; + } + + return NULL; +} + +static void memoryoperand(IAOperand *op, InlineAsm *ia, Boolean flag, short effect) { + IAExpr expr; + + InlineAsm_ExpressionPPC(&expr, 0); + if (expr.object) { + if (!flag) + CError_Error(CErrorStr155); + if (expr.xC) + PPCError_Error(122, expr.xC); + + op[0].type = IAOpnd_Reg; + op[0].u.reg.rclass = RegClass_GPR; + op[0].u.reg.object = expr.object; + op[0].u.reg.num = 0; + op[0].u.reg.effect = effect; + if (expr.object || expr.reg) + op[0].u.reg.effect = effect; + else + op[0].u.reg.effect = 0; + + ia->argcount++; + op[1].type = IAOpnd_Imm; + switch (expr.type) { + case IAExpr_5: + expr.type = IAExpr_6; + if (expr.object->datatype != DLOCAL || !OBJECT_REG(expr.object)) + PPCError_Error(180); + case IAExpr_2: + case IAExpr_6: + case IAExpr_7: + case IAExpr_8: + op[1].u.imm.value = InlineAsm_GetExprValue(&expr); + break; + default: + CError_Error(CErrorStr155); + } + + expr.object->flags |= OBJECT_FLAGS_UNUSED; + return; + } + + if (expr.xC) { + if (expr.x10) + PPCError_Error(123, expr.xC->name->name, expr.x10->name->name); + + if (flag) { + if (tk == '(') { + if (flag) { + tk = lex(); + registeroperand(op, RegClass_GPR, effect); + if ((expr.type == IAExpr_8 || expr.type == IAExpr_7) && copts.codegen_pic && pic_base_reg) + CError_Error(CErrorStr155); + if (tk != ')') + CError_Error(CErrorStr115); + tk = lex(); + } + } else { + op[0].type = IAOpnd_Reg; + op[0].u.reg.rclass = RegClass_GPR; + op[0].u.reg.object = expr.object; + op[0].u.reg.num = expr.reg; + } + + if (expr.object || expr.reg) + op[0].u.reg.effect = effect; + else + op[0].u.reg.effect = 0; + + ia->argcount++; + op++; + } + + if (expr.xC->datatype == DLOCAL) { + op[0].type = IAOpnd_4; + op[0].u.obj.unk = IAExpr_1; + } else { + op[0].type = IAOpnd_3; + if (expr.type == IAExpr_5) { + expr.type = IAExpr_6; + PPCError_Error(180); + } + op[0].u.obj.unk = expr.type; + } + + op[0].u.obj.obj = expr.xC; + op[0].u.obj.offset = expr.value; + expr.xC->flags |= OBJECT_FLAGS_UNUSED; + return; + } + + if (flag) { + if (tk == '(') { + tk = lex(); + registeroperand(op, RegClass_GPR, effect); + ia->argcount++; + op++; + if (tk != ')') + CError_Error(CErrorStr115); + tk = lex(); + } else { + op->type = IAOpnd_Reg; + op->u.reg.rclass = RegClass_GPR; + op->u.reg.object = expr.object; + op->u.reg.num = expr.reg; + ia->argcount++; + op++; + } + } + + if (expr.label) { + if (expr.x18) { + op->type = IAOpnd_LabDiff; + op->negated = 0; + op->u.labdiff.label1 = expr.label; + op->u.labdiff.label2 = expr.x18; + op->u.labdiff.offset = expr.value; + } else { + PPCError_Error(125, expr.label->name->name); + } + } else { + op->type = IAOpnd_Imm; + op->u.imm.value = InlineAsm_GetExprValue(&expr); + } +} + +static void registeroperand(IAOperand *op, char rclass, short effect) { + IARegister *reg; + Object *obj; + + if (tk == TK_IDENTIFIER && (reg = InlineAsm_LookupRegisterPPCName(tkidentifier)) && reg->rclass == rclass) { + SInt32 num; + obj = reg->object; + num = reg->num; + op->type = IAOpnd_Reg; + op->u.reg.rclass = rclass; + op->u.reg.object = obj; + op->u.reg.num = num; + op->u.reg.effect = effect; + if (obj) { + reg->object->flags |= OBJECT_FLAGS_UNUSED; + Registers_GetVarInfo(obj)->flags |= VarInfoFlag40; + } + } else if (rclass == RegClass_CRFIELD) { + op->type = IAOpnd_Reg; + op->u.reg.rclass = RegClass_CRFIELD; + op->u.reg.object = NULL; + op->u.reg.num = getimmediateoperand(0, 7); + op->u.reg.effect = effect; + return; + } else if (rclass == RegClass_SPR) { + op->type = IAOpnd_Reg; + op->u.reg.rclass = RegClass_SPR; + op->u.reg.object = NULL; + op->u.reg.num = getimmediateoperand(0, 1024); + op->u.reg.effect = effect; + return; + } else if (tk == '%' && InlineAsm_gccmode) { + SInt32 num; + tk = lex(); + if (tk != TK_INTCONST) { + CError_Error(CErrorStr144); + } else { + num = ExtractValue(tkintconst); + if (num < 0) + CError_Error(CErrorStr144); + } + + op->type = IAOpnd_6; + op->u.unk6.num = num; + op->u.unk6.unk4 = 2; + op->u.unk6.effect = effect; + op->u.unk6.rclass = rclass; + tk = lex(); + return; + } else if (tk == TK_IDENTIFIER) { + NotInRegisterError(tkidentifier->name, rclass); + } else { + PPCError_Error(171); + } + + tk = lex(); + if (!strcmp(tkidentifier->name, "@loword")) { + tk = lex(); + } else if (!strcmp(tkidentifier->name, "@hiword")) { + if (reg->object) + op->u.reg.num = 1; + else + PPCError_Error(168); + tk = lex(); + } else if (rclass == RegClass_GPR) { + if (reg->object && reg->object->type->size == 8) { + HashNameNode *name = reg->object->name; + PPCError_Error(127, name->name, name->name, name->name); + } + } +} + +static void cr0_operand(IAOperand *op, short effect) { + IARegister *reg; + + if ((reg = InlineAsm_LookupRegisterPPC("cr0"))) { + op->type = IAOpnd_Reg; + op->u.reg.rclass = RegClass_CRFIELD; + op->u.reg.object = reg->object; + op->u.reg.num = reg->num; + op->u.reg.effect = effect; + } else { + NotInRegisterError("cr0", RegClass_CRFIELD); + } +} + +static void r0_operand(IAOperand *op) { + IARegister *reg; + + if ((reg = InlineAsm_LookupRegisterPPC("r0"))) { + op->type = IAOpnd_Reg; + op->u.reg.rclass = RegClass_GPR; + op->u.reg.object = reg->object; + op->u.reg.num = reg->num; + op->u.reg.effect = 0; + tk = lex(); + } else { + NotInRegisterError("r0", RegClass_GPR); + } +} + +static void labeloperand(InlineAsm *ia, IAOperand *op, Boolean flag1, Boolean flag2, Boolean flag3) { + IALookupResult result; + + if (tk == TK_IDENTIFIER) { + if (!InlineAsm_LookupSymbol(tkidentifier, &result)) + result.label = InlineAsm_DeclareLabel(tkidentifier); + + if (result.label) { + op->type = IAOpnd_Lab; + op->u.lab.label = result.label; + } else if (result.object && result.object->datatype == DFUNC) { + if (flag3) + ia->flags |= IAFlag2; + op->type = IAOpnd_3; + op->u.obj.obj = result.object; + op->u.obj.offset = 0; + + if (flag1) { + op->u.obj.unk = IAExpr_4; + if (flag2) + CError_Error(CErrorStr261); + } else { + op->u.obj.unk = IAExpr_2; + if (flag2) + op->u.obj.unk = IAExpr_10; + op->u.obj.unk = IAExpr_6; + PPCError_Error(180); + } + } else { + CError_Error(CErrorStr144); + } + + tk = lex(); + } else if (tk == '*') { + if (!flag2) { + tk = lex(); + if (tk == '+') { + tk = lex(); + if (flag1) + immediateoperand(op, -0x2000000, 0x1FFFFFF); + else + immediateoperand(op, -0x8000, 0xFFFF); + } else if (tk == '-') { + tk = lex(); + op->u.imm.value = flag1 ? -immediatevalue(op, -0x1FFFFFF, 0x2000000) : -immediatevalue(op, -0x7FFF, 0x10000); + } else { + CError_Error(CErrorStr144); + } + } else { + CError_Error(CErrorStr144); + } + } else { + if (flag2) { + if (flag1) + immediateoperand(op, -0x2000000, 0x1FFFFFF); + else + immediateoperand(op, -0x8000, 0xFFFF); + } else { + CError_Error(CErrorStr144); + } + } +} + +static void imm_or_labeldiff_operand(InlineAsm *ia, IAOperand *op, SInt32 minimum, SInt32 maximum, Boolean negate) { + IAExpr expr; + Object *obj; + SInt32 value; + + InlineAsm_ExpressionPPC(&expr, 0); + + if ((obj = expr.xC) && !expr.x10 && expr.type == IAExpr_5 && obj->datatype == DDATA && IS_TYPE_INT_OR_ENUM(obj->type) && (obj->qual & Q_10000)) { + switch (ia->opcode) { + case PC_ADDI: + case PC_ADDIC: + case PC_ADDICR: + case PC_ADDIS: + case PC_ORI: + case PC_ORIS: + if (ia->args[1].u.imm.value) { + SInt32 cmp; + if (obj->datatype != DLOCAL) { + cmp = copts.codegen_pic ? INVALID_PIC_REG : NO_REG; + } else { + cmp = local_base_register(obj); + } + if (ia->args[1].u.imm.value == cmp) + break; + } + case PC_LI: + case PC_LIS: + case PC_TWI: + case PC_OPWORD: + InlineAsm_InitExpr5(&expr, expr.value + CInt64_GetULong(&obj->u.data.u.intconst)); + break; + } + } + + if (expr.label) { + if (expr.x18) { + op->type = IAOpnd_LabDiff; + if (negate) + op->negated = 1; + else + op->negated = 0; + op->u.labdiff.label1 = expr.label; + op->u.labdiff.label2 = expr.x18; + op->u.labdiff.offset = expr.value; + } else { + PPCError_Error(125, expr.label->name->name); + } + return; + } + + if (expr.xC) { + if (!expr.x10) { + if (ia->opcode != PC_OPWORD && expr.type == IAExpr_5) { + IllegalObjectInConst(&expr); + return; + } + + if (expr.xC->datatype == DLOCAL) { + op->type = IAOpnd_4; + op->u.obj.unk = IAExpr_1; + } else { + op->type = IAOpnd_3; + if (expr.type == IAExpr_5) { + expr.type = IAExpr_6; + PPCError_Error(180); + } + op->u.obj.unk = expr.type; + } + op->u.obj.obj = expr.xC; + op->u.obj.offset = expr.value; + } else { + PPCError_Error(123, expr.xC->name->name, expr.x10->name->name); + } + return; + } + + value = InlineAsm_GetExprValue(&expr); + if (value < minimum || value > maximum) + CError_Error(CErrorStr154); + + op->type = IAOpnd_Imm; + if (negate) + op->u.imm.value = -value; + else + op->u.imm.value = value; +} + +static void eatcommatoken(void) { + if (tk == ',') + tk = lex(); + else + CError_Error(CErrorStr116); +} + +static InlineAsm *InlineAsm_ScanAssemblyOperands(IAMnemonic *mnemonic) { + OpcodeInfo *info; + InlineAsm *ia; + SInt32 buffersize; + IAOperand *op; + int argcount; + char *format; + IARegister *reg; + + char code; + short effect; + Boolean has_excl; + Boolean has_question; + Boolean negate; + UInt32 t; + + info = &opcodeinfo[mnemonic->x4]; + argcount = info->x8; + if (PCODE_FLAG_SET_F(info) & fPCodeFlag8000000) + argcount++; + if (!(PCODE_FLAG_SET_F(info) & fPCodeFlag10000000) && (PCODE_FLAG_SET_F(info) & fPCodeFlag4000000)) + argcount++; + if (PCODE_FLAG_SET_T(info) & fPCodeFlag2000000) + argcount++; + + buffersize = sizeof(InlineAsm) + sizeof(IAOperand) * argcount; + ia = galloc(buffersize); + memset(ia, 0, buffersize); + + ia->opcode = mnemonic->x4; + ia->flags = 0; + ia->argcount = 0; + + op = ia->args; + for (format = mnemonic->format; *format; format++) { +#line 1664 + CError_ASSERT(ia->argcount < argcount); + + if (*format == ',') { + eatcommatoken(); + format++; + } else if (*format == ';') { + format++; + } + + if (*format == '[' || *format == '(') + format++; + + effect = EffectRead; + has_excl = 0; + has_question = 0; + negate = 0; + if (*format == '=') { + effect = EffectWrite; + format++; + } else if (*format == '+') { + effect = EffectRead | EffectWrite; + format++; + } + + if (*format == '-') { + negate = 1; + format++; + } + + if (*format == '?') { + has_question = 1; + format++; + } + + if (*format == '!') { + has_excl = 1; + format++; + } + + switch (*format) { + case 'p': + continue; + case '&': + if (format[1] == '2') { + op[0] = op[-2]; + format++; + if (op->type == IAOpnd_Reg) + op->u.reg.effect = effect; + ia->argcount++; + + op[1] = op[-1]; + op++; + if (op->type == IAOpnd_Reg) + op->u.reg.effect = effect; + } else { + op[0] = op[-1]; + if (op->type == IAOpnd_Reg) + op->u.reg.effect = effect; + } + break; + + case '%': { + SInt32 value; + format += pcode_const_from_format(format + 1, &value); + op->type = IAOpnd_Imm; + op->u.imm.value = value; + break; + } + + case 'b': + if (!isregisteroperand(RegClass_GPR)) { + if (tk == TK_INTCONST && tkintconst.lo == 0) + r0_operand(op); + } else { + registeroperand(op, RegClass_GPR, effect); + if (op->u.reg.object == NULL && op->u.reg.num == 0) + op->u.reg.effect = 0; + } + break; + + case 'r': + registeroperand(op, RegClass_GPR, effect); + break; + + case 'B': + case 'a': + case 'i': + case 't': + case 'u': + case 'x': + { + SInt32 value, hi, lo; + code = *format; + value = 16; + if (code == 'a') { + if (isdigit(format[1])) { + code = *(++format); + } else { +#line 1804 + CError_FATAL(); + } + } + + if (isdigit(format[1])) { + format += pcode_const_from_format(format + 1, &value); + } else if (code == 't' || code == 'B') { + code = 'u'; + value = 5; + } + + pcode_get_hi_lo(value, code, &hi, &lo); + if (!has_question || tk == ',') { + if (has_question) + tk = lex(); + if (has_excl) + getimmediateoperand(lo, hi); + else + immediateoperand(op, lo, hi); + } else { + op->type = IAOpnd_Imm; + op->u.imm.value = 0; + } + + if (code == 'i' && value == 16) + op->u.imm.value = (short) op->u.imm.value; + if (negate) + op->u.imm.value = -op->u.imm.value; + + if (pcode_check_imm_bits(op->u.imm.value, value, code)) { +#line 1838 + CError_FATAL(); + } + + break; + } + + case 'O': + if (tk == TK_INTCONST && tkintconst.lo == 0) { + getimmediateoperand(0, 0); + eatcommatoken(); + } + continue; + + case 'f': + registeroperand(op, RegClass_FPR, effect); + break; + + case 'v': + registeroperand(op, RegClass_VR, effect); + break; + + case 'T': + if (!has_question || tk == ',') { + if (has_question) + tk = lex(); + + immediateoperand(op, 268, 269); + if (op->u.reg.num == 268) + op->u.reg.num = 284; + else + op->u.reg.num = 285; + } else { + op->u.reg.num = 284; + } + + op->type = IAOpnd_Reg; + op->u.reg.rclass = RegClass_SPR; + op->u.reg.effect = effect; + break; + + case 'S': + { + SInt32 value; + format += pcode_const_from_format(format + 1, &value); + op->type = IAOpnd_Reg; + op->u.reg.rclass = RegClass_SPR; + op->u.reg.num = value; + op->u.reg.effect = effect; + break; + } + + case 'c': + if (has_question) { + if (isregisteroperand(RegClass_CRFIELD) || tk == TK_INTCONST) { + registeroperand(op, RegClass_CRFIELD, effect); + } else { + cr0_operand(op, effect); + if (format[1] == ',') + format++; + } + } else { + registeroperand(op, RegClass_CRFIELD, effect); + } + break; + + case 'l': + switch (ia->opcode) { + case PC_B: + case PC_BL: + labeloperand(ia, op, 1, mnemonic->x10 & 2, mnemonic->x10 & 1); + break; + default: + labeloperand(ia, op, 0, mnemonic->x10 & 2, mnemonic->x10 & 1); + break; + } + break; + + case 'w': + imm_or_labeldiff_operand(ia, op, -0x80000000, 0x7FFFFFFF, negate); + break; + + case 'M': + case 'm': + case 'n': + imm_or_labeldiff_operand(ia, op, -0x8000, 0xFFFF, negate); + break; + + case 'Q': + { + SInt32 cr = crbitoperand(); + op->type = IAOpnd_Reg; + op->u.reg.num = cr >> 2; + op->u.reg.rclass = RegClass_CRFIELD; + op->u.reg.effect = effect; + + ia->argcount++; + op[1].type = IAOpnd_Imm; + op[1].u.imm.value = cr % 4; + op++; + break; + } + + case 'd': { + short effect2; +#line 1971 + CError_ASSERT(format[1] == '('); + format++; + effect2 = EffectRead; + if (format[1] == '=') { + effect2 = EffectWrite; + format++; + } else if (format[1] == '+') { + effect2 = EffectRead | EffectWrite; + format++; + } + +#line 1983 + CError_ASSERT(format[1] == 'b'); +#line 1985 + CError_ASSERT(format[2] == ')'); + format += 2; + + switch (ia->opcode) { + case PC_LFS: + if (tk == TK_FLOATCONST) + floatoperand(op, ia, TYPE(&stfloat)); + else + memoryoperand(op, ia, 1, effect2); + break; + case PC_LFD: + if (tk == TK_FLOATCONST) + floatoperand(op, ia, TYPE(&stdouble)); + else + memoryoperand(op, ia, 1, effect2); + break; + default: + memoryoperand(op, ia, 1, effect2); + } + + break; + } + + case 'N': + immediateoperand(op, 1, 32); + break; + + case 's': + registeroperand(op, RegClass_SPR, effect); + break; + + case 'D': + if (tk == TK_IDENTIFIER && (reg = InlineAsm_LookupDCRRegister(tkidentifier->name))) { + op->type = IAOpnd_Imm; + op->u.imm.value = reg->num; + } else { + immediateoperand(op, 0, 1023); + } + break; + + case 'Y': + { + SInt32 mask = 255; + SInt32 i; + if (ia->opcode == PC_MTCRF) { + if (ia->args[0].type != IAOpnd_Imm) + CError_Error(CErrorStr144); + mask = ia->args[0].u.imm.value; + } + for (i = 0; i < 8; i++) { + if ((0x80 >> i) & mask) { + op->type = IAOpnd_Reg; + op->u.reg.num = i; + op->u.reg.rclass = RegClass_CRFIELD; + op->u.reg.effect = effect; + ia->argcount++; + op++; + } + } + ia->argcount--; + op--; + break; + } + + case 'P': + op->type = IAOpnd_Reg; + op->u.reg.rclass = RegClass_SPR; + op->u.reg.object = NULL; + if (format[1] == '3') { + format++; + op->u.reg.num = getimmediateoperand(0, 7); + } else { + op->u.reg.num = getimmediateoperand(0, 3); + } + op->u.reg.effect = effect; + break; + + case 'C': + op->type = IAOpnd_Reg; + op->u.reg.rclass = RegClass_SPR; + op->u.reg.object = NULL; + op->u.reg.num = 9; + op->u.reg.effect = effect; + break; + + case 'L': + op->type = IAOpnd_Reg; + op->u.reg.rclass = RegClass_SPR; + op->u.reg.object = NULL; + op->u.reg.num = 8; + op->u.reg.effect = effect; + break; + + case 'X': + op->type = IAOpnd_Reg; + op->u.reg.rclass = RegClass_SPR; + op->u.reg.object = NULL; + op->u.reg.num = 1; + op->u.reg.effect = effect; + break; + + case 'Z': + op->type = IAOpnd_Reg; + op->u.reg.rclass = RegClass_CRFIELD; + op->u.reg.object = NULL; + t = info->flags & 0xC0000000; + if (t == 0x40000000) { + op->u.reg.num = 1; + } else if (t == 0xC0000000) { + op->u.reg.num = 6; + } else { + op->u.reg.num = 0; + } + op->u.reg.effect = effect; + break; + + default: +#line 2266 + CError_FATAL(); + } + + while (format[1] && strchr("/<>|*", format[1])) { + int index; + SInt32 value; + SInt32 value2; + IAOperand tmp; + switch ((code = *(++format))) { + case '/': + index = -1; + if (format[1] == '2') { + index = -2; + format++; + } + + tmp = op[index]; + op[index] = op[0]; + op[0] = tmp; + break; + case '*': + case '<': + case '>': + case '|': + if (op->type == IAOpnd_Imm) { + value = op->u.imm.value; + } else if (op->type == IAOpnd_Reg) { + value = op->u.reg.num; + } else { +#line 2312 + CError_FATAL(); + } + + if (format[1] == 'p') { + format++; + if (op[-1].type == IAOpnd_Imm) { + value2 = op[-1].u.imm.value; + } else if (op[-1].type == IAOpnd_Reg) { + value2 = op[-1].u.reg.num; + } else { +#line 2322 + CError_FATAL(); + } + } else if (isdigit(format[1])) { + format += pcode_const_from_format(format + 1, &value2); + } else { +#line 2327 + CError_FATAL(); + } + + switch (code) { + case '<': + value = value2 - value; + break; + case '>': + value = value - value2; + break; + case '|': + value = value + value2; + break; + case '*': + value = value * value2; + break; + default: +#line 2348 + CError_FATAL(); + } + + if (op->type == IAOpnd_Imm) { + op->u.imm.value = value; + } else if (op->type == IAOpnd_Reg) { + op->u.reg.num = value; + } else { +#line 2355 + CError_FATAL(); + } + break; + } + } + + ia->argcount++; + op++; + if (format[1] == ']' || format[1] == ')') + format++; + } + + return ia; +} + +static int mnemonic_has_overflow(char *buf) { + int result = 0; + + if (buf[strlen(buf) - 1] == 'o') { + if (!strcmp(buf, "bso")) + return 0; + if (!strcmp(buf, "fcmpo")) + return 0; + if (!strcmp(buf, "eieio")) + return 0; + if (!strcmp(buf, "vslo")) + return 0; + if (!strcmp(buf, "vsro")) + return 0; + result = 1; + } + + return result; +} + +static int mnemonic_has_absolute(char *buf) { + int result = 0; + char last = buf[strlen(buf) - 1]; + + if (buf[0] == 'b' && last == 'a') + result = 1; + + return result; +} + +static int mnemonic_has_linkregister(char *buf) { + int result = 0; + char last = buf[strlen(buf) - 1]; + + if (buf[0] == 'b' && last == 'l') + result = 1; + + return result; +} + +static int mnemonic_has_record(char *buf) { + int result = 0; + + if (lookahead() == '.') { + tk = lex(); + result = 1; + strcat(buf, "."); + } + + return result; +} + +static void installregistervariables(void) { +} + +void InlineAsm_InitializePPC(void) { + Test_Version_Numbers(); + allow_array_expressions = 1; + supports_hardware_fpu = 1; + assembledinstructions = 0; + + switch (copts.cpu) { + case CPU_PPC401: cpu = CPUMask_401; break; + case CPU_PPC403: cpu = CPUMask_403; break; + case CPU_PPC505: cpu = CPUMask_50x; break; + case CPU_PPC509: cpu = CPUMask_50x; break; + case CPU_PPC555: cpu = CPUMask_55x_56x; break; + case CPU_PPC556: cpu = CPUMask_55x_56x; break; + case CPU_PPC565: cpu = CPUMask_55x_56x; break; + case CPU_PPC601: cpu = CPUMask_601; break; + case CPU_PPC602: cpu = CPUMask_602; break; + case CPU_PPC8240: cpu = CPUMask_8240; break; + case CPU_PPC8260: cpu = CPUMask_8260; break; + case CPU_PPC603: cpu = CPUMask_603; break; + case CPU_PPC603e: cpu = CPUMask_603; break; + case CPU_PPC604: cpu = CPUMask_604; break; + case CPU_PPC604e: cpu = CPUMask_604; break; + case CPU_PPC740: cpu = CPUMask_740_750; break; + case CPU_PPC750: cpu = CPUMask_740_750; break; + case CPU_PPC801: cpu = CPUMask_801_821_860; break; + case CPU_PPC821: cpu = CPUMask_801_821_860; break; + case CPU_PPC823: cpu = CPUMask_823_850; break; + case CPU_PPC850: cpu = CPUMask_823_850; break; + case CPU_PPC860: cpu = CPUMask_801_821_860; break; + case CPU_PPC7400: case CPU_PPC7450: cpu = CPUMask_74xx; break; + case CPU_Generic: cpu = CPUMask_Generic; break; + default: +#line 2613 + CError_FATAL(); + } + + if (copts.altivec_model) + cpu |= 0x40000000; +} + +void InlineAsm_Initialize(UInt8 assemblertype) { + assembler_type = assemblertype; + + if (assembler_type == 0) { + InlineAsm_InitializePPC(); + pic_base_reg = INVALID_PIC_REG; + } else { + pic_base_reg = 0; + pic_base_label = NULL; + } + + InlineAsm_InitializeMnemonicsPPC(); + InlineAsm_InitializeRegisters(); + InlineAsm_InitializeRegistersPPC(); + + if (assembler_type == 0) { + installregistervariables(); + } else { + process_arguments(setup_assembly_argument, 0); + assign_local_addresses(); + } +} + +static IAEntryPoint *InlineAsm_CreateEntryPoint(HashNameNode *name, Boolean flag) { + Object *obj; + IAEntryPoint *ep; + IALookupResult result; + + if (InlineAsm_LookupSymbol(name, &result) && (obj = result.object)) { + if (!(obj->datatype == DFUNC && !(obj->flags & OBJECT_FLAGS_4))) + CError_Error(CErrorStr122, name->name); + + obj->flags |= OBJECT_FLAGS_4; + obj->sclass = flag ? TK_STATIC : TK_EXTERN; + + ep = lalloc(sizeof(IAEntryPoint)); + memclrw(ep, sizeof(IAEntryPoint)); + ep->x0 = IADirective_Entry; + ep->x2 = 1; + ep->x8 = obj; + ep->size = assembledinstructions * 4; + } else { + CError_Error(CErrorStr140, name->name); + } + + return ep; +} + +static InlineAsm *InlineAsm_CreateFrFree(void) { + InlineAsm *ia = lalloc(sizeof(InlineAsm)); + memclrw(ia, sizeof(InlineAsm)); + ia->opcode = IADirective_FrFree; + ia->flags = IAFlag1; + return ia; +} + +SInt32 InlineAsm_IsDirective(UInt8 assemblertype) { + char *name; + SInt32 directive = IADirective_Null; + + if (tk == '.') + tk = lex(); + + if (tk == TK_IDENTIFIER) { + name = tkidentifier->name; + if (!strcmp(name, "machine")) { + directive = IADirective_Machine; + } else if (assemblertype == 1) { + if (!strcmp(name, "entry")) { + directive = IADirective_Entry; + } else if (!strcmp(name, "fralloc")) { + directive = IADirective_FrAlloc; + } else if (!strcmp(name, "nofralloc")) { + directive = IADirective_NoFrAlloc; + } else if (!strcmp(name, "frfree")) { + directive = IADirective_FrFree; + } else if (!strcmp(name, "smclass")) { + directive = IADirective_SmClass; + } else if (!strcmp(name, "picbase")) { + directive = IADirective_PicBase; + } else { + directive = IADirective_Null; + } + } + } + + return directive; +} + +void InlineAsm_ProcessDirective(SInt32 directive) { + Boolean flag; + Statement *stmt; + IAOperand op; + + switch (directive) { + case IADirective_Entry: + flag = 0; + tk = lex(); + if (tk == TK_STATIC) { + flag = 1; + tk = lex(); + } else if (tk == TK_EXTERN) { + tk = lex(); + } + + if (tk != TK_IDENTIFIER) + CError_Error(CErrorStr107); + + stmt = CFunc_AppendStatement(ST_ASM); + stmt->expr = NULL; + stmt->expr = (ENode *) InlineAsm_CreateEntryPoint(tkidentifier, flag); + stmt->sourceoffset = -1; + tk = lex(); + break; + + case IADirective_FrAlloc: + if (assembledinstructions) + CError_Error(CErrorStr166); + if (asm_alloc_flags[0]) + CError_Error(CErrorStr165); + if (asm_alloc_flags[1] || asm_alloc_flags[2]) + CError_Error(CErrorStr166); + + tk = lex(); + if (tk != TK_NEG7 && tk != ';') + fralloc_parameter_area_size = getimmediateoperand(0x20, 0x7FFE); + + requires_frame = 1; + asm_alloc_flags[0] = 1; + break; + + case IADirective_NoFrAlloc: + if (asm_alloc_flags[0] || asm_alloc_flags[1]) + CError_Error(CErrorStr165); + if (asm_alloc_flags[2]) + CError_Error(CErrorStr166); + if (assembledinstructions) + CError_Error(CErrorStr166); + tk = lex(); + + asm_alloc_flags[1] = 1; + user_responsible_for_frame = 1; + break; + + case IADirective_FrFree: + if (asm_alloc_flags[1] || asm_alloc_flags[2]) + CError_Error(CErrorStr166); + + asm_alloc_flags[2] = 1; + stmt = CFunc_AppendStatement(ST_ASM); + stmt->expr = NULL; + stmt->expr = (ENode *) InlineAsm_CreateFrFree(); + if (copts.isGeneratingDebugInfo) + stmt->sourceoffset = CPrep_GetFileOffsetInfo(&cparser_fileoffset); + else + stmt->sourceoffset = -1; + tk = lex(); + break; + + case IADirective_Machine: + tk = lex(); + if (tk == TK_INTCONST) { + switch (tkintconst.lo) { + case 401: cpu = CPUMask_401; break; + case 403: cpu = CPUMask_403; break; + case 505: cpu = CPUMask_50x; break; + case 509: cpu = CPUMask_50x; break; + case 555: cpu = CPUMask_55x_56x; break; + case 556: cpu = CPUMask_55x_56x; break; + case 565: cpu = CPUMask_55x_56x; break; + case 601: cpu = CPUMask_601; break; + case 602: cpu = CPUMask_602; break; + case 8240: cpu = CPUMask_8240; break; + case 8260: cpu = CPUMask_8260; break; + case 603: cpu = CPUMask_603; break; + case 604: cpu = CPUMask_604; break; + case 740: cpu = CPUMask_740_750; break; + case 750: cpu = CPUMask_740_750; break; + case 801: cpu = CPUMask_801_821_860; break; + case 821: cpu = CPUMask_801_821_860; break; + case 823: cpu = CPUMask_823_850; break; + case 850: cpu = CPUMask_823_850; break; + case 860: cpu = CPUMask_801_821_860; break; + case 7400: cpu = CPUMask_74xx; break; + default: + CError_Error(CErrorStr144); + } + } else if (tk == TK_IDENTIFIER) { + if (!strcmp(tkidentifier->name, "all")) { + cpu = CPUMask_All; + } else if (!strcmp(tkidentifier->name, "generic")) { + cpu = CPUMask_Generic; + } else if (!strcmp(tkidentifier->name, "603e")) { + cpu = CPUMask_603; + } else if (!strcmp(tkidentifier->name, "604e")) { + cpu = CPUMask_604; + } else if (!strcmp(tkidentifier->name, "PPC603e")) { + cpu = CPUMask_603; + } else if (!strcmp(tkidentifier->name, "PPC604e")) { + cpu = CPUMask_604; + } else if (!strcmp(tkidentifier->name, "altivec")) { + cpu = CPUMask_74xx; + } else { + CError_Error(CErrorStr144); + } + } else { + CError_Error(CErrorStr144); + } + tk = lex(); + break; + + case IADirective_SmClass: + tk = lex(); + if (tk == TK_IDENTIFIER) { + if (!strcmp(tkidentifier->name, "PR")) + sm_section = 1; + else + CError_Error(CErrorStr144); + } else { + CError_Error(CErrorStr144); + } + tk = lex(); + break; + + case IADirective_PicBase: + tk = lex(); + registeroperand(&op, RegClass_GPR, EffectRead); + + if (!(op.type == IAOpnd_Reg && op.u.reg.object == NULL)) + CError_Error(CErrorStr144); + + tk = lex(); + if (tk == TK_IDENTIFIER) { + savepicbase(op.u.reg.num, tkidentifier); + tk = lex(); + } else { + CError_Error(CErrorStr144); + } + break; + + default: + CError_Error(CErrorStr261); + } +} + +void InlineAsm_ScanAssemblyDirective(void) { + SInt32 directive; + + if ((directive = InlineAsm_IsDirective(assembler_type)) != IADirective_Null) + InlineAsm_ProcessDirective(directive); +} + +void InlineAsm_ScanAssemblyInstruction(void) { + Statement *stmt; + InlineAsm *ia; + IAMnemonic *mnemonic; + Boolean record_flag; + Boolean flag3; + Boolean flag4; + Boolean flag5; + Boolean flag1; + Boolean flag2; + SInt32 directive; + char buf[20]; + + flag1 = 0; + flag2 = 0; + if ((directive = InlineAsm_IsDirective(assembler_type)) != IADirective_Null) { + InlineAsm_ProcessDirective(directive); + return; + } + + stmt = CFunc_AppendStatement(ST_ASM); + stmt->expr = NULL; + if (copts.isGeneratingDebugInfo) + stmt->sourceoffset = CPrep_GetFileOffsetInfo(&cparser_fileoffset); + else + stmt->sourceoffset = -1; + + strncpy(buf, tkidentifier->name, sizeof(buf)); + record_flag = mnemonic_has_record(buf); + mnemonic = InlineAsm_LookupMnemonicPPC(buf); + if (!mnemonic) + CError_Error(CErrorStr261); + + flag3 = (FLAG_SET_F(opcodeinfo[mnemonic->x4].flags) & fPCodeFlag4000000) && (mnemonic->x10 & 0x400); + flag4 = (FLAG_SET_T(opcodeinfo[mnemonic->x4].flags) & fPCodeFlag20000000) && (mnemonic->x10 & 2); + flag5 = (FLAG_SET_T(opcodeinfo[mnemonic->x4].flags) & fPCodeFlag2000000) && (mnemonic->x10 & 1); + + if ((cpu == CPUMask_Generic) && (cpu & CPUFLAG_LOW_MASK) != ((cpu & mnemonic->cpu) & CPUFLAG_LOW_MASK)) { + CError_Error(CErrorStr152); + } else if (((cpu & mnemonic->cpu) & CPUFLAG_LOW_MASK) == 0) { + CError_Error(CErrorStr152); + } else if ((mnemonic->cpu & CPUFLAG_10000000) && !(cpu & CPUFLAG_10000000)) { + CError_Error(CErrorStr152); + } else if ((mnemonic->cpu & CPUFLAG_8000000) && !(cpu & CPUFLAG_8000000)) { + CError_Error(CErrorStr152); + } else if ((mnemonic->cpu & CPUFLAG_2000000) && !(cpu & CPUFLAG_2000000)) { + CError_Error(CErrorStr152); + } else if ((mnemonic->cpu & CPUFLAG_4000000) && !(cpu & CPUFLAG_4000000)) { + CError_Error(CErrorStr152); + } else if ((mnemonic->cpu & CPUFLAG_1000000) && !(cpu & CPUFLAG_1000000)) { + CError_Error(CErrorStr152); + } else if ((mnemonic->cpu & CPUFLAG_40000000) && !(cpu & CPUFLAG_40000000)) { + CError_Error(CErrorStr152); + } else if ((mnemonic->cpu & CPUFLAG_20000000) && !(cpu & CPUFLAG_20000000)) { + CError_Error(CErrorStr152); + } else if ((mnemonic->cpu & CPUFLAG_800000) && !(cpu & CPUFLAG_800000)) { + CError_Error(CErrorStr152); + } + + tk = lex(); + if (tk == '+' || tk == '-') { + if ( + ((OPCODE_PART_1(mnemonic->x10) == 16) && (OPCODE_PART_2(mnemonic->x10) != 20)) || + ((OPCODE_PART_1(mnemonic->x10) == 19) && (OPCODE_PART_3(mnemonic->x10) == 528) && (OPCODE_PART_2(mnemonic->x10) != 20)) || + ((OPCODE_PART_1(mnemonic->x10) == 19) && (OPCODE_PART_3(mnemonic->x10) == 16) && (OPCODE_PART_2(mnemonic->x10) != 20)) + ) { + if (tk == '+') + flag1 = 1; + else if (tk == '-') + flag2 = 1; + tk = lex(); + } else { + CError_Error(CErrorStr120); + } + } + + stmt->expr = (ENode *) InlineAsm_ScanAssemblyOperands(mnemonic); + + ia = (InlineAsm *) stmt->expr; + if (record_flag) + ia->flags2 |= IAFlagsB_1; + if (flag3) + ia->flags2 |= IAFlagsB_2; + if (flag4) + ia->flags2 |= IAFlagsB_4; + if (flag5) + ia->flags2 |= IAFlagsB_8; + if (flag1) + ia->flags2 |= IAFlagsB_10; + if (flag2) + ia->flags2 |= IAFlagsB_20; + if (volatileasm) + ia->flags2 |= IAFlagsB_40; + + ++assembledinstructions; +} + +static PCode *InlineAsm_TranslateIRtoPCodePPC(InlineAsm *ia, int argcount, UInt8 assemblertype) { + OpcodeInfo *info; + PCode *pc; + int index; + int extra_args; + int reg; + int newargcount; + SInt32 buffersize; + IAOperand *src; + PCodeArg *dest; + + info = &opcodeinfo[ia->opcode]; + index = 0; + extra_args = 0; + reg = 0; + + if ((PCODE_FLAG_SET_F(info) & fPCodeFlag8000000) && !(PCODE_FLAG_SET_F(info) & fPCodeFlag20000000)) + extra_args++; + + if (!(PCODE_FLAG_SET_F(info) & fPCodeFlag10000000) && (PCODE_FLAG_SET_F(info) & fPCodeFlag4000000)) + extra_args++; + + if (argcount < ia->argcount) { + if ((argcount + extra_args) >= ia->argcount) { + extra_args -= (ia->argcount - argcount); + argcount = ia->argcount; + } else { +#line 3317 + CError_FATAL(); + } + } + + if (ia->opcode == PC_B && ia->args[0].type == IAOpnd_Imm) + ia->flags2 |= IAFlagsB_40; + + if (ia->opcode == PC_TWI || ia->opcode == PC_TW || ia->opcode == PC_TRAP || ia->opcode == PC_SC) + ia->flags |= IAFlag2; + + if (ia->flags & IAFlag2) { + newargcount = argcount + branch_count_volatiles(); + if (copts.exceptions && current_statement && assembler_type == 0) + newargcount += countexceptionactionregisters(current_statement->dobjstack); + + buffersize = sizeof(PCode) + sizeof(PCodeArg) * (newargcount + extra_args); + pc = lalloc(buffersize); + memset(pc, 0, buffersize); + pc->argCount = newargcount; + } else if (ia->opcode == PC_STMW || ia->opcode == PC_LMW) { + reg = ia->args[0].u.reg.object ? OBJECT_REG(ia->args[0].u.reg.object) : ia->args[0].u.reg.num; + newargcount = argcount + (32 - reg); + + buffersize = sizeof(PCode) + sizeof(PCodeArg) * newargcount; + pc = lalloc(buffersize); + memset(pc, 0, buffersize); + pc->argCount = newargcount; + } else { + buffersize = sizeof(PCode) + sizeof(PCodeArg) * (argcount + extra_args); + pc = lalloc(buffersize); + memset(pc, 0, buffersize); + pc->argCount = (ia->argcount > argcount) ? ia->argcount : argcount; + } + + pc->op = ia->opcode; + pc->flags = info->flags; + pc->sourceoffset = current_statement ? current_statement->sourceoffset : -1; + + dest = pc->args; + src = ia->args; + argcount += extra_args; + while (index < argcount) { + if (index >= ia->argcount) { + dest->kind = PCOp_PLACEHOLDEROPERAND; + } else { + switch (src->type) { + case IAOpnd_0: + dest->kind = PCOp_PLACEHOLDEROPERAND; + break; + + case IAOpnd_Imm: + dest->kind = PCOp_IMMEDIATE; + dest->data.imm.value = src->u.imm.value; + if (pc->flags & (fPCodeFlag2 | fPCodeFlag4)) + pc->flags |= fPCodeFlag20; + dest->data.imm.obj = NULL; + break; + + case IAOpnd_Reg: { + int r20; + r20 = 0; + if (src->u.reg.object) { + if (Registers_GetVarInfo(src->u.reg.object)->flags & VarInfoFlag2) { + if (src->u.reg.num == 1) + r20 = OBJECT_REG_HI(src->u.reg.object); + else + r20 = OBJECT_REG(src->u.reg.object); + } else { + if (Registers_GetVarInfo(src->u.reg.object)->flags & VarInfoFlag40) + PPCError_Error(172, src->u.reg.object->name->name); + else + PPCError_Error(167, src->u.reg.object->name->name); + } + } else if (src->u.reg.num == INVALID_PIC_REG) { + r20 = pic_base_reg; + } else { + r20 = src->u.reg.num; + } + + dest->kind = PCOp_REGISTER; + dest->arg = src->u.reg.rclass; + dest->data.reg.reg = r20; + dest->data.reg.effect = src->u.reg.effect; + if (pc->op == PC_RLWIMI && (dest->data.reg.effect & EffectWrite) && dest->arg == RegClass_GPR && !(dest->data.reg.effect & EffectRead)) { +#line 3442 + CError_FATAL(); + } + + if (dest->arg == RegClass_SPR) { + int i; + dest->kind = PCOp_SYSREG; + for (i = 0; i < 4; i++) { + if (dest->data.reg.reg == spr_to_sysreg[i]) { + dest->kind = PCOp_REGISTER; + dest->arg = RegClass_SPR; + dest->data.reg.reg = i; + break; + } + } + pcsetsideeffects(pc); + } else if (dest->arg == RegClass_6 || dest->arg == RegClass_DCR) { + short save = dest->data.reg.reg; + dest->kind = PCOp_IMMEDIATE; + dest->data.imm.value = save; + dest->data.imm.obj = NULL; + break; + } + + if ((src->u.reg.effect & EffectWrite) && dest->data.reg.reg < n_real_registers[dest->arg]) { + if (src->u.reg.object) { + if (Registers_GetVarInfo(src->u.reg.object)->flags & VarInfoFlag4) { + int reg, regHi; +#line 3474 + CError_ASSERT(dest->arg == RegClass_GPR); + + regHi = OBJECT_REG_HI(src->u.reg.object); + reg = OBJECT_REG(src->u.reg.object); + retain_GPR_pair(src->u.reg.object, reg, regHi); + } else { + retain_register(src->u.reg.object, dest->arg, dest->data.reg.reg); + } + } else { + retain_register(NULL, dest->arg, dest->data.reg.reg); + } + } + + break; + } + + case IAOpnd_Lab: + if (!src->u.lab.label->pclabel) + src->u.lab.label->pclabel = makepclabel(); + dest->kind = PCOp_LABEL; + dest->data.label.label = src->u.lab.label->pclabel; + break; + + case IAOpnd_3: + case IAOpnd_4: + dest->kind = PCOp_MEMORY; + dest->arg = src->u.obj.unk; + dest->data.mem.obj = src->u.obj.obj; + dest->data.mem.offset = src->u.obj.offset; + if (pc->flags & (fPCodeFlag2 | fPCodeFlag4 | fPCodeFlag20000 | fPCodeFlag40000)) { + pc->_18 = make_alias(dest->data.mem.obj, dest->data.mem.offset, nbytes_loaded_or_stored_by(pc)); + if (is_volatile_object(dest->data.mem.obj)) + pc->flags |= fIsVolatile; + if (OBJ_GET_TARGET_CONST(dest->data.mem.obj)) + pc->flags |= fIsConst; + } + break; + + case IAOpnd_LabDiff: + if (src->u.labdiff.label1->pclabel == NULL) + src->u.labdiff.label1->pclabel = makepclabel(); + if (src->u.labdiff.label2->pclabel == NULL) + src->u.labdiff.label2->pclabel = makepclabel(); + if (pc->flags & (fPCodeFlag2 | fPCodeFlag4)) + pc->flags |= fPCodeFlag20; + dest->kind = PCOp_LABELDIFF; + dest->data.labeldiff.labelA = src->u.labdiff.label1->pclabel; + dest->data.labeldiff.labelB = src->u.labdiff.label2->pclabel; + dest->arg = src->negated; + dest->data.labeldiff.offset = src->u.labdiff.offset; + break; + + default: +#line 3528 + CError_FATAL(); + } + } + + index++; + dest++; + src++; + } + + if (ia->opcode == PC_STMW || ia->opcode == PC_LMW) { + int i; + for (i = reg; i < 32; i++, dest++) { + dest->kind = PCOp_REGISTER; + dest->arg = RegClass_GPR; + dest->data.reg.reg = i; + dest->data.reg.effect = (short) ((ia->opcode == PC_LMW) ? EffectWrite : EffectRead); + } + } + + if (ia->flags & IAFlag2) { + UInt32 masks[5] = {0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF}; + branch_record_volatiles(dest, masks); + if (copts.exceptions && current_statement && assembler_type == 0) + noteexceptionactionregisters(current_statement->dobjstack, dest); + } + + return pc; +} + +void InlineAsm_TranslateIRtoPCode(Statement *stmt) { + InlineAsm *ia; + PCode *pc; + + ia = (InlineAsm *) stmt->expr; + pc = InlineAsm_TranslateIRtoPCodePPC(ia, opcodeinfo[ia->opcode].x8, assembler_type); + appendpcode(pclastblock, pc); + + if ((ia->flags2 & IAFlagsB_40) || !copts.optimizewithasm) + setpcodeflags(fSideEffects); + + if (ia->flags2 & IAFlagsB_1) { + if (PCODE_FLAG_SET_F(pc) & fPCodeFlag8000000) + pcsetrecordbit(pclastblock->lastPCode); + else + CError_Error(CErrorStr261); + } + + if (ia->flags2 & IAFlagsB_2) { + if (PCODE_FLAG_SET_F(pc) & fPCodeFlag4000000) + setpcodeflags(fOverflow); // idk? + else + CError_Error(CErrorStr261); + } + + if (ia->flags2 & IAFlagsB_4) { + if (PCODE_FLAG_SET_T(pc) & fPCodeFlag20000000) { + int i; + for (i = 0; i < pc->argCount; i++) { + if (pc->args[i].kind == PCOp_LABEL || pc->args[i].kind == PCOp_MEMORY) { + PPCError_Error(177); + break; + } + } + setpcodeflags(fAbsolute); // idk? + } else { + CError_Error(CErrorStr261); + } + } + + if (ia->flags2 & IAFlagsB_8) { + if (PCODE_FLAG_SET_T(pc) & fPCodeFlag2000000) { + pcsetlinkbit(pclastblock->lastPCode); + if (!(ia->flags & IAFlag2)) { + pclastblock->lastPCode->flags &= ~fPCodeFlag8; + pclastblock->lastPCode->flags |= fPCodeFlag1; + } + makes_call = 1; + } else { + CError_Error(CErrorStr261); + } + } + + if (ia->flags2 & IAFlagsB_10) + setpcodeflags(fPCodeFlag8000000); + if (ia->flags2 & IAFlagsB_20) + setpcodeflags(fPCodeFlag4000000); + + if (OPCODE_PART_1(opcodeinfo[pc->op].insn) == 16) { + PCodeLabel *dest = NULL; + PCodeLabel *src = makepclabel(); + switch (pc->op) { + case PC_BC: + if (pc->args[3].kind == PCOp_LABEL) + dest = pc->args[3].data.label.label; + break; + case PC_BT: + case PC_BF: + case PC_BDNZT: + case PC_BDNZF: + case PC_BDZT: + case PC_BDZF: + if (pc->args[2].kind == PCOp_LABEL) + dest = pc->args[2].data.label.label; + break; + case PC_BDNZ: + case PC_BDZ: + if (pc->args[0].kind == PCOp_LABEL) + dest = pc->args[0].data.label.label; + break; + default: +#line 3715 + CError_FATAL(); + } + + if (dest) { + pcbranch(pclastblock, dest); + pcbranch(pclastblock, src); + makepcblock(); + pclabel(pclastblock, src); + } + return; + } + + if (OPCODE_PART_1(opcodeinfo[pc->op].insn) == 18) { + PCodeLabel *label; + if (ia->flags2 & IAFlagsB_8) { + label = makepclabel(); + pcbranch(pclastblock, label); + } + if (pc->args[0].kind == PCOp_LABEL) + pcbranch(pclastblock, pc->args[0].data.label.label); + makepcblock(); + if (ia->flags2 & IAFlagsB_8) { + pclabel(pclastblock, label); + } + return; + } + + if (OPCODE_PART_1(opcodeinfo[pc->op].insn) == 19) { + switch (pc->op) { + case PC_BLR: + case PC_RFI: + if (asm_alloc_flags[3]) + asm_alloc_flags[9] = 1; + else + asm_alloc_flags[8] = 1; + + if (asm_alloc_flags[4]) + asm_alloc_flags[5] = 1; + + if (pc->op == PC_BLR) + asm_alloc_flags[6] = 1; + else + asm_alloc_flags[7] = 1; + break; + } + } +} + +const char *InlineAsm_GetMnemonic(InlineAsm *ia) { + return opcodeinfo[ia->opcode].name; +} + +static void savepicbase(short reg, HashNameNode *name) { + IALookupResult result; + + if (!InlineAsm_LookupSymbol(name, &result)) + result.label = InlineAsm_DeclareLabel(name); + + pic_base_label = result.label; + pic_base_reg = reg; + uses_globals = 1; +} + +static SInt32 InlineAsm_OpcodeSize(InlineAsm *ia) { + if (opcodeinfo[ia->opcode].flags & (fPCodeFlag2 | fPCodeFlag4)) { + switch (ia->opcode) { + case PC_LBZ: + case PC_LBZU: + case PC_LBZX: + case PC_LBZUX: + case PC_STB: + case PC_STBU: + case PC_STBX: + case PC_STBUX: + return 1; + case PC_LHZ: + case PC_LHZU: + case PC_LHZX: + case PC_LHZUX: + case PC_LHA: + case PC_LHAU: + case PC_LHAX: + case PC_LHAUX: + case PC_LHBRX: + case PC_STH: + case PC_STHU: + case PC_STHX: + case PC_STHUX: + case PC_STHBRX: + return 2; + case PC_LWZ: + case PC_LWZU: + case PC_LWZX: + case PC_LWZUX: + case PC_LWBRX: + case PC_STW: + case PC_STWU: + case PC_STWX: + case PC_STWUX: + case PC_STWBRX: + case PC_LFS: + case PC_LFSU: + case PC_LFSX: + case PC_LFSUX: + case PC_STFS: + case PC_STFSU: + case PC_STFSX: + case PC_STFSUX: + case PC_LWARX: + case PC_STFIWX: + case PC_STWCX: + case PC_ECIWX: + case PC_ECOWX: + case PC_MFROM: + case PC_LSCBX: + return 4; + case PC_LMW: + case PC_STMW: + if (ia->args[0].type == IAOpnd_Reg && ia->args[0].u.reg.object == NULL) + return (32 - ia->args[0].u.reg.num) * 4; + else + return 128; + case PC_LFD: + case PC_LFDU: + case PC_LFDX: + case PC_LFDUX: + case PC_STFD: + case PC_STFDU: + case PC_STFDX: + case PC_STFDUX: + return 8; + case PC_LSWI: + case PC_STSWI: + return ia->args[2].u.imm.value; + case PC_LSWX: + case PC_STSWX: + return 128; + case PC_LVEBX: + case PC_STVEBX: + return 1; + case PC_LVEHX: + case PC_STVEHX: + return 2; + case PC_LVEWX: + case PC_STVEWX: + return 4; + case PC_LVSL: + case PC_LVSR: + case PC_LVX: + case PC_LVXL: + case PC_STVX: + case PC_STVXL: + return 16; + default: +#line 3924 + CError_FATAL(); + } + } else { + if (opcodeinfo[ia->opcode].flags & fPCodeFlag80000000) + return 4; + if (opcodeinfo[ia->opcode].flags & fPCodeFlag40000000) + return 8; + if (opcodeinfo[ia->opcode].flags & (fPCodeFlag80000000 | fPCodeFlag40000000)) + return 16; + + if (opcodeinfo[ia->opcode].flags & fSideEffects) { + switch (ia->opcode) { + case PC_TLBIE: + case PC_TLBLD: + case PC_TLBLI: + return 4; + default: +#line 3941 + CError_FATAL(); + } + } + } + +#line 3944 + CError_FATAL(); + return 0; +} + +void CodeGen_GetAsmEffects(Statement *stmt, IAEffects *effects) { + InlineAsm *ia; + OpcodeInfo *info; + int i; + IAOperand *op; + VarInfo *vi; + + ia = (InlineAsm *) stmt->expr; + info = &opcodeinfo[ia->opcode]; + + effects->numoperands = 0; + effects->numlabels = 0; + effects->x1 = 0; + effects->x2 = 0; + effects->x3 = 0; + effects->x4 = 0; + effects->x0 = 0; + effects->x5 = 0; + + if (info->flags & fPCodeFlag20) { + if (info->flags & fPCodeFlag2) + effects->x1 = 1; + if (info->flags & fPCodeFlag4) + effects->x2 = 1; + } + + if (PCODE_FLAG_SET_T(info) & fPCodeFlag2000000) { + if (ia->flags2 & IAFlagsB_8) + effects->x4 = 1; + else if ((info->flags & fPCodeFlag8) || (info->flags & fPCodeFlag4)) + effects->x3 = 1; + + if (ia->opcode == PC_B) { + if (ia->args[0].type == IAOpnd_Imm) + effects->x0 = 1; + effects->x5 = 1; + } + } + + if (info->flags & fSideEffects) + effects->x0 = 1; + + if (ia->opcode == PC_BC && (ia->flags2 & IAFlagsB_8)) + effects->x4 = 1; + + for (i = 0, op = ia->args; i < ia->argcount; i++, op++) { + switch (op->type) { + case IAOpnd_0: + case IAOpnd_Imm: + break; + case IAOpnd_Reg: + if (op->u.reg.object) { + if ((vi = Registers_GetVarInfo(op->u.reg.object))) + vi->flags |= VarInfoFlag40; + if (op->u.reg.effect & EffectRead) { + if ( + TYPE_FITS_IN_REGISTER(op->u.reg.object->type) || + IS_TYPE_FLOAT(op->u.reg.object->type) || + IS_TYPE_VECTOR(op->u.reg.object->type) + ) { + effects->operands[effects->numoperands].type = IAEffect_0; + effects->operands[effects->numoperands].object = op->u.reg.object; + effects->operands[effects->numoperands].offset = 0; + effects->operands[effects->numoperands].size = op->u.reg.object->type->size; + effects->numoperands++; + } else { +#line 4051 + CError_FATAL(); + } + } + } + break; + case IAOpnd_3: + case IAOpnd_4: + if (op->u.obj.obj) { + if (info->flags & fPCodeFlag2) { + effects->operands[effects->numoperands].type = IAEffect_0; + effects->operands[effects->numoperands].object = op->u.obj.obj; + effects->operands[effects->numoperands].offset = op->u.obj.offset; + effects->operands[effects->numoperands].size = InlineAsm_OpcodeSize(ia); + effects->numoperands++; + } else if (!(info->flags & (fPCodeFlag1 | fPCodeFlag8))) { + effects->operands[effects->numoperands].type = IAEffect_3; + effects->operands[effects->numoperands].object = op->u.obj.obj; + effects->operands[effects->numoperands].offset = op->u.obj.offset; + effects->operands[effects->numoperands].size = InlineAsm_OpcodeSize(ia); + effects->numoperands++; + } + } + break; + case IAOpnd_Lab: + effects->labels[effects->numlabels] = op->u.lab.label; + effects->numlabels++; + break; + case IAOpnd_LabDiff: + effects->labels[effects->numlabels] = op->u.labdiff.label1; + effects->numlabels++; + effects->labels[effects->numlabels] = op->u.labdiff.label2; + effects->numlabels++; + effects->x3 = 1; + break; + default: +#line 4087 + CError_FATAL(); + } + +#line 4090 + CError_ASSERT(effects->numoperands <= 16); +#line 4093 + CError_ASSERT(effects->numlabels <= 16); + } + + for (i = 0, op = ia->args; i < ia->argcount; i++, op++) { + switch (op->type) { + case IAOpnd_Reg: + if (op->u.reg.object) { + if ((vi = Registers_GetVarInfo(op->u.reg.object))) + vi->flags |= VarInfoFlag40; + if (op->u.reg.effect & EffectWrite) { + if ( + TYPE_FITS_IN_REGISTER(op->u.reg.object->type) || + IS_TYPE_FLOAT(op->u.reg.object->type) || + IS_TYPE_VECTOR(op->u.reg.object->type) + ) { + effects->operands[effects->numoperands].type = IAEffect_1; + effects->operands[effects->numoperands].object = op->u.reg.object; + effects->operands[effects->numoperands].offset = 0; + effects->operands[effects->numoperands].size = op->u.reg.object->type->size; + effects->numoperands++; + } else { +#line 4132 + CError_FATAL(); + } + } + } + break; + case IAOpnd_3: + case IAOpnd_4: + if (op->u.obj.obj) { + if (info->flags & fPCodeFlag4) { + effects->operands[effects->numoperands].type = IAEffect_1; + effects->operands[effects->numoperands].object = op->u.obj.obj; + effects->operands[effects->numoperands].offset = op->u.obj.offset; + effects->operands[effects->numoperands].size = InlineAsm_OpcodeSize(ia); + effects->numoperands++; + } + } + break; + } + +#line 4151 + CError_ASSERT(effects->numoperands <= 16); + } + + if ((info->flags & (fPCodeFlag1 | fPCodeFlag8)) && (SInt32)effects->numlabels == 0) + effects->x3 = 1; +} + +void CodeGen_PropagateIntoAsm(Statement *stmt, Object *obj, ENode *expr) { + InlineAsm *ia; + Object *newobj; + + ia = (InlineAsm *) stmt->expr; + if (ENODE_IS(expr, EOBJREF)) { + newobj = expr->data.objref; + if (obj->otype == newobj->otype && obj->datatype == newobj->datatype) { + int i; + for (i = 0; i < ia->argcount; i++) { + switch (ia->args[i].type) { + case IAOpnd_Reg: + if (ia->args[i].u.reg.object == obj && + (ia->args[i].u.reg.effect & (EffectRead | EffectWrite)) == EffectRead) { + if (TYPE_FITS_IN_REGISTER(newobj->type) && + ia->args[i].u.reg.rclass == RegClass_GPR) { + ia->args[i].u.reg.object = newobj; + } else if (IS_TYPE_FLOAT(newobj->type) && + ia->args[i].u.reg.rclass == RegClass_FPR) { + ia->args[i].u.reg.object = newobj; + } else if (IS_TYPE_VECTOR(newobj->type) && + ia->args[i].u.reg.rclass == RegClass_VR) { + ia->args[i].u.reg.object = newobj; + } + } + break; + case IAOpnd_3: + case IAOpnd_4: + if (!(opcodeinfo[ia->opcode].flags & (fPCodeFlag4 | fPCodeFlag40000)) && + ia->args[i].u.obj.obj == obj) + ia->args[i].u.obj.obj = newobj; + break; + } + } + } + } +} + +Statement *CodeGen_CopyAsmStat(Statement *stmt) { + Statement *copy; + SInt32 size; + InlineAsm *ia; + InlineAsm *iacopy; + + copy = galloc(sizeof(Statement)); + *copy = *stmt; + + ia = (InlineAsm *) stmt->expr; + size = sizeof(InlineAsm) + sizeof(IAOperand) * ia->argcount; + iacopy = galloc(size); + memcpy(iacopy, ia, size); + copy->expr = (ENode *) iacopy; + + return copy; +} + diff --git a/compiler_and_linker/unsorted/InlineAsmRegisters.c b/compiler_and_linker/unsorted/InlineAsmRegisters.c new file mode 100644 index 0000000..31f94c4 --- /dev/null +++ b/compiler_and_linker/unsorted/InlineAsmRegisters.c @@ -0,0 +1,50 @@ +#include "compiler/InlineAsmRegisters.h" +#include "compiler/CompilerTools.h" + +#ifdef __MWERKS__ +#pragma options align=mac68k +#endif +typedef struct HashedRegister { + struct HashedRegister *next; + IARegister reg; +} HashedRegister; +#ifdef __MWERKS__ +#pragma options align=reset +#endif + +static HashedRegister *hashedregisters[64]; + +void InlineAsm_InitializeRegisters() { + SInt32 i; + + for (i = 0; i < 64; i++) + hashedregisters[i] = NULL; +} + +void InlineAsm_InsertRegister(char *name, char rclass, short num, Object *object) { + HashedRegister **ptr; + HashedRegister *hr; + + ptr = hashedregisters + (CHash(name) & 63); + hr = lalloc(sizeof(HashedRegister)); + hr->reg.name = name; + hr->reg.rclass = rclass; + hr->reg.num = num; + hr->reg.object = object; + + hr->next = *ptr; + *ptr = hr; +} + +IARegister *InlineAsm_LookupRegister(char *name) { + HashedRegister *scan; + IARegister *reg; + + for (scan = hashedregisters[CHash(name) & 63]; scan; scan = scan->next) { + reg = &scan->reg; + if (!strcmp(scan->reg.name, name)) + return reg; + } + + return NULL; +} diff --git a/compiler_and_linker/unsorted/InlineAsmRegistersPPC.c b/compiler_and_linker/unsorted/InlineAsmRegistersPPC.c new file mode 100644 index 0000000..a60bc15 --- /dev/null +++ b/compiler_and_linker/unsorted/InlineAsmRegistersPPC.c @@ -0,0 +1,854 @@ +#include "compiler/InlineAsmRegistersPPC.h" +#include "compiler/InlineAsm.h" +#include "compiler/InlineAsmRegisters.h" +#include "compiler/CompilerTools.h" +#include "compiler/RegisterInfo.h" +#include "compiler/objects.h" +#include "compiler/types.h" +#include "compiler/InlineAsmPPC.h" +#include "compiler/CParser.h" +#include "compiler/PPCError.h" +#include "compiler/CFunc.h" + +#pragma pool_strings on + +#ifdef __MWERKS__ +#pragma options align=mac68k +#endif +typedef struct RegInfo { + struct RegInfo *next; + UInt32 b; + IARegister reg; +} RegInfo; + +typedef struct AsmRegister { + char *name; + char rclass; + SInt32 num; +} AsmRegister; + +typedef struct AsmSpr { + char *name; + SInt32 num; + UInt32 mask; +} AsmSpr; +#ifdef __MWERKS__ +#pragma options align=reset +#endif + +static RegInfo *hashedsprs[64]; +static RegInfo *hasheddcrs[64]; + +static AsmRegister asm_registers[] = { + "r0", RegClass_GPR, 0, + "r1", RegClass_GPR, 1, + "r2", RegClass_GPR, 2, + "r3", RegClass_GPR, 3, + "r4", RegClass_GPR, 4, + "r5", RegClass_GPR, 5, + "r6", RegClass_GPR, 6, + "r7", RegClass_GPR, 7, + "r8", RegClass_GPR, 8, + "r9", RegClass_GPR, 9, + "r10", RegClass_GPR, 10, + "r11", RegClass_GPR, 11, + "r12", RegClass_GPR, 12, + "r13", RegClass_GPR, 13, + "r14", RegClass_GPR, 14, + "r15", RegClass_GPR, 15, + "r16", RegClass_GPR, 16, + "r17", RegClass_GPR, 17, + "r18", RegClass_GPR, 18, + "r19", RegClass_GPR, 19, + "r20", RegClass_GPR, 20, + "r21", RegClass_GPR, 21, + "r22", RegClass_GPR, 22, + "r23", RegClass_GPR, 23, + "r24", RegClass_GPR, 24, + "r25", RegClass_GPR, 25, + "r26", RegClass_GPR, 26, + "r27", RegClass_GPR, 27, + "r28", RegClass_GPR, 28, + "r29", RegClass_GPR, 29, + "r30", RegClass_GPR, 30, + "r31", RegClass_GPR, 31, + "gpr0", RegClass_GPR, 0, + "gpr1", RegClass_GPR, 1, + "gpr2", RegClass_GPR, 2, + "gpr3", RegClass_GPR, 3, + "gpr4", RegClass_GPR, 4, + "gpr5", RegClass_GPR, 5, + "gpr6", RegClass_GPR, 6, + "gpr7", RegClass_GPR, 7, + "gpr8", RegClass_GPR, 8, + "gpr9", RegClass_GPR, 9, + "gpr10", RegClass_GPR, 10, + "gpr11", RegClass_GPR, 11, + "gpr12", RegClass_GPR, 12, + "gpr13", RegClass_GPR, 13, + "gpr14", RegClass_GPR, 14, + "gpr15", RegClass_GPR, 15, + "gpr16", RegClass_GPR, 16, + "gpr17", RegClass_GPR, 17, + "gpr18", RegClass_GPR, 18, + "gpr19", RegClass_GPR, 19, + "gpr20", RegClass_GPR, 20, + "gpr21", RegClass_GPR, 21, + "gpr22", RegClass_GPR, 22, + "gpr23", RegClass_GPR, 23, + "gpr24", RegClass_GPR, 24, + "gpr25", RegClass_GPR, 25, + "gpr26", RegClass_GPR, 26, + "gpr27", RegClass_GPR, 27, + "gpr28", RegClass_GPR, 28, + "gpr29", RegClass_GPR, 29, + "gpr30", RegClass_GPR, 30, + "gpr31", RegClass_GPR, 31, + "rtoc", RegClass_GPR, 2, + "RTOC", RegClass_GPR, 2, + "sp", RegClass_GPR, 1, + "SP", RegClass_GPR, 1, + "rsp", RegClass_GPR, 1, + "RSP", RegClass_GPR, 1, + "RPIC", RegClass_GPR, -2, + "rpic", RegClass_GPR, -2, + "f0", RegClass_FPR, 0, + "f1", RegClass_FPR, 1, + "f2", RegClass_FPR, 2, + "f3", RegClass_FPR, 3, + "f4", RegClass_FPR, 4, + "f5", RegClass_FPR, 5, + "f6", RegClass_FPR, 6, + "f7", RegClass_FPR, 7, + "f8", RegClass_FPR, 8, + "f9", RegClass_FPR, 9, + "f10", RegClass_FPR, 10, + "f11", RegClass_FPR, 11, + "f12", RegClass_FPR, 12, + "f13", RegClass_FPR, 13, + "f14", RegClass_FPR, 14, + "f15", RegClass_FPR, 15, + "f16", RegClass_FPR, 16, + "f17", RegClass_FPR, 17, + "f18", RegClass_FPR, 18, + "f19", RegClass_FPR, 19, + "f20", RegClass_FPR, 20, + "f21", RegClass_FPR, 21, + "f22", RegClass_FPR, 22, + "f23", RegClass_FPR, 23, + "f24", RegClass_FPR, 24, + "f25", RegClass_FPR, 25, + "f26", RegClass_FPR, 26, + "f27", RegClass_FPR, 27, + "f28", RegClass_FPR, 28, + "f29", RegClass_FPR, 29, + "f30", RegClass_FPR, 30, + "f31", RegClass_FPR, 31, + "fp0", RegClass_FPR, 0, + "fp1", RegClass_FPR, 1, + "fp2", RegClass_FPR, 2, + "fp3", RegClass_FPR, 3, + "fp4", RegClass_FPR, 4, + "fp5", RegClass_FPR, 5, + "fp6", RegClass_FPR, 6, + "fp7", RegClass_FPR, 7, + "fp8", RegClass_FPR, 8, + "fp9", RegClass_FPR, 9, + "fp10", RegClass_FPR, 10, + "fp11", RegClass_FPR, 11, + "fp12", RegClass_FPR, 12, + "fp13", RegClass_FPR, 13, + "fp14", RegClass_FPR, 14, + "fp15", RegClass_FPR, 15, + "fp16", RegClass_FPR, 16, + "fp17", RegClass_FPR, 17, + "fp18", RegClass_FPR, 18, + "fp19", RegClass_FPR, 19, + "fp20", RegClass_FPR, 20, + "fp21", RegClass_FPR, 21, + "fp22", RegClass_FPR, 22, + "fp23", RegClass_FPR, 23, + "fp24", RegClass_FPR, 24, + "fp25", RegClass_FPR, 25, + "fp26", RegClass_FPR, 26, + "fp27", RegClass_FPR, 27, + "fp28", RegClass_FPR, 28, + "fp29", RegClass_FPR, 29, + "fp30", RegClass_FPR, 30, + "fp31", RegClass_FPR, 31, + "v0", RegClass_VR, 0, + "v1", RegClass_VR, 1, + "v2", RegClass_VR, 2, + "v3", RegClass_VR, 3, + "v4", RegClass_VR, 4, + "v5", RegClass_VR, 5, + "v6", RegClass_VR, 6, + "v7", RegClass_VR, 7, + "v8", RegClass_VR, 8, + "v9", RegClass_VR, 9, + "v10", RegClass_VR, 10, + "v11", RegClass_VR, 11, + "v12", RegClass_VR, 12, + "v13", RegClass_VR, 13, + "v14", RegClass_VR, 14, + "v15", RegClass_VR, 15, + "v16", RegClass_VR, 16, + "v17", RegClass_VR, 17, + "v18", RegClass_VR, 18, + "v19", RegClass_VR, 19, + "v20", RegClass_VR, 20, + "v21", RegClass_VR, 21, + "v22", RegClass_VR, 22, + "v23", RegClass_VR, 23, + "v24", RegClass_VR, 24, + "v25", RegClass_VR, 25, + "v26", RegClass_VR, 26, + "v27", RegClass_VR, 27, + "v28", RegClass_VR, 28, + "v29", RegClass_VR, 29, + "v30", RegClass_VR, 30, + "v31", RegClass_VR, 31, + "vr0", RegClass_VR, 0, + "vr1", RegClass_VR, 1, + "vr2", RegClass_VR, 2, + "vr3", RegClass_VR, 3, + "vr4", RegClass_VR, 4, + "vr5", RegClass_VR, 5, + "vr6", RegClass_VR, 6, + "vr7", RegClass_VR, 7, + "vr8", RegClass_VR, 8, + "vr9", RegClass_VR, 9, + "vr10", RegClass_VR, 10, + "vr11", RegClass_VR, 11, + "vr12", RegClass_VR, 12, + "vr13", RegClass_VR, 13, + "vr14", RegClass_VR, 14, + "vr15", RegClass_VR, 15, + "vr16", RegClass_VR, 16, + "vr17", RegClass_VR, 17, + "vr18", RegClass_VR, 18, + "vr19", RegClass_VR, 19, + "vr20", RegClass_VR, 20, + "vr21", RegClass_VR, 21, + "vr22", RegClass_VR, 22, + "vr23", RegClass_VR, 23, + "vr24", RegClass_VR, 24, + "vr25", RegClass_VR, 25, + "vr26", RegClass_VR, 26, + "vr27", RegClass_VR, 27, + "vr28", RegClass_VR, 28, + "vr29", RegClass_VR, 29, + "vr30", RegClass_VR, 30, + "vr31", RegClass_VR, 31, + "cr0", RegClass_CRFIELD, 0, + "cr1", RegClass_CRFIELD, 1, + "cr2", RegClass_CRFIELD, 2, + "cr3", RegClass_CRFIELD, 3, + "cr4", RegClass_CRFIELD, 4, + "cr5", RegClass_CRFIELD, 5, + "cr6", RegClass_CRFIELD, 6, + "cr7", RegClass_CRFIELD, 7, + "crf0", RegClass_CRFIELD, 0, + "crf1", RegClass_CRFIELD, 1, + "crf2", RegClass_CRFIELD, 2, + "crf3", RegClass_CRFIELD, 3, + "crf4", RegClass_CRFIELD, 4, + "crf5", RegClass_CRFIELD, 5, + "crf6", RegClass_CRFIELD, 6, + "crf7", RegClass_CRFIELD, 7, + "lt", RegClass_6, 0, + "gt", RegClass_6, 1, + "eq", RegClass_6, 2, + "so", RegClass_6, 3, + "un", RegClass_6, 3, + "LT", RegClass_6, 0, + "GT", RegClass_6, 1, + "EQ", RegClass_6, 2, + "SO", RegClass_6, 3, + "UN", RegClass_6, 3, + NULL, 0, 0 +}; + +static AsmSpr asm_sprs[] = { + "xer", 1, 0xFFFFF, + "lr", 8, 0xFFFFF, + "ctr", 9, 0xFFFFF, + "mq", 0, 1, + "rtcu", 4, 1, + "rtcl", 5, 1, + "dsisr", 0x12, 0xFF83F, + "dar", 0x13, 0xFF83F, + "dec", 0x16, 0xFF83F, + "sdr1", 0x19, 0xFE00F, + "srr0", 0x1A, 0xFFFFF, + "srr1", 0x1B, 0xFFFFF, + "eie", 0x50, 0x1830, + "eid", 0x51, 0x1830, + "nri", 0x52, 0x1830, + "cmpa", 0x90, 0x1830, + "cmpb", 0x91, 0x1830, + "cmpc", 0x92, 0x1830, + "cmpd", 0x93, 0x1830, + "icr", 0x94, 0x30, + "ecr", 0x94, 0x1800, + "der", 0x95, 0x1830, + "counta", 0x96, 0x1830, + "countb", 0x97, 0x1830, + "cmpe", 0x98, 0x1830, + "cmpf", 0x99, 0x1830, + "cmpg", 0x9A, 0x1830, + "cmph", 0x9B, 0x1830, + "lctrl1", 0x9C, 0x1830, + "lctrl2", 0x9D, 0x1830, + "ictrl", 0x9E, 0x1830, + "bar", 0x9F, 0x1830, + "vrsave", 0x100, 0x40000000, + "sprg0", 0x110, 0xFFFFF, + "sprg1", 0x111, 0xFFFFF, + "sprg2", 0x112, 0xFFFFF, + "sprg3", 0x113, 0xFFFFF, + "ear", 0x11A, 0xFE7CF, + "tbl", 0x11C, 0xFF83F, + "tbu", 0x11D, 0xFF83F, + "tbl_write", 0x11C, 0xFF83F, + "tbu_write", 0x11D, 0xFF83F, + "pvr", 0x11F, 0xFFFFF, + "ibat0u", 0x210, 0xFE7CF, + "mi_gra", 0x210, 0x1000, + "ibat0l", 0x211, 0xFE7CF, + "ibat1u", 0x212, 0xFE7CF, + "ibat1l", 0x213, 0xFE7CF, + "ibat2u", 0x214, 0xFE7CF, + "ibat2l", 0x215, 0xFE7CF, + "ibat3u", 0x216, 0xFE7CF, + "ibat3l", 0x217, 0xFE7CF, + "dbat0u", 0x218, 0xFE7CE, + "l2u_gra", 0x218, 0x1000, + "dbat0l", 0x219, 0xFE7CE, + "dbat1u", 0x21A, 0xFE7CE, + "dbat1l", 0x21B, 0xFE7CE, + "dbat2u", 0x21C, 0xFE7CE, + "dbat2l", 0x21D, 0xFE7CE, + "dbat3u", 0x21E, 0xFE7CE, + "dbat3l", 0x21F, 0xFE7CE, + "ic_cst", 0x230, 0x30, + "iccst", 0x230, 0x800, + "bbcmcr", 0x230, 0x1000, + "ic_adr", 0x231, 0x30, + "icadr", 0x231, 0x800, + "ic_dat", 0x232, 0x30, + "icdat", 0x232, 0x800, + "dc_cst", 0x238, 0x30, + "l2u_mcr", 0x238, 0x1000, + "dc_adr", 0x239, 0x30, + "dc_dat", 0x23A, 0x30, + "dpdr", 0x276, 0x1830, + "dpir", 0x277, 0x30, + "immr", 0x27E, 0x30, + "mi_ctr", 0x310, 0x30, + "mi_rba0", 0x310, 0x1000, + "mi_rba1", 0x311, 0x1000, + "mi_rba2", 0x312, 0x1000, + "mi_ap", 0x312, 0x30, + "mi_epn", 0x313, 0x30, + "mi_rba3", 0x313, 0x1000, + "mi_twc", 0x315, 0x30, + "mi_l1dl2p", 0x315, 0x30, + "mi_rpn", 0x316, 0x30, + "md_ctr", 0x318, 0x30, + "l2u_rba0", 0x318, 0x1000, + "l2u_rba1", 0x319, 0x1000, + "m_casid", 0x319, 0x30, + "md_ap", 0x31A, 0x30, + "l2u_rba2", 0x31A, 0x1000, + "l2u_rba3", 0x31B, 0x1000, + "md_epn", 0x31B, 0x30, + "m_twb", 0x31C, 0x30, + "md_l1p", 0x31C, 0x30, + "md_twc", 0x31D, 0x30, + "md_l1dl2p", 0x31D, 0x30, + "md_rpn", 0x31E, 0x30, + "m_tw", 0x31F, 0x30, + "m_save", 0x31F, 0x30, + "mi_dbcam", 0x330, 0x10, + "mi_cam", 0x330, 0x20, + "mi_ra0", 0x330, 0x1000, + "mi_ra1", 0x331, 0x1000, + "mi_dbram0", 0x331, 0x10, + "mi_ram0", 0x331, 0x20, + "mi_dbram1", 0x332, 0x10, + "mi_ram1", 0x332, 0x20, + "mi_ra2", 0x332, 0x1000, + "mi_ra3", 0x333, 0x1000, + "md_dbcam", 0x338, 0x10, + "md_cam", 0x338, 0x20, + "l2u_ra0", 0x338, 0x1000, + "l2u_ra1", 0x339, 0x1000, + "md_dbram0", 0x339, 0x10, + "md_ram0", 0x339, 0x20, + "md_dbram1", 0x33A, 0x10, + "md_ram1", 0x33A, 0x20, + "l2u_ra2", 0x33A, 0x1000, + "l2u_ra3", 0x33B, 0x1000, + "ummcr2", 0x3A0, 0x4000, + "ubamr", 0x3A7, 0x4000, + "ummcr0", 0x3A8, 0xE000, + "upmc1", 0x3A9, 0xE000, + "upmc2", 0x3AA, 0xE000, + "usia", 0x3AB, 0x2000, + "usiar", 0x3AB, 0x4000, + "ummcr1", 0x3AC, 0xE000, + "upmc3", 0x3AD, 0xE000, + "upmc4", 0x3AE, 0xE000, + "zpr", 0x3B0, 0x200, + "mmcr2", 0x3B0, 0x4000, + "pid", 0x3B1, 0x200, + "bamr", 0x3B7, 0x4000, + "mmcr0", 0x3B8, 0xE008, + "pmc1", 0x3B9, 0xE008, + "sgr", 0x3B9, 0x240, + "pmc2", 0x3BA, 0xE008, + "dcwr", 0x3BA, 0x240, + "sia", 0x3BB, 0xE008, + "siar", 0x3BB, 0x4000, + "sler", 0x3BB, 0x40, + "mmcr1", 0x3BC, 0xE000, + "pmc3", 0x3BD, 0xE000, + "pmc4", 0x3BE, 0xE000, + "sda", 0x3BF, 8, + "tbhu", 0x3CC, 0x240, + "tblu", 0x3CD, 0x240, + "dmiss", 0x3D0, 0x10006, + "dcmp", 0x3D1, 0x10006, + "hash1", 0x3D2, 0x10006, + "hash2", 0x3D3, 0x10006, + "icdbdr", 0x3D3, 0x7C0, + "imiss", 0x3D4, 0x10006, + "esr", 0x3D4, 0x7C0, + "icmp", 0x3D5, 0x10006, + "dear", 0x3D5, 0x7C0, + "rpa", 0x3D6, 0x10006, + "evpr", 0x3D6, 0x7C0, + "cdbcr", 0x3D7, 0x7C0, + "tsr", 0x3D8, 0x7C0, + "tcr", 0x3D8, 2, + "tcr", 0x3DA, 0x7C0, + "ibr", 0x3DA, 2, + "pit", 0x3DB, 0x7C0, + "esasrr", 0x3DB, 2, + "tbhi", 0x3DC, 0x7C0, + "tblo", 0x3DD, 0x7C0, + "srr2", 0x3DE, 0x7C0, + "sebr", 0x3DE, 2, + "srr3", 0x3DF, 0x7C0, + "ser", 0x3DF, 2, + "mid0", 0x3F0, 0x1E00F, + "dbsr", 0x3F0, 0x80, + "hid1", 0x3F1, 0x1E007, + "hid2", 0x3F2, 1, + "iabr", 0x3F2, 0x1E00F, + "dbcr", 0x3F2, 0x7C0, + "hid2", 0x3F3, 0x10000, + "iac1", 0x3F4, 0x80, + "iac", 0x3F4, 0x40, + "dabr", 0x3F5, 0xE009, + "iac2", 0x3F5, 0x80, + "hid5", 0x3F5, 1, + "dac1", 0x3F6, 0x80, + "dac", 0x3F6, 0x40, + "msscr0", 0x3F6, 0x4000, + "dac2", 0x3F7, 0x80, + "l2cr", 0x3F9, 0xE000, + "dccr", 0x3FA, 0x7C0, + "iccr", 0x3FB, 0x7C0, + "ictc", 0x3FB, 0xE000, + "pbl1", 0x3FC, 0x80, + "thrm1", 0x3FC, 0xE000, + "pbu1", 0x3FD, 0x80, + "thrm2", 0x3FD, 0xE000, + "fpecr", 0x3FE, 0x1800, + "pbl2", 0x3FE, 0x80, + "thrm3", 0x3FE, 0xE000, + "pir", 0x3FF, 0x4008, + "hid15", 0x3FF, 1, + "pbu2", 0x3FF, 0x80, + NULL, 0, 0 +}; + +UInt32 spr_cpus[1024] = { + 1, 0xFFFFF, 0, 0, 1, 1, 0, 0, + 0xFFFFF, 0xFFFFF, 0, 0, 0, 0, 0, 0, + 0, 0, 0xFF83F, 0xFF83F, 0, 0, 0xFF83F, 0, + 0, 0xFE00F, 0xFFFFF, 0xFFFFF, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0x1830, 0x1830, 0x1830, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0x1830, 0x1830, 0x1830, 0x1830, 0x1830, 0x1830, 0x1830, 0x1830, + 0x1830, 0x1830, 0x1830, 0x1830, 0x1830, 0x1830, 0x1830, 0x1830, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0x40000000, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0xFFFFF, 0xFFFFF, 0xFFFFF, 0xFFFFF, 0, 0, 0, 0, + 0, 0, 0xFE7CF, 0, 0xFF83F, 0xFF83F, 0, 0xFFFFF, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0xFF7CF, 0xFE7CF, 0xFE7CF, 0xFE7CF, 0xFE7CF, 0xFE7CF, 0xFE7CF, 0xFE7CF, + 0xFF7CE, 0xFE7CE, 0xFE7CE, 0xFE7CE, 0xFE7CE, 0xFE7CE, 0xFE7CE, 0xFE7CE, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0x1830, 0x1830, 0x1830, 0, 0, 0, 0, 0, + 0x1030, 0x30, 0x30, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0x1830, 0x30, + 0, 0, 0, 0, 0, 0, 0x30, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0x1030, 0x1000, 0x1030, 0x1030, 0, 0x30, 0x30, 0, + 0x1030, 0x1030, 0x1030, 0x1030, 0x30, 0x30, 0x30, 0x30, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0x1030, 0x1030, 0x1030, 0x1000, 0, 0, 0, 0, + 0x1030, 0x1030, 0x1030, 0x1000, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0x20000000, 0x20000000, 0x20000000, 0x20000000, 0x20000000, 0x20000000, 0x20000000, 0x20000000, + 0x20000000, 0x20000000, 0x20000000, 0x20000000, 0, 0, 0, 0, + 0x4000, 0, 0, 0, 0, 0, 0, 0x4000, + 0xE000, 0xE000, 0xE000, 0xE000, 0xE000, 0xE000, 0xE000, 0, + 0x4200, 0x200, 0, 0, 0, 0, 0, 0x4000, + 0xE008, 0xE248, 0xE248, 0xE048, 0xE000, 0xE000, 0xE000, 8, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0x240, 0x240, 0, 0, + 0x10006, 0x10006, 0x10006, 0x107C6, 0x107C6, 0x107C6, 0x107C6, 0x7C0, + 0x7C2, 0, 0x7C2, 0x7C2, 0x7C0, 0x7C0, 0x7C2, 0x7C2, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0x1E08F, 0x1E007, 0x1E7CF, 0x10000, 0xC0, 0xE089, 0x40C0, 0x80, + 0, 0xE000, 0x7C0, 0xE7C0, 0xE080, 0xE080, 0xF880, 0xE089 +}; + +static void InlineAsm_InsertSPR(char *name, short num, UInt32 b) { + RegInfo **ptr; + RegInfo *info; + + ptr = hashedsprs + (CHash(name) & 63); + info = lalloc(sizeof(RegInfo)); + info->b = b; + info->reg.name = name; + info->reg.rclass = RegClass_SPR; + info->reg.num = num; + info->reg.object = NULL; + + info->next = *ptr; + *ptr = info; +} + +static void InlineAsm_InsertRegisterDCR(char *name, UInt32 b, short num) { + RegInfo **ptr; + RegInfo *info; + + ptr = hasheddcrs + (CHash(name) & 63); + info = lalloc(sizeof(RegInfo)); + info->b = b; + info->reg.name = name; + info->reg.rclass = RegClass_DCR; + info->reg.num = num; + info->reg.object = NULL; + + info->next = *ptr; + *ptr = info; +} + +IARegister *InlineAsm_LookupRegisterPPCName(HashNameNode *name) { + IALookupResult result; + IARegister *reg; + Type *type; + + if (InlineAsm_LookupSymbol(name, &result) && result.object && is_register_object(result.object)) { + type = result.object->type; + if ((reg = InlineAsm_LookupRegisterPPC(name->name)) && reg->object == result.object) + return reg; + + if (IS_TYPE_FLOAT(type)) { + InlineAsm_InsertRegister(name->name, RegClass_FPR, 0, result.object); + } else if (IS_TYPE_VECTOR(type)) { + InlineAsm_InsertRegister(name->name, RegClass_VR, 0, result.object); + } else { + InlineAsm_InsertRegister(name->name, RegClass_GPR, 0, result.object); + } + } + + return InlineAsm_LookupRegisterPPC(name->name); +} + +IARegister *InlineAsm_LookupRegisterPPC(char *name) { + RegInfo *scan; + IARegister *reg; + IARegister *check; + char buf[40]; + + if ((check = InlineAsm_LookupRegister(name))) + return check; + + reg = NULL; + if (strlen(name) < 40) + CToLowercase(name, buf); + else + return NULL; + + for (scan = hashedsprs[CHash(buf) & 63]; scan; scan = scan->next) { + check = &scan->reg; + if (!strcmp(scan->reg.name, buf)) { + if (cpu == CPUMask_Generic) { + if ((cpu & CPUFLAG_LOW_MASK) == ((cpu & CPUFLAG_LOW_MASK) & scan->b)) + return check; + } else { + if (scan->b & cpu) + return check; + } + reg = check; + } + } + + if (reg) { + if (copts.warn_possunwant) + PPCError_Warning(117, name); + return reg; + } + + if (!strncmp("spr", buf, 3)) { + static IARegister thespr; + UInt32 result; + Boolean overflow; + ScanDec(buf + 3, &result, &overflow); + if (overflow || result > 1024) { + PPCError_Error(117, name); + return NULL; + } + + thespr.name = NULL; + thespr.rclass = RegClass_SPR; + thespr.num = result; + thespr.object = NULL; + + if (copts.warn_possunwant) { + if (cpu == CPUMask_Generic) { + if ((cpu & CPUFLAG_LOW_MASK) != ((cpu & CPUFLAG_LOW_MASK) & spr_cpus[result])) + PPCError_Warning(117, name); + } else { + if (!(cpu & spr_cpus[result])) + PPCError_Warning(117, name); + } + } + + return &thespr; + } + + return NULL; +} + +IARegister *InlineAsm_LookupDCRRegister(char *name) { + RegInfo *scan; + IARegister *check; + IARegister *reg; + char buf[40]; + + if (strlen(name) < 40) + CToLowercase(name, buf); + else + return NULL; + + reg = NULL; + for (scan = hasheddcrs[CHash(buf) & 63]; scan; scan = scan->next) { + check = &scan->reg; + if (!strcmp(scan->reg.name, buf)) { + if (cpu == CPUMask_Generic) { + if ((cpu & CPUFLAG_LOW_MASK) == ((cpu & CPUFLAG_LOW_MASK) & scan->b)) + return check; + } else { + if (scan->b & cpu) + return check; + } + reg = check; + } + } + + if (reg) { + if (copts.warn_possunwant) + PPCError_Warning(117, name); + return reg; + } + + if (!strncmp("dcr", buf, 3)) { + static IARegister thespr; + UInt32 result; + Boolean overflow; + ScanDec(buf + 3, &result, &overflow); + if (overflow || result > 1024) { + PPCError_Error(117, name); + return NULL; + } + + thespr.name = NULL; + thespr.rclass = RegClass_DCR; + thespr.num = result; + thespr.object = NULL; + return &thespr; + } + + return NULL; +} + +void InlineAsm_InitializeRegistersPPC(void) { + AsmRegister *asmreg; + AsmSpr *asmspr; + HashNameNode *name; + Object *obj; + ObjectList *list; + char buf[16]; + SInt32 i; + + setup_diagnostic_reg_strings(); + + for (i = 0; i < 64; i++) + hashedsprs[i] = NULL; + for (i = 0; i < 64; i++) + hasheddcrs[i] = NULL; + + for (asmreg = asm_registers; asmreg->name; asmreg++) { + name = GetHashNameNodeExport(asmreg->name); + for (list = arguments; list; list = list->next) { + obj = list->object; + if (obj && obj->name == name) { + switch (asmreg->rclass) { + case RegClass_SPR: + case RegClass_CRFIELD: + case RegClass_VR: + case RegClass_FPR: + case RegClass_GPR: + sprintf(buf, register_class_format[asmreg->rclass], asmreg->num); + break; + case RegClass_6: + sprintf(buf, "crbit_%ld", asmreg->num); + break; + case RegClass_DCR: + sprintf(buf, "DCR%ld", asmreg->num); + break; + default: + sprintf(buf, "{?}%ld", asmreg->num); + break; + } + PPCError_Warning(100, obj->name->name, buf); + } + } + for (list = locals; list; list = list->next) { + obj = list->object; + if (obj && obj->name == name) { + switch (asmreg->rclass) { + case RegClass_SPR: + case RegClass_CRFIELD: + case RegClass_VR: + case RegClass_FPR: + case RegClass_GPR: + sprintf(buf, register_class_format[asmreg->rclass], asmreg->num); + break; + case RegClass_6: + sprintf(buf, "crbit_%ld", asmreg->num); + break; + case RegClass_DCR: + sprintf(buf, "DCR%ld", asmreg->num); + break; + default: + sprintf(buf, "{?}%ld", asmreg->num); + break; + } + PPCError_Warning(100, obj->name->name, buf); + } + } + + InlineAsm_InsertRegister(asmreg->name, asmreg->rclass, asmreg->num, NULL); + } + + for (asmspr = asm_sprs; asmspr->name; asmspr++) { + InlineAsm_InsertSPR(asmspr->name, asmspr->num, asmspr->mask); + } +} diff --git a/compiler_and_linker/unsorted/InstrSelection.c b/compiler_and_linker/unsorted/InstrSelection.c new file mode 100644 index 0000000..ac60baf --- /dev/null +++ b/compiler_and_linker/unsorted/InstrSelection.c @@ -0,0 +1,4858 @@ +#include "compiler/InstrSelection.h" +#include "compiler/CError.h" +#include "compiler/CInt64.h" +#include "compiler/CMachine.h" +#include "compiler/CParser.h" +#include "compiler/CodeGen.h" +#include "compiler/Operands.h" +#include "compiler/PCode.h" +#include "compiler/PCodeInfo.h" +#include "compiler/PCodeUtilities.h" +#include "compiler/RegisterInfo.h" +#include "compiler/TOC.h" +#include "compiler/CompilerTools.h" +#include "compiler/enode.h" +#include "compiler/objects.h" +#include "compiler/types.h" + +// TODO: move me +extern void move_block(Operand *, Operand *, SInt32, SInt32); + +PrecomputedOperand *precomputedoperands; +void (*cgdispatch[MAXEXPR + 1])(ENode *, short, short, Operand *); + +// forward decls +static int ispowerof2(SInt32 val); +static void binary_immediate(Opcode opcode, ENode *left, SInt32 value, short outputReg, Operand *output); +static void shift_left_immediate(ENode *expr, short shift, short negate, short outputReg, Operand *output); +static void shift_right_immediate(ENode *expr, Type *type, short shift, short outputReg, Operand *output); +static void or_xor_immediate(Opcode opcode, ENode *expr, SInt32 value, short outputReg, Operand *output); +static void signed_divide_by_power_of_2(ENode *expr, int shift, int negate, short outputReg, Operand *output); +static void signed_mod_by_power_of_2(ENode *expr, int shift, int negate, short outputReg, Operand *output); +static void fp_binary_operator(Opcode opcode, ENode *left, ENode *right, short outputReg, Operand *output); +static void logical_expression_nobranch(ENode *cond, Boolean invert, Operand *output); +static void shift_and_mask(ENode *expr, short a, short b, short c, short outputReg, Operand *output); +static ENodeType invert_relop(ENodeType nt); + +#define IS_INT_CONST(node) ( ENODE_IS((node), EINTCONST) && IS_TYPE_INT((node)->rtype) && (node)->rtype->size <= 4 ) +#define IS_INT_CONST_ZERO(node) ( IS_INT_CONST(node) && (node)->data.intval.lo == 0 ) + +void init_cgdispatch(void) { + ENodeType t; + + for (t = 0; t <= MAXEXPR; t++) + cgdispatch[t] = gen_UNEXPECTED; + + cgdispatch[EPOSTINC] = gen_POSTINCDEC; + cgdispatch[EPOSTDEC] = gen_POSTINCDEC; + cgdispatch[EINDIRECT] = gen_INDIRECT; + cgdispatch[EMONMIN] = gen_MONMIN; + cgdispatch[EBINNOT] = gen_BINNOT; + cgdispatch[ELOGNOT] = gen_LOGICAL; + cgdispatch[EFORCELOAD] = gen_FORCELOAD; + cgdispatch[EMUL] = gen_MUL; + cgdispatch[EDIV] = gen_DIV; + cgdispatch[EMODULO] = gen_MODULO; + cgdispatch[EADD] = gen_ADD; + cgdispatch[ESUB] = gen_SUB; + cgdispatch[ESHL] = gen_SHL; + cgdispatch[ESHR] = gen_SHR; + cgdispatch[ELESS] = gen_COMPARE; + cgdispatch[EGREATER] = gen_COMPARE; + cgdispatch[ELESSEQU] = gen_COMPARE; + cgdispatch[EGREATEREQU] = gen_COMPARE; + cgdispatch[EEQU] = gen_COMPARE; + cgdispatch[ENOTEQU] = gen_COMPARE; + cgdispatch[EAND] = gen_AND; + cgdispatch[EXOR] = gen_XOR; + cgdispatch[EOR] = gen_OR; + cgdispatch[ELAND] = gen_LOGICAL; + cgdispatch[ELOR] = gen_LOGICAL; + cgdispatch[EASS] = gen_ASS; + cgdispatch[ECOMMA] = gen_COMMA; + cgdispatch[ETYPCON] = gen_TYPCON; + cgdispatch[EBITFIELD] = gen_BITFIELD; + cgdispatch[EINTCONST] = gen_INTCONST; + cgdispatch[EFLOATCONST] = gen_FLOATCONST; + cgdispatch[ESTRINGCONST] = gen_STRINGCONST; + cgdispatch[ECOND] = gen_COND; + cgdispatch[EFUNCCALL] = gen_FUNCCALL; + cgdispatch[EFUNCCALLP] = gen_FUNCCALL; + cgdispatch[EOBJREF] = gen_OBJREF; + cgdispatch[ENULLCHECK] = gen_NULLCHECK; + cgdispatch[EPRECOMP] = gen_PRECOMP; + cgdispatch[EDEFINE] = gen_DEFINE; + cgdispatch[EREUSE] = gen_REUSE; + cgdispatch[EVECTOR128CONST] = gen_VECTOR128CONST; + cgdispatch[ECONDASS] = gen_CONDASS; +} + +void gen_DEFINE(ENode *expr, short outputReg, short outputRegHi, Operand *output) { + Operand *op; + + if (!expr->data.diadic.right) { + op = lalloc(sizeof(Operand)); + memclrw(op, sizeof(Operand)); + expr->data.diadic.right = (ENode *) op; + GEN_NODE(expr->data.diadic.left, op); + } + + op = (Operand *) expr->data.diadic.right; + *output = *op; +} + +void gen_REUSE(ENode *expr, short outputReg, short outputRegHi, Operand *output) { + ENode *inner = expr->data.monadic; +#line 250 + CError_ASSERT(ENODE_IS(inner, EDEFINE)); + gen_DEFINE(inner, outputReg, outputRegHi, output); +} + +void gen_POSTINCDEC(ENode *expr, short outputReg, short outputRegHi, Operand *output) { + TypeBitfield *tbitfield; + ENode *inner; + Type *type; + Operand a; + Operand b; + Operand c; + Float fval; + int objReg; + int constReg; + int finalReg; + SInt32 incval; + + inner = expr->data.monadic->data.monadic; + type = expr->rtype; + tbitfield = NULL; + + memclrw(&a, sizeof(Operand)); + memclrw(&b, sizeof(Operand)); + memclrw(&c, sizeof(Operand)); + + if (TYPE_IS_8BYTES(type)) { + I8_gen_POSTINCDEC(expr, outputReg, outputRegHi, output); + return; + } + + if (IS_TYPE_FLOAT(type)) { + if (ENODE_IS(inner, EOBJREF) && (objReg = OBJECT_REG(inner->data.objref))) { + output->optype = OpndType_FPR; + output->reg = (outputReg && outputReg != objReg) ? outputReg : ALLOC_FPR(); + emitpcode(PC_FMR, output->reg, objReg); + fval = one_point_zero; + load_floating_constant(constReg = ALLOC_FPR(), type, &fval.value); + + if (ENODE_IS(expr, EPOSTINC)) { + emitpcode((type->size == 4) ? PC_FADDS : PC_FADD, objReg, objReg, constReg); + } else { + emitpcode((type->size == 4) ? PC_FSUBS : PC_FSUB, objReg, objReg, constReg); + } + } else { + GEN_NODE(inner, &a); + indirect(&a, inner); + b = a; + ENSURE_FPR(&b, type, 0); + + output->optype = OpndType_FPR; + output->reg = ALLOC_FPR(); + emitpcode(PC_FMR, output->reg, b.reg); + + fval = one_point_zero; + load_floating_constant(constReg = ALLOC_FPR(), type, &fval.value); + + finalReg = ALLOC_FPR(); + if (ENODE_IS(expr, EPOSTINC)) + emitpcode((type->size == 4) ? PC_FADDS : PC_FADD, finalReg, b.reg, constReg); + else + emitpcode((type->size == 4) ? PC_FSUBS : PC_FSUB, finalReg, b.reg, constReg); + + store_fp(finalReg, &a, type); + } + } else { + if (IS_TYPE_POINTER(type)) { + if (ENODE_IS(expr, EPOSTINC)) + incval = TPTR_TARGET(type)->size; + else + incval = -TPTR_TARGET(type)->size; + } else { + if (ENODE_IS(expr, EPOSTINC)) + incval = 1; + else + incval = -1; + } + + if (ENODE_IS(inner, EOBJREF) && (objReg = OBJECT_REG(inner->data.objref))) { + output->optype = OpndType_GPR; + output->reg = (outputReg && outputReg != objReg) ? outputReg : ALLOC_GPR(); + emitpcode(PC_MR, output->reg, objReg); + add_register_immediate(objReg, objReg, incval); + } else { + if (ENODE_IS(inner, EBITFIELD)) { + tbitfield = TYPE_BITFIELD(TPTR_TARGET(inner)); + inner = inner->data.monadic; + } + GEN_NODE(inner, &a); + indirect(&a, inner); + b = a; + ENSURE_GPR(&b, type, 0); + + if (tbitfield) { + c = b; + extract_bitfield(&c, tbitfield, 0, &b); + } + output->optype = OpndType_GPR; + + output->reg = ALLOC_GPR(); + emitpcode(PC_MR, output->reg, b.reg); + + finalReg = ALLOC_GPR(); + add_register_immediate(finalReg, b.reg, incval); + + if (tbitfield) { + insert_bitfield(finalReg, &c, tbitfield); + finalReg = c.reg; + } + + store(finalReg, &a, type); + } + } +} + +void gen_INDIRECT(ENode *expr, short outputReg, short outputRegHi, Operand *output) { + Type *type; + ENode *inner; + VarInfo *vi; + SInt32 postincvalue; + Operand op; + + type = expr->rtype; + inner = expr->data.monadic; + + if (TYPE_IS_8BYTES(type)) { + I8_gen_INDIRECT(expr, outputReg, outputRegHi, output); + return; + } + + memclrw(&op, sizeof(Operand)); + if (ENODE_IS(inner, EOBJREF) && OBJECT_REG(inner->data.objref)) { + vi = Registers_GetVarInfo(inner->data.objref); + switch (vi->rclass) { + case RegClass_GPR: + output->optype = OpndType_GPR; + break; + case RegClass_FPR: + output->optype = OpndType_FPR; + break; + case RegClass_VR: + output->optype = OpndType_VR; + break; + case RegClass_CRFIELD: + output->optype = OpndType_CRField; + break; + default: +#line 456 + CError_FATAL(); + } + output->reg = vi->reg; + output->object = NULL; + return; + } + + if (ENODE_IS(inner, EBITFIELD)) { + GEN_NODE(inner->data.monadic, &op); + indirect(&op, expr); + ENSURE_GPR(&op, type, 0); + extract_bitfield(&op, TYPE_BITFIELD(inner->rtype), outputReg, output); + return; + } + + if (ispostincrementopportunity(inner, &op, &postincvalue) && (TYPE_FITS_IN_REGISTER(type) || IS_TYPE_FLOAT(type) || IS_TYPE_VECTOR(type))) { + indirect(&op, expr); + *output = op; + if (TYPE_FITS_IN_REGISTER(type)) { + ENSURE_GPR(output, type, outputReg); + } else if (IS_TYPE_FLOAT(type)) { + ENSURE_FPR(output, type, outputReg); + } else { + ENSURE_VR(output, type, outputReg); + } + + add_register_immediate(op.reg, op.reg, postincvalue); + return; + } + + GEN_NODE(inner, output); + indirect(output, expr); +} + +void gen_MONMIN(ENode *expr, short outputReg, short outputRegHi, Operand *output) { + ENode *inner; + Type *type; + ENode *scan; + + inner = expr->data.monadic; + type = expr->rtype; + + if (TYPE_IS_8BYTES(type)) { + I8_gen_MONMIN(expr, outputReg, outputRegHi, output); + return; + } + + if (IS_TYPE_FLOAT(type)) { + if (ENODE_IS(inner, EADD) && ENODE_IS(inner->data.diadic.left, EMUL) && copts.fp_contract) { + fp_multiply_add( + (type->size == 4) ? PC_FNMADDS : PC_FNMADD, + inner->data.diadic.left->data.diadic.left, + inner->data.diadic.left->data.diadic.right, + inner->data.diadic.right, + outputReg, + output); + } else if (ENODE_IS(inner, EADD) && ENODE_IS(inner->data.diadic.right, EMUL) && copts.fp_contract) { + fp_multiply_add( + (type->size == 4) ? PC_FNMADDS : PC_FNMADD, + inner->data.diadic.right->data.diadic.left, + inner->data.diadic.right->data.diadic.right, + inner->data.diadic.left, + outputReg, + output); + } else if (ENODE_IS(inner, ESUB) && ENODE_IS(inner->data.diadic.left, EMUL) && copts.fp_contract) { + fp_multiply_add( + (type->size == 4) ? PC_FNMSUBS : PC_FNMSUB, + inner->data.diadic.left->data.diadic.left, + inner->data.diadic.left->data.diadic.right, + inner->data.diadic.right, + outputReg, + output); + } else { + fp_unary_operator(PC_FNEG, inner, outputReg, output); + } + return; + } + + scan = inner; + while (ENODE_IS(scan, ETYPCON) && IS_TYPE_INT_OR_ENUM(type) && !is_unsigned(type)) + scan = scan->data.monadic; + + switch (scan->type) { + case ELESS: + case EGREATER: + case ELESSEQU: + case EGREATEREQU: + case EEQU: + case ENOTEQU: + if (TYPE_FITS_IN_REGISTER(scan->data.diadic.left->rtype) && TYPE_FITS_IN_REGISTER(scan->data.diadic.right->rtype)) { + gen_negated_condition_gpr(scan, output, outputReg); + return; + } + } + unary_operator(PC_NEG, inner, outputReg, output); +} + +void gen_BINNOT(ENode *expr, short outputReg, short outputRegHi, Operand *output) { + ENode *inner; + Type *type; + + inner = expr->data.monadic; + type = expr->rtype; + + if (TYPE_IS_8BYTES(type)) { + I8_gen_BINNOT(expr, outputReg, outputRegHi, output); + return; + } + + if (ENODE_IS(inner, EAND)) + binary_operator(PC_NAND, inner->data.diadic.left, inner->data.diadic.right, outputReg, output); + else if (ENODE_IS(inner, EOR)) + binary_operator(PC_NOR, inner->data.diadic.left, inner->data.diadic.right, outputReg, output); + else if (ENODE_IS(inner, EXOR)) + binary_operator(PC_EQV, inner->data.diadic.left, inner->data.diadic.right, outputReg, output); + else + unary_operator(PC_NOT, inner, outputReg, output); +} + +void gen_FORCELOAD(ENode *expr, short outputReg, short outputRegHi, Operand *output) { + ENode *inner; + + inner = expr->data.monadic; + GEN_NODE(inner, output); + + if (IS_TYPE_FLOAT(inner->rtype)) { + ENSURE_FPR(output, inner->rtype, outputReg); + } else if (IS_TYPE_VECTOR(inner->rtype)) { + ENSURE_VR(output, inner->rtype, outputReg); + } else if (TYPE_FITS_IN_REGISTER(inner->rtype)) { + if (TYPE_IS_8BYTES(inner->rtype)) + coerce_to_register_pair(output, inner->rtype, outputReg, outputRegHi); + else + ENSURE_GPR(output, inner->rtype, outputReg); + } else if (!IS_TYPE_VOID(inner->rtype)) { +#line 681 + CError_FATAL(); + } +} + +void gen_MUL(ENode *expr, short outputReg, short outputRegHi, Operand *output) { + ENode *left; + ENode *right; + Type *type; + int tmp; + + left = expr->data.diadic.left; + right = expr->data.diadic.right; + type = expr->rtype; + + if (TYPE_IS_8BYTES(type)) { + I8_gen_MUL(expr, outputReg, outputRegHi, output); + return; + } + + if (IS_TYPE_FLOAT(type)) { + fp_binary_operator((type->size == 4) ? PC_FMULS : PC_FMUL, left, right, outputReg, output); + return; + } + + if (ENODE_IS(right, EINTCONST) && (tmp = ispowerof2(right->data.intval.lo))) { + shift_left_immediate(left, tmp, 0, outputReg, output); + } else if (ENODE_IS(right, EINTCONST) && (tmp = ispowerof2(-right->data.intval.lo))) { + shift_left_immediate(left, tmp, 1, outputReg, output); + } else if (ENODE_IS(left, EINTCONST) && (tmp = ispowerof2(left->data.intval.lo))) { + shift_left_immediate(right, tmp, 0, outputReg, output); + } else if (ENODE_IS(left, EINTCONST) && (tmp = ispowerof2(-left->data.intval.lo))) { + shift_left_immediate(right, tmp, 1, outputReg, output); + } else if (ENODE_IS(right, EINTCONST) && FITS_IN_SHORT(right->data.intval.lo)) { + binary_immediate(PC_MULLI, left, right->data.intval.lo, outputReg, output); + } else if (ENODE_IS(left, EINTCONST) && FITS_IN_SHORT(left->data.intval.lo)) { + binary_immediate(PC_MULLI, right, left->data.intval.lo, outputReg, output); + } else { + binary_operator(PC_MULLW, left, right, outputReg, output); + } +} + +struct ms { + SInt32 m; + int s; +}; +static void create_signed_magic(SInt32 val, struct ms *output) { + // PowerPC CWG page 57-58 + int p; + UInt32 ad, anc, delta, q1, r1, q2, r2, t; + + ad = abs(val); + t = 0x80000000U + ((UInt32) val >> 31); + anc = t - 1 - t % ad; + p = 31; + q1 = 0x80000000U / anc; + r1 = 0x80000000U - q1 * anc; + q2 = 0x80000000U / ad; + r2 = 0x80000000U - q2 * ad; + + do { + p = p + 1; + q1 = 2 * q1; + r1 = 2 * r1; + if (r1 >= anc) { + q1 = q1 + 1; + r1 = r1 - anc; + } + q2 = 2 * q2; + r2 = 2 * r2; + if (r2 >= ad) { + q2 = q2 + 1; + r2 = r2 - ad; + } + delta = ad - r2; + } while (q1 < delta || (q1 == delta && r1 == 0)); + + // after loop + output->m = q2 + 1; + if (val < 0) + output->m = -output->m; + output->s = p - 32; +} + +struct mu { + UInt32 m; + int a; + int s; +}; +static void create_unsigned_magic(UInt32 val, struct mu *output) { + // PowerPC CWG page 58-59 + int p; + UInt32 nc, delta, q1, r1, q2, r2; + + output->a = 0; + nc = - 1 - (-val) % val; + p = 31; + q1 = 0x80000000U / nc; + r1 = 0x80000000U - q1 * nc; + q2 = 0x7FFFFFFFU / val; + r2 = 0x7FFFFFFFU - q2 * val; + do { + p = p + 1; + if (r1 >= nc - r1) { + q1 = 2 * q1 + 1; + r1 = 2 * r1 - nc; + } else { + q1 = 2 * q1; + r1 = 2 * r1; + } + if (r2 + 1 >= val - r2) { + if (q2 >= 0x7FFFFFFFU) + output->a = 1; + q2 = 2 * q2 + 1; + r2 = 2 * r2 + 1 - val; + } else { + if (q2 >= 0x80000000U) + output->a = 1; + q2 = 2 * q2; + r2 = 2 * r2 + 1; + } + delta = val - 1 - r2; + } while (p < 64 && (q1 < delta || (q1 == delta && r1 == 0))); + + output->m = q2 + 1; + output->s = p - 32; +} + +void gen_DIV(ENode *expr, short outputReg, short outputRegHi, Operand *output) { + ENode *left; + ENode *right; + Type *type; + int tmp; + + left = expr->data.diadic.left; + right = expr->data.diadic.right; + type = expr->rtype; + + if (TYPE_IS_8BYTES(type)) { + I8_gen_DIV_MOD(expr, outputReg, outputRegHi, output); + return; + } + + if (IS_TYPE_FLOAT(type)) { + fp_binary_operator((type->size == 4) ? PC_FDIVS : PC_FDIV, left, right, outputReg, output); + return; + } + + if (is_unsigned(type)) { + if (ENODE_IS(right, EINTCONST) && (tmp = ispowerof2(right->data.intval.lo))) { + shift_right_immediate(left, type, tmp, outputReg, output); + } else if (!copts.optimize_for_size && ENODE_IS(right, EINTCONST) && right->data.intval.lo != 1) { + SInt32 value; + int tmpreg1; + int tmpreg2; + int tmpreg3; + int tmpreg4; + int tmpreg5; + int tmpreg6; + int finalReg; + struct mu u_magicoutput; + Operand op1; + value = right->data.intval.lo; + tmpreg1 = ALLOC_GPR(); + tmpreg2 = ALLOC_GPR(); + finalReg = outputReg ? outputReg : ALLOC_GPR(); + + memclrw(&op1, sizeof(Operand)); + GEN_NODE(left, &op1); + ENSURE_GPR(&op1, left->rtype, 0); + + tmpreg3 = op1.reg; + create_unsigned_magic(value, &u_magicoutput); + load_immediate(tmpreg2, u_magicoutput.m); + emitpcode(PC_MULHWU, tmpreg1, tmpreg2, tmpreg3); + if (u_magicoutput.a == 0) { + if (u_magicoutput.s) + emitpcode(PC_RLWINM, finalReg, tmpreg1, (32 - u_magicoutput.s) & 31, u_magicoutput.s, 31); + else + emitpcode(PC_MR, finalReg, tmpreg1); + } else if (u_magicoutput.a == 1) { + tmpreg4 = ALLOC_GPR(); + if (copts.optimizationlevel > 1) { + tmpreg5 = ALLOC_GPR(); + tmpreg6 = ALLOC_GPR(); + } else { + tmpreg5 = tmpreg4; + tmpreg6 = tmpreg4; + } + + emitpcode(PC_SUBF, tmpreg4, tmpreg1, tmpreg3); + emitpcode(PC_RLWINM, tmpreg5, tmpreg4, 31, 1, 31); + emitpcode(PC_ADD, tmpreg6, tmpreg5, tmpreg1); + emitpcode(PC_RLWINM, finalReg, tmpreg6, (32 - (u_magicoutput.s - 1)) & 31, u_magicoutput.s - 1, 31); + } + + output->optype = OpndType_GPR; + output->reg = finalReg; + } else { + binary_operator(PC_DIVWU, left, right, outputReg, output); + } + } else { + SInt32 value; + if (ENODE_IS(right, EINTCONST) && (tmp = ispowerof2(right->data.intval.lo))) { + signed_divide_by_power_of_2(left, tmp, 0, outputReg, output); + } else if (ENODE_IS(right, EINTCONST) && (tmp = ispowerof2(-right->data.intval.lo))) { + signed_divide_by_power_of_2(left, tmp, 1, outputReg, output); + } else if (!copts.optimize_for_size && ENODE_IS(right, EINTCONST) && (value = right->data.intval.lo) != 1u && value != -1) { + int tmpreg2; + int tmpreg3; + int tmpreg1; + int tmpreg4; + int finalReg; + struct ms s_magicoutput; + Operand op2; + value = right->data.intval.lo; + tmpreg1 = ALLOC_GPR(); + tmpreg2 = ALLOC_GPR(); + tmpreg3 = ALLOC_GPR(); + finalReg = outputReg ? outputReg : ALLOC_GPR(); + + memclrw(&op2, sizeof(Operand)); + GEN_NODE(left, &op2); + ENSURE_GPR(&op2, left->rtype, 0); + + tmpreg4 = op2.reg; + create_signed_magic(value, &s_magicoutput); + load_immediate(tmpreg2, s_magicoutput.m); + emitpcode(PC_MULHW, tmpreg1, tmpreg2, tmpreg4); + if (value > 0 && s_magicoutput.m < 0) { + int t = ALLOC_GPR(); + emitpcode(PC_ADD, t, tmpreg1, tmpreg4); + tmpreg1 = t; + } else if (value < 0 && s_magicoutput.m > 0) { + int t = ALLOC_GPR(); + emitpcode(PC_SUBF, t, tmpreg4, tmpreg1); + tmpreg1 = t; + } + + if (s_magicoutput.s) { + int t = ALLOC_GPR(); + emitpcode(PC_SRAWI, t, tmpreg1, s_magicoutput.s); + tmpreg1 = t; + } + + emitpcode(PC_RLWINM, tmpreg3, tmpreg1, 1, 31, 31); + emitpcode(PC_ADD, finalReg, tmpreg1, tmpreg3); + + output->optype = OpndType_GPR; + output->reg = finalReg; + } else { + binary_operator(PC_DIVW, left, right, outputReg, output); + } + } +} + +void gen_MODULO(ENode *expr, short outputReg, short outputRegHi, Operand *output) { + ENode *left; + ENode *right; + int tmp; + struct mu u_magicoutput; + struct ms s_magicoutput; + Operand op1; + Operand op2; + SInt32 value; + + left = expr->data.diadic.left; + right = expr->data.diadic.right; + memclrw(&op1, sizeof(Operand)); + memclrw(&op2, sizeof(Operand)); + + if (TYPE_IS_8BYTES(expr->rtype)) { + I8_gen_DIV_MOD(expr, outputReg, outputRegHi, output); + return; + } + + if (ENODE_IS(right, EINTCONST) && (tmp = ispowerof2(right->data.intval.lo))) { + if (is_unsigned(expr->rtype)) + shift_and_mask(left, 0, 32 - tmp, 31, outputReg, output); + else + signed_mod_by_power_of_2(left, tmp, 0, outputReg, output); + } else if (!copts.optimize_for_size && ENODE_IS(right, EINTCONST) && (value = right->data.intval.lo) != 1u && value != -1) { + GEN_NODE(left, &op1); + ENSURE_GPR(&op1, left->rtype, 0); + + if (is_unsigned(expr->rtype)) { + int tmpreg1; + int tmpreg2; + int tmpreg3; + int tmpreg4; + int tmpreg5; + int tmpreg6; + int tmpreg7; + int tmpreg8; + int finalReg; + + tmpreg1 = op1.reg; + tmpreg2 = ALLOC_GPR(); + tmpreg3 = ALLOC_GPR(); + tmpreg4 = ALLOC_GPR(); + finalReg = outputReg ? outputReg : ALLOC_GPR(); + + create_unsigned_magic(right->data.intval.lo, &u_magicoutput); + load_immediate(tmpreg3, u_magicoutput.m); + emitpcode(PC_MULHWU, tmpreg2, tmpreg3, tmpreg1); + + if (u_magicoutput.a == 0 && u_magicoutput.s != 0) + emitpcode(PC_RLWINM, tmpreg2, tmpreg2, (32 - u_magicoutput.s) & 31, u_magicoutput.s, 31); + + if (u_magicoutput.a == 1) { + tmpreg5 = ALLOC_GPR(); + if (copts.optimizationlevel > 1) { + tmpreg6 = ALLOC_GPR(); + tmpreg7 = ALLOC_GPR(); + tmpreg8 = ALLOC_GPR(); + } else { + tmpreg6 = tmpreg5; + tmpreg7 = tmpreg5; + tmpreg8 = tmpreg5; + } + emitpcode(PC_SUBF, tmpreg5, tmpreg2, tmpreg1); + emitpcode(PC_RLWINM, tmpreg6, tmpreg5, 31, 1, 31); + emitpcode(PC_ADD, tmpreg7, tmpreg6, tmpreg2); + emitpcode(PC_RLWINM, tmpreg8, tmpreg7, (32 - (u_magicoutput.s - 1)) & 31, u_magicoutput.s - 1, 31); + tmpreg2 = tmpreg8; + } + + if (value > 0 && value < 0x7FFF) { + emitpcode(PC_MULLI, tmpreg4, tmpreg2, value); + } else { + GEN_NODE(right, &op2); + ENSURE_GPR(&op2, right->rtype, 0); + emitpcode(PC_MULLW, tmpreg4, tmpreg2, op2.reg); + } + + emitpcode(PC_SUBF, finalReg, tmpreg4, tmpreg1); + output->optype = OpndType_GPR; + output->reg = finalReg; + } else { + int tmpreg1; + int tmpreg2; + int tmpreg3; + int tmpreg4; + int tmpreg5; + int tmpreg6; + int finalReg; + + tmpreg1 = op1.reg; + tmpreg2 = ALLOC_GPR(); + tmpreg3 = ALLOC_GPR(); + tmpreg4 = ALLOC_GPR(); + tmpreg5 = ALLOC_GPR(); + tmpreg6 = ALLOC_GPR(); + finalReg = outputReg ? outputReg : ALLOC_GPR(); + + create_signed_magic(right->data.intval.lo, &s_magicoutput); + load_immediate(tmpreg3, s_magicoutput.m); + emitpcode(PC_MULHW, tmpreg2, tmpreg3, tmpreg1); + + if (value > 0 && s_magicoutput.m < 0) { + int tmp = ALLOC_GPR(); + emitpcode(PC_ADD, tmp, tmpreg2, tmpreg1); + tmpreg2 = tmp; + } else if (value < 0 && s_magicoutput.m > 0) { + int tmp = ALLOC_GPR(); + emitpcode(PC_SUBF, tmp, tmpreg1, tmpreg2); + tmpreg2 = tmp; + } + + if (s_magicoutput.s != 0) { + int tmp = ALLOC_GPR(); + emitpcode(PC_SRAWI, tmp, tmpreg2, s_magicoutput.s); + tmpreg2 = tmp; + } + + emitpcode(PC_RLWINM, tmpreg4, tmpreg2, 1, 31, 31); + emitpcode(PC_ADD, tmpreg5, tmpreg2, tmpreg4); + + if (value < 0x7FFF && value > -0x4000) { + emitpcode(PC_MULLI, tmpreg6, tmpreg5, value); + } else { + GEN_NODE(right, &op2); + ENSURE_GPR(&op2, right->rtype, 0); + + emitpcode(PC_MULLW, tmpreg6, tmpreg5, op2.reg); + } + + emitpcode(PC_SUBF, finalReg, tmpreg6, tmpreg1); + output->optype = OpndType_GPR; + output->reg = finalReg; + } + } else { + int tmpreg1; + int tmpreg2; + int finalReg; + + if (right->hascall) { + GEN_NODE(right, &op2); + ENSURE_GPR(&op2, right->rtype, 0); + GEN_NODE(left, &op1); + ENSURE_GPR(&op1, left->rtype, 0); + } else { + GEN_NODE(left, &op1); + ENSURE_GPR(&op1, left->rtype, 0); + GEN_NODE(right, &op2); + ENSURE_GPR(&op2, right->rtype, 0); + } + + tmpreg1 = ALLOC_GPR(); + tmpreg2 = ALLOC_GPR(); + finalReg = outputReg ? outputReg : ALLOC_GPR(); + + emitpcode(is_unsigned(expr->rtype) ? PC_DIVWU : PC_DIVW, tmpreg1, op1.reg, op2.reg); + emitpcode(PC_MULLW, tmpreg2, tmpreg1, op2.reg); + emitpcode(PC_SUBF, finalReg, tmpreg2, op1.reg); + + output->optype = OpndType_GPR; + output->reg = finalReg; + } +} + +void gen_ADD(ENode *expr, short outputReg, short outputRegHi, Operand *output) { + ENode *left; + ENode *right; + Type *type; + Operand opleft; + Operand opright; + + left = expr->data.diadic.left; + right = expr->data.diadic.right; + type = expr->rtype; + + memclrw(&opleft, sizeof(Operand)); + memclrw(&opright, sizeof(Operand)); + + if (TYPE_IS_8BYTES(type)) { + I8_gen_ADD(expr, outputReg, outputRegHi, output); + return; + } + + if (IS_TYPE_FLOAT(type)) { + if (ENODE_IS(left, EMUL) && copts.fp_contract) { + fp_multiply_add( + (type->size == 4) ? PC_FMADDS : PC_FMADD, + left->data.diadic.left, + left->data.diadic.right, + right, + outputReg, output); + } else if (ENODE_IS(right, EMUL) && copts.fp_contract) { + fp_multiply_add( + (type->size == 4) ? PC_FMADDS : PC_FMADD, + right->data.diadic.left, + right->data.diadic.right, + left, + outputReg, output); + } else { + fp_binary_operator( + (type->size == 4) ? PC_FADDS : PC_FADD, + left, right, + outputReg, output); + } + return; + } + + if (right->hascall) { + GEN_NODE(right, &opright); + if (opright.optype >= OpndType_IndirectGPR_ImmOffset) + ENSURE_GPR(&opright, right->rtype, 0); + + GEN_NODE(left, &opleft); + if (opleft.optype >= OpndType_IndirectGPR_ImmOffset) + ENSURE_GPR(&opleft, left->rtype, 0); + } else { + GEN_NODE(left, &opleft); + if (opleft.optype >= OpndType_IndirectGPR_ImmOffset) + ENSURE_GPR(&opleft, left->rtype, 0); + + GEN_NODE(right, &opright); + if (opright.optype >= OpndType_IndirectGPR_ImmOffset) + ENSURE_GPR(&opright, right->rtype, 0); + } + + if (IS_TYPE_POINTER(expr->rtype)) { + if (TYPE_IS_8BYTES(expr->data.diadic.left->rtype)) { + opleft.optype = OpndType_GPR; + opleft.regHi = 0; + } + if (TYPE_IS_8BYTES(expr->data.diadic.right->rtype)) { + opright.optype = OpndType_GPR; + opright.regHi = 0; + } + } + + combine(&opleft, &opright, outputReg, output); +} + +void gen_SUB(ENode *expr, short outputReg, short outputRegHi, Operand *output) { + ENode *left; + ENode *right; + Type *type; + + left = expr->data.diadic.left; + right = expr->data.diadic.right; + type = expr->rtype; + + if (TYPE_IS_8BYTES(type)) { + I8_gen_SUB(expr, outputReg, outputRegHi, output); + return; + } + + if (IS_TYPE_FLOAT(type)) { + if (ENODE_IS(left, EMUL) && copts.fp_contract) { + fp_multiply_add( + (type->size == 4) ? PC_FMSUBS : PC_FMSUB, + left->data.diadic.left, + left->data.diadic.right, + right, + outputReg, output); + } else if (ENODE_IS(right, EMUL) && copts.fp_contract) { + fp_multiply_add( + (type->size == 4) ? PC_FNMSUBS : PC_FNMSUB, + right->data.diadic.left, + right->data.diadic.right, + left, + outputReg, output); + } else { + fp_binary_operator( + (type->size == 4) ? PC_FSUBS : PC_FSUB, + left, right, + outputReg, output); + } + return; + } + + if (ENODE_IS(left, EINTCONST) && FITS_IN_SHORT(left->data.intval.lo)) + binary_immediate(PC_SUBFIC, right, left->data.intval.lo, outputReg, output); + else + binary_operator(PC_SUBF, right, left, outputReg, output); +} + +void gen_SHL(ENode *expr, short outputReg, short outputRegHi, Operand *output) { + Type *type; + ENode *left; + ENode *right; + + left = expr->data.diadic.left; + right = expr->data.diadic.right; + type = expr->rtype; + + if (TYPE_IS_8BYTES(type)) { + I8_gen_SHL_SHR(expr, outputReg, outputRegHi, output); + return; + } + + if (ENODE_IS(right, EINTCONST)) + shift_left_immediate(left, right->data.intval.lo, 0, outputReg, output); + else + binary_operator(PC_SLW, left, right, outputReg, output); +} + +void gen_SHR(ENode *expr, short outputReg, short outputRegHi, Operand *output) { + Type *type; + ENode *left; + ENode *right; + + left = expr->data.diadic.left; + right = expr->data.diadic.right; + type = expr->rtype; + + if (TYPE_IS_8BYTES(type)) { + I8_gen_SHL_SHR(expr, outputReg, outputRegHi, output); + return; + } + + if (ENODE_IS(right, EINTCONST)) + shift_right_immediate(left, type, right->data.intval.lo, outputReg, output); + else + binary_operator(is_unsigned(type) ? PC_SRW : PC_SRAW, left, right, outputReg, output); +} + +void gen_AND(ENode *expr, short outputReg, short outputRegHi, Operand *output) { + Type *type; + ENode *left; + ENode *right; + short first; + short last; + + left = expr->data.diadic.left; + right = expr->data.diadic.right; + type = expr->rtype; + + if (TYPE_IS_8BYTES(type)) { + I8_gen_AND(expr, outputReg, outputRegHi, output); + return; + } + + if (ENODE_IS(right, EINTCONST) && ismaskconstant(right->data.intval.lo, &first, &last)) { + if (ENODE_IS(left, ESHL) && ENODE_IS(left->data.diadic.right, EINTCONST) && (int)(left->data.diadic.right->data.intval.lo + last) < 32) { + shift_and_mask( + left->data.diadic.left, + left->data.diadic.right->data.intval.lo, + first, last, + outputReg, output); + } else if (ENODE_IS(left, ESHR) && ENODE_IS(left->data.diadic.right, EINTCONST) && (int)left->data.diadic.right->data.intval.lo <= first && last >= first) { + if (left->data.diadic.right->data.intval.lo == 0) + shift_and_mask(left->data.diadic.left, 0, first, last, outputReg, output); + else + shift_and_mask(left->data.diadic.left, 32 - left->data.diadic.right->data.intval.lo, first, last, outputReg, output); + } else { + shift_and_mask(left, 0, first, last, outputReg, output); + } + return; + } + + if (ENODE_IS(right, EINTCONST) && FITS_IN_USHORT(right->data.intval.lo)) { + binary_immediate(PC_ANDI, left, right->data.intval.lo, outputReg, output); + return; + } + if (ENODE_IS(right, EINTCONST) && FITS_IN_HI_SHORT(right->data.intval.lo)) { + binary_immediate(PC_ANDIS, left, right->data.intval.lo >> 16, outputReg, output); + return; + } + + if (ENODE_IS(left, EINTCONST) && ismaskconstant(left->data.intval.lo, &first, &last)) { + if (ENODE_IS(right, ESHL) && ENODE_IS(right->data.diadic.right, EINTCONST) && (int)(right->data.diadic.right->data.intval.lo + last) < 32) { + shift_and_mask( + right->data.diadic.left, + right->data.diadic.right->data.intval.lo, + first, last, + outputReg, output); + } else if (ENODE_IS(right, ESHR) && ENODE_IS(right->data.diadic.right, EINTCONST) && (int)right->data.diadic.right->data.intval.lo <= first) { + if (right->data.diadic.right->data.intval.lo == 0) + shift_and_mask(right->data.diadic.left, 0, first, last, outputReg, output); + else + shift_and_mask(right->data.diadic.left, 32 - right->data.diadic.right->data.intval.lo, first, last, outputReg, output); + } else { + shift_and_mask(right, 0, first, last, outputReg, output); + } + return; + } + + if (ENODE_IS(left, EINTCONST) && FITS_IN_USHORT(left->data.intval.lo)) { + binary_immediate(PC_ANDI, right, left->data.intval.lo, outputReg, output); + return; + } + if (ENODE_IS(left, EINTCONST) && FITS_IN_HI_SHORT(left->data.intval.lo)) { + binary_immediate(PC_ANDIS, right, left->data.intval.lo >> 16, outputReg, output); + return; + } + + if (ENODE_IS(right, EBINNOT)) + binary_operator(PC_ANDC, left, right->data.monadic, outputReg, output); + else if (ENODE_IS(left, EBINNOT)) + binary_operator(PC_ANDC, right, left->data.monadic, outputReg, output); + else + binary_operator(PC_AND, left, right, outputReg, output); +} + +void gen_XOR(ENode *expr, short outputReg, short outputRegHi, Operand *output) { + Type *type; + ENode *left; + ENode *right; + + left = expr->data.diadic.left; + right = expr->data.diadic.right; + type = expr->rtype; + + if (TYPE_IS_8BYTES(type)) { + I8_gen_XOR(expr, outputReg, outputRegHi, output); + return; + } + + if (ENODE_IS(left, EINTCONST)) + or_xor_immediate(PC_XORI, right, left->data.intval.lo, outputReg, output); + else if (ENODE_IS(right, EINTCONST)) + or_xor_immediate(PC_XORI, left, right->data.intval.lo, outputReg, output); + else if (ENODE_IS(right, EBINNOT)) + binary_operator(PC_EQV, left, right->data.monadic, outputReg, output); + else if (ENODE_IS(left, EBINNOT)) + binary_operator(PC_EQV, left->data.monadic, right, outputReg, output); + else + binary_operator(PC_XOR, left, right, outputReg, output); +} + +void gen_OR(ENode *expr, short outputReg, short outputRegHi, Operand *output) { + Type *type; + ENode *left; + ENode *right; + + left = expr->data.diadic.left; + right = expr->data.diadic.right; + type = expr->rtype; + + if (TYPE_IS_8BYTES(type)) { + I8_gen_OR(expr, outputReg, outputRegHi, output); + return; + } + + if (ENODE_IS(left, EINTCONST)) + or_xor_immediate(PC_ORI, right, left->data.intval.lo, outputReg, output); + else if (ENODE_IS(right, EINTCONST)) + or_xor_immediate(PC_ORI, left, right->data.intval.lo, outputReg, output); + else if (ENODE_IS(right, EBINNOT)) + binary_operator(PC_ORC, left, right->data.monadic, outputReg, output); + else if (ENODE_IS(left, EBINNOT)) + binary_operator(PC_ORC, right, left->data.monadic, outputReg, output); + else + binary_operator(PC_OR, left, right, outputReg, output); +} + +void gen_ASS(ENode *expr, short outputReg, short outputRegHi, Operand *output) { + Type *type; + ENode *left; + ENode *right; + Operand opleft; + Operand opright; + Operand op2; + VarInfo *vi; + SInt32 incval; + short align; + short align2; + + type = expr->rtype; + if (ENODE_IS(expr, ECONDASS)) { + left = expr->data.cond.expr1; + if (ENODE_IS(left, EINDIRECT)) { + left = left->data.monadic; + } else { +#line 1759 + CError_FATAL(); + } + right = expr->data.cond.expr2; + } else { + left = expr->data.diadic.left; + right = expr->data.diadic.right; + } + + memclrw(&opleft, sizeof(Operand)); + memclrw(&opright, sizeof(Operand)); + memclrw(&op2, sizeof(Operand)); + + if (TYPE_IS_8BYTES(type)) { + I8_gen_ASS(expr, outputReg, outputRegHi, output); + return; + } + + if (ENODE_IS(left, EOBJREF) && OBJECT_REG(left->data.objref)) { + vi = Registers_GetVarInfo(left->data.objref); + GEN_NODE_TO_REG(right, vi->reg, 0, &opright); + switch (vi->rclass) { + case RegClass_GPR: + ENSURE_GPR(&opright, type, vi->reg); + output->optype = OpndType_GPR; + break; + case RegClass_FPR: + ENSURE_FPR(&opright, type, vi->reg); + output->optype = OpndType_FPR; + break; + case RegClass_VR: + ENSURE_VR(&opright, type, vi->reg); + output->optype = OpndType_VR; + break; + default: +#line 1810 + CError_FATAL(); + } + if (opright.reg != vi->reg) { + PCodeArg a, b; + a.kind = PCOp_REGISTER; + a.arg = vi->rclass; + a.data.reg.reg = vi->reg; + a.data.reg.effect = EffectWrite; + b.kind = PCOp_REGISTER; + b.arg = vi->rclass; + b.data.reg.reg = opright.reg; + b.data.reg.effect = EffectRead; + appendpcode(pclastblock, makecopyinstruction(&b, &a)); + } + output->reg = vi->reg; + return; + } + + if (IS_TYPE_FLOAT(type)) { + GEN_NODE_TO_FPR(right, &opright, right->rtype, 0); + if (ispostincrementopportunity(left, &opleft, &incval)) { + indirect(&opleft, expr); + store_fp(opright.reg, &opleft, type); + add_register_immediate(opleft.reg, opleft.reg, incval); + } else { + GEN_NODE(left, &opleft); + indirect(&opleft, expr); + store_fp(opright.reg, &opleft, type); + } + output->optype = OpndType_FPR; + output->reg = opright.reg; + return; + } + + if (IS_TYPE_VECTOR(type)) { + GEN_NODE(right, &opright); + if (opright.optype == OpndType_Absolute) + ENSURE_VR(&opright, type, 0); + else + ENSURE_VR(&opright, right->rtype, 0); + + if (ispostincrementopportunity(left, &opleft, &incval)) { + indirect(&opleft, expr); + store_v(opright.reg, &opleft, type); + add_register_immediate(opleft.reg, opleft.reg, incval); + } else { + GEN_NODE(left, &opleft); + indirect(&opleft, expr); + store_v(opright.reg, &opleft, type); + } + output->optype = OpndType_VR; + output->reg = opright.reg; + return; + } + + if (TYPE_FITS_IN_REGISTER(type)) { + GEN_NODE_TO_GPR(right, &opright, right->rtype, 0); + + if (ENODE_IS(left, EBITFIELD)) { + GEN_NODE(left->data.monadic, &opleft); + indirect(&opleft, expr); + + op2 = opleft; + ENSURE_GPR(&op2, type, 0); + insert_bitfield(opright.reg, &op2, TYPE_BITFIELD(left->rtype)); + store(op2.reg, &opleft, type); + + if (!expr->ignored) + extract_bitfield(&op2, TYPE_BITFIELD(left->rtype), opright.reg, &opleft); + } else if (ispostincrementopportunity(left, &opleft, &incval)) { + indirect(&opleft, expr); + store(opright.reg, &opleft, type); + add_register_immediate(opleft.reg, opleft.reg, incval); + } else { + GEN_NODE(left, &opleft); + indirect(&opleft, expr); + store(opright.reg, &opleft, type); + } + + output->optype = OpndType_GPR; + output->reg = opright.reg; + return; + } + + GEN_NODE(right, &opright); + GEN_NODE(left, output); + + indirect(output, expr); + if (output->object) { + if (output->object->datatype == DLOCAL && (output->object->u.var.info->flags & VarInfoFlag1)) + align = CMach_ArgumentAlignment(type); + else + align = CMach_AllocationAlignment(type, output->object->qual); + } else { + align = CMach_AllocationAlignment(type, 0); + } + if (opright.object) { + if (opright.object->datatype == DLOCAL && (opright.object->u.var.info->flags & VarInfoFlag1)) + align2 = CMach_ArgumentAlignment(type); + else + align2 = CMach_AllocationAlignment(type, opright.object->qual); + } else { + align2 = CMach_AllocationAlignment(type, 0); + } + + if (align2 < align) + align = align2; + + move_block(output, &opright, type->size, align); +} + +ENode *evaluate_and_skip_comma(ENode *expr) { + Operand op; + ENode *inner; + + memclrw(&op, sizeof(Operand)); + while (ENODE_IS(expr, ECOMMA)) { + inner = expr->data.diadic.left; + GEN_NODE(inner, &op); + if (ENODE_IS(inner, EINDIRECT) && (op.flags & OpndFlags_Volatile)) { + if (TYPE_FITS_IN_REGISTER_2(inner->rtype)) { + ENSURE_GPR(&op, inner->rtype, 0); + } else if (IS_TYPE_FLOAT(inner->rtype)) { + ENSURE_FPR(&op, inner->rtype, 0); + } + } + expr = expr->data.diadic.right; + } + return expr; +} + +void gen_COMMA(ENode *expr, short outputReg, short outputRegHi, Operand *output) { + ENode *left; + ENode *right; + + left = expr->data.diadic.left; + right = expr->data.diadic.right; + GEN_NODE(left, output); + + if (ENODE_IS(left, EINDIRECT) && (output->flags & OpndFlags_Volatile)) { + if (TYPE_FITS_IN_REGISTER_2(left->rtype)) { + ENSURE_GPR(output, left->rtype, 0); + } else if (IS_TYPE_FLOAT(left->rtype)) { + ENSURE_FPR(output, left->rtype, 0); + } + } + + GEN_NODE_TO_REG(right, outputReg, 0, output); +} + +void gen_TYPCON(ENode *expr, short outputReg, short outputRegHi, Operand *output) { + ENode *inner; + Type *srctype; + Type *dsttype; + + inner = expr->data.monadic; + srctype = inner->rtype; + dsttype = expr->rtype; + + if (TYPE_IS_8BYTES(srctype) || TYPE_IS_8BYTES(dsttype)) { + I8_gen_TYPCON(expr, outputReg, outputRegHi, output); + return; + } + + if (IS_TYPE_VOID(dsttype)) { + GEN_NODE(inner, output); + if (ENODE_IS(inner, EINDIRECT) && (output->flags & OpndFlags_Volatile)) { + if (TYPE_FITS_IN_REGISTER_2(srctype)) { + ENSURE_GPR(output, srctype, 0); + } else if (IS_TYPE_FLOAT(srctype)) { + ENSURE_FPR(output, srctype, 0); + } + } + } else if (IS_TYPE_INT_OR_ENUM(srctype)) { + if (IS_TYPE_FLOAT(dsttype)) { + GEN_NODE(inner, output); + if (srctype->size < 4) + extend32(output, srctype, 0); + ENSURE_GPR(output, srctype, 0); + + if (is_unsigned(srctype)) + convert_unsigned_to_floating(output, dsttype->size == 4, outputReg); + else + convert_integer_to_floating(output, dsttype->size == 4, outputReg); + } else if (IS_TYPE_VECTOR(dsttype)) { + GEN_NODE_TO_REG(inner, outputReg, 0, output); + ENSURE_VR(output, dsttype, outputReg); + } else if ( + srctype->size < dsttype->size && + !ENODE_IS_INDIRECT_TO(inner, EBITFIELD) && + !ENODE_IS_ASSIGN_TO(inner, EBITFIELD) && + !(ENODE_IS_RANGE(inner, EPOSTINC, EPREDEC) && ENODE_IS(inner->data.monadic->data.monadic, EBITFIELD)) + ) { + GEN_NODE(inner, output); + extend32(output, srctype, outputReg); + } else if (dsttype->size < srctype->size || dsttype->size < 4) { + GEN_NODE(inner, output); + ENSURE_GPR(output, srctype, 0); + extend32(output, dsttype, outputReg); + } else { + GEN_NODE_TO_REG(inner, outputReg, 0, output); + } + } else if (IS_TYPE_POINTER(srctype)) { + GEN_NODE_TO_REG(inner, outputReg, 0, output); + if (dsttype->size < srctype->size) + ENSURE_GPR(output, srctype, outputReg); + } else if (IS_TYPE_FLOAT(srctype)) { + if (IS_TYPE_FLOAT(dsttype)) { + GEN_NODE_TO_REG(inner, outputReg, 0, output); + ENSURE_FPR(output, srctype, outputReg); + + if (dsttype->size == 4 && srctype->size != 4) { + int tmp = outputReg ? outputReg : ALLOC_FPR(); + emitpcode(PC_FRSP, tmp, output->reg); + output->optype = OpndType_FPR; + output->reg = tmp; + } + } else if (is_unsigned(dsttype) && dsttype->size == 4) { + GEN_NODE_TO_REG(inner, 1, 0, output); + ENSURE_FPR(output, srctype, 1); + convert_floating_to_unsigned(output, outputReg); + } else { + GEN_NODE_TO_REG(inner, 0, 0, output); + ENSURE_FPR(output, srctype, 0); + convert_floating_to_integer(output, outputReg); + } + } else if (IS_TYPE_VECTOR(srctype) && IS_TYPE_VECTOR(dsttype)) { + GEN_NODE_TO_REG(inner, outputReg, 0, output); + ENSURE_VR(output, srctype, outputReg); + } else if (srctype->size == dsttype->size) { + GEN_NODE_TO_REG(inner, outputReg, 0, output); + } else { +#line 2224 + CError_FATAL(); + } +} + +void gen_BITFIELD(ENode *expr, short outputReg, short outputRegHi, Operand *output) { +#line 2238 + CError_FATAL(); +} + +void gen_INTCONST(ENode *expr, short outputReg, short outputRegHi, Operand *output) { + if (TYPE_IS_8BYTES(expr->rtype)) { + I8_gen_INTCONST(expr, outputReg, outputRegHi, output); + return; + } + + output->optype = OpndType_Absolute; + output->immediate = CInt64_GetULong(&expr->data.intval); +} + +void gen_FLOATCONST(ENode *expr, short outputReg, short outputRegHi, Operand *output) { +#line 2294 + CError_FATAL(); +} + +void gen_STRINGCONST(ENode *expr, short outputReg, short outputRegHi, Operand *output) { +#line 2308 + CError_FATAL(); +} + +static Boolean COND_is_ABS_MatchNodes(ENode *cond, ENode *expr1, ENode *expr2) { + if (cond->type != expr1->type || cond->type != expr2->type) + return 0; + + if (!(TYPE_FITS_IN_REGISTER(cond->rtype) && TYPE_FITS_IN_REGISTER(expr1->rtype) && TYPE_FITS_IN_REGISTER(expr2->rtype))) + return 0; + + if (cond->rtype->size != expr1->rtype->size || cond->rtype->size != expr2->rtype->size) + return 0; + + switch (cond->type) { + case EOBJREF: + if (cond->data.objref != expr1->data.objref || cond->data.objref != expr2->data.objref) + return 0; + return 1; + case EINDIRECT: + case ETYPCON: + return COND_is_ABS_MatchNodes(cond->data.monadic, expr1->data.monadic, expr2->data.monadic); + default: + return 0; + } +} + +static ENode *COND_is_ABS(ENode *cond, ENode *expr1, ENode *expr2) { + ENode *tmp; + + int parity = 0; + while (ENODE_IS(cond, ELOGNOT)) { + parity = (parity + 1) & 1; + cond = cond->data.monadic; + } + + if (parity) { + tmp = expr1; + expr1 = expr2; + expr2 = tmp; + } + + switch (cond->type) { + case ELESS: + case ELESSEQU: + tmp = expr1; + expr1 = expr2; + expr2 = tmp; + break; + case EGREATER: + case EGREATEREQU: + break; + default: + return NULL; + } + + if (IS_INT_CONST_ZERO(cond->data.diadic.right)) { + cond = cond->data.diadic.left; + } else if (IS_INT_CONST_ZERO(cond->data.diadic.left)) { + cond = cond->data.diadic.left; + tmp = expr1; + expr1 = expr2; + expr2 = tmp; + } else { + return NULL; + } + + if (ENODE_IS(expr1, EADD) && ENODE_IS(expr2, ESUB)) { + if (COND_is_ABS_MatchNodes(cond, expr1->data.diadic.right, expr2->data.diadic.right)) + return expr1; + else + return NULL; + } + + if (!ENODE_IS(expr2, EMONMIN)) + return NULL; + + expr2 = expr2->data.monadic; + if (COND_is_ABS_MatchNodes(cond, expr1, expr2)) + return expr1; + + return NULL; +} + +static int COND_has_const(ENode *expr1, ENode *expr2) { + SInt32 diff; + int result = 0; + + if (IS_INT_CONST(expr1)) + result += 1; + if (IS_INT_CONST(expr2)) + result += 2; + + if (result & 1) { + if (IS_INT_CONST_ZERO(expr1)) + return 5; + } + if (result & 2) { + if (IS_INT_CONST_ZERO(expr2)) + return 6; + } + + if (result == 3) { + diff = expr1->data.intval.lo - expr2->data.intval.lo; + if (diff == 1 || diff == -1) + return 4; + } + + return result; +} + +static Boolean COND_is_COMPARE(ENode *cond, ENode *expr1, ENode *expr2, short outputReg, Operand *output) { + SInt32 left; + SInt32 right; + int parity; + int negate; + ENodeType nt; + + while (ENODE_IS(expr1, ETYPCON) && TYPE_FITS_IN_REGISTER(expr1->rtype)) + expr1 = expr1->data.monadic; + while (ENODE_IS(expr2, ETYPCON) && TYPE_FITS_IN_REGISTER(expr2->rtype)) + expr2 = expr2->data.monadic; + + if (!(ENODE_IS(expr1, EINTCONST) && TYPE_FITS_IN_REGISTER(expr1->rtype) && CInt64_IsInRange(expr1->data.intval, 4))) + return 0; + if (!(ENODE_IS(expr2, EINTCONST) && TYPE_FITS_IN_REGISTER(expr2->rtype) && CInt64_IsInRange(expr2->data.intval, 4))) + return 0; + + left = CInt64_GetULong(&expr1->data.intval); + right = CInt64_GetULong(&expr2->data.intval); + parity = 0; + negate = 0; + switch (left) { + case 1: + if (right != 0) + return 0; + break; + case 0: + parity = 1; + if (right == -1) + negate = 1; + else if (right != 1) + return 0; + break; + case -1: + if (right != 0) + return 0; + negate = 1; + break; + default: + return 0; + } + + while (ENODE_IS(cond, ELOGNOT)) { + parity = (parity + 1) & 1; + cond = cond->data.monadic; + } + + if (parity) { + nt = invert_relop(cond->type); + if (nt == cond->type) + return 0; + cond->type = nt; + } + + if (negate) + gen_negated_condition_gpr(cond, output, outputReg); + else + gen_condition_gpr(cond, output, outputReg); + + return 1; +} + +void gen_COND(ENode *expr, short outputReg, short outputRegHi, Operand *output) { + ENode *cond; + ENode *expr1; + ENode *expr2; + Type *type; + PCodeLabel *label1; + PCodeLabel *label2; + PCodeLabel *label3; + Operand op1; + Operand op2; + int has_const; + int reg1; + int reg2; + int reg3; + short align; + short max_align; + + expr1 = expr->data.cond.expr1; + expr2 = expr->data.cond.expr2; + type = expr->rtype; + + label1 = makepclabel(); + label2 = makepclabel(); + label3 = makepclabel(); + + memclrw(&op1, sizeof(Operand)); + memclrw(&op2, sizeof(Operand)); + + cond = evaluate_and_skip_comma(expr->data.cond.cond); + + if (TOC_use_fsel(expr)) { + ENode *left; + ENode *right; + ENode *tmp; + ENodeType nt; + Boolean flag; + Operand op; + int fneg_reg; + int fsel_reg; + int final_reg; + + left = cond->data.diadic.left; + right = cond->data.diadic.right; + nt = cond->type; + flag = 0; + memclrw(&op, sizeof(Operand)); + + switch (nt) { + case EGREATEREQU: + case EEQU: + break; + case EGREATER: + tmp = left; + left = right; + right = tmp; + case ELESS: + case ENOTEQU: + tmp = expr1; + expr1 = expr2; + expr2 = tmp; + break; + case ELESSEQU: + tmp = left; + left = right; + right = tmp; + break; + default: +#line 2780 + CError_FATAL(); + } + + if (ENODE_IS(left, EFLOATCONST) && CMach_FloatIsZero(left->data.floatval)) { + GEN_NODE(right, &op); + ENSURE_FPR(&op, right->rtype, 0); + flag = 1; + } else if (ENODE_IS(right, EFLOATCONST) && CMach_FloatIsZero(right->data.floatval)) { + GEN_NODE(left, &op); + ENSURE_FPR(&op, left->rtype, 0); + } else { + fp_binary_operator((type->size == 4) ? PC_FSUBS : PC_FSUB, left, right, 0, &op); + } + + switch (cond->type) { + case EEQU: + case ENOTEQU: + if (flag) { + GEN_NODE_TO_FPR(expr1, &op1, expr1->rtype, 0); + GEN_NODE_TO_FPR(expr2, &op2, expr2->rtype, 0); + + fneg_reg = ALLOC_FPR(); + emitpcode(PC_FNEG, fneg_reg, op.reg); + fsel_reg = ALLOC_FPR(); + emitpcode(PC_FSEL, fsel_reg, op.reg, op1.reg, op2.reg); + final_reg = outputReg ? outputReg : ALLOC_FPR(); + emitpcode(PC_FSEL, final_reg, fneg_reg, fsel_reg, op2.reg); + } else { + GEN_NODE_TO_FPR(expr1, &op1, expr1->rtype, 0); + GEN_NODE_TO_FPR(expr2, &op2, expr2->rtype, 0); + + fneg_reg = ALLOC_FPR(); + emitpcode(PC_FNEG, fneg_reg, op.reg); + fsel_reg = ALLOC_FPR(); + emitpcode(PC_FSEL, fsel_reg, op.reg, op1.reg, op2.reg); + final_reg = outputReg ? outputReg : ALLOC_FPR(); + emitpcode(PC_FSEL, final_reg, fneg_reg, fsel_reg, op2.reg); + } + break; + case ELESS: + case EGREATER: + case ELESSEQU: + case EGREATEREQU: + GEN_NODE_TO_FPR(expr1, &op1, expr1->rtype, 0); + GEN_NODE_TO_FPR(expr2, &op2, expr2->rtype, 0); + + fneg_reg = op.reg; + if (flag) { + fneg_reg = ALLOC_FPR(); + emitpcode(PC_FNEG, fneg_reg, op.reg); + } + + final_reg = outputReg ? outputReg : ALLOC_FPR(); + emitpcode(PC_FSEL, final_reg, fneg_reg, op1.reg, op2.reg); + break; + default: +#line 2862 + CError_FATAL(); + } + + output->optype = OpndType_FPR; + output->reg = final_reg; + return; + } + + if (TOC_use_isel(expr, 1)) { + Operand isel_op1; + Operand isel_op2; + ENode *x; + ENode *y; + ENode *abs_expr; + + memclrw(&isel_op1, sizeof(Operand)); + memclrw(&isel_op2, sizeof(Operand)); + + if (COND_is_COMPARE(cond, expr1, expr2, outputReg, output)) + return; + + if ((abs_expr = COND_is_ABS(cond, expr1, expr2))) { + if (ENODE_IS(expr1, EADD) && ENODE_IS(expr2, ESUB)) { + x = expr1->data.diadic.left; + y = expr2->data.diadic.right; + if (y->hascall) { + GEN_NODE(y, &op2); + ENSURE_GPR(&op2, y->rtype, 0); + + GEN_NODE(x, &op1); + if (op1.optype >= OpndType_IndirectGPR_ImmOffset) + ENSURE_GPR(&op1, x->rtype, 0); + } else { + GEN_NODE(x, &op1); + if (op1.optype >= OpndType_IndirectGPR_ImmOffset) + ENSURE_GPR(&op1, x->rtype, 0); + + GEN_NODE(y, &op2); + ENSURE_GPR(&op2, y->rtype, 0); + } + + reg1 = ALLOC_GPR(); + emitpcode(PC_SRAWI, reg1, op2.reg, 31); + reg2 = ALLOC_GPR(); + emitpcode(PC_XOR, reg2, reg1, op2.reg); + reg3 = ALLOC_GPR(); + emitpcode(PC_SUBF, reg3, reg1, reg2); + op2.optype = OpndType_GPR; + op2.reg = reg3; + combine(&op1, &op2, outputReg, output); + } else { + GEN_NODE(abs_expr, output); + ENSURE_GPR(output, abs_expr->rtype, 0); + + reg1 = ALLOC_GPR(); + emitpcode(PC_SRAWI, reg1, output->reg, 31); + reg2 = ALLOC_GPR(); + emitpcode(PC_XOR, reg2, reg1, output->reg); + reg3 = outputReg ? outputReg : ALLOC_GPR(); + emitpcode(PC_SUBF, reg3, reg1, reg2); + op2.optype = OpndType_GPR; + op2.reg = reg3; + } + return; + } + + if ((has_const = COND_has_const(expr1, expr2))) { + switch (COND_has_const(expr1, expr2)) { + case 0: + case 2: + break; + case 3: + case 4: + if (has_const == 4) { + if (expr1->data.intval.lo < expr2->data.intval.lo) + gen_negated_condition_gpr(cond, &isel_op1, 0); + else + gen_condition_gpr(cond, &isel_op1, 0); + + GEN_NODE(expr1, &op1); + GEN_NODE(expr2, &op2); + reg1 = ALLOC_GPR(); + ENSURE_GPR(&op2, expr2->rtype, reg1); + emitpcode(PC_ADD, reg1, isel_op1.reg, op2.reg); + if (outputReg) { + emitpcode(PC_MR, reg2 = outputReg, reg1); + reg1 = reg2; + } + output->optype = OpndType_GPR; + output->reg = reg1; + return; + } + break; + case 5: + case 6: + gen_negated_condition_gpr(cond, &isel_op1, 0); + ENSURE_GPR(&isel_op1, TYPE(&stunsignedint), 0); + GEN_NODE(expr1, &op1); + GEN_NODE(expr2, &op2); + + reg1 = outputReg ? outputReg : ALLOC_GPR(); + if (op1.optype == OpndType_Absolute && op1.immediate == 0) { + ENSURE_GPR(&op2, expr2->rtype, 0); + emitpcode(PC_ANDC, reg1, op2.reg, isel_op1.reg); + } else if (op2.optype == OpndType_Absolute && op2.immediate == 0) { + ENSURE_GPR(&op1, expr1->rtype, 0); + emitpcode(PC_AND, reg1, op1.reg, isel_op1.reg); + } else { +#line 3119 + CError_FATAL(); + } + + output->optype = OpndType_GPR; + output->reg = reg1; + return; + case 1: + reg2 = ALLOC_GPR(); + reg1 = reg2; + logical_expression_nobranch(cond, 0, &isel_op2); + + GEN_NODE_TO_REG(expr1, reg1, 0, &op1); + ENSURE_GPR(&op1, expr1->rtype, reg1); + if (op1.reg != reg1) + emitpcode(PC_MR, reg1, op1.reg); + + branch_conditional(isel_op2.reg, isel_op2.regOffset, 1, label2); + branch_label(label1); + + GEN_NODE_TO_REG(expr2, reg1, 0, &op2); + ENSURE_GPR(&op2, expr2->rtype, reg1); + if (op2.reg != reg1) + emitpcode(PC_MR, reg1, op2.reg); + + branch_label(label2); + + if (outputReg) { + emitpcode(PC_MR, reg2 = outputReg, reg1); + reg1 = reg2; + } + + output->optype = OpndType_GPR; + output->reg = reg1; + return; + + default: +#line 3168 + CError_FATAL(); + } + } + + reg1 = ALLOC_GPR(); + logical_expression_nobranch(cond, 0, &isel_op2); + + GEN_NODE_TO_REG(expr2, reg1, 0, &op2); + ENSURE_GPR(&op2, expr2->rtype, reg1); + if (op2.reg != reg1) + emitpcode(PC_MR, reg1, op2.reg); + + branch_conditional(isel_op2.reg, isel_op2.regOffset, 0, label2); + branch_label(label1); + + GEN_NODE_TO_REG(expr1, reg1, 0, &op1); + ENSURE_GPR(&op1, expr1->rtype, reg1); + if (op1.reg != reg1) + emitpcode(PC_MR, reg1, op1.reg); + + branch_label(label2); + + if (outputReg) { + emitpcode(PC_MR, reg2 = outputReg, reg1); + reg1 = reg2; + } + + output->optype = OpndType_GPR; + output->reg = reg1; + return; + } + + logical_expression(cond, label1, label2, label1); + branch_label(label1); + + if (IS_TYPE_VOID(type) || expr->ignored) { + GEN_NODE(expr1, &op1); + branch_always(label3); + branch_label(label2); + GEN_NODE(expr2, &op2); + } else if (IS_TYPE_FLOAT(type)) { + if (expr1->hascall || expr2->hascall) + reg1 = ALLOC_FPR(); + else + reg1 = outputReg ? outputReg : ALLOC_FPR(); + + GEN_NODE_TO_REG(expr1, reg1, 0, &op1); + ENSURE_FPR(&op1, expr1->rtype, reg1); + if (op1.reg != reg1) + emitpcode(PC_FMR, reg1, op1.reg); + + branch_always(label3); + branch_label(label2); + + GEN_NODE_TO_REG(expr2, reg1, 0, &op2); + ENSURE_FPR(&op2, expr2->rtype, reg1); + if (op2.reg != reg1) + emitpcode(PC_FMR, reg1, op2.reg); + + output->optype = OpndType_FPR; + output->reg = reg1; + } else if (TYPE_IS_8BYTES(type)) { + if (expr1->hascall || expr2->hascall) { + reg1 = ALLOC_GPR(); + reg3 = ALLOC_GPR(); + reg2 = reg3; + } else { + reg1 = outputReg ? outputReg : ALLOC_GPR(); + reg3 = outputRegHi ? outputRegHi : ALLOC_GPR(); + reg2 = reg3; + } + + GEN_NODE_TO_REG(expr1, reg1, reg2, &op1); + coerce_to_register_pair(&op1, expr1->rtype, reg1, reg2); + + branch_always(label3); + branch_label(label2); + + GEN_NODE_TO_REG(expr2, reg1, reg2, &op2); + coerce_to_register_pair(&op2, expr2->rtype, reg1, reg2); + + output->optype = OpndType_GPRPair; + output->reg = reg1; + output->regHi = reg2; + } else if (TYPE_FITS_IN_REGISTER(type)) { + if (expr1->hascall || expr2->hascall) + reg1 = ALLOC_GPR(); + else + reg1 = outputReg ? outputReg : ALLOC_GPR(); + + GEN_NODE_TO_REG(expr1, reg1, 0, &op1); + ENSURE_GPR(&op1, expr1->rtype, reg1); + if (op1.reg != reg1) + emitpcode(PC_MR, reg1, op1.reg); + + branch_always(label3); + branch_label(label2); + + GEN_NODE_TO_REG(expr2, reg1, 0, &op2); + ENSURE_GPR(&op2, expr2->rtype, reg1); + if (op2.reg != reg1) + emitpcode(PC_MR, reg1, op2.reg); + + output->optype = OpndType_GPR; + output->reg = reg1; + } else if (IS_TYPE_VECTOR(type)) { + if (expr1->hascall || expr2->hascall) + reg1 = ALLOC_VR(); + else + reg1 = outputReg ? outputReg : ALLOC_VR(); + + GEN_NODE_TO_REG(expr1, reg1, 0, &op1); + ENSURE_VR(&op1, expr1->rtype, reg1); + if (op1.reg != reg1) + emitpcode(PC_VMR, reg1, op1.reg); + + branch_always(label3); + branch_label(label2); + + GEN_NODE_TO_REG(expr2, reg1, 0, &op2); + ENSURE_VR(&op2, expr2->rtype, reg1); + if (op2.reg != reg1) + emitpcode(PC_VMR, reg1, op2.reg); + + output->optype = OpndType_VR; + output->reg = reg1; + } else { + symbol_operand(output, maketemporary(type)); + indirect(output, NULL); + coerce_to_addressable(output); + + GEN_NODE(expr1, &op1); + + if (op1.object) { + if (op1.object->datatype == DLOCAL && (op1.object->u.var.info->flags & VarInfoFlag1)) + align = CMach_ArgumentAlignment(type); + else + align = CMach_AllocationAlignment(type, op1.object->qual); + } else { + align = CMach_AllocationAlignment(type, 0); + } + + max_align = CMach_AllocationAlignment(type, 0); + if (align > max_align) + align = max_align; + + move_block(output, &op1, type->size, align); + + branch_always(label3); + branch_label(label2); + + GEN_NODE(expr2, &op2); + + if (op2.object) { + if (op2.object->datatype == DLOCAL && (op2.object->u.var.info->flags & VarInfoFlag1)) + align = CMach_ArgumentAlignment(type); + else + align = CMach_AllocationAlignment(type, op2.object->qual); + } else { + align = CMach_AllocationAlignment(type, 0); + } + + if (align > max_align) + align = max_align; + + move_block(output, &op2, type->size, align); + } + + branch_label(label3); +} + +static Boolean CONDASS_is_ABS(ENode *cond, ENode *expr1, ENode *expr2) { + ENode *inner; + + int parity = 0; + while (ENODE_IS(cond, ELOGNOT)) { + parity = (parity + 1) & 1; + cond = cond->data.monadic; + } + + if (IS_INT_CONST_ZERO(cond->data.diadic.right)) { + inner = cond->data.diadic.left; + } else if (IS_INT_CONST_ZERO(cond->data.diadic.left)) { + inner = cond->data.diadic.left; + parity = (parity + 1) & 1; + } else { + return 0; + } + + switch (cond->type) { + case EGREATER: + case EGREATEREQU: + if (!parity) + return 0; + break; + case ELESS: + case ELESSEQU: + if (parity) + return 0; + break; + default: + return 0; + } + + if (!ENODE_IS(expr2, EMONMIN)) + return 0; + + expr2 = expr2->data.monadic; + if (ENODE_IS(inner, EASS)) { + inner = inner->data.diadic.left; + if (!ENODE_IS(expr2, EINDIRECT)) + return 0; + expr2 = expr2->data.monadic; + if (!ENODE_IS(expr1, EINDIRECT)) + return 0; + expr1 = expr1->data.monadic; + } + + return COND_is_ABS_MatchNodes(inner, expr1, expr2); +} + +static int CONDASS_is_OPASS_One(ENode *a, ENode *b, SInt32 *value, ENodeType *nodetype) { + Type *type; + + type = a->rtype; + if (!ENODE_IS(a, EINDIRECT)) + return 0; + a = a->data.monadic; + if (!ENODE_IS(a, EOBJREF)) + return 0; + + if (ENODE_IS(b, ETYPCON) && b->rtype == type) + b = b->data.monadic; + + if (b->type != EOR && b->type != EADD && b->type != ESUB) + return 0; + + *nodetype = b->type; + if (!IS_INT_CONST(b->data.diadic.right)) + return 0; + *value = b->data.diadic.right->data.intval.lo; + + if (*value != 1 && *value != -1) + return 0; + + b = b->data.diadic.left; + if (ENODE_IS(b, ETYPCON) && TYPE_FITS_IN_REGISTER(b->rtype)) + b = b->data.monadic; + + if (!ENODE_IS(b, EINDIRECT)) + return 0; + b = b->data.monadic; + if (!ENODE_IS(b, EOBJREF)) + return 0; + + if (a->data.objref == b->data.objref) + return 1; + return 0; +} + +void gen_CONDASS(ENode *expr, short outputReg, short outputRegHi, Operand *output) { + ENode *cond; + ENode *expr1; + ENode *expr2; + Type *type; + PCodeLabel *label1; + PCodeLabel *label2; + Operand op1; + Operand op2; + Operand op3; + int reg1; + int reg2; + + expr1 = expr->data.cond.expr1; + expr2 = expr->data.cond.expr2; + type = expr->rtype; + + label1 = makepclabel(); + label2 = makepclabel(); + + memclrw(&op1, sizeof(Operand)); + memclrw(&op2, sizeof(Operand)); + memclrw(&op3, sizeof(Operand)); + + cond = evaluate_and_skip_comma(expr->data.cond.cond); + + if (TOC_use_fsel(expr)) { + ENode *left; + ENode *right; + ENode *tmp; + ENodeType nt; + Boolean flag; + Boolean flag2; + Operand op; + int tmpreg; + int fneg_reg; + int fsel_reg; + int final_reg; + + left = cond->data.diadic.left; + right = cond->data.diadic.right; + nt = cond->type; + flag = 0; + memclrw(&op, sizeof(Operand)); + +#line 3704 + CError_ASSERT(ENODE_IS(expr1, EINDIRECT)); + CError_ASSERT(ENODE_IS(expr1->data.monadic, EOBJREF)); + + tmpreg = OBJECT_REG(expr1->data.monadic->data.objref); + final_reg = outputReg ? tmpreg : ALLOC_FPR(); + + switch (nt) { + case EGREATER: + tmp = left; + left = right; + right = tmp; + case ELESS: + case ENOTEQU: + tmp = expr1; + expr1 = expr2; + expr2 = tmp; + flag2 = 1; + break; + case ELESSEQU: + tmp = left; + left = right; + right = tmp; + flag2 = 0; + break; + case EGREATEREQU: + case EEQU: + flag2 = 0; + break; + default: +#line 3744 + CError_FATAL(); + } + + if (ENODE_IS(left, EFLOATCONST) && CMach_FloatIsZero(left->data.floatval)) { + GEN_NODE(right, &op); + ENSURE_FPR(&op, right->rtype, 0); + flag = 1; + } else if (ENODE_IS(right, EFLOATCONST) && CMach_FloatIsZero(right->data.floatval)) { + GEN_NODE(left, &op); + ENSURE_FPR(&op, left->rtype, 0); + } else { + fp_binary_operator((type->size == 4) ? PC_FSUBS : PC_FSUB, left, right, 0, &op); + } + + switch (cond->type) { + case EEQU: + case ENOTEQU: + if (flag) { + GEN_NODE(expr1, &op1); + op3 = op1; + ENSURE_FPR(&op1, expr1->rtype, 0); + + GEN_NODE_TO_FPR(expr2, &op2, expr2->rtype, 0); + + fneg_reg = ALLOC_FPR(); + emitpcode(PC_FNEG, fneg_reg, op.reg); + fsel_reg = ALLOC_FPR(); + emitpcode(PC_FSEL, fsel_reg, op.reg, op2.reg, op1.reg); + emitpcode(PC_FSEL, final_reg, fneg_reg, op2.reg, fsel_reg); + } else { + GEN_NODE(expr1, &op1); + op3 = op1; + ENSURE_FPR(&op1, expr1->rtype, 0); + + GEN_NODE_TO_FPR(expr2, &op2, expr2->rtype, 0); + + fneg_reg = ALLOC_FPR(); + emitpcode(PC_FNEG, fneg_reg, op.reg); + fsel_reg = ALLOC_FPR(); + emitpcode(PC_FSEL, fsel_reg, op.reg, op2.reg, op1.reg); + emitpcode(PC_FSEL, final_reg, fneg_reg, op2.reg, fsel_reg); + } + break; + case ELESS: + case EGREATER: + case ELESSEQU: + case EGREATEREQU: + GEN_NODE(expr1, &op1); + GEN_NODE(expr2, &op2); + op3 = flag2 ? op2 : op1; + + ENSURE_FPR(&op1, expr1->rtype, 0); + ENSURE_FPR(&op2, expr2->rtype, 0); + + fneg_reg = op.reg; + if (flag) { + fneg_reg = ALLOC_FPR(); + emitpcode(PC_FNEG, fneg_reg, op.reg); + } + + emitpcode(PC_FSEL, final_reg, fneg_reg, op2.reg, op1.reg); + break; + default: +#line 2862 + CError_FATAL(); + } + + if (op3.optype != OpndType_FPR) + store_fp(final_reg, &op3, type); + + output->optype = OpndType_FPR; + output->reg = final_reg; + return; + } + + if (TOC_use_isel(expr, 1)) { + Operand isel_op; + ENode *x; + ENode *y; + ENode *abs_expr; + + memclrw(&isel_op, sizeof(Operand)); +#line 3966 + CError_ASSERT(ENODE_IS(expr1, EINDIRECT)); +#line 3968 + CError_ASSERT(ENODE_IS(expr1->data.monadic, EOBJREF)); + + if (CONDASS_is_ABS(cond, expr1, expr2)) { + if (ENODE_IS(cond->data.diadic.left, EASS)) + GEN_NODE(cond->data.diadic.left, &isel_op); + else if (ENODE_IS(cond->data.diadic.right, EASS)) + GEN_NODE(cond->data.diadic.right, &isel_op); + + outputReg = OBJECT_REG(expr1->data.monadic->data.objref); +#line 3979 + CError_ASSERT(outputReg); + + GEN_NODE(expr1, &op1); + op3 = op1; + +#line 3986 + CError_ASSERT(op3.optype == OpndType_GPR && op3.reg == outputReg); + + ENSURE_GPR(&op1, expr1->rtype, 0); + if (expr1->rtype->size < 4) + extend32(output, expr1->rtype, op3.reg); + + reg1 = ALLOC_GPR(); + reg2 = ALLOC_GPR(); + emitpcode(PC_SRAWI, reg1, op1.reg, 31); + emitpcode(PC_XOR, reg2, reg1, op1.reg); + emitpcode(PC_SUBF, outputReg, reg1, reg2); + output->optype = OpndType_GPR; + output->reg = op3.reg; + + if (expr1->rtype->size < 4) + extend32(output, expr1->rtype, op3.reg); + + return; + } + } + + logical_expression(cond, label1, label2, label1); + branch_label(label1); + gen_ASS(expr, outputReg, outputRegHi, output); + branch_label(label2); +} + +void gen_FUNCCALL(ENode *expr, short outputReg, short outputRegHi, Operand *output) { +} + +void gen_OBJREF(ENode *expr, short outputReg, short outputRegHi, Operand *output) { + symbol_operand(output, expr->data.objref); +} + +void gen_UNEXPECTED(ENode *expr, short outputReg, short outputRegHi, Operand *output) { +#line 4160 + CError_FATAL(); +} + +static int small(ENode *expr) { + Type *type; + + type = expr->rtype; + if (!ENODE_IS(expr, ETYPCON)) + return 0; + + do { + expr = expr->data.monadic; + } while (ENODE_IS(expr, ETYPCON) && (type = expr->rtype)->size == 4); + + return IS_TYPE_INT_OR_ENUM(type) && ((type->size < 2) || (type->size == 2 && !is_unsigned(type))); +} + +void binary_operator(Opcode opcode, ENode *left, ENode *right, short outputReg, Operand *output) { + Operand opleft; + Operand opright; + int reg; + + memclrw(&opleft, sizeof(Operand)); + memclrw(&opright, sizeof(Operand)); + + if (right->hascall) { + GEN_NODE_TO_GPR(right, &opright, right->rtype, 0); + GEN_NODE_TO_GPR(left, &opleft, left->rtype, 0); + } else { + GEN_NODE_TO_GPR(left, &opleft, left->rtype, 0); + GEN_NODE_TO_GPR(right, &opright, right->rtype, 0); + } + + reg = outputReg ? outputReg : ALLOC_GPR(); + + if (opcode == PC_MULLW && small(left)) + emitpcode(opcode, reg, opright.reg, opleft.reg); + else + emitpcode(opcode, reg, opleft.reg, opright.reg); + + output->optype = OpndType_GPR; + output->reg = reg; +} + +static void binary_immediate(Opcode opcode, ENode *left, SInt32 value, short outputReg, Operand *output) { + Operand opleft; + int reg; + + memclrw(&opleft, sizeof(Operand)); + GEN_NODE_TO_GPR(left, &opleft, left->rtype, 0); + + reg = outputReg ? outputReg : ALLOC_GPR(); + + if (opcode == PC_MULLI && value == 0) + emitpcode(PC_LI, reg, 0); + else if (opcode == PC_MULLI && value == 1) + emitpcode(PC_MR, reg, opleft.reg); + else + emitpcode(opcode, reg, opleft.reg, value); + + output->optype = OpndType_GPR; + output->reg = reg; +} + +void unary_operator(Opcode opcode, ENode *expr, short outputReg, Operand *output) { + Operand op; + int reg; + + memclrw(&op, sizeof(Operand)); + GEN_NODE_TO_GPR(expr, &op, expr->rtype, 0); + + reg = outputReg ? outputReg : ALLOC_GPR(); + emitpcode(opcode, reg, op.reg); + + output->optype = OpndType_GPR; + output->reg = reg; +} + +static void or_xor_immediate(Opcode opcode, ENode *expr, SInt32 value, short outputReg, Operand *output) { + Operand op; + int reg; + + memclrw(&op, sizeof(Operand)); + GEN_NODE_TO_GPR(expr, &op, expr->rtype, 0); + + reg = outputReg ? outputReg : ALLOC_GPR(); + + if (expr->rtype->size > 2 && value != (value & 0xFFFF)) { + if (value & 0xFFFF) { + emitpcode((opcode == PC_ORI) ? PC_ORIS : PC_XORIS, reg, op.reg, value >> 16); + emitpcode(opcode, reg, reg, value & 0xFFFF); + } else { + emitpcode((opcode == PC_ORI) ? PC_ORIS : PC_XORIS, reg, op.reg, value >> 16); + } + } else { + emitpcode(opcode, reg, op.reg, value & 0xFFFF); + } + + output->optype = OpndType_GPR; + output->reg = reg; +} + +static void shift_left_immediate(ENode *expr, short shift, short negate, short outputReg, Operand *output) { + Operand op; + int reg; + + memclrw(&op, sizeof(Operand)); + GEN_NODE_TO_GPR(expr, &op, expr->rtype, 0); + + if (negate) + reg = ALLOC_GPR(); + else + reg = outputReg ? outputReg : ALLOC_GPR(); + + emitpcode(PC_RLWINM, reg, op.reg, shift & 31, 0, 31 - (shift & 31)); + + if (negate) { + int tmp = outputReg ? outputReg : ALLOC_GPR(); + emitpcode(PC_NEG, tmp, reg); + reg = tmp; + } + + output->optype = OpndType_GPR; + output->reg = reg; +} + +static void shift_right_immediate(ENode *expr, Type *type, short shift, short outputReg, Operand *output) { + Operand op; + int reg; + + memclrw(&op, sizeof(Operand)); + GEN_NODE_TO_GPR(expr, &op, expr->rtype, 0); + + reg = outputReg ? outputReg : ALLOC_GPR(); + + if (is_unsigned(type)) + emitpcode(PC_RLWINM, reg, op.reg, (32 - (shift & 31)) & 31, (shift & 31) + (32 - (type->size * 8)), 31); + else + emitpcode(PC_SRAWI, reg, op.reg, shift & 31); + + output->optype = OpndType_GPR; + output->reg = reg; +} + +static void signed_divide_by_power_of_2(ENode *expr, int shift, int negate, short outputReg, Operand *output) { + Operand op; + int reg; + int tmpreg1; + int tmpreg2; + + memclrw(&op, sizeof(Operand)); + GEN_NODE_TO_GPR(expr, &op, expr->rtype, 0); + + if (!copts.optimize_for_size && shift == 1) { + tmpreg1 = ALLOC_GPR(); + emitpcode(PC_RLWINM, tmpreg1, op.reg, 1, 31, 31); + tmpreg2 = ALLOC_GPR(); + emitpcode(PC_ADD, tmpreg2, tmpreg1, op.reg); + reg = (outputReg && !negate) ? outputReg : ALLOC_GPR(); + emitpcode(PC_SRAWI, reg, tmpreg2, 1); + } else { + tmpreg1 = ALLOC_GPR(); + emitpcode(PC_SRAWI, tmpreg1, op.reg, shift); + reg = (outputReg && !negate) ? outputReg : ALLOC_GPR(); + emitpcode(PC_ADDZE, reg, tmpreg1); + } + + if (negate) { + int prevreg = reg; + reg = outputReg ? outputReg : ALLOC_GPR(); + emitpcode(PC_NEG, reg, prevreg); + } + + output->optype = OpndType_GPR; + output->reg = reg; +} + +static void signed_mod_by_power_of_2(ENode *expr, int shift, int negate, short outputReg, Operand *output) { + Operand op; + int reg; + int tmpreg1; + int tmpreg2; + int tmpreg3; + int tmpreg4; + + memclrw(&op, sizeof(Operand)); + GEN_NODE_TO_GPR(expr, &op, expr->rtype, 0); + + reg = outputReg ? outputReg : ALLOC_GPR(); + tmpreg1 = ALLOC_GPR(); + tmpreg2 = ALLOC_GPR(); + tmpreg3 = ALLOC_GPR(); + + if (shift == 1) { + emitpcode(PC_RLWINM, tmpreg1, op.reg, 1, 31, 31); + emitpcode(PC_RLWINM, tmpreg2, op.reg, 0, 31, 31); + emitpcode(PC_XOR, tmpreg3, tmpreg2, tmpreg1); + emitpcode(PC_SUBF, reg, tmpreg1, tmpreg3); + } else { + tmpreg4 = ALLOC_GPR(); + emitpcode(PC_RLWINM, tmpreg1, op.reg, 32 - shift, 0, 31 - (32 - shift)); + emitpcode(PC_RLWINM, tmpreg2, op.reg, 1, 31, 31); + emitpcode(PC_SUBF, tmpreg3, tmpreg2, tmpreg1); + emitpcode(PC_RLWINM, tmpreg4, tmpreg3, shift, 0, 31); + emitpcode(PC_ADD, reg, tmpreg4, tmpreg2); + } + + output->optype = OpndType_GPR; + output->reg = reg; +} + +static void fp_binary_operator(Opcode opcode, ENode *left, ENode *right, short outputReg, Operand *output) { + Operand opleft; + Operand opright; + int reg; + + memclrw(&opleft, sizeof(Operand)); + memclrw(&opright, sizeof(Operand)); + + if (right->hascall) { + GEN_NODE_TO_FPR(right, &opright, right->rtype, 0); + GEN_NODE_TO_FPR(left, &opleft, left->rtype, 0); + } else { + GEN_NODE_TO_FPR(left, &opleft, left->rtype, 0); + GEN_NODE_TO_FPR(right, &opright, right->rtype, 0); + } + + reg = outputReg ? outputReg : ALLOC_FPR(); + emitpcode(opcode, reg, opleft.reg, opright.reg); + + output->optype = OpndType_FPR; + output->reg = reg; +} + +void fp_unary_operator(Opcode opcode, ENode *expr, short outputReg, Operand *output) { + Operand op; + int reg; + + memclrw(&op, sizeof(Operand)); + GEN_NODE_TO_FPR(expr, &op, expr->rtype, 0); + + reg = outputReg ? outputReg : ALLOC_FPR(); + emitpcode(opcode, reg, op.reg); + + output->optype = OpndType_FPR; + output->reg = reg; +} + +void fp_multiply_add(Opcode opcode, ENode *a, ENode *b, ENode *c, short outputReg, Operand *output) { + Operand opA; + Operand opB; + Operand opC; + int reg; + + memclrw(&opA, sizeof(Operand)); + memclrw(&opB, sizeof(Operand)); + memclrw(&opC, sizeof(Operand)); + + if (c->hascall) { + GEN_NODE_TO_FPR(c, &opC, c->rtype, 0); + if (b->hascall) { + GEN_NODE_TO_FPR(b, &opB, b->rtype, 0); + GEN_NODE_TO_FPR(a, &opA, a->rtype, 0); + } else { + GEN_NODE_TO_FPR(a, &opA, a->rtype, 0); + GEN_NODE_TO_FPR(b, &opB, b->rtype, 0); + } + } else { + if (b->hascall) { + GEN_NODE_TO_FPR(b, &opB, b->rtype, 0); + GEN_NODE_TO_FPR(a, &opA, a->rtype, 0); + GEN_NODE_TO_FPR(c, &opC, c->rtype, 0); + } else { + GEN_NODE_TO_FPR(a, &opA, a->rtype, 0); + GEN_NODE_TO_FPR(b, &opB, b->rtype, 0); + GEN_NODE_TO_FPR(c, &opC, c->rtype, 0); + } + } + + reg = outputReg ? outputReg : ALLOC_FPR(); + emitpcode(opcode, reg, opA.reg, opB.reg, opC.reg); + + output->optype = OpndType_FPR; + output->reg = reg; +} + +void gen_COMPARE(ENode *expr, short outputReg, short outputRegHi, Operand *output) { + expr = evaluate_and_skip_comma(expr); + if (TYPE_IS_8BYTES(expr->data.diadic.right->rtype) || TYPE_IS_8BYTES(expr->data.diadic.left->rtype)) + I8_gen_condition(expr, output, 1); + else + gen_condition_gpr(expr, output, outputReg); +} + +void gen_LOGICAL(ENode *expr, short outputReg, short outputRegHi, Operand *output) { + ENode *inner; + ENodeType op; + + expr = evaluate_and_skip_comma(expr); + inner = evaluate_and_skip_comma(expr->data.monadic); + expr->data.monadic = inner; + + if (ENODE_IS(expr, ELOGNOT) && !ENODE_IS2(inner, ELAND, ELOR)) { + op = inner->type; + if (ENODE_IS(inner, ELOGNOT)) { + switch (inner->data.monadic->type) { + case ELOGNOT: + case ELESS: + case EGREATER: + case ELESSEQU: + case EGREATEREQU: + case EEQU: + case ENOTEQU: + case ELAND: + case ELOR: + GEN_NODE(inner->data.monadic, output); + if (expr->data.monadic->rtype->size < 4) + extend32(output, expr->data.monadic->rtype, 0); + ENSURE_GPR(output, expr->data.monadic->rtype, 0); + return; + } + } + + if (ENODE_IS(inner, ENOTEQU) && !TYPE_IS_8BYTES(inner->data.diadic.left->rtype) && ENODE_IS(inner->data.diadic.right, EINTCONST) && inner->data.diadic.right->data.intval.lo == 0) { + int tmpreg1; + int tmpreg2; + GEN_NODE(inner->data.diadic.left, output); + if (inner->data.diadic.left->rtype->size < 4) + extend32(output, inner->data.diadic.left->rtype, 0); + ENSURE_GPR(output, inner->data.diadic.left->rtype, 0); + + tmpreg1 = ALLOC_GPR(); + tmpreg2 = ALLOC_GPR(); +#line 4853 + CError_ASSERT(output->optype == OpndType_GPR); + + emitpcode(PC_CNTLZW, tmpreg2, output->reg); + emitpcode(PC_RLWINM, tmpreg1, tmpreg2, 27, 5, 31); + output->optype = OpndType_GPR; + output->reg = tmpreg1; + } else { + int tmpreg1; + int tmpreg2; + ENodeType inverted; + + inverted = invert_relop(op); + if (op != inverted && !IS_TYPE_FLOAT(inner->data.diadic.left->rtype)) { + inner->type = inverted; + gen_COMPARE(inner, 0, 0, output); + inner->type = inverted; + return; + } + + GEN_NODE(inner, output); + if (inner->rtype->size < 4) + extend32(output, inner->rtype, 0); + ENSURE_GPR(output, inner->rtype, 0); + + tmpreg1 = ALLOC_GPR(); + tmpreg2 = ALLOC_GPR(); +#line 4883 + CError_ASSERT(output->optype == OpndType_GPR); + + emitpcode(PC_CNTLZW, tmpreg2, output->reg); + emitpcode(PC_RLWINM, tmpreg1, tmpreg2, 27, 5, 31); + output->optype = OpndType_GPR; + output->reg = tmpreg1; + } + } else { + PCodeLabel *label1; + PCodeLabel *label2; + int tmpreg; + + label1 = makepclabel(); + label2 = makepclabel(); + + tmpreg = ALLOC_GPR(); + emitpcode(PC_LI, tmpreg, 0); + logical_expression(expr, label1, label2, label1); + branch_label(label1); + emitpcode(PC_LI, tmpreg, 1); + branch_label(label2); + output->optype = OpndType_GPR; + output->reg = tmpreg; + } +} + +void gen_NULLCHECK(ENode *expr, short outputReg, short outputRegHi, Operand *output) { + ENode *left; + ENode *right; + Operand opleft; + Operand opright; + PrecomputedOperand *precomp; + int flag; + int reg; + PCodeLabel *label; + + left = expr->data.nullcheck.nullcheckexpr; + right = expr->data.nullcheck.condexpr; + memclrw(&opleft, sizeof(Operand)); + memclrw(&opright, sizeof(Operand)); + flag = !IS_TYPE_VOID(expr->rtype) && !expr->ignored; + + GEN_NODE(left, &opleft); + if (left->rtype->size < 4) + extend32(&opleft, left->rtype, 0); + ENSURE_GPR(&opleft, left->rtype, 0); + + precomp = lalloc(sizeof(PrecomputedOperand)); + precomp->precompid = expr->data.nullcheck.precompid; + precomp->operand = opleft; + precomp->next = precomputedoperands; + precomputedoperands = precomp; + + emitpcode(PC_CMPI, 0, opleft.reg, 0); + if (flag) { + emitpcode(PC_MR, reg = ALLOC_GPR(), opleft.reg); + } + + label = makepclabel(); + branch_conditional(0, EEQU, 1, label); + GEN_NODE(right, &opright); + precomputedoperands = precomputedoperands->next; + + if (flag) { + ENSURE_GPR(&opright, right->rtype, reg); + if (opright.reg != reg) + emitpcode(PC_MR, reg, opright.reg); + output->optype = OpndType_GPR; + output->reg = reg; + } + + branch_label(label); +} + +void gen_PRECOMP(ENode *expr, short outputReg, short outputRegHi, Operand *output) { + PrecomputedOperand *precomp; + + for (precomp = precomputedoperands; precomp; precomp = precomp->next) { + if (precomp->precompid == expr->data.precompid) + break; + } + + *output = precomp->operand; +} + +void logical_expression(ENode *cond, PCodeLabel *if_true, PCodeLabel *if_false, PCodeLabel *end) { + PCodeLabel *label; + Operand op; + memclrw(&op, sizeof(Operand)); + + cond = evaluate_and_skip_comma(cond); + switch (cond->type) { + case ELAND: + label = makepclabel(); + logical_expression(cond->data.diadic.left, label, if_false, label); + branch_label(label); + logical_expression(cond->data.diadic.right, if_true, if_false, end); + break; + case ELOR: + label = makepclabel(); + logical_expression(cond->data.diadic.left, if_true, label, label); + branch_label(label); + logical_expression(cond->data.diadic.right, if_true, if_false, end); + break; + case ELOGNOT: + logical_expression(cond->data.monadic, if_false, if_true, end); + break; + case ELESS: + case EGREATER: + case ELESSEQU: + case EGREATEREQU: + case EEQU: + case ENOTEQU: + if (TYPE_IS_8BYTES(cond->data.diadic.right->rtype) || TYPE_IS_8BYTES(cond->data.diadic.left->rtype)) + I8_gen_condition(cond, &op, 0); + else + gen_condition(cond, &op); + + if (end == if_true) + branch_conditional(op.reg, op.regOffset, 0, if_false); + else + branch_conditional(op.reg, op.regOffset, 1, if_true); + break; + default: +#line 5160 + CError_FATAL(); + } +} + +static void logical_expression_nobranch(ENode *cond, Boolean invert, Operand *output) { + cond = evaluate_and_skip_comma(cond); + switch (cond->type) { + case ELOGNOT: + logical_expression_nobranch(cond->data.monadic, 1, output); + break; + case ELESS: + case EGREATER: + case ELESSEQU: + case EGREATEREQU: + case EEQU: + case ENOTEQU: + if (invert) { + ENodeType nt = invert_relop(cond->type); +#line 5190 + CError_ASSERT(nt != cond->type); + cond->type = nt; + } + + if (TYPE_IS_8BYTES(cond->data.diadic.right->rtype) || TYPE_IS_8BYTES(cond->data.diadic.left->rtype)) + I8_gen_condition(cond, output, 0); + else + gen_condition(cond, output); + + break; + default: +#line 5206 + CError_FATAL(); + } +} + +static ENodeType invert_relop(ENodeType nt) { + switch (nt) { + case ELESS: return EGREATEREQU; + case EGREATER: return ELESSEQU; + case ELESSEQU: return EGREATER; + case EGREATEREQU: return ELESS; + case EEQU: return ENOTEQU; + case ENOTEQU: return EEQU; + default: return nt; + } +} + +static int reverse_relop(int nt) { + switch (nt) { + case ELESS: return EGREATER; + case EGREATER: return ELESS; + case ELESSEQU: return EGREATEREQU; + case EGREATEREQU: return ELESSEQU; + default: return nt; + } +} + +void gen_condition(ENode *cond, Operand *output) { + ENode *left; + ENode *right; + + left = cond->data.diadic.left; + right = cond->data.diadic.right; + if (IS_TYPE_FLOAT(left->rtype)) { + compare_floating(cond->type, left, right, output); + return; + } + + if (ENODE_IS(right, EINTCONST)) { + if (is_unsigned(left->rtype)) { + UInt32 val = right->data.intval.lo; + if (FITS_IN_USHORT(val)) { + compare_immediate(cond->type, left, val, output); + return; + } else if (ENODE_IS2(cond, EEQU, ENOTEQU)) { + compare_immediate_long(cond->type, left, val, output); + return; + } + } else { + UInt32 val = right->data.intval.lo; + if (FITS_IN_SHORT(val)) { + compare_immediate(cond->type, left, val, output); + return; + } else if (ENODE_IS2(cond, EEQU, ENOTEQU)) { + compare_immediate_long(cond->type, left, val, output); + return; + } + } + } else if (ENODE_IS(left, EINTCONST)) { + if (is_unsigned(right->rtype)) { + UInt32 val = left->data.intval.lo; + if (FITS_IN_USHORT(val)) { + compare_immediate(reverse_relop(cond->type), right, val, output); + return; + } else if (ENODE_IS2(cond, EEQU, ENOTEQU)) { + compare_immediate_long(reverse_relop(cond->type), right, val, output); + return; + } + } else { + UInt32 val = left->data.intval.lo; + if (FITS_IN_SHORT(val)) { + compare_immediate(reverse_relop(cond->type), right, val, output); + return; + } else if (ENODE_IS2(cond, EEQU, ENOTEQU)) { + compare_immediate_long(reverse_relop(cond->type), right, val, output); + return; + } + } + } + + compare_integer(cond->type, left, right, output); +} + +void gen_condition_gpr(ENode *cond, Operand *output, short outputReg) { + ENode *left; + ENode *right; + Operand op1; + int tmpReg; + int reg; + int a; + int b; + + left = cond->data.diadic.left; + right = cond->data.diadic.right; + memclrw(&op1, sizeof(Operand)); + + if (!IS_TYPE_FLOAT(left->rtype)) { + Operand op2; + Operand op3; + Operand op4; + memclrw(&op2, sizeof(Operand)); + memclrw(&op3, sizeof(Operand)); + memclrw(&op4, sizeof(Operand)); + + if (right->hascall) { + GEN_NODE(right, &op3); + if (!IS_INT_CONST_ZERO(right)) { + if (right->rtype->size < 4) + extend32(&op3, right->rtype, 0); + ENSURE_GPR(&op3, right->rtype, 0); + } + + GEN_NODE(left, &op2); + if (left->rtype->size < 4) + extend32(&op2, left->rtype, 0); + ENSURE_GPR(&op2, left->rtype, 0); + } else { + GEN_NODE(left, &op2); + ENSURE_GPR(&op2, left->rtype, 0); + if (left->rtype->size < 4) + extend32(&op2, left->rtype, 0); + + GEN_NODE(right, &op3); + if (!IS_INT_CONST_ZERO(right)) { + if (right->rtype->size < 4) + extend32(&op3, right->rtype, 0); + ENSURE_GPR(&op3, right->rtype, 0); + } + } + + switch (cond->type) { + case EEQU: + if ( + copts.peephole && + IS_INT_CONST(right) && + pclastblock->pcodeCount > 0) { + PCode *pc = pclastblock->lastPCode; + if (pc->op == PC_RLWINM && pc->args[0].data.reg.reg == op2.reg) { + SInt32 r6 = pc->args[2].data.imm.value; + SInt32 r7 = pc->args[3].data.imm.value; + SInt32 r3 = right->data.intval.lo; + if (r7 == pc->args[4].data.imm.value) { + reg = outputReg ? outputReg : ALLOC_GPR(); + if (r3 != (r3 & 1)) { + emitpcode(PC_LI, reg, 0); + } else if (r3 == 0) { + int tmpreg = ALLOC_GPR(); + emitpcode( + PC_RLWINM, tmpreg, + pc->args[1].data.reg.reg, + (r6 + r7 + 1) & 31, 31, 31); + emitpcode(PC_XORI, reg, tmpreg, 1); + } else if (r3 == 1) { + emitpcode( + PC_RLWINM, reg, + pc->args[1].data.reg.reg, + (r6 + r7 + 1) & 31, 31, 31); + } else { +#line 5434 + CError_FATAL(); + } + output->optype = OpndType_GPR; + output->reg = reg; + return; + } + } + } + + if (IS_INT_CONST_ZERO(right)) { + //int tmpReg = ALLOC_GPR(); // affected + int tmpReg; + int t = used_virtual_registers[RegClass_GPR]; + used_virtual_registers[RegClass_GPR]++; + emitpcode(PC_CNTLZW, t, op2.reg, 0); + tmpReg = t; + reg = outputReg ? outputReg : ALLOC_GPR(); + emitpcode(PC_RLWINM, reg, tmpReg, 27, 5, 31); + output->optype = OpndType_GPR; + output->reg = reg; + return; + } else { + int tmpReg, tmpReg2; + tmpReg = ALLOC_GPR(); // affected + emitpcode(PC_SUBF, tmpReg, op2.reg, op3.reg); + tmpReg2 = ALLOC_GPR(); + emitpcode(PC_CNTLZW, tmpReg2, tmpReg); + reg = outputReg ? outputReg : ALLOC_GPR(); + emitpcode(PC_RLWINM, reg, tmpReg2, 27, 5, 31); + output->optype = OpndType_GPR; + output->reg = reg; + return; + } + + case ENOTEQU: + if ( + copts.peephole && + IS_INT_CONST(right) && + pclastblock->pcodeCount > 0) { + PCode *pc = pclastblock->lastPCode; + if (pc->op == PC_RLWINM && pc->args[0].data.reg.reg == op2.reg) { + SInt32 r6 = pc->args[2].data.imm.value; + SInt32 r7 = pc->args[3].data.imm.value; + SInt32 r3 = right->data.intval.lo; + if (r7 == pc->args[4].data.imm.value) { + reg = outputReg ? outputReg : ALLOC_GPR(); + if (r3 != (r3 & 1)) { + emitpcode(PC_LI, reg, 1); + } else if (r3 == 0) { + emitpcode( + PC_RLWINM, reg, + pc->args[1].data.reg.reg, + (r6 + r7 + 1) & 31, 31, 31); + } else if (r3 == 1) { + int tmpreg = ALLOC_GPR(); // affected + emitpcode( + PC_RLWINM, tmpreg, + pc->args[1].data.reg.reg, + (r6 + r7 + 1) & 31, 31, 31); + emitpcode(PC_XORI, reg, tmpreg, 1); + } else { +#line 5503 + CError_FATAL(); + } + output->optype = OpndType_GPR; + output->reg = reg; + return; + } + } + } + + if (IS_INT_CONST_ZERO(right)) { + if (copts.optimize_for_size) { + int tmpReg; + tmpReg = ALLOC_GPR(); // affected + emitpcode(PC_ADDIC, tmpReg, op2.reg, -1); + reg = outputReg ? outputReg : ALLOC_GPR(); + emitpcode(PC_SUBFE, reg, tmpReg, op2.reg); + } else { + int tmpReg, tmpReg2; + // tmpReg, tmpReg2 swap + tmpReg = ALLOC_GPR(); + emitpcode(PC_NEG, tmpReg, op2.reg); + tmpReg2 = ALLOC_GPR(); + emitpcode(PC_OR, tmpReg2, tmpReg, op2.reg); + reg = outputReg ? outputReg : ALLOC_GPR(); + emitpcode(PC_RLWINM, reg, tmpReg2, 1, 31, 31); + } + output->optype = OpndType_GPR; + output->reg = reg; + return; + } else { + if (copts.optimize_for_size) { + int tmpReg, tmpReg2; + // tmpReg, tmpReg2 swap + tmpReg = ALLOC_GPR(); + emitpcode(PC_SUBF, tmpReg, op2.reg, op3.reg); + tmpReg2 = ALLOC_GPR(); + emitpcode(PC_ADDIC, tmpReg2, tmpReg, -1); + reg = outputReg ? outputReg : ALLOC_GPR(); + emitpcode(PC_SUBFE, reg, tmpReg2, tmpReg); + } else { + int tmpReg, tmpReg2, tmpReg3; + // tmpReg, tmpReg2 swap + tmpReg = ALLOC_GPR(); + emitpcode(PC_SUBF, tmpReg, op2.reg, op3.reg); + tmpReg2 = ALLOC_GPR(); + emitpcode(PC_SUBF, tmpReg2, op3.reg, op2.reg); + tmpReg3 = ALLOC_GPR(); + emitpcode(PC_OR, tmpReg3, tmpReg, tmpReg2); + reg = outputReg ? outputReg : ALLOC_GPR(); + emitpcode(PC_RLWINM, reg, tmpReg3, 1, 31, 31); + } + output->optype = OpndType_GPR; + output->reg = reg; + return; + } + + case EGREATEREQU: + if (!is_unsigned(left->rtype) && IS_INT_CONST_ZERO(right)) { + int tmpReg; + tmpReg = ALLOC_GPR(); + emitpcode(PC_RLWINM, tmpReg, op2.reg, 1, 31, 31); + reg = outputReg ? outputReg : ALLOC_GPR(); + emitpcode(PC_XORI, reg, tmpReg, 1); + output->optype = OpndType_GPR; + output->reg = reg; + return; + } + op4 = op3; + op3 = op2; + op2 = op4; + case ELESSEQU: + if (is_unsigned(left->rtype)) { + if (copts.optimize_for_size) { + int tmpReg, tmpReg2; + tmpReg = ALLOC_GPR(); + emitpcode(PC_LI, tmpReg, -1); + tmpReg2 = ALLOC_GPR(); + emitpcode(PC_SUBFC, tmpReg2, op2.reg, op3.reg); + reg = outputReg ? outputReg : ALLOC_GPR(); + emitpcode(PC_SUBFZE, reg, tmpReg); + } else { + int tmpReg, tmpReg2, tmpReg3, tmpReg4; + tmpReg = ALLOC_GPR(); + emitpcode(PC_SUBF, tmpReg, op2.reg, op3.reg); + tmpReg2 = ALLOC_GPR(); + emitpcode(PC_ORC, tmpReg2, op3.reg, op2.reg); + tmpReg3 = ALLOC_GPR(); + emitpcode(PC_RLWINM, tmpReg3, tmpReg, 31, 1, 31); + tmpReg4 = ALLOC_GPR(); + emitpcode(PC_SUBF, tmpReg4, tmpReg3, tmpReg2); + reg = outputReg ? outputReg : ALLOC_GPR(); + emitpcode(PC_RLWINM, reg, tmpReg4, 1, 31, 31); + } + output->optype = OpndType_GPR; + output->reg = reg; + return; + } + + if (IS_INT_CONST_ZERO(right)) { + int tmpReg, tmpReg2; + tmpReg = ALLOC_GPR(); + emitpcode(PC_LI, tmpReg, 1); + tmpReg2 = ALLOC_GPR(); + emitpcode(PC_CNTLZW, tmpReg2, op2.reg); + reg = outputReg ? outputReg : ALLOC_GPR(); + emitpcode(PC_RLWNM, reg, tmpReg, tmpReg2, 31, 31); + output->optype = OpndType_GPR; + output->reg = reg; + return; + } else { + int tmpReg, tmpReg2, tmpReg3; + tmpReg2 = ALLOC_GPR(); + emitpcode(PC_SRAWI, tmpReg2, op3.reg, 31); + tmpReg = ALLOC_GPR(); + emitpcode(PC_RLWINM, tmpReg, op2.reg, 1, 31, 31); + tmpReg3 = ALLOC_GPR(); + emitpcode(PC_SUBFC, tmpReg3, op2.reg, op3.reg); + reg = outputReg ? outputReg : ALLOC_GPR(); + emitpcode(PC_ADDE, reg, tmpReg2, tmpReg); + output->optype = OpndType_GPR; + output->reg = reg; + return; + } + + case EGREATER: + if (!is_unsigned(left->rtype) && IS_INT_CONST_ZERO(right)) { + int tmpReg, tmpReg2; + tmpReg = ALLOC_GPR(); + emitpcode(PC_NEG, tmpReg, op2.reg); + tmpReg2 = ALLOC_GPR(); + emitpcode(PC_ANDC, tmpReg2, tmpReg, op2.reg); + reg = outputReg ? outputReg : ALLOC_GPR(); + emitpcode(PC_RLWINM, reg, tmpReg2, 1, 31, 31); + output->optype = OpndType_GPR; + output->reg = reg; + return; + } + + op4 = op3; + op3 = op2; + op2 = op4; + case ELESS: + if (is_unsigned(left->rtype)) { + if (left->rtype->size <= 2) { + int tmpReg; + tmpReg = ALLOC_GPR(); + emitpcode(PC_SUBF, tmpReg, op3.reg, op2.reg); + reg = outputReg ? outputReg : ALLOC_GPR(); + emitpcode(PC_RLWINM, reg, tmpReg, 1, 31, 31); + output->optype = OpndType_GPR; + output->reg = reg; + } else { + if (copts.optimize_for_size) { + int tmpReg, tmpReg2; + tmpReg = ALLOC_GPR(); + emitpcode(PC_SUBFC, tmpReg, op3.reg, op2.reg); + tmpReg2 = ALLOC_GPR(); + emitpcode(PC_SUBFE, tmpReg2, tmpReg, tmpReg); + reg = outputReg ? outputReg : ALLOC_GPR(); + emitpcode(PC_NEG, reg, tmpReg2); + } else { + int tmpReg, tmpReg2, tmpReg3; + tmpReg = ALLOC_GPR(); + emitpcode(PC_XOR, tmpReg, op3.reg, op2.reg); + tmpReg2 = ALLOC_GPR(); + emitpcode(PC_CNTLZW, tmpReg2, tmpReg); + tmpReg3 = ALLOC_GPR(); + emitpcode(PC_SLW, tmpReg3, op3.reg, tmpReg2); + reg = outputReg ? outputReg : ALLOC_GPR(); + emitpcode(PC_RLWINM, reg, tmpReg3, 1, 31, 31); + } + output->optype = OpndType_GPR; + output->reg = reg; + return; + } + return; + } else { + if (IS_INT_CONST_ZERO(right)) { + reg = outputReg ? outputReg : ALLOC_GPR(); + emitpcode(PC_RLWINM, reg, op2.reg, 1, 31, 31); + output->optype = OpndType_GPR; + output->reg = reg; + return; + } else { + int tmpReg, tmpReg2, tmpReg3, tmpReg4; + tmpReg = ALLOC_GPR(); + emitpcode(PC_XOR, tmpReg, op3.reg, op2.reg); + tmpReg2 = ALLOC_GPR(); + emitpcode(PC_SRAWI, tmpReg2, tmpReg, 1); + tmpReg3 = ALLOC_GPR(); + emitpcode(PC_AND, tmpReg3, tmpReg, op3.reg); + tmpReg4 = ALLOC_GPR(); + emitpcode(PC_SUBF, tmpReg4, tmpReg3, tmpReg2); + + reg = outputReg ? outputReg : ALLOC_GPR(); + emitpcode(PC_RLWINM, reg, tmpReg4, 1, 31, 31); + output->optype = OpndType_GPR; + output->reg = reg; + return; + } + } + + default: +#line 5777 + CError_FATAL(); + } + } + + gen_condition(cond, &op1); + emitpcode(PC_MFCR, tmpReg = used_virtual_registers[RegClass_GPR]++); + a = 0; + b = op1.reg * 4; + switch (op1.regOffset) { + case ENOTEQU: + a = 1; + case EEQU: + b += 2; + break; + case EGREATEREQU: + a = 1; + break; + case ELESSEQU: + a = 1; + case EGREATER: + b += 1; + break; + } + + reg = outputReg ? outputReg : ALLOC_GPR(); + if (a) { + emitpcode(PC_RLWINM, tmpReg, tmpReg, b + 1, 31, 31); + emitpcode(PC_XORI, reg, tmpReg, 1); + } else { + emitpcode(PC_RLWINM, reg, tmpReg, b + 1, 31, 31); + } + output->optype = OpndType_GPR; + output->reg = reg; +} + +void gen_negated_condition_gpr(ENode *cond, Operand *output, short outputReg) { +} + +void compare_floating(short nt, ENode *left, ENode *right, Operand *output) { + Operand opleft; + Operand opright; + + memclrw(&opleft, sizeof(Operand)); + memclrw(&opright, sizeof(Operand)); + + if (right->hascall) { + GEN_NODE_TO_FPR(right, &opright, right->rtype, 0); + GEN_NODE_TO_FPR(left, &opleft, left->rtype, 0); + } else { + GEN_NODE_TO_FPR(left, &opleft, left->rtype, 0); + GEN_NODE_TO_FPR(right, &opright, right->rtype, 0); + } + + emitpcode((nt == EEQU || nt == ENOTEQU) ? PC_FCMPU : PC_FCMPO, 0, opleft.reg, opright.reg); + if (nt == ELESSEQU) { + emitpcode(PC_CROR, 0, 2, 0, 0, 0, 2); + nt = EEQU; + } else if (nt == EGREATEREQU) { + emitpcode(PC_CROR, 0, 2, 0, 1, 0, 2); + nt = EEQU; + } + + output->optype = OpndType_CRField; + output->reg = 0; + output->regOffset = nt; +} + +void compare_integer(short nt, ENode *left, ENode *right, Operand *output) { + Operand opleft; + Operand opright; + + memclrw(&opleft, sizeof(Operand)); + memclrw(&opright, sizeof(Operand)); + + if (right->hascall) { + GEN_NODE(right, &opright); + if (right->rtype->size < 4) + extend32(&opright, right->rtype, 0); + ENSURE_GPR(&opright, right->rtype, 0); + + GEN_NODE(left, &opleft); + if (left->rtype->size < 4) + extend32(&opleft, left->rtype, 0); + ENSURE_GPR(&opleft, left->rtype, 0); + } else { + GEN_NODE(left, &opleft); + ENSURE_GPR(&opleft, left->rtype, 0); + if (left->rtype->size < 4) + extend32(&opleft, left->rtype, 0); + + GEN_NODE(right, &opright); + if (right->rtype->size < 4) + extend32(&opright, right->rtype, 0); + ENSURE_GPR(&opright, right->rtype, 0); + } + + emitpcode(is_unsigned(left->rtype) ? PC_CMPL : PC_CMP, 0, opleft.reg, opright.reg); + + output->optype = OpndType_CRField; + output->reg = 0; + output->regOffset = nt; +} + +void compare_immediate(short nt, ENode *left, SInt32 value, Operand *output) { +} + +void compare_immediate_long(short nt, ENode *left, SInt32 value, Operand *output) { +} + +static int ismask(SInt32 value, short *first, short *last) { + int start, end, bit; + start = end = -1; + for (bit = 31; bit >= 0; bit--) { + if (value & 1) { + if (start != -1) + return 0; + if (end == -1) + end = bit; + } else { + if (end != -1 && start == -1) + start = bit + 1; + } + value >>= 1; + } + + if (end == -1) + return 0; + if (start == -1) + start = 0; + *first = start; + *last = end; + return 1; +} + +int ismaskconstant(SInt32 value, short *first, short *last) { + short my_first; + short my_last; + if (ismask(value, first, last)) + return 1; + + if (value && ismask(~value, &my_first, &my_last)) { + *first = my_last + 1; + *last = my_first - 1; + return 1; + } else { + return 0; + } +} + +static void shift_and_mask(ENode *expr, short a, short b, short c, short outputReg, Operand *output) { + Operand op; + int reg; + + memclrw(&op, sizeof(Operand)); + GEN_NODE(expr, &op); + ENSURE_GPR(&op, expr->rtype, 0); + + reg = outputReg ? outputReg : ALLOC_GPR(); + emitpcode(PC_RLWINM, reg, op.reg, a, b, c); + + output->optype = OpndType_GPR; + output->reg = reg; +} + +int ispostincrementopportunity(ENode *expr, Operand *op, SInt32 *value) { + Type *type; + int reg; + + type = expr->rtype; + if (!ENODE_IS2(expr, EPOSTINC, EPOSTDEC)) + return 0; + if (!ENODE_IS(expr->data.monadic, EINDIRECT)) + return 0; + if (!ENODE_IS(expr->data.monadic->data.monadic, EOBJREF)) + return 0; + + reg = OBJECT_REG(expr->data.monadic->data.monadic->data.objref); + if (!reg) + return 0; + + if (IS_TYPE_POINTER(type)) { + if (ENODE_IS(expr, EPOSTINC)) + *value = TPTR_TARGET(type)->size; + else + *value = -TPTR_TARGET(type)->size; + } else { + if (ENODE_IS(expr, EPOSTINC)) + *value = 1; + else + *value = -1; + } + + op->optype = OpndType_GPR; + op->reg = reg; + return 1; +} + +void add_register_immediate(short regA, short regB, SInt32 value) { + if (!FITS_IN_SHORT(value)) { + emitpcode(PC_ADDIS, regA, regB, 0, HIGH_PART(value)); + if (LOW_PART(value)) + emitpcode(PC_ADDI, regA, regA, 0, LOW_PART(value)); + } else { + emitpcode(PC_ADDI, regA, regB, 0, value); + } +} + +static int ispowerof2(SInt32 val) { + int bit = getbit(val); + return (bit > 0 && bit < 31) ? bit : 0; +} + +void I8_gen_ADD(ENode *expr, short outputReg, short outputRegHi, Operand *output) { + int is_uns; + ENode *left; + ENode *right; + short reg; + short regHi; + short tmpreg1; + short tmpreg2; + SInt32 skipleft; + SInt32 skipright; + Operand opleft; + Operand opright; + + left = expr->data.diadic.left; + right = expr->data.diadic.right; + memclrw(&opleft, sizeof(Operand)); + memclrw(&opright, sizeof(Operand)); + + if (right->hascall) { + GEN_NODE(right, &opright); + if (TYPE_IS_8BYTES(right->rtype)) + coerce_to_register_pair(&opright, right->rtype, 0, 0); + else + ENSURE_GPR(&opright, right->rtype, 0); + + GEN_NODE(left, &opleft); + if (TYPE_IS_8BYTES(left->rtype)) + coerce_to_register_pair(&opleft, left->rtype, 0, 0); + else + ENSURE_GPR(&opleft, left->rtype, 0); + } else { + GEN_NODE(left, &opleft); + if (TYPE_IS_8BYTES(left->rtype)) + coerce_to_register_pair(&opleft, left->rtype, 0, 0); + else + ENSURE_GPR(&opleft, left->rtype, 0); + + GEN_NODE(right, &opright); + if (TYPE_IS_8BYTES(right->rtype)) + coerce_to_register_pair(&opright, right->rtype, 0, 0); + else + ENSURE_GPR(&opright, right->rtype, 0); + } + + reg = ALLOC_GPR(); + regHi = ALLOC_GPR(); + is_uns = is_unsigned(expr->rtype) != 0; + skipleft = GetSizeSkip(left); + skipright = GetSizeSkip(right); + + if (skipleft < skipright) { + Operand tmpop; + SInt32 tmp; + + expr->data.diadic.left = right; + expr->data.diadic.right = left; + left = expr->data.diadic.left; + right = expr->data.diadic.right; + + tmpop = opright; + opright = opleft; + opleft = tmpop; + + tmp = skipleft; + skipleft = skipright; + skipright = tmp; + } + + switch (skipleft + skipright) { + case 1 + 1: + case 1 + 2: + case 2 + 2: + if (ENODE_IS(left, EINTCONST) && FITS_IN_SHORT2(left->data.intval.lo)) { + emitpcode(PC_ADDIC, reg, opright.reg, LOW_PART(left->data.intval.lo)); + } else if (ENODE_IS(right, EINTCONST) && FITS_IN_SHORT2(right->data.intval.lo)) { + emitpcode(PC_ADDIC, reg, opleft.reg, LOW_PART(right->data.intval.lo)); + } else { + emitpcode(PC_ADDC, reg, opleft.reg, opright.reg); + } + if (is_uns) + emitpcode(PC_LI, regHi, 0); + else + emitpcode(PC_SRAWI, regHi, reg, 31); + break; + case 1 + 4: + case 2 + 4: + case 4 + 4: + if (!is_uns) { + tmpreg1 = ALLOC_GPR(); + tmpreg2 = ALLOC_GPR(); + emitpcode(PC_SRAWI, tmpreg2, opleft.reg, 31); + emitpcode(PC_SRAWI, tmpreg1, opright.reg, 31); + } + if (ENODE_IS(left, EINTCONST) && FITS_IN_SHORT2(left->data.intval.lo)) { + emitpcode(PC_ADDIC, reg, opright.reg, LOW_PART(left->data.intval.lo)); + } else if (ENODE_IS(right, EINTCONST) && FITS_IN_SHORT2(right->data.intval.lo)) { + emitpcode(PC_ADDIC, reg, opleft.reg, LOW_PART(right->data.intval.lo)); + } else { + emitpcode(PC_ADDC, reg, opleft.reg, opright.reg); + } + if (is_uns) { + tmpreg1 = ALLOC_GPR(); + emitpcode(PC_LI, tmpreg1, 0); + emitpcode(PC_ADDZE, regHi, tmpreg1); + } else { + emitpcode(PC_ADDE, regHi, tmpreg1, tmpreg2); + } + break; + case 1 + 8: + case 2 + 8: + case 4 + 8: +#line 6933 + CError_ASSERT(skipleft == 8); + if (!is_uns) { + tmpreg2 = ALLOC_GPR(); + emitpcode(PC_SRAWI, tmpreg2, opright.reg, 31); + } + if (ENODE_IS(left, EINTCONST) && FITS_IN_SHORT2(left->data.intval.lo) && left->data.intval.hi == 0) { + emitpcode(PC_ADDIC, reg, opright.reg, LOW_PART(left->data.intval.lo)); + } else if (ENODE_IS(right, EINTCONST) && FITS_IN_SHORT2(right->data.intval.lo) && right->data.intval.hi == 0) { + emitpcode(PC_ADDIC, reg, opleft.reg, LOW_PART(right->data.intval.lo)); + } else { + emitpcode(PC_ADDC, reg, opleft.reg, opright.reg); + } + if (is_uns) + emitpcode(PC_ADDZE, regHi, opleft.regHi); + else + emitpcode(PC_ADDE, regHi, opleft.regHi, tmpreg2); + break; + case 8 + 8: + emitpcode(PC_ADDC, reg, opleft.reg, opright.reg); + emitpcode(PC_ADDE, regHi, opleft.regHi, opright.regHi); + break; + default: +#line 6979 + CError_FATAL(); + } + + output->optype = OpndType_GPRPair; + output->reg = reg; + output->regHi = regHi; +} + +void I8_gen_INTCONST(ENode *expr, short outputReg, short outputRegHi, Operand *output) { + short reg; + short regHi; + + reg = outputReg ? outputReg : ALLOC_GPR(); + regHi = outputRegHi ? outputRegHi : ALLOC_GPR(); + + load_immediate(reg, expr->data.intval.lo); + load_immediate(regHi, expr->data.intval.hi); + + output->optype = OpndType_GPRPair; + output->reg = reg; + output->regHi = regHi; +} + +void I8_gen_SUB(ENode *expr, short outputReg, short outputRegHi, Operand *output) { + int is_uns; + ENode *left; + ENode *right; + short reg; + short regHi; + short tmpreg1; + short tmpreg2; + short tmpreg3; + SInt32 skipleft; + SInt32 skipright; + Operand opleft; + Operand opright; + + left = expr->data.diadic.left; + right = expr->data.diadic.right; + memclrw(&opleft, sizeof(Operand)); + memclrw(&opright, sizeof(Operand)); + + if (right->hascall) { + GEN_NODE(right, &opright); + if (TYPE_IS_8BYTES(right->rtype)) + coerce_to_register_pair(&opright, right->rtype, 0, 0); + else + ENSURE_GPR(&opright, right->rtype, 0); + + GEN_NODE(left, &opleft); + if (TYPE_IS_8BYTES(left->rtype)) + coerce_to_register_pair(&opleft, left->rtype, 0, 0); + else + ENSURE_GPR(&opleft, left->rtype, 0); + } else { + GEN_NODE(left, &opleft); + if (TYPE_IS_8BYTES(left->rtype)) + coerce_to_register_pair(&opleft, left->rtype, 0, 0); + else + ENSURE_GPR(&opleft, left->rtype, 0); + + GEN_NODE(right, &opright); + if (TYPE_IS_8BYTES(right->rtype)) + coerce_to_register_pair(&opright, right->rtype, 0, 0); + else + ENSURE_GPR(&opright, right->rtype, 0); + } + + reg = ALLOC_GPR(); + regHi = ALLOC_GPR(); + is_uns = is_unsigned(expr->rtype) != 0; + skipleft = GetSizeSkip(left); + skipright = GetSizeSkip(right); + + switch (skipleft + skipright) { + case 1 + 1: + case 1 + 2: + case 2 + 2: + if (ENODE_IS(left, EINTCONST) && FITS_IN_SHORT2(left->data.intval.lo)) { + emitpcode(PC_SUBFIC, reg, opright.reg, LOW_PART(left->data.intval.lo)); + } else { + emitpcode(PC_SUBFC, reg, opright.reg, opleft.reg); + } + if (is_uns) + emitpcode(PC_LI, regHi, 0); + else + emitpcode(PC_SRAWI, regHi, reg, 31); + break; + case 1 + 4: + case 2 + 4: + case 4 + 4: + if (!is_uns) { + tmpreg1 = ALLOC_GPR(); + tmpreg2 = ALLOC_GPR(); + emitpcode(PC_SRAWI, tmpreg2, opleft.reg, 31); + emitpcode(PC_SRAWI, tmpreg1, opright.reg, 31); + } + if (ENODE_IS(left, EINTCONST) && FITS_IN_SHORT2(left->data.intval.lo)) { + emitpcode(PC_SUBFIC, reg, opright.reg, LOW_PART(left->data.intval.lo)); + } else { + emitpcode(PC_SUBFC, reg, opright.reg, opleft.reg); + } + if (is_uns) { + tmpreg1 = ALLOC_GPR(); + emitpcode(PC_LI, tmpreg1, 0); + emitpcode(PC_SUBFZE, regHi, tmpreg1); + } else { + emitpcode(PC_SUBFE, regHi, tmpreg1, tmpreg2); + } + break; + case 1 + 8: + case 2 + 8: + case 4 + 8: + if (skipleft < skipright) { + emitpcode(PC_SUBFC, reg, opright.reg, opleft.reg); + emitpcode(PC_SUBFE, regHi, opright.regHi, opleft.regHi); + } else { + if (ENODE_IS(left, EINTCONST) && FITS_IN_SHORT2(left->data.intval.lo) && left->data.intval.hi == 0) { + emitpcode(PC_SUBFIC, reg, opright.reg, LOW_PART(left->data.intval.lo)); + } else { + emitpcode(PC_SUBFC, reg, opright.reg, opleft.reg); + } + tmpreg1 = ALLOC_GPR(); + emitpcode(PC_LI, tmpreg1, 0); + emitpcode(PC_SUBFE, regHi, tmpreg1, opleft.regHi); + } + break; + case 8 + 8: + emitpcode(PC_SUBFC, reg, opright.reg, opleft.reg); + emitpcode(PC_SUBFE, regHi, opright.regHi, opleft.regHi); + break; + default: +#line 7211 + CError_FATAL(); + } + + output->optype = OpndType_GPRPair; + output->reg = reg; + output->regHi = regHi; +} + +void I8_gen_XOR(ENode *expr, short outputReg, short outputRegHi, Operand *output) { +} + +void I8_gen_OR(ENode *expr, short outputReg, short outputRegHi, Operand *output) { +} + +void I8_gen_AND(ENode *expr, short outputReg, short outputRegHi, Operand *output) { +} + +int I8_getbit(UInt64 val) { + switch (val) { + case 0: return -1; + case 1ULL << 0: return 0; + case 1ULL << 1: return 1; + case 1ULL << 2: return 2; + case 1ULL << 3: return 3; + case 1ULL << 4: return 4; + case 1ULL << 5: return 5; + case 1ULL << 6: return 6; + case 1ULL << 7: return 7; + case 1ULL << 8: return 8; + case 1ULL << 9: return 9; + case 1ULL << 10: return 10; + case 1ULL << 11: return 11; + case 1ULL << 12: return 12; + case 1ULL << 13: return 13; + case 1ULL << 14: return 14; + case 1ULL << 15: return 15; + case 1ULL << 16: return 16; + case 1ULL << 17: return 17; + case 1ULL << 18: return 18; + case 1ULL << 19: return 19; + case 1ULL << 20: return 20; + case 1ULL << 21: return 21; + case 1ULL << 22: return 22; + case 1ULL << 23: return 23; + case 1ULL << 24: return 24; + case 1ULL << 25: return 25; + case 1ULL << 26: return 26; + case 1ULL << 27: return 27; + case 1ULL << 28: return 28; + case 1ULL << 29: return 29; + case 1ULL << 30: return 30; + case 1ULL << 31: return 31; + case 1ULL << 32: return 32; + case 1ULL << 33: return 33; + case 1ULL << 34: return 34; + case 1ULL << 35: return 35; + case 1ULL << 36: return 36; + case 1ULL << 37: return 37; + case 1ULL << 38: return 38; + case 1ULL << 39: return 39; + case 1ULL << 40: return 40; + case 1ULL << 41: return 41; + case 1ULL << 42: return 42; + case 1ULL << 43: return 43; + case 1ULL << 44: return 44; + case 1ULL << 45: return 45; + case 1ULL << 46: return 46; + case 1ULL << 47: return 47; + case 1ULL << 48: return 48; + case 1ULL << 49: return 49; + case 1ULL << 50: return 50; + case 1ULL << 51: return 51; + case 1ULL << 52: return 52; + case 1ULL << 53: return 53; + case 1ULL << 54: return 54; + case 1ULL << 55: return 55; + case 1ULL << 56: return 56; + case 1ULL << 57: return 57; + case 1ULL << 58: return 58; + case 1ULL << 59: return 59; + case 1ULL << 60: return 60; + case 1ULL << 61: return 61; + case 1ULL << 62: return 62; + case 1ULL << 63: return 63; + default: return -2; + } +} + +int I8_log2n(UInt64 val) { + int bit = I8_getbit(val); + return (bit > 0 && bit < 63) ? bit : 0; +} + +void I8_ShiftLeftImmediate(Operand opnd, SInt32 value, int is_unsigned, SInt32 size, short reg, short regHi) { + if (opnd.reg == reg || opnd.regHi == regHi || opnd.reg == regHi || opnd.regHi == reg) { +#line 7703 + CError_FATAL(); + } + + if (value < 32) { + emitpcode(PC_RLWINM, reg, opnd.reg, value, 0, 31 - value); + if (size > 4) { + emitpcode(PC_RLWINM, regHi, opnd.regHi, value, 0, 31 - value); + emitpcode(PC_RLWIMI, regHi, opnd.reg, value, 32 - value, 31); + } else { + emitpcode(PC_RLWINM, regHi, opnd.reg, value, 32 - value, 31); + } + } else if (value <= 63) { + if (value == 32) + emitpcode(PC_MR, regHi, opnd.reg); + else + emitpcode(PC_RLWINM, regHi, opnd.reg, value - 32, 0, 63 - value); + emitpcode(PC_LI, reg, 0); + } else { +#line 7732 + CError_FATAL(); + } +} + +void I8_ShiftRightImmediate(Operand opnd, SInt32 value, int is_unsigned, short reg, short regHi, int unk) { + short tmpreg1; + short tmpreg2; + short tmpreg3; + short tmpreg4; + + if (opnd.reg == reg || opnd.regHi == regHi || opnd.reg == regHi || opnd.regHi == reg) { +#line 7756 + CError_FATAL(); + } + + if (value < 32) { + emitpcode(PC_RLWINM, reg, opnd.reg, 32 - value, 0, 31); + emitpcode(PC_RLWIMI, reg, opnd.regHi, 32 - value, 0, value - 1); + if (is_unsigned) { + emitpcode(PC_RLWINM, regHi, opnd.regHi, 32 - value, value, 31); + } else if (unk) { + tmpreg1 = ALLOC_GPR(); + emitpcode(PC_MR, tmpreg1, opnd.regHi); + emitpcode(PC_RLWIMI, tmpreg1, opnd.reg, 0, 31 - (value - 1), 31); + emitpcode(PC_SRAWI, regHi, tmpreg1, value); + } else { + emitpcode(PC_SRAWI, regHi, opnd.regHi, value); + } + } else if (value == 32) { + if (is_unsigned) { + emitpcode(PC_MR, reg, opnd.regHi); + emitpcode(PC_LI, regHi, 0); + } else if (unk) { + tmpreg1 = ALLOC_GPR(); + tmpreg2 = ALLOC_GPR(); + tmpreg3 = ALLOC_GPR(); + emitpcode(PC_NEG, tmpreg1, opnd.reg); + emitpcode(PC_OR, tmpreg2, tmpreg1, opnd.reg); + emitpcode(PC_RLWINM, tmpreg3, tmpreg2, 1, 31, 31); + emitpcode(PC_RLWIMI, tmpreg3, opnd.regHi, 0, 0, 0); + emitpcode(PC_MR, reg, opnd.regHi); + emitpcode(PC_SRAWI, regHi, value, 31); + } else { + emitpcode(PC_MR, reg, opnd.regHi); + emitpcode(PC_SRAWI, regHi, opnd.regHi, 31); + } + } else if (value <= 63) { + if (is_unsigned) { + emitpcode(PC_RLWINM, reg, opnd.regHi, 64 - value, value - 32, 31); + emitpcode(PC_LI, regHi, 0); + } else if (unk) { + tmpreg1 = ALLOC_GPR(); + tmpreg2 = ALLOC_GPR(); + tmpreg3 = ALLOC_GPR(); + tmpreg4 = ALLOC_GPR(); + emitpcode(PC_NEG, tmpreg1, opnd.reg); + emitpcode(PC_OR, tmpreg2, tmpreg1, opnd.reg); + emitpcode(PC_RLWINM, tmpreg3, tmpreg2, 1, 31, 31); + emitpcode(PC_OR, tmpreg4, opnd.regHi, tmpreg3); + emitpcode(PC_SRAWI, regHi, opnd.regHi, 31); + emitpcode(PC_SRAWI, reg, tmpreg4, value - 32); + } else { + emitpcode(PC_SRAWI, reg, opnd.regHi, value - 32); + emitpcode(PC_SRAWI, regHi, opnd.regHi, 31); + } + } else { +#line 7866 + CError_FATAL(); + } +} + +void I8_gen_MUL(ENode *expr, short outputReg, short outputRegHi, Operand *output) { + int is_uns; + ENode *left; + ENode *right; + short reg; + short regHi; + short tmpreg1; + short tmpreg2; + short tmpreg3; + short tmpreg4; + SInt32 skipleft; + SInt32 skipright; + Operand opleft; + Operand opright; + SInt64 leftval; + SInt64 rightval; + int shift; + + left = expr->data.diadic.left; + right = expr->data.diadic.right; + memclrw(&opleft, sizeof(Operand)); + memclrw(&opright, sizeof(Operand)); + skipleft = GetSizeSkip(left); + skipright = GetSizeSkip(right); + + if (ENODE_IS(right, EINTCONST) && ENODE_IS(left, EINTCONST)) { +#line 7900 + CError_FATAL(); + } + + if (ENODE_IS(left, EINTCONST)) + leftval = left->data.intval.lo + (((SInt64) ((skipleft < 8) ? 0 : left->data.intval.hi)) << 32); + if (ENODE_IS(right, EINTCONST)) + rightval = right->data.intval.lo + (((SInt64) ((skipright < 8) ? 0 : right->data.intval.hi)) << 32); + + if (right->hascall) { + GEN_NODE(right, &opright); + if (TYPE_IS_8BYTES(right->rtype)) + coerce_to_register_pair(&opright, right->rtype, 0, 0); + else + ENSURE_GPR(&opright, right->rtype, 0); + + if (!(ENODE_IS(left, EINTCONST) && I8_log2n(leftval) > 0)) { + GEN_NODE(left, &opleft); + if (TYPE_IS_8BYTES(left->rtype)) + coerce_to_register_pair(&opleft, left->rtype, 0, 0); + else + ENSURE_GPR(&opleft, left->rtype, 0); + } + } else { + if (!(ENODE_IS(left, EINTCONST) && I8_log2n(leftval) > 0)) { + GEN_NODE(left, &opleft); + if (TYPE_IS_8BYTES(left->rtype)) + coerce_to_register_pair(&opleft, left->rtype, 0, 0); + else + ENSURE_GPR(&opleft, left->rtype, 0); + } + + if (!(ENODE_IS(right, EINTCONST) && I8_log2n(rightval) > 0)) { + GEN_NODE(right, &opright); + if (TYPE_IS_8BYTES(right->rtype)) + coerce_to_register_pair(&opright, right->rtype, 0, 0); + else + ENSURE_GPR(&opright, right->rtype, 0); + } + } + + is_uns = is_unsigned(expr->rtype) != 0; + + if (skipleft < skipright) { + Operand tmpop; + SInt64 tmp64; + SInt32 tmp; + + expr->data.diadic.left = right; + expr->data.diadic.right = left; + left = expr->data.diadic.left; + right = expr->data.diadic.right; + + tmpop = opright; + opright = opleft; + opleft = tmpop; + + tmp64 = leftval; + leftval = rightval; + rightval = tmp64; + + tmp = skipleft; + skipleft = skipright; + skipright = tmp; + } + + reg = ALLOC_GPR(); + regHi = ALLOC_GPR(); + + if (ENODE_IS(left, EINTCONST) && (shift = I8_log2n(leftval)) > 0) { + I8_ShiftLeftImmediate(opright, shift, is_uns, skipright, reg, regHi); + } else if (ENODE_IS(right, EINTCONST) && (shift = I8_log2n(rightval)) > 0) { + I8_ShiftLeftImmediate(opleft, shift, is_uns, skipleft, reg, regHi); + } else { + switch (skipleft + skipright) { + case 1 + 1: + case 1 + 2: + case 2 + 2: + if (ENODE_IS(left, EINTCONST) && FITS_IN_SHORT2(left->data.intval.lo)) { + emitpcode(PC_MULLI, reg, opright.reg, LOW_PART(left->data.intval.lo)); + } else if (ENODE_IS(right, EINTCONST) && FITS_IN_SHORT2(right->data.intval.lo)) { + emitpcode(PC_MULLI, reg, opleft.reg, LOW_PART(right->data.intval.lo)); + } else { + emitpcode(PC_MULLW, reg, opleft.reg, opright.reg); + } + if (is_uns) + emitpcode(PC_LI, regHi, 0); + else + emitpcode(PC_SRAWI, regHi, reg, 31); + break; + case 1 + 4: + case 2 + 4: + case 4 + 4: + if (ENODE_IS(left, EINTCONST) && FITS_IN_SHORT2(left->data.intval.lo)) { + emitpcode(PC_MULLI, reg, opright.reg, LOW_PART(left->data.intval.lo)); + } else if (ENODE_IS(right, EINTCONST) && FITS_IN_SHORT2(right->data.intval.lo)) { + emitpcode(PC_MULLI, reg, opleft.reg, LOW_PART(right->data.intval.lo)); + } else { + emitpcode(PC_MULLW, reg, opleft.reg, opright.reg); + } + if (is_uns) + emitpcode(PC_MULHWU, regHi, opleft.reg, opright.reg); + else + emitpcode(PC_MULHW, regHi, opleft.reg, opright.reg); + break; + case 1 + 8: + case 2 + 8: + case 4 + 8: +#line 8097 + CError_ASSERT(skipleft == 8); + if (ENODE_IS(left, EINTCONST) && FITS_IN_SHORT2(left->data.intval.lo) && left->data.intval.hi == 0) { + emitpcode(PC_MULLI, reg, opright.reg, LOW_PART(left->data.intval.lo)); + if (is_uns) + emitpcode(PC_MULHWU, regHi, opright.reg, opleft.reg); + else + emitpcode(PC_MULHW, regHi, opright.reg, opleft.reg); + } else if (ENODE_IS(right, EINTCONST) && FITS_IN_SHORT2(right->data.intval.lo) && right->data.intval.hi == 0) { + tmpreg1 = ALLOC_GPR(); + tmpreg2 = ALLOC_GPR(); + if (is_uns) { + emitpcode(PC_MULHWU, tmpreg2, opleft.reg, opright.reg); + emitpcode(PC_MULLI, tmpreg1, opleft.regHi, LOW_PART(right->data.intval.lo)); + emitpcode(PC_MULLI, reg, opleft.reg, LOW_PART(right->data.intval.lo)); + emitpcode(PC_ADD, regHi, tmpreg2, tmpreg1); + } else { + tmpreg3 = ALLOC_GPR(); + tmpreg4 = ALLOC_GPR(); + emitpcode(PC_SRAWI, tmpreg4, opright.reg, 31); + emitpcode(PC_MULHWU, tmpreg2, opleft.reg, opright.reg); + emitpcode(PC_MULLI, tmpreg1, opleft.regHi, LOW_PART(right->data.intval.lo)); + emitpcode(PC_MULLI, reg, opleft.reg, LOW_PART(right->data.intval.lo)); + emitpcode(PC_MULLW, tmpreg3, opleft.reg, tmpreg4); + emitpcode(PC_ADD, regHi, tmpreg2, tmpreg1); + emitpcode(PC_ADD, regHi, regHi, tmpreg3); + } + } else { + tmpreg1 = ALLOC_GPR(); + tmpreg2 = ALLOC_GPR(); + if (is_uns) { + emitpcode(PC_MULHWU, tmpreg2, opleft.reg, opright.reg); + emitpcode(PC_MULLW, tmpreg1, opleft.regHi, opright.reg); + emitpcode(PC_MULLW, reg, opleft.reg, opright.reg); + emitpcode(PC_ADD, regHi, tmpreg2, tmpreg1); + } else { + tmpreg3 = ALLOC_GPR(); + tmpreg4 = ALLOC_GPR(); + emitpcode(PC_SRAWI, tmpreg4, opright.reg, 31); + emitpcode(PC_MULHWU, tmpreg2, opleft.reg, opright.reg); + emitpcode(PC_MULLW, tmpreg1, opleft.regHi, opright.reg); + emitpcode(PC_MULLW, reg, opleft.reg, opright.reg); + emitpcode(PC_MULLW, tmpreg3, opleft.reg, tmpreg4); + emitpcode(PC_ADD, regHi, tmpreg2, tmpreg1); + emitpcode(PC_ADD, regHi, regHi, tmpreg3); + } + } + break; + case 8 + 8: + if (ENODE_IS(left, EINTCONST) && FITS_IN_SHORT2(left->data.intval.lo) && left->data.intval.hi == 0) { + tmpreg1 = ALLOC_GPR(); + tmpreg2 = ALLOC_GPR(); + emitpcode(PC_MULHWU, tmpreg1, opright.reg, opleft.reg); + emitpcode(PC_MULLW, tmpreg2, opright.reg, opleft.regHi); + emitpcode(PC_MULLI, reg, opright.reg, LOW_PART(left->data.intval.lo)); + emitpcode(PC_ADD, regHi, tmpreg1, tmpreg2); + } else if (ENODE_IS(right, EINTCONST) && FITS_IN_SHORT2(right->data.intval.lo) && right->data.intval.hi == 0) { + tmpreg1 = ALLOC_GPR(); + tmpreg2 = ALLOC_GPR(); + emitpcode(PC_MULHWU, tmpreg2, opleft.reg, opright.reg); + emitpcode(PC_MULLW, tmpreg1, opleft.regHi, opright.reg); + emitpcode(PC_MULLI, reg, opleft.reg, LOW_PART(right->data.intval.lo)); + emitpcode(PC_ADD, regHi, tmpreg2, tmpreg1); + } else { + tmpreg1 = ALLOC_GPR(); + tmpreg2 = ALLOC_GPR(); + tmpreg3 = ALLOC_GPR(); + tmpreg4 = ALLOC_GPR(); + emitpcode(PC_MULHWU, tmpreg2, opleft.reg, opright.reg); + emitpcode(PC_MULLW, tmpreg1, opleft.regHi, opright.reg); + emitpcode(PC_ADD, tmpreg3, tmpreg2, tmpreg1); + emitpcode(PC_MULLW, tmpreg4, opleft.reg, opright.regHi); + emitpcode(PC_MULLW, reg, opleft.reg, opright.reg); + emitpcode(PC_ADD, regHi, tmpreg3, tmpreg4); + } + break; + default: +#line 8218 + CError_FATAL(); + } + } + + output->optype = OpndType_GPRPair; + output->reg = reg; + output->regHi = regHi; +} + +void I8_gen_BINNOT(ENode *expr, short outputReg, short outputRegHi, Operand *output) { + ENode *inner; + Operand op; + int reg; + int regHi; + + inner = expr->data.monadic; + memclrw(&op, sizeof(Operand)); + GEN_NODE(inner, &op); + coerce_to_register_pair(&op, inner->rtype, 0, 0); + + reg = outputReg ? outputReg : ALLOC_GPR(); + regHi = outputRegHi ? outputRegHi : ALLOC_GPR(); + emitpcode(PC_NOR, reg, op.reg, op.reg); + emitpcode(PC_NOR, regHi, op.regHi, op.regHi); + + output->optype = OpndType_GPRPair; + output->reg = reg; + output->regHi = regHi; +} + +void I8_gen_MONMIN(ENode *expr, short outputReg, short outputRegHi, Operand *output) { + ENode *inner; + Operand op; + int reg; + int regHi; + + inner = expr->data.monadic; + memclrw(&op, sizeof(Operand)); + GEN_NODE(inner, &op); + coerce_to_register_pair(&op, inner->rtype, 0, 0); + + reg = outputReg ? outputReg : ALLOC_GPR(); + regHi = outputRegHi ? outputRegHi : ALLOC_GPR(); + emitpcode(PC_SUBFIC, reg, op.reg, 0); + emitpcode(PC_SUBFZE, regHi, op.regHi); + + output->optype = OpndType_GPRPair; + output->reg = reg; + output->regHi = regHi; +} + +void I8_gen_ASS(ENode *expr, short outputReg, short outputRegHi, Operand *output) { + Type *type; + ENode *left; + ENode *right; + Operand opleft; + Operand opright; + VarInfo *vi; + + type = expr->rtype; + if (ENODE_IS(expr, ECONDASS)) { + left = expr->data.cond.expr1; + if (ENODE_IS(left, EINDIRECT)) { + left = left->data.monadic; + } else { +#line 8328 + CError_FATAL(); + } + right = expr->data.cond.expr2; + } else { + left = expr->data.diadic.left; + right = expr->data.diadic.right; + } + + memclrw(&opleft, sizeof(Operand)); + memclrw(&opright, sizeof(Operand)); + + if (ENODE_IS(left, EOBJREF) && OBJECT_REG(left->data.objref)) { + vi = Registers_GetVarInfo(left->data.objref); + GEN_NODE_TO_REG(right, vi->reg, vi->regHi, &opright); + if (vi->rclass != RegClass_GPR) { +#line 8348 + CError_FATAL(); + } else { + coerce_to_register_pair(&opright, type, vi->reg, vi->regHi); + *output = opright; + } + return; + } + + if (TYPE_FITS_IN_REGISTER(type)) { + GEN_NODE(right, &opright); + coerce_to_register_pair(&opright, right->rtype, 0, 0); + + if (ENODE_IS(left, EBITFIELD)) { +#line 8376 + CError_FATAL(); + } else { + GEN_NODE(left, &opleft); + indirect(&opleft, left); + store_pair(opright.reg, opright.regHi, &opleft, type); + } + + output->optype = OpndType_GPRPair; + output->reg = opright.reg; + output->regHi = opright.regHi; + } +} + +void I8_gen_POSTINCDEC(ENode *expr, short outputReg, short outputRegHi, Operand *output) { + ENode *inner; + Type *type; + int flag; + int reg; + int regHi; + Operand op1; + Operand op2; + Operand op3; + + inner = expr->data.monadic->data.monadic; + type = expr->rtype; + flag = 0; + memclrw(&op1, sizeof(Operand)); + memclrw(&op2, sizeof(Operand)); + + if (ENODE_IS(inner, EOBJREF) && (reg = OBJECT_REG(inner->data.objref))) { + regHi = Registers_GetVarInfo(inner->data.objref)->regHi; + output->optype = OpndType_GPRPair; + output->reg = (outputReg && outputReg != reg && outputReg != regHi) ? outputReg : ALLOC_GPR(); + output->regHi = (outputRegHi && outputRegHi != regHi && outputRegHi != reg) ? outputRegHi : ALLOC_GPR(); + emitpcode(PC_MR, output->reg, reg); + emitpcode(PC_MR, output->regHi, regHi); + if (ENODE_IS(expr, EPOSTINC)) { + emitpcode(PC_ADDIC, reg, reg, 1); + emitpcode(PC_ADDME, regHi, regHi); + } else { + emitpcode(PC_ADDIC, reg, reg, -1); + emitpcode(PC_ADDZE, regHi, regHi); + } + return; + } + +#line 8446 + CError_ASSERT(!ENODE_IS(inner, EBITFIELD)); + + GEN_NODE(inner, &op1); + indirect(&op1, inner); + op2 = op1; + coerce_to_register_pair(&op2, type, 0, 0); + + output->optype = OpndType_GPRPair; + output->reg = ALLOC_GPR(); + output->regHi = ALLOC_GPR(); + + emitpcode(PC_MR, output->reg, op2.reg); + emitpcode(PC_MR, output->regHi, op2.regHi); + + reg = ALLOC_GPR(); + regHi = ALLOC_GPR(); + + if (ENODE_IS(expr, EPOSTINC)) { + emitpcode(PC_ADDIC, reg, op2.reg, 1); + emitpcode(PC_ADDZE, regHi, op2.regHi); + } else { + emitpcode(PC_ADDIC, reg, op2.reg, -1); + emitpcode(PC_ADDME, regHi, op2.regHi); + } + store_pair(reg, regHi, &op1, type); +} + +void I8_gen_INDIRECT(ENode *expr, short outputReg, short outputRegHi, Operand *output) { + ENode *inner; + VarInfo *vi; + + inner = expr->data.monadic; + if (ENODE_IS(inner, EOBJREF) && OBJECT_REG(inner->data.objref)) { + vi = Registers_GetVarInfo(inner->data.objref); + switch (vi->rclass) { + case RegClass_GPR: + output->optype = OpndType_GPRPair; + break; + case RegClass_FPR: + output->optype = OpndType_FPR; + break; + default: +#line 8511 + CError_FATAL(); + } + + output->reg = vi->reg; + output->regHi = vi->regHi; + output->object = NULL; + return; + } + + if (ENODE_IS(inner, EBITFIELD)) { +#line 8529 + CError_FATAL(); + return; + } + + GEN_NODE(inner, output); + indirect(output, inner); +} + +void I8_gen_condition(ENode *cond, Operand *output, int write_to_gpr) { + ENode *left; + ENode *right; + Operand opleft; + Operand opright; + Operand tmpop; + int reg1; + int reg2; + int reg3; + int reg4; + int reg5; + + left = cond->data.diadic.left; + right = cond->data.diadic.right; + memclrw(&opleft, sizeof(Operand)); + memclrw(&opright, sizeof(Operand)); + memclrw(&tmpop, sizeof(Operand)); + + if (right->hascall) { + GEN_NODE(right, &opright); + if (right->rtype->size < 4) + extend32(&opright, right->rtype, 0); + ENSURE_GPR(&opright, right->rtype, 0); + + if (right->rtype->size < 8) { + short tmp = ALLOC_GPR(); + if (is_unsigned(right->rtype)) + load_immediate(tmp, 0); + else + emitpcode(PC_SRAWI, tmp, opright.reg, 31); + opright.optype = OpndType_GPRPair; + opright.regHi = tmp; + } + + GEN_NODE(left, &opleft); + if (left->rtype->size < 4) + extend32(&opleft, left->rtype, 0); + ENSURE_GPR(&opleft, left->rtype, 0); + + if (left->rtype->size < 8) { + short tmp = ALLOC_GPR(); + // this looks like a bug??? surely this should check left->rtype + if (is_unsigned(right->rtype)) + load_immediate(tmp, 0); + else + emitpcode(PC_SRAWI, tmp, opleft.reg, 31); + opleft.optype = OpndType_GPRPair; + opleft.regHi = tmp; + } + } else { + GEN_NODE(left, &opleft); + ENSURE_GPR(&opleft, left->rtype, 0); + if (left->rtype->size < 4) + extend32(&opleft, left->rtype, 0); + + if (left->rtype->size < 8) { + short tmp = ALLOC_GPR(); + if (is_unsigned(right->rtype)) + load_immediate(tmp, 0); + else + emitpcode(PC_SRAWI, tmp, opleft.reg, 31); + opleft.optype = OpndType_GPRPair; + opleft.regHi = tmp; + } + + GEN_NODE(right, &opright); + if (right->rtype->size < 4) + extend32(&opright, right->rtype, 0); + ENSURE_GPR(&opright, right->rtype, 0); + + if (right->rtype->size < 8) { + short tmp = ALLOC_GPR(); + if (is_unsigned(right->rtype)) + load_immediate(tmp, 0); + else + emitpcode(PC_SRAWI, tmp, opright.reg, 31); + opright.optype = OpndType_GPRPair; + opright.regHi = tmp; + } + } + +#line 8704 + CError_ASSERT(opleft.optype == OpndType_GPRPair && opright.optype == OpndType_GPRPair); + + switch (cond->type) { + case EEQU: + case ENOTEQU: + reg1 = ALLOC_GPR(); + reg2 = ALLOC_GPR(); + emitpcode(PC_XOR, reg1, opleft.reg, opright.reg); + emitpcode(PC_XOR, reg2, opleft.regHi, opright.regHi); + emitpcode(PC_OR, reg2, reg1, reg2); + if (write_to_gpr) { + if (ENODE_IS(cond, EEQU)) { + emitpcode(PC_CNTLZW, reg2, reg2); + emitpcode(PC_RLWINM, reg2, reg2, 27, 5, 31); + } else { + emitpcode(PC_ADDIC, reg1, reg2, -1); + emitpcode(PC_SUBFE, reg2, reg1, reg2); + } + output->optype = OpndType_GPR; + output->reg = reg2; + output->regHi = 0; + } else { + emitpcode(PC_CMPI, 0, reg2, 0); + output->optype = OpndType_CRField; + output->reg = 0; + output->regOffset = cond->type; + } + break; + case EGREATER: + tmpop = opleft; + opleft = opright; + opright = tmpop; + case ELESS: + reg1 = ALLOC_GPR(); + reg2 = ALLOC_GPR(); + reg3 = ALLOC_GPR(); + if (left->rtype != TYPE(&stunsignedlonglong) && right->rtype != TYPE(&stunsignedlonglong)) { + emitpcode(PC_XORIS, reg1, opleft.regHi, 0x8000); + emitpcode(PC_XORIS, reg2, opright.regHi, 0x8000); + reg4 = reg1; + reg5 = reg2; + } else { + reg4 = opleft.regHi; + reg5 = opright.regHi; + } + emitpcode(PC_SUBFC, reg3, opright.reg, opleft.reg); + emitpcode(PC_SUBFE, reg2, reg5, reg4); + emitpcode(PC_SUBFE, reg2, reg1, reg1); + emitpcode(PC_NEG, reg2, reg2); + if (write_to_gpr) { + output->optype = OpndType_GPR; + output->reg = reg2; + output->regHi = 0; + } else { + emitpcode(PC_CMPI, 0, reg2, 0); + output->optype = OpndType_CRField; + output->reg = 0; + output->regOffset = ENOTEQU; + } + break; + case ELESSEQU: + tmpop = opleft; + opleft = opright; + opright = tmpop; + case EGREATEREQU: + reg1 = ALLOC_GPR(); + reg2 = ALLOC_GPR(); + reg3 = ALLOC_GPR(); + if (left->rtype != TYPE(&stunsignedlonglong) && right->rtype != TYPE(&stunsignedlonglong)) { + emitpcode(PC_XORIS, reg1, opleft.regHi, 0x8000); + emitpcode(PC_XORIS, reg2, opright.regHi, 0x8000); + reg4 = reg1; + reg5 = reg2; + } else { + reg4 = opleft.regHi; + reg5 = opright.regHi; + } + emitpcode(PC_SUBFC, reg3, opright.reg, opleft.reg); + emitpcode(PC_SUBFE, reg2, reg5, reg4); + emitpcode(PC_SUBFE, reg2, reg1, reg1); + emitpcode(PC_NEG, reg2, reg2); + if (write_to_gpr) { + emitpcode(PC_SUBFIC, reg2, reg2, 1); + output->optype = OpndType_GPR; + output->reg = reg2; + output->regHi = 0; + } else { + emitpcode(PC_CMPI, 0, reg2, 0); + output->optype = OpndType_CRField; + output->reg = 0; + output->regOffset = EEQU; + } + break; + default: +#line 8814 + CError_FATAL(); + } +} + +void I8_gen_SHL_SHR(ENode *expr, short outputReg, short outputRegHi, Operand *output) { + static UInt32 used_regs[RegClassMax] = {0, 0, 0, 0, (1 << 3) | (1 << 4) | (1 << 5)}; + + ENode *left; + ENode *right; + Operand opleft; + Operand opright; + int is_uns; + + left = expr->data.diadic.left; + right = expr->data.diadic.right; + memclrw(&opleft, sizeof(Operand)); + memclrw(&opright, sizeof(Operand)); + + GEN_NODE(left, &opleft); + coerce_to_register_pair(&opleft, left->rtype, 0, 0); + + output->optype = OpndType_GPRPair; + output->reg = ALLOC_GPR(); + output->regHi = ALLOC_GPR(); + + is_uns = is_unsigned(expr->rtype) != 0; + + if (ENODE_IS(right, EINTCONST)) { + if (ENODE_IS(expr, ESHL)) { + I8_ShiftLeftImmediate(opleft, right->data.intval.lo, is_uns, expr->rtype->size, output->reg, output->regHi); + } else { + I8_ShiftRightImmediate(opleft, right->data.intval.lo, is_uns, output->reg, output->regHi, 0); + } + return; + } + + GEN_NODE(right, &opright); + ENSURE_GPR(&opright, right->rtype, 0); + if (opright.optype == OpndType_GPRPair) { + opright.regHi = 0; + opright.optype = OpndType_GPR; + } + +#line 8890 + CError_ASSERT(opleft.optype == OpndType_GPRPair && opright.optype == OpndType_GPR); + + if (opleft.regHi != high_reg) + emitpcode(PC_MR, high_reg, opleft.regHi); + if (opleft.reg != low_reg) + emitpcode(PC_MR, low_reg, opleft.reg); + if (opright.reg != 5) + emitpcode(PC_MR, 5, opright.reg); + + if (ENODE_IS(expr, ESHR)) { + if (is_unsigned(left->rtype)) + branch_subroutine(rt_shr2u, 0, used_regs); + else + branch_subroutine(rt_shr2i, 0, used_regs); + } else if (ENODE_IS(expr, ESHL)) { + branch_subroutine(rt_shl2i, 0, used_regs); + } else { +#line 8909 + CError_FATAL(); + } + + emitpcode(PC_MR, output->reg, low_reg); + emitpcode(PC_MR, output->regHi, high_reg); +} + +void I8_gen_DIV_MOD(ENode *expr, short outputReg, short outputRegHi, Operand *output) { + static UInt32 used_regs[RegClassMax] = {0, 0, 0, 0, (1 << 3) | (1 << 4) | (1 << 5) | (1 << 6)}; + + int is_uns; + ENode *left; + ENode *right; + Operand opleft; + Operand opright; + SInt64 constval; + int shift; + + left = expr->data.diadic.left; + right = expr->data.diadic.right; + memclrw(&opleft, sizeof(Operand)); + memclrw(&opright, sizeof(Operand)); + + GEN_NODE(left, &opleft); + coerce_to_register_pair(&opleft, left->rtype, 0, 0); + + output->optype = OpndType_GPRPair; + output->reg = ALLOC_GPR(); + output->regHi = ALLOC_GPR(); + + is_uns = is_unsigned(expr->rtype) != 0; + + if (ENODE_IS(right, EINTCONST)) + constval = (((SInt64) right->data.intval.hi) << 32) + right->data.intval.lo; + if (ENODE_IS(right, EINTCONST) && ((shift = I8_log2n(constval)) > 0)) { +#line 8976 + CError_ASSERT(opleft.optype == OpndType_GPRPair); + if (ENODE_IS(expr, EDIV)) { + I8_ShiftRightImmediate(opleft, shift, is_uns, output->reg, output->regHi, 1); + if (!is_uns) { + emitpcode(PC_ADDZE, output->reg, output->reg); + emitpcode(PC_ADDZE, output->regHi, output->regHi); + } + } else { + if (is_uns) { + if (shift < 32) { + emitpcode(PC_LI, output->regHi, 0); + emitpcode(PC_RLWINM, output->reg, opleft.reg, 0, 32 - shift, 31); + } else if (shift == 32) { + emitpcode(PC_LI, output->regHi, 0); + emitpcode(PC_MR, output->reg, opleft.reg); + } else if (shift <= 63) { + emitpcode(PC_RLWINM, output->regHi, opleft.regHi, 0, 32 - (shift - 32), 31); + emitpcode(PC_MR, output->reg, opleft.reg); + } else { +#line 9018 + CError_FATAL(); + } + } else { + short tmpreg1 = ALLOC_GPR(); + short tmpreg2 = ALLOC_GPR(); + I8_ShiftRightImmediate(opleft, shift, is_uns, output->reg, output->regHi, 1); + emitpcode(PC_ADDZE, output->reg, output->reg); + emitpcode(PC_ADDZE, output->regHi, output->regHi); + I8_ShiftLeftImmediate(*output, shift, is_uns, expr->rtype->size, tmpreg1, tmpreg2); + emitpcode(PC_SUBFC, output->reg, tmpreg1, opleft.reg); + emitpcode(PC_SUBFE, output->regHi, tmpreg2, opleft.regHi); + } + } + return; + } + + GEN_NODE(right, &opright); + coerce_to_register_pair(&opright, right->rtype, 0, 0); + +#line 9048 + CError_ASSERT(opleft.optype == OpndType_GPRPair && opright.optype == OpndType_GPRPair); + + if (opleft.regHi != high_reg) + emitpcode(PC_MR, high_reg, opleft.regHi); + if (opleft.reg != low_reg) + emitpcode(PC_MR, low_reg, opleft.reg); + if (opright.regHi != high_reg2) + emitpcode(PC_MR, high_reg2, opright.regHi); + if (opright.reg != low_reg2) + emitpcode(PC_MR, low_reg2, opright.reg); + + if (ENODE_IS(expr, EDIV)) { + if (is_unsigned(left->rtype) || is_unsigned(right->rtype)) + branch_subroutine(rt_div2u, 0, used_regs); + else + branch_subroutine(rt_div2i, 0, used_regs); + } else if (ENODE_IS(expr, EMODULO)) { + if (is_unsigned(left->rtype) || is_unsigned(right->rtype)) + branch_subroutine(rt_mod2u, 0, used_regs); + else + branch_subroutine(rt_mod2i, 0, used_regs); + } else { +#line 9074 + CError_FATAL(); + } + + emitpcode(PC_MR, output->reg, low_reg); + emitpcode(PC_MR, output->regHi, high_reg); +} + +void I8_gen_TYPCON(ENode *expr, short outputReg, short outputRegHi, Operand *output) { + Type *dsttype; + ENode *inner; + Type *srctype; + short regHi; + short reg; + + static UInt32 used_regs[RegClassMax] = {0, 0, 0, 0, (1 << 3) | (1 << 4)}; + static UInt32 used_regs_f1[RegClassMax] = {0, 0, 0, (1 << 1), 0}; + + inner = expr->data.monadic; + srctype = inner->rtype; + dsttype = expr->rtype; + + if (IS_TYPE_VOID(dsttype)) { + GEN_NODE(inner, output); + if (ENODE_IS(inner, EINDIRECT) && (output->flags & OpndFlags_Volatile)) + coerce_to_register_pair(output, inner->rtype, 0, 0); + output->optype = OpndType_Absolute; + output->immediate = 0; + return; + } + + if (IS_TYPE_INT_OR_ENUM(srctype)) { + if (IS_TYPE_FLOAT(dsttype)) { + GEN_NODE(inner, output); + coerce_to_register_pair(output, srctype, 0, 0); + if (output->regHi != high_reg) + emitpcode(PC_MR, high_reg, output->regHi); + if (output->reg != low_reg) + emitpcode(PC_MR, low_reg, output->reg); + + if (is_unsigned(srctype)) { + branch_subroutine( + (dsttype->size == 4) ? rt_cvt_ull_flt : rt_cvt_ull_dbl, + 0, + used_regs); + } else { + branch_subroutine( + (dsttype->size == 4) ? rt_cvt_sll_flt : rt_cvt_sll_dbl, + 0, + used_regs); + } + + output->optype = OpndType_FPR; + output->reg = ALLOC_FPR(); + emitpcode(PC_FMR, output->reg, 1); + return; + } + + if (srctype->size < dsttype->size) { +#line 9171 + CError_ASSERT(TYPE_IS_8BYTES(dsttype)); + + GEN_NODE(inner, output); + if (srctype->size < 4 && + !ENODE_IS_INDIRECT_TO(inner, EBITFIELD) && + !((ENODE_IS_ASSIGN(inner) || ENODE_IS_RANGE(inner, EPOSTINC, EPREDEC)) && ENODE_IS(inner->data.monadic->data.monadic, EBITFIELD)) + ) { + extend32(output, srctype, outputReg); + } + extend64(output, srctype, outputReg, outputRegHi); + } else { + GEN_NODE_TO_REG(inner, outputReg, 0, output); + if (dsttype->size < srctype->size) { + coerce_to_register_pair(output, srctype, outputReg, outputRegHi); + output->optype = OpndType_GPR; + output->regHi = 0; + } + } + return; + } + + if (IS_TYPE_POINTER(srctype)) { + GEN_NODE_TO_REG(inner, outputReg, 0, output); +#line 9200 + CError_ASSERT(TYPE_IS_8BYTES(expr->rtype)); + GEN_NODE_TO_REG(inner, outputReg, 0, output); + + regHi = outputRegHi ? outputRegHi : ALLOC_GPR(); + if (regHi == output->reg) { + reg = outputReg ? outputReg : ALLOC_GPR(); + emitpcode(PC_MR, reg, output->reg); + output->reg = reg; + } + if (is_unsigned(inner->rtype)) + load_immediate(regHi, 0); + else + emitpcode(PC_SRAWI, regHi, output->reg, 31); + output->optype = OpndType_GPRPair; + output->regHi = regHi; + return; + } + + if (IS_TYPE_FLOAT(srctype)) { + if (IS_TYPE_FLOAT(dsttype)) { +#line 9222 + CError_FATAL(); + return; + } + + GEN_NODE(inner, output); + ENSURE_FPR(output, srctype, 0); + if (output->reg != 1) + emitpcode(PC_FMR, 1, output->reg); + + branch_subroutine(rt_cvt_dbl_usll, 0, used_regs_f1); + + output->optype = OpndType_GPRPair; + output->reg = ALLOC_GPR(); + output->regHi = ALLOC_GPR(); + emitpcode(PC_MR, output->reg, low_reg); + emitpcode(PC_MR, output->regHi, high_reg); + return; + } + + if (IS_TYPE_STRUCT(srctype)) { + GEN_NODE_TO_REG(inner, outputReg, 0, output); + + if (TYPE_IS_8BYTES(expr->rtype) && dsttype->size == srctype->size) { + coerce_to_register_pair(output, srctype, outputReg, outputRegHi); + } else { +#line 9256 + CError_FATAL(); + } + return; + } + +#line 9261 + CError_FATAL(); +} + +void gen_VECTOR128CONST(ENode *expr, short outputReg, short outputRegHi, Operand *output) { + int gpr; + int vr; + COVCResult result; + + vr = outputReg ? outputReg : ALLOC_VR(); + if (!canoptimizevectorconst(&expr->data.vector128val, expr->rtype, &result)) { +#line 9282 + CError_FATAL(); + } + + if (result.op1 != -1) { + emitpcode(result.op1, vr, result.arg); + output->optype = OpndType_VR; + output->reg = vr; + return; + } + + if (result.op2 != -1) { + gpr = ALLOC_GPR(); + emitpcode(PC_LI, gpr, result.arg); + emitpcode(result.op2, vr, 0, gpr); + output->optype = OpndType_VR; + output->reg = vr; + return; + } + +#line 9298 + CError_FATAL(); +} diff --git a/compiler_and_linker/unsorted/InterferenceGraph.c b/compiler_and_linker/unsorted/InterferenceGraph.c new file mode 100644 index 0000000..e69de29 --- /dev/null +++ b/compiler_and_linker/unsorted/InterferenceGraph.c diff --git a/compiler_and_linker/unsorted/Intrinsics.c b/compiler_and_linker/unsorted/Intrinsics.c new file mode 100644 index 0000000..e69de29 --- /dev/null +++ b/compiler_and_linker/unsorted/Intrinsics.c diff --git a/compiler_and_linker/unsorted/IrOptimizer.c b/compiler_and_linker/unsorted/IrOptimizer.c new file mode 100644 index 0000000..e69de29 --- /dev/null +++ b/compiler_and_linker/unsorted/IrOptimizer.c diff --git a/compiler_and_linker/unsorted/IroBitVect.c b/compiler_and_linker/unsorted/IroBitVect.c new file mode 100644 index 0000000..ecaea04 --- /dev/null +++ b/compiler_and_linker/unsorted/IroBitVect.c @@ -0,0 +1,114 @@ +#include "compiler/IroBitVect.h" +#include "compiler/CompilerTools.h" + +void Bv_AllocVector(BitVector **bv, UInt32 size) { + UInt32 long_size = (size / 32) + 1; + *bv = oalloc(sizeof(BitVector) + sizeof(UInt32) * long_size); + (*bv)->size = long_size; + Bv_Clear(*bv); +} + +void Bv_AllocVectorLocal(BitVector **bv, UInt32 size) { + UInt32 long_size = (size / 32) + 1; + *bv = lalloc(sizeof(BitVector) + sizeof(UInt32) * long_size); + (*bv)->size = long_size; + Bv_Clear(*bv); +} + +void Bv_ClearBit(UInt32 bit, BitVector *bv) { + if ((bit / 32) < bv->size) { + bv->data[bit / 32] &= ~(1 << (bit & 31)); + } else { +#line 73 + CError_FATAL(); + } +} + +void Bv_And(const BitVector *a, BitVector *b) { + UInt32 i; + for (i = 0; i < b->size; i++) + b->data[i] &= a->data[i]; +} + +void Bv_Or(const BitVector *a, BitVector *b) { + UInt32 i, len; + + len = a->size; + if (b->size < len) + len = b->size; + + for (i = 0; i < len; i++) { + b->data[i] |= a->data[i]; + } +} + +Boolean Bv_BitsInCommon(const BitVector *a, const BitVector *b) { + UInt32 len; + UInt32 i; + + len = a->size; + if (b->size < len) + len = b->size; + + for (i = 0; i < len; i++) { + if (a->data[i] & b->data[i]) + return 1; + } + + return 0; +} + +Boolean Bv_Compare(const BitVector *a, const BitVector *b) { + UInt32 i; + for (i = 0; i < a->size; i++) { + if (a->data[i] != b->data[i]) + return 0; + } + + return 1; +} + +void Bv_Minus(const BitVector *a, BitVector *b) { + UInt32 i; + for (i = 0; i < b->size; i++) + b->data[i] &= ~a->data[i]; +} + +void Bv_Copy(const BitVector *src, BitVector *dst) { + memcpy(dst->data, src->data, sizeof(UInt32) * dst->size); +} + +void Bv_Clear(BitVector *bv) { + memset(bv->data, 0, sizeof(UInt32) * bv->size); +} + +void Bv_Set(BitVector *bv) { + memset(bv->data, 0xFF, sizeof(UInt32) * bv->size); +} + +Boolean Bv_IsSubset(const BitVector *a, const BitVector *b) { + UInt32 i; + + for (i = 0; i < a->size; i++) { + if (b->size < i) { + if (a->data[i]) + return 0; + } else { + if (a->data[i] & ~(b->data[i])) + return 0; + } + } + + return 1; +} + +Boolean Bv_IsEmpty(const BitVector *bv) { + UInt32 i; + + for (i = 0; i < bv->size; i++) { + if (bv->data[i]) + return 0; + } + + return 1; +} diff --git a/compiler_and_linker/unsorted/IroCSE.c b/compiler_and_linker/unsorted/IroCSE.c new file mode 100644 index 0000000..e69de29 --- /dev/null +++ b/compiler_and_linker/unsorted/IroCSE.c diff --git a/compiler_and_linker/unsorted/IroDump.c b/compiler_and_linker/unsorted/IroDump.c new file mode 100644 index 0000000..e69de29 --- /dev/null +++ b/compiler_and_linker/unsorted/IroDump.c diff --git a/compiler_and_linker/unsorted/IroEmptyLoop.c b/compiler_and_linker/unsorted/IroEmptyLoop.c new file mode 100644 index 0000000..e69de29 --- /dev/null +++ b/compiler_and_linker/unsorted/IroEmptyLoop.c diff --git a/compiler_and_linker/unsorted/IroEval.c b/compiler_and_linker/unsorted/IroEval.c new file mode 100644 index 0000000..e69de29 --- /dev/null +++ b/compiler_and_linker/unsorted/IroEval.c diff --git a/compiler_and_linker/unsorted/IroExprRegeneration.c b/compiler_and_linker/unsorted/IroExprRegeneration.c new file mode 100644 index 0000000..e69de29 --- /dev/null +++ b/compiler_and_linker/unsorted/IroExprRegeneration.c diff --git a/compiler_and_linker/unsorted/IroFlowgraph.c b/compiler_and_linker/unsorted/IroFlowgraph.c new file mode 100644 index 0000000..e69de29 --- /dev/null +++ b/compiler_and_linker/unsorted/IroFlowgraph.c diff --git a/compiler_and_linker/unsorted/IroJump.c b/compiler_and_linker/unsorted/IroJump.c new file mode 100644 index 0000000..e69de29 --- /dev/null +++ b/compiler_and_linker/unsorted/IroJump.c diff --git a/compiler_and_linker/unsorted/IroLinearForm.c b/compiler_and_linker/unsorted/IroLinearForm.c new file mode 100644 index 0000000..e69de29 --- /dev/null +++ b/compiler_and_linker/unsorted/IroLinearForm.c diff --git a/compiler_and_linker/unsorted/IroLoop.c b/compiler_and_linker/unsorted/IroLoop.c new file mode 100644 index 0000000..e69de29 --- /dev/null +++ b/compiler_and_linker/unsorted/IroLoop.c diff --git a/compiler_and_linker/unsorted/IroMalloc.c b/compiler_and_linker/unsorted/IroMalloc.c new file mode 100644 index 0000000..e69de29 --- /dev/null +++ b/compiler_and_linker/unsorted/IroMalloc.c diff --git a/compiler_and_linker/unsorted/IroPointerAnalysis.c b/compiler_and_linker/unsorted/IroPointerAnalysis.c new file mode 100644 index 0000000..e69de29 --- /dev/null +++ b/compiler_and_linker/unsorted/IroPointerAnalysis.c diff --git a/compiler_and_linker/unsorted/IroPropagate.c b/compiler_and_linker/unsorted/IroPropagate.c new file mode 100644 index 0000000..e69de29 --- /dev/null +++ b/compiler_and_linker/unsorted/IroPropagate.c diff --git a/compiler_and_linker/unsorted/IroRangePropagation.c b/compiler_and_linker/unsorted/IroRangePropagation.c new file mode 100644 index 0000000..e69de29 --- /dev/null +++ b/compiler_and_linker/unsorted/IroRangePropagation.c diff --git a/compiler_and_linker/unsorted/IroSubable.c b/compiler_and_linker/unsorted/IroSubable.c new file mode 100644 index 0000000..e69de29 --- /dev/null +++ b/compiler_and_linker/unsorted/IroSubable.c diff --git a/compiler_and_linker/unsorted/IroTransform.c b/compiler_and_linker/unsorted/IroTransform.c new file mode 100644 index 0000000..e69de29 --- /dev/null +++ b/compiler_and_linker/unsorted/IroTransform.c diff --git a/compiler_and_linker/unsorted/IroUnrollLoop.c b/compiler_and_linker/unsorted/IroUnrollLoop.c new file mode 100644 index 0000000..e69de29 --- /dev/null +++ b/compiler_and_linker/unsorted/IroUnrollLoop.c diff --git a/compiler_and_linker/unsorted/IroUtil.c b/compiler_and_linker/unsorted/IroUtil.c new file mode 100644 index 0000000..e69de29 --- /dev/null +++ b/compiler_and_linker/unsorted/IroUtil.c diff --git a/compiler_and_linker/unsorted/IroVars.c b/compiler_and_linker/unsorted/IroVars.c new file mode 100644 index 0000000..e69de29 --- /dev/null +++ b/compiler_and_linker/unsorted/IroVars.c diff --git a/compiler_and_linker/unsorted/LoadDeletion.c b/compiler_and_linker/unsorted/LoadDeletion.c new file mode 100644 index 0000000..e69de29 --- /dev/null +++ b/compiler_and_linker/unsorted/LoadDeletion.c diff --git a/compiler_and_linker/unsorted/LoopDetection.c b/compiler_and_linker/unsorted/LoopDetection.c new file mode 100644 index 0000000..e69de29 --- /dev/null +++ b/compiler_and_linker/unsorted/LoopDetection.c diff --git a/compiler_and_linker/unsorted/LoopOptimization.c b/compiler_and_linker/unsorted/LoopOptimization.c new file mode 100644 index 0000000..e69de29 --- /dev/null +++ b/compiler_and_linker/unsorted/LoopOptimization.c diff --git a/compiler_and_linker/unsorted/MachO.c b/compiler_and_linker/unsorted/MachO.c new file mode 100644 index 0000000..e69de29 --- /dev/null +++ b/compiler_and_linker/unsorted/MachO.c diff --git a/compiler_and_linker/unsorted/ObjGenMachO.c b/compiler_and_linker/unsorted/ObjGenMachO.c new file mode 100644 index 0000000..e69de29 --- /dev/null +++ b/compiler_and_linker/unsorted/ObjGenMachO.c diff --git a/compiler_and_linker/unsorted/Operands.c b/compiler_and_linker/unsorted/Operands.c index c0fee65..68883e0 100644 --- a/compiler_and_linker/unsorted/Operands.c +++ b/compiler_and_linker/unsorted/Operands.c @@ -75,12 +75,12 @@ void indirect(Operand *op, ENode *expr) { set_op_flags(op, expr); break; case OpndType_Absolute: - if (FITS_IN_SHORT(op->abs_address)) { + if (FITS_IN_SHORT(op->immediate)) { op->reg = 0; - op->immOffset = op->abs_address; + op->immOffset = op->immediate; } else { - emitpcode(PC_LIS, op->reg = used_virtual_registers[RegClass_GPR]++, 0, (short) HIGH_PART(op->abs_address)); - op->immOffset = LOW_PART(op->abs_address); + emitpcode(PC_LIS, op->reg = used_virtual_registers[RegClass_GPR]++, 0, (short) HIGH_PART(op->immediate)); + op->immOffset = LOW_PART(op->immediate); } op->object = NULL; op->optype = OpndType_IndirectGPR_ImmOffset; @@ -201,27 +201,27 @@ void combine(Operand *opA, Operand *opB, short output_reg, Operand *opOut) { opOut->reg = opB->reg; opOut->immOffset = opB->immOffset; opOut->object = opB->object; - if (FITS_IN_SHORT(opOut->immOffset + opA->abs_address)) { - opOut->immOffset += opA->abs_address; + if (FITS_IN_SHORT(opOut->immOffset + opA->immediate)) { + opOut->immOffset += opA->immediate; } else { opOut->reg = output_reg ? output_reg : used_virtual_registers[RegClass_GPR]++; - if (!HIGH_PART(opA->abs_address)) { - emitpcode(PC_ADDI, opOut->reg, opB->reg, 0, LOW_PART(opA->abs_address)); + if (!HIGH_PART(opA->immediate)) { + emitpcode(PC_ADDI, opOut->reg, opB->reg, 0, LOW_PART(opA->immediate)); } else { - emitpcode(PC_ADDIS, opOut->reg, opB->reg, 0, (short) HIGH_PART(opA->abs_address)); - if (FITS_IN_SHORT(opOut->immOffset + LOW_PART(opA->abs_address))) { - opOut->immOffset += LOW_PART(opA->abs_address); + emitpcode(PC_ADDIS, opOut->reg, opB->reg, 0, (short) HIGH_PART(opA->immediate)); + if (FITS_IN_SHORT(opOut->immOffset + LOW_PART(opA->immediate))) { + opOut->immOffset += LOW_PART(opA->immediate); } else { - emitpcode(PC_ADDI, opOut->reg, opOut->reg, 0, LOW_PART(opA->abs_address)); + emitpcode(PC_ADDI, opOut->reg, opOut->reg, 0, LOW_PART(opA->immediate)); } } } break; - } else if (opB->object->datatype == DLOCAL && can_add_displ_to_local(opB->object, opB->immOffset + opA->abs_address)) { + } else if (opB->object->datatype == DLOCAL && can_add_displ_to_local(opB->object, opB->immOffset + opA->immediate)) { opOut->optype = OpndType_GPR_ImmOffset; opOut->object = opB->object; opOut->reg = opB->reg; - opOut->immOffset = LOW_PART(opB->immOffset + opA->abs_address); + opOut->immOffset = LOW_PART(opB->immOffset + opA->immediate); break; } else { opOut->reg = output_reg ? output_reg : used_virtual_registers[RegClass_GPR]++; @@ -237,14 +237,14 @@ void combine(Operand *opA, Operand *opB, short output_reg, Operand *opOut) { opA = opB; opB = tmp_op; case COMBO_OP(OpndType_Absolute, OpndType_GPR): - opOut->optype = (opA->abs_address != 0) ? OpndType_GPR_ImmOffset : OpndType_GPR; - opOut->immOffset = LOW_PART(opA->abs_address); + opOut->optype = (opA->immediate != 0) ? OpndType_GPR_ImmOffset : OpndType_GPR; + opOut->immOffset = LOW_PART(opA->immediate); opOut->object = NULL; - if (FITS_IN_SHORT(opA->abs_address)) { + if (FITS_IN_SHORT(opA->immediate)) { opOut->reg = opB->reg; } else { opOut->reg = output_reg ? output_reg : used_virtual_registers[RegClass_GPR]++; - emitpcode(PC_ADDIS, opOut->reg, opB->reg, 0, (short) HIGH_PART(opA->abs_address)); + emitpcode(PC_ADDIS, opOut->reg, opB->reg, 0, (short) HIGH_PART(opA->immediate)); } break; case COMBO_OP(OpndType_GPR_Indexed, OpndType_Absolute): @@ -255,17 +255,17 @@ void combine(Operand *opA, Operand *opB, short output_reg, Operand *opOut) { opOut->optype = OpndType_GPR_Indexed; opOut->reg = opB->reg; opOut->regOffset = (output_reg && (output_reg != opB->reg)) ? output_reg : used_virtual_registers[RegClass_GPR]++; - if (!HIGH_PART(opA->abs_address)) { - emitpcode(PC_ADDI, opOut->regOffset, opB->regOffset, 0, LOW_PART(opA->abs_address)); + if (!HIGH_PART(opA->immediate)) { + emitpcode(PC_ADDI, opOut->regOffset, opB->regOffset, 0, LOW_PART(opA->immediate)); } else { - emitpcode(PC_ADDIS, opOut->regOffset, opB->regOffset, 0, (short) HIGH_PART(opA->abs_address)); - if (opA->abs_address != 0) - emitpcode(PC_ADDI, opOut->regOffset, opOut->regOffset, 0, LOW_PART(opA->abs_address)); + emitpcode(PC_ADDIS, opOut->regOffset, opB->regOffset, 0, (short) HIGH_PART(opA->immediate)); + if (opA->immediate != 0) + emitpcode(PC_ADDI, opOut->regOffset, opOut->regOffset, 0, LOW_PART(opA->immediate)); } break; case COMBO_OP(OpndType_Absolute, OpndType_Absolute): opOut->optype = OpndType_Absolute; - opOut->abs_address = opA->abs_address + opB->abs_address; + opOut->immediate = opA->immediate + opB->immediate; break; default: #line 415 @@ -344,7 +344,6 @@ void coerce_to_addressable(Operand *op) { } } -void Coerce_to_register(Operand *op, Type *type, short output_reg) { SInt32 offset; short opcode; short reg; @@ -375,7 +374,7 @@ void Coerce_to_register(Operand *op, Type *type, short output_reg) { break; case OpndType_Absolute: reg = output_reg ? output_reg : used_virtual_registers[RegClass_GPR]++; - offset = op->abs_address; + offset = op->immediate; if (FITS_IN_SHORT(offset)) { emitpcode(PC_LI, reg, offset); } else { @@ -534,7 +533,7 @@ void coerce_to_register_pair(Operand *op, Type *type, short output_reg, short ou break; case OpndType_Absolute: reg = output_reg ? output_reg : used_virtual_registers[RegClass_GPR]++; - offset = op->abs_address; + offset = op->immediate; if (FITS_IN_SHORT(offset)) { emitpcode(PC_LI, reg, offset); } else { @@ -648,19 +647,19 @@ void Coerce_to_v_register(Operand *op, TypeStruct *tstruct, short output_reg) { case STRUCT_TYPE_4: case STRUCT_TYPE_5: case STRUCT_TYPE_6: - emitpcode(PC_VSPLTISB, reg, op->abs_address); + emitpcode(PC_VSPLTISB, reg, op->immediate); break; case STRUCT_TYPE_7: case STRUCT_TYPE_8: case STRUCT_TYPE_9: case STRUCT_TYPE_E: - emitpcode(PC_VSPLTISH, reg, op->abs_address); + emitpcode(PC_VSPLTISH, reg, op->immediate); break; case STRUCT_TYPE_A: case STRUCT_TYPE_B: case STRUCT_TYPE_C: case STRUCT_TYPE_D: - emitpcode(PC_VSPLTISW, reg, op->abs_address); + emitpcode(PC_VSPLTISW, reg, op->immediate); break; default: #line 1049 @@ -754,7 +753,7 @@ void store_pair(short reg, short regHi, Operand *op, Type *type) { } } -void store_fp(short reg, Operand *op, TypeIntegral *tint) { +void store_fp(short reg, Operand *op, Type *tint) { coerce_to_addressable(op); switch (op->optype) { case OpndType_IndirectGPR_ImmOffset: @@ -771,7 +770,7 @@ void store_fp(short reg, Operand *op, TypeIntegral *tint) { } } -void store_v(short reg, Operand *op, TypeStruct *tstruct) { +void store_v(short reg, Operand *op, Type *tstruct) { coerce_to_addressable(op); switch (op->optype) { case OpndType_IndirectGPR_ImmOffset: @@ -880,7 +879,7 @@ void extend64(Operand *op, Type *type, short output_reg, short output_regHi) { op->regHi = regHi; } -void load_floating_constant(short reg, TypeIntegral *type, double *data) { +void load_floating_constant(short reg, Type *type, double *data) { // do me AFTER } diff --git a/compiler_and_linker/unsorted/PCode.c b/compiler_and_linker/unsorted/PCode.c index 0fde159..f53030b 100644 --- a/compiler_and_linker/unsorted/PCode.c +++ b/compiler_and_linker/unsorted/PCode.c @@ -1,18 +1,22 @@ -#include "compiler.h" #include "compiler/CompilerTools.h" +#include "compiler/CFunc.h" +#include "compiler/CodeGen.h" #include "compiler/PCode.h" #include "compiler/PCodeInfo.h" +// TODO: move me +extern void initialize_aliases(); + PCodeBlock *pcbasicblocks; PCodeBlock *pclastblock; -void *prologue; -void *epilogue; +PCodeBlock *prologue; +PCodeBlock *epilogue; PCodeBlock **depthfirstordering; int pcblockcount; int pcloopweight; static unsigned short pclabelcount; -void initpcode() { +void initpcode(void) { pclastblock = 0; pcbasicblocks = 0; pcblockcount = 0; @@ -21,7 +25,7 @@ void initpcode() { initialize_aliases(); } -PCode *makepcode(short op, ...) { +PCode *makepcode(Opcode op, ...) { PCode *pcode; va_list list; @@ -31,7 +35,7 @@ PCode *makepcode(short op, ...) { return pcode; } -void emitpcode(short op, ...) { +void emitpcode(Opcode op, ...) { PCode *pcode; va_list list; @@ -67,7 +71,7 @@ PCode *copypcode(PCode *pcode) { return newpc; } -PCodeLabel *makepclabel() { +PCodeLabel *makepclabel(void) { PCodeLabel *label; label = (PCodeLabel *) lalloc(sizeof(PCodeLabel)); @@ -76,7 +80,7 @@ PCodeLabel *makepclabel() { return label; } -PCodeBlock *makepcblock() { +PCodeBlock *makepcblock(void) { PCodeBlock *block; block = (PCodeBlock *) lalloc(sizeof(PCodeBlock)); @@ -123,7 +127,7 @@ void pcbranch(PCodeBlock *block, PCodeLabel *label) { block->successors = link; } -void pccomputepredecessors() { +void pccomputepredecessors(void) { PCodeBlock *block; PCLink *succ; PCLink *pred; @@ -147,7 +151,7 @@ void deleteblock(PCodeBlock *block) { block->flags |= fPCBlockFlag20; } -void deleteunreachableblocks() { +void deleteunreachableblocks(void) { PCodeBlock *block; computedepthfirstordering(); @@ -238,7 +242,7 @@ void clearpcodeflags(int flags) { pclastblock->lastPCode->flags &= ~flags; } -int pccomputeoffsets() { +int pccomputeoffsets(void) { int offset; PCodeBlock *block; @@ -258,7 +262,7 @@ typedef struct _DFO { static int depthfirstorder; -void computedepthfirstordering() { +void computedepthfirstordering(void) { PCodeBlock *block; PCLink *link; DFO *dfo; diff --git a/compiler_and_linker/unsorted/PCodeAssembly.c b/compiler_and_linker/unsorted/PCodeAssembly.c new file mode 100644 index 0000000..e69de29 --- /dev/null +++ b/compiler_and_linker/unsorted/PCodeAssembly.c diff --git a/compiler_and_linker/unsorted/PCodeInfo.c b/compiler_and_linker/unsorted/PCodeInfo.c index e48dac0..3646930 100644 --- a/compiler_and_linker/unsorted/PCodeInfo.c +++ b/compiler_and_linker/unsorted/PCodeInfo.c @@ -90,7 +90,7 @@ int pcode_check_imm_bits(SInt32 value, int bits, char typechar) { return 0; } -int pcode_const_from_format(const char *format, int *pResult) { +int pcode_const_from_format(const char *format, SInt32 *pResult) { char buf[32]; int len = 0; diff --git a/compiler_and_linker/unsorted/PCodeListing.c b/compiler_and_linker/unsorted/PCodeListing.c new file mode 100644 index 0000000..e69de29 --- /dev/null +++ b/compiler_and_linker/unsorted/PCodeListing.c diff --git a/compiler_and_linker/unsorted/PPCError.c b/compiler_and_linker/unsorted/PPCError.c new file mode 100644 index 0000000..2ba28bd --- /dev/null +++ b/compiler_and_linker/unsorted/PPCError.c @@ -0,0 +1,71 @@ +#include "compiler/PPCError.h" +#include "compiler/CError.h" +#include "compiler/CParser.h" +#include "compiler/InlineAsm.h" +#include "cos.h" + +static void PPCError_GetErrorString(char *str, short code) { + short scode; + + scode = (short) code; +#line 40 + CError_ASSERT(scode >= 100 && scode < 212); + + COS_GetString(str, 10001, scode - 99); +} + +static void PPCError_VAErrorMessage(int code, va_list list, Boolean flag1, Boolean flag2) { + char format[256]; + PPCError_GetErrorString(format, code); + CError_ErrorMessageVA(code + 10001, format, list, flag1, flag2); +} + +void PPCError_Error(int code, ...) { + va_list list; + + if (trychain) + longjmp(trychain->jmpbuf, 1); + + va_start(list, code); + PPCError_VAErrorMessage(code, list, 0, 0); + va_end(list); + + if (in_assembler) + AssemblerError(); +} + +void PPCError_Warning(int code, ...) { + va_list list; + + if (!trychain) { + va_start(list, code); + PPCError_VAErrorMessage(code, list, 0, 1); + va_end(list); + } +} + +void PPCError_Message(char *format, ...) { + va_list list; + + if (!trychain) { + va_start(list, format); + CError_ErrorMessageVA(10213, format, list, 0, 1); + va_end(list); + } +} + +void PPCError_ErrorTerm(short code, ...) { + va_list list; + + if (trychain) + longjmp(trychain->jmpbuf, 1); + + va_start(list, code); + PPCError_VAErrorMessage(code, list, 1, 0); + va_end(list); + + if (in_assembler) + AssemblerError(); + + longjmp(errorreturn, 1); +} diff --git a/compiler_and_linker/unsorted/Peephole.c b/compiler_and_linker/unsorted/Peephole.c new file mode 100644 index 0000000..e69de29 --- /dev/null +++ b/compiler_and_linker/unsorted/Peephole.c diff --git a/compiler_and_linker/unsorted/RegisterInfo.c b/compiler_and_linker/unsorted/RegisterInfo.c index c1e67d8..80e348d 100644 --- a/compiler_and_linker/unsorted/RegisterInfo.c +++ b/compiler_and_linker/unsorted/RegisterInfo.c @@ -1,7 +1,11 @@ -#include "compiler.h" +#include "compiler/RegisterInfo.h" +#include "compiler/CodeGen.h" #include "compiler/CError.h" -#include "compiler/objects.h" +#include "compiler/CParser.h" #include "compiler/PCode.h" +#include "compiler/CompilerTools.h" +#include "compiler/objects.h" +#include "compiler/types.h" short last_exception_register[RegClassMax]; short first_fe_temporary_register[RegClassMax]; @@ -12,8 +16,6 @@ char *special_register_names[RegClassMax][RegisterMax]; static short used_regs_before_coloring; static UInt8 save_state[RegisterMax]; -char *XXspecial_register_names[RegClassMax * RegisterMax]; - short spr_to_sysreg[4] = {1, 8, 9, 0x100}; void asm_used_register(char rclass, short reg) { @@ -104,7 +106,7 @@ static int first_nonvolatile_reg(char rclass) { return GetABIFirstNonVolatile(rclass); } -void setup_diagnostic_reg_strings() { +void setup_diagnostic_reg_strings(void) { register_class_name[RegClass_SPR] = "SPR"; register_class_format[RegClass_SPR] = "spr%ld"; register_class_name[RegClass_CRFIELD] = "CRFIELD"; @@ -117,7 +119,7 @@ void setup_diagnostic_reg_strings() { register_class_format[RegClass_GPR] = "r%ld"; } -void init_target_registers() { +void init_target_registers(void) { char rclass; int reg; int end; @@ -244,7 +246,7 @@ void assign_GPR_pair(Object *obj) { } } -void open_fe_temp_registers() { +void open_fe_temp_registers(void) { int r; r = used_virtual_registers[RegClass_GPR]; @@ -258,13 +260,13 @@ void open_fe_temp_registers() { //first_fe_temporary_register[RegClass_VR] = last_temporary_register[RegClass_VR] = used_virtual_registers[RegClass_VR]; } -void set_last_exception_registers() { +void set_last_exception_registers(void) { last_exception_register[RegClass_GPR] = used_virtual_registers[RegClass_GPR] - 1; last_exception_register[RegClass_FPR] = used_virtual_registers[RegClass_FPR] - 1; last_exception_register[RegClass_VR] = used_virtual_registers[RegClass_VR] - 1; } -static VarInfo *Registers_GetNewVarInfo() { +static VarInfo *Registers_GetNewVarInfo(void) { VarInfo *vi = galloc(sizeof(VarInfo)); memclrw(vi, sizeof(VarInfo)); return vi; @@ -302,7 +304,7 @@ VarInfo *Registers_GetVarInfo(Object *obj) { } } -int used_vrstate_VRs() { +int used_vrstate_VRs(void) { int count = 0; int i; for (i = 0; i < RegisterMax; i++) { @@ -318,9 +320,9 @@ UInt32 colored_vrs_as_vrsave(PCodeBlock *block) { int i; mask = 0; - if (copts.x1B == 2) + if (copts.altivec_vrsave == 2) return 0xFFFFFFFF; - if (copts.x1B == 0) + if (copts.altivec_vrsave == 0) return 0; while (block) { @@ -359,7 +361,7 @@ int is_nonvolatile_register(char rclass, int reg) { return 0; } -void init_endian() { +void init_endian(void) { if (copts.little_endian) { high_offset = 4; low_offset = 0; @@ -377,7 +379,7 @@ void init_endian() { } } -void update_asm_nonvolatile_registers() { +void update_asm_nonvolatile_registers(void) { char rclass; int r31; diff --git a/compiler_and_linker/unsorted/Registers.c b/compiler_and_linker/unsorted/Registers.c index 9bcbf05..b8951b7 100644 --- a/compiler_and_linker/unsorted/Registers.c +++ b/compiler_and_linker/unsorted/Registers.c @@ -1,6 +1,9 @@ -#include "compiler.h" -#include "compiler/objects.h" +#include "compiler/Registers.h" +#include "compiler/RegisterInfo.h" +#include "compiler/CParser.h" #include "compiler/PCode.h" +#include "compiler/CompilerTools.h" +#include "compiler/objects.h" // haven't checked this object file for .data stuff yet @@ -30,7 +33,7 @@ typedef struct ModifiedRegisters { } ModifiedRegisters; static ModifiedRegisters *mod_regs_table[128]; -void init_registers() { +void init_registers(void) { char rclass; int j; @@ -117,7 +120,7 @@ short obtain_nonvolatile_register(char rclass) { return best; } -void open_temp_registers() { +void open_temp_registers(void) { int rclass; for (rclass = 0; (char)rclass < RegClassMax; rclass++) { @@ -135,7 +138,7 @@ void open_temp_registers() { }*/ } -void check_temp_registers() { +void check_temp_registers(void) { char rclass; if (!optimizing) { @@ -148,7 +151,7 @@ void check_temp_registers() { } } -void close_temp_registers() { +void close_temp_registers(void) { char rclass; for (rclass = 0; rclass < RegClassMax; rclass++) { @@ -159,7 +162,7 @@ void close_temp_registers() { } } -int count_scratch_registers() { +int count_scratch_registers(void) { int rclass; int count; @@ -169,7 +172,7 @@ int count_scratch_registers() { return count; } -void init_modified_registers() { +void init_modified_registers(void) { int i = 0; for (i = 0; i < 128; i++) diff --git a/compiler_and_linker/unsorted/Scheduler.c b/compiler_and_linker/unsorted/Scheduler.c new file mode 100644 index 0000000..e69de29 --- /dev/null +++ b/compiler_and_linker/unsorted/Scheduler.c diff --git a/compiler_and_linker/unsorted/SpillCode.c b/compiler_and_linker/unsorted/SpillCode.c new file mode 100644 index 0000000..e69de29 --- /dev/null +++ b/compiler_and_linker/unsorted/SpillCode.c diff --git a/compiler_and_linker/unsorted/StackFrame.c b/compiler_and_linker/unsorted/StackFrame.c index 5789cb5..18cb6fd 100644 --- a/compiler_and_linker/unsorted/StackFrame.c +++ b/compiler_and_linker/unsorted/StackFrame.c @@ -64,7 +64,7 @@ static void save_nonvolatile_GPRs(int reg, SInt32 offset); static void restore_nonvolatile_GPRs(int reg, SInt32 offset); static void do_allocate_dynamic_stack_space(Boolean flag1, int reg1, int reg2, SInt32 size); -void init_stack_globals(void) { +void init_stack_globals(Object *funcobj) { char rclass; UInt8 oclass; @@ -115,7 +115,7 @@ void init_stack_globals(void) { } } -void init_frame_sizes(void) { +void init_frame_sizes(Boolean has_varargs) { ObjectList *scan; Object *obj; SInt32 r30; @@ -326,7 +326,7 @@ static void allocate_new_frame(int reg1, int reg2) { } } -void generate_prologue(PCodeBlock *block) { +void generate_prologue(PCodeBlock *block, Boolean has_varargs) { PCodeBlock *save_block; Boolean needs_lr; Statement *save_statement; diff --git a/compiler_and_linker/unsorted/StrengthReduction.c b/compiler_and_linker/unsorted/StrengthReduction.c new file mode 100644 index 0000000..e69de29 --- /dev/null +++ b/compiler_and_linker/unsorted/StrengthReduction.c diff --git a/compiler_and_linker/unsorted/StructMoves.c b/compiler_and_linker/unsorted/StructMoves.c new file mode 100644 index 0000000..e69de29 --- /dev/null +++ b/compiler_and_linker/unsorted/StructMoves.c diff --git a/compiler_and_linker/unsorted/Switch.c b/compiler_and_linker/unsorted/Switch.c new file mode 100644 index 0000000..af62eb3 --- /dev/null +++ b/compiler_and_linker/unsorted/Switch.c @@ -0,0 +1,78 @@ +#include "compiler/Switch.h" +#include "compiler/CError.h" +#include "compiler/CFunc.h" +#include "compiler/CInt64.h" +#include "compiler/objects.h" +#include "compiler/CParser.h" +#include "compiler/PCode.h" + +ObjectList *switchtables; +static void *caselabels; +static void *caseranges; +static SInt32 ncases; +static SInt32 nranges_minus1; +static CInt64 min; +static CInt64 max; +static CInt64 first; +static short selector_gpr; +static short selector_gprHi; +static Type *selector_type; +static PCodeLabel *defaultlabel; +static CInt64 range; + +static void compare_cases() { +} + +static void build_case_ranges(Type *type, SwitchCase *cases, CLabel *label) { +} + +static void treecompare() { +} + +static void I8_treecompare() { +} + +static void generate_tree(ENode *expr) { +} + +static void create_switch_table() { +} + +static void generate_table(ENode *expr, SwitchInfo *info) { +} + +void switchstatement(ENode *expr, SwitchInfo *info) { + Boolean use_table; + SwitchCase *swcase; + + use_table = copts.switch_tables; + + ncases = 0; + for (swcase = info->cases; swcase; swcase = swcase->next) { + if (!swcase->label->pclabel) + swcase->label->pclabel = makepclabel(); + ncases++; + } + +#line 656 + CError_ASSERT(ncases >= 0 && ncases <= 0x3333332); + + if (!info->defaultlabel->pclabel) + info->defaultlabel->pclabel = makepclabel(); + defaultlabel = info->defaultlabel->pclabel; + + build_case_ranges(expr->rtype, info->cases, info->defaultlabel); + + if (TYPE_IS_8BYTES(expr->rtype)) { + generate_tree(expr); + return; + } + + if (!use_table || nranges_minus1 < 8 || (nranges_minus1 * 2) < ((range.lo / 1) + 4)) + generate_tree(expr); + else + generate_table(expr, info); +} + +void dumpswitchtables(Object *funcobj) { +} diff --git a/compiler_and_linker/unsorted/TOC.c b/compiler_and_linker/unsorted/TOC.c index 65dc39b..0f3024f 100644 --- a/compiler_and_linker/unsorted/TOC.c +++ b/compiler_and_linker/unsorted/TOC.c @@ -1,15 +1,21 @@ #include "cos.h" #include "compiler/TOC.h" +#include "compiler/CDecl.h" #include "compiler/CError.h" #include "compiler/CInt64.h" +#include "compiler/CFunc.h" +#include "compiler/CMachine.h" +#include "compiler/CMangler.h" +#include "compiler/CParser.h" +#include "compiler/CodeGen.h" #include "compiler/Operands.h" #include "compiler/PCode.h" #include "compiler/PCodeInfo.h" #include "compiler/StackFrame.h" +#include "compiler/CompilerTools.h" #include "compiler/enode.h" #include "compiler/objects.h" #include "compiler/types.h" -#include "compiler.h" ObjectList *toclist; ObjectList *exceptionlist; diff --git a/compiler_and_linker/unsorted/Unmangle.c b/compiler_and_linker/unsorted/Unmangle.c new file mode 100644 index 0000000..e69de29 --- /dev/null +++ b/compiler_and_linker/unsorted/Unmangle.c diff --git a/compiler_and_linker/unsorted/UseDefChains.c b/compiler_and_linker/unsorted/UseDefChains.c new file mode 100644 index 0000000..e69de29 --- /dev/null +++ b/compiler_and_linker/unsorted/UseDefChains.c diff --git a/compiler_and_linker/unsorted/ValueNumbering.c b/compiler_and_linker/unsorted/ValueNumbering.c new file mode 100644 index 0000000..e69de29 --- /dev/null +++ b/compiler_and_linker/unsorted/ValueNumbering.c diff --git a/compiler_and_linker/unsorted/VectorArraysToRegs.c b/compiler_and_linker/unsorted/VectorArraysToRegs.c new file mode 100644 index 0000000..e69de29 --- /dev/null +++ b/compiler_and_linker/unsorted/VectorArraysToRegs.c diff --git a/includes/compiler.h b/includes/compiler.h index 6557749..cea535f 100644 --- a/includes/compiler.h +++ b/includes/compiler.h @@ -32,113 +32,6 @@ struct InlineXRef { -typedef enum ExceptionActionType { - EAT_NOP, - EAT_DESTROYLOCAL, - EAT_DESTROYLOCALCOND, - EAT_DESTROYLOCALOFFSET, - EAT_DESTROYLOCALPOINTER, - EAT_DESTROYLOCALARRAY, - EAT_DESTROYPARTIALARRAY, - EAT_DESTROYMEMBER, - EAT_DESTROYMEMBERCOND, - EAT_DESTROYMEMBERARRAY, - EAT_DELETEPOINTER, - EAT_DELETELOCALPOINTER, - EAT_DELETEPOINTERCOND, - EAT_CATCHBLOCK, - EAT_ACTIVECATCHBLOCK, - EAT_SPECIFICATION, - EAT_TERMINATE, - EAT_DESTROYBASE, - EAT_NACTIONS -} ExceptionActionType; - -struct ExceptionAction { - ExceptionAction *prev; - union { - struct { - Object *local; - Object *dtor; - } destroy_local; - struct { - Object *local; - Object *cond; - Object *dtor; - } destroy_local_cond; - struct { - Object *local; - Object *dtor; - SInt32 offset; - } destroy_local_offset; - struct { - Object *pointer; - Object *dtor; - } destroy_local_pointer; - struct { - Object *localarray; - Object *dtor; - SInt32 elements; - SInt32 element_size; - } destroy_local_array; - struct { - Object *arraypointer; - Object *arraycounter; - Object *dtor; - Object *element_size; - } destroy_partial_array; - struct { - Object *objectptr; - Object *dtor; - SInt32 offset; - } destroy_member; - struct { - Object *objectptr; - Object *cond; - Object *dtor; - SInt32 offset; - } destroy_member_cond; - struct { - Object *objectptr; - Object *dtor; - SInt32 offset; - SInt32 elements; - SInt32 element_size; - } destroy_member_array; - struct { - Object *pointerobject; - Object *deletefunc; - } delete_pointer; - struct { - Object *pointerobject; - Object *deletefunc; - Object *cond; - } delete_pointer_cond; - struct { - Object *catch_object; - Object *catch_info_object; - CLabel *catch_label; - Object *catch_typeid; - Type *catch_type; - UInt32 catch_qual; - } catch_block; - struct { - Object *catch_info_object; - Boolean call_dtor; - } active_catch_block; - struct { - SInt32 unexp_ids; - Object **unexp_id; - CLabel *unexp_label; - Object *unexp_info_object; - } specification; - struct { - Object *object; - Boolean is_dep; - } local; - } data; - ExceptionActionType type; -}; struct MemInitializer { MemInitializer *next; @@ -211,89 +104,8 @@ typedef struct Substitution { } Substitution; // Registers.c -enum { - RegisterMax = 32 -}; -const char RegClass_SPR = 0; -const char RegClass_CRFIELD = 1; -const char RegClass_VR = 2; -const char RegClass_FPR = 3; -const char RegClass_GPR = 4; -const char RegClassMax = 5; -/*enum RegClass { - RegClass_SPR, - RegClass_CRFIELD, - RegClass_VR, - RegClass_FPR, - RegClass_GPR, - RegClassMax -};*/ - -enum { - RegState0 = 0, - RegState1 = 1, - RegState2 = 2 -}; - -extern int used_virtual_registers[RegClassMax]; -extern int used_nonvolatile_registers[RegClassMax]; -extern int assignable_registers[RegClassMax]; -extern int n_real_registers[RegClassMax]; -extern int n_scratch_registers[RegClassMax]; -extern int scratch_registers[RegClassMax][RegisterMax]; -extern int n_nonvolatile_registers[RegClassMax]; -extern int nonvolatile_registers[RegClassMax][RegisterMax]; -extern UInt8 reg_state[RegClassMax][RegisterMax]; -extern int first_temporary_register[RegClassMax]; -extern int last_temporary_register[RegClassMax]; -extern char *register_class_name[RegClassMax]; -extern char *register_class_format[RegClassMax]; -extern int coloring; -extern int optimizing; - -extern void init_registers(); -extern void assign_register_to_variable(Object *obj, char rclass); -extern void retain_register_for_argument(Object *obj, char rclass, short reg); -extern int available_registers(char rclass); -extern UInt32 volatile_registers(char rclass); -extern short obtain_nonvolatile_register(char rclass); -extern void open_temp_registers(); -extern void check_temp_registers(); -extern void close_temp_registers(); -extern int count_scratch_registers(); -extern void init_modified_registers(); -extern void note_modified_registers(Object *obj); -extern void find_modified_registers(Object *obj, UInt32 *masks); // RegisterInfo.c -extern short last_exception_register[RegClassMax]; -extern short first_fe_temporary_register[RegClassMax]; -extern short last_argument_register[RegClassMax]; -extern short _FP_; -extern short _CALLER_SP_; -extern char *special_register_names[RegClassMax][RegisterMax]; -extern short spr_to_sysreg[4]; - -extern void asm_used_register(char rclass, short reg); -extern void retain_register(Object *obj, char rclass, short reg); -extern void retain_GPR_pair(Object *obj, short reg, short regHi); -extern int is_register_object(Object *obj); -extern int GetABIFirstNonVolatile(char rclass); -extern char GetRegisterClassName(char rclass); -extern void setup_diagnostic_reg_strings(); -extern void init_target_registers(); -extern void assign_register_by_type(Object *obj); -extern void assign_GPR_pair(Object *obj); -extern void open_fe_temp_registers(); -extern void set_last_exception_registers(); -extern VarInfo *Registers_GetVarInfo(Object *obj); -extern int used_vrstate_VRs(); -extern UInt32 colored_vrs_as_vrsave(PCodeBlock *block); -extern void save_before_coloring_nonvolatile_registers(char rclass); -extern void reset_nonvolatile_registers(char rclass); -extern int is_nonvolatile_register(char rclass, int reg); -extern void init_endian(); -extern void update_asm_nonvolatile_registers(); // LOOSE DECLS extern short high_offset; @@ -453,42 +265,8 @@ enum { INTRINSIC_36 = 36 }; -enum { - CPU_PPC401, - CPU_PPC403, - CPU_PPC505, - CPU_PPC509, - CPU_PPC555, - CPU_PPC601, - CPU_PPC602, - CPU_PPC603, - CPU_PPC603e, - CPU_PPC604, - CPU_PPC604e, - CPU_PPC740, - CPU_PPC750, - CPU_PPC801, - CPU_PPC821, - CPU_PPC823, - CPU_PPC850, - CPU_PPC860, - CPU_PPC8240, - CPU_PPC8260, - CPU_PPC7400 = 0x15, - CPU_PPCGEKKO, - CPU_PPCELF, - CPU_PPC7450, - CPU_PPC556, - CPU_PPC565 -}; - extern char *ScanFloat(char *input, double *output, Boolean *fail); -#define FITS_IN_SHORT(value) ( (value) == ((short) (value)) ) -// should HIGH_PART have (short) around it? -#define HIGH_PART(value) ( (((value) >> 16) + (((value) & 0x8000) >> 15)) ) -#define LOW_PART(value) ( (short) (value) ) - #ifdef __MWERKS__ #pragma options align=reset #endif diff --git a/includes/compiler/AddPropagation.h b/includes/compiler/AddPropagation.h new file mode 100644 index 0000000..1f4b94a --- /dev/null +++ b/includes/compiler/AddPropagation.h @@ -0,0 +1,6 @@ +#ifndef COMPILER_ADDPROPAGATION_H +#define COMPILER_ADDPROPAGATION_H + +#include "compiler/common.h" + +#endif diff --git a/includes/compiler/Alias.h b/includes/compiler/Alias.h new file mode 100644 index 0000000..39f7220 --- /dev/null +++ b/includes/compiler/Alias.h @@ -0,0 +1,6 @@ +#ifndef COMPILER_ALIAS_H +#define COMPILER_ALIAS_H + +#include "compiler/common.h" + +#endif diff --git a/includes/compiler/BitVectors.h b/includes/compiler/BitVectors.h new file mode 100644 index 0000000..7849dcb --- /dev/null +++ b/includes/compiler/BitVectors.h @@ -0,0 +1,6 @@ +#ifndef COMPILER_BITVECTORS_H +#define COMPILER_BITVECTORS_H + +#include "compiler/common.h" + +#endif diff --git a/includes/compiler/CABI.h b/includes/compiler/CABI.h index fde5b21..8f0d3f4 100644 --- a/includes/compiler/CABI.h +++ b/includes/compiler/CABI.h @@ -8,7 +8,7 @@ #pragma options align=mac68k #endif -extern short CABI_GetStructResultArgumentIndex(void); +extern short CABI_GetStructResultArgumentIndex(TypeFunc *tfunc); extern Type *CABI_GetSizeTType(void); extern Type *CABI_GetPtrDiffTType(void); extern SInt16 CABI_StructSizeAlignValue(Type *type, SInt32 size); diff --git a/includes/compiler/CBrowse.h b/includes/compiler/CBrowse.h new file mode 100644 index 0000000..2bcfb51 --- /dev/null +++ b/includes/compiler/CBrowse.h @@ -0,0 +1,6 @@ +#ifndef COMPILER_CBROWSE_H +#define COMPILER_CBROWSE_H + +#include "compiler/common.h" + +#endif diff --git a/includes/compiler/CClass.h b/includes/compiler/CClass.h index edefa92..083588c 100644 --- a/includes/compiler/CClass.h +++ b/includes/compiler/CClass.h @@ -25,7 +25,7 @@ extern ENode *CClass_DefaultConstructorCall(TypeClass *a, TypeClass *b, ENode *e extern Object *CClass_AssignmentOperator(TypeClass *tclass); extern Object *CClass_CopyConstructor(TypeClass *tclass); extern NameSpaceObjectList *CClass_MemberObject(TypeClass *tclass, HashNameNode *name); -extern Object *CClass_Constructor(TypeClass *tclass); +extern NameSpaceObjectList *CClass_Constructor(TypeClass *tclass); extern Object *CClass_Destructor(TypeClass *tclass); extern Boolean CClass_IsConstructor(Object *obj); extern Boolean CClass_IsDestructor(Object *obj); diff --git a/includes/compiler/CCompiler.h b/includes/compiler/CCompiler.h new file mode 100644 index 0000000..92b483c --- /dev/null +++ b/includes/compiler/CCompiler.h @@ -0,0 +1,14 @@ +#ifndef COMPILER_CCOMPILER_H +#define COMPILER_CCOMPILER_H + +#include "compiler/common.h" + +extern Boolean systemHandles; +extern Boolean crippled; +extern SInt32 license_cookie; +extern CParams cparams; + +extern CWPLUGIN_ENTRY(MWC_main)(CWPluginContext context); +extern void PrintProgressFunction(const char *str); + +#endif diff --git a/includes/compiler/CException.h b/includes/compiler/CException.h new file mode 100644 index 0000000..0a4d60d --- /dev/null +++ b/includes/compiler/CException.h @@ -0,0 +1,6 @@ +#ifndef COMPILER_CEXCEPTION_H +#define COMPILER_CEXCEPTION_H + +#include "compiler/common.h" + +#endif diff --git a/includes/compiler/CExpr.h b/includes/compiler/CExpr.h index a82e56e..24f0646 100644 --- a/includes/compiler/CExpr.h +++ b/includes/compiler/CExpr.h @@ -45,19 +45,26 @@ typedef struct Match5 { } Match5; typedef struct Match13 { - short x0; - short x2; - short x4; - short x6; - short x8; - short xA; - short xC; + Object *obj; + Match5 anotherm5; short xE; Match5 match5; + ObjectList *list; } Match13; +typedef struct FuncMatchArgs { + ENodeList *exprs; + FuncArg *args; +} FuncMatchArgs; + +typedef struct Conversion { + ENode *x0; + ENode *left; + ENode *right; +} Conversion; + // CExpr.c -extern Boolean (*name_obj_check)(void *, Object *); // TODO figure out the right type +extern Boolean (*name_obj_check)(HashNameNode *, Object *); extern Boolean disallowgreaterthan; // CExpr2.c @@ -65,63 +72,63 @@ extern ENode *assign_node; extern Boolean temp_reference_init; // CExpr.c -extern void CExpr_RewriteConst(); +extern ENode *CExpr_RewriteConst(ENode *expr); extern void optimizecomm(ENode *expr); extern short canadd(ENode *expr, SInt32 value); extern ENode *checkreference(ENode *expr); extern ENode *pointer_generation(ENode *expr); -extern void CExpr_PointerGeneration(); -extern void oldassignmentpromotion(); +extern ENode *CExpr_PointerGeneration(ENode *expr); +extern ENode *oldassignmentpromotion(ENode *expr, Type *type, short qual, Boolean flag); extern ENode *argumentpromotion(ENode *expr, Type *type, short qual, Boolean flag); extern ENode *classargument(ENode *expr); -extern ENodeList *CExpr_ScanExpressionList(Boolean flag); -extern void CExpr_DoExplicitConversion(); -extern void CExpr_MakeNameLookupResultExpr(); -extern void scansizeof(); -extern void scanalignof(); +extern ENodeList *CExpr_ScanExpressionList(Boolean is_parens); +extern ENode *CExpr_DoExplicitConversion(Type *type, UInt32 qual, ENodeList *list); +extern ENode *CExpr_MakeNameLookupResultExpr(CScopeParseResult *pr); +extern SInt32 scansizeof(void); +extern SInt32 scanalignof(void); extern ENode *getnodeaddress(ENode *expr, Boolean flag); -extern void getpointertomemberfunc(); -extern void CExpr_New_ELOGNOT_Node(); -extern void CExpr_New_EMONMIN_Node(); -extern void CExpr_New_EBINNOT_Node(); +extern ENode *getpointertomemberfunc(ENode *expr, Type *type, Boolean flag); +extern ENode *CExpr_New_ELOGNOT_Node(ENode *expr); +extern ENode *CExpr_New_EMONMIN_Node(ENode *expr); +extern ENode *CExpr_New_EBINNOT_Node(ENode *expr); extern ENode *unary_expression(void); -extern ENode *do_castnullcheck(ENode *a, ENode *b); -extern void CExpr_SafeClassPointerCast(); +extern ENode *do_castnullcheck(ENode *condexpr, ENode *nullcheckexpr); +extern ENode *CExpr_SafeClassPointerCast(ENode *expr, TypeClass *a, TypeClass *b, Boolean typconflag, Boolean pathcheckflag); extern ENode *PointerToMemberCast(ENode *expr, TypeMemberPointer *tm1, TypeMemberPointer *tm2, Boolean flag); -extern void CExpr_MemberPointerConversion(); +extern ENode *CExpr_MemberPointerConversion(ENode *expr, TypeMemberPointer *type, Boolean flag1); extern ENode *do_typecast(ENode *expr, Type *type, UInt32 qual); -extern void cast_expression(); -extern void CExpr_New_EMUL_Node(); -extern void CExpr_New_EDIV_Node(); -extern void CExpr_New_EMODULO_Node(); -extern void CExpr_New_EADD_Node(); -extern void CExpr_New_ESUB_Node(); -extern void CExpr_New_ESHL_Node(); -extern void CExpr_New_ESHR_Node(); -extern void CExpr_New_ELESS_Node(); -extern void CExpr_New_ELESSEQU_Node(); -extern void CExpr_New_EGREATER_Node(); -extern void CExpr_New_EGREATEREQU_Node(); +extern ENode *cast_expression(void); +extern ENode *CExpr_New_EMUL_Node(ENode *left, ENode *right); +extern ENode *CExpr_New_EDIV_Node(ENode *left, ENode *right, Boolean no_warning); +extern ENode *CExpr_New_EMODULO_Node(ENode *left, ENode *right, Boolean no_warning); +extern ENode *CExpr_New_EADD_Node(ENode *left, ENode *right); +extern ENode *CExpr_New_ESUB_Node(ENode *left, ENode *right); +extern ENode *CExpr_New_ESHL_Node(ENode *left, ENode *right); +extern ENode *CExpr_New_ESHR_Node(ENode *left, ENode *right); +extern ENode *CExpr_New_ELESS_Node(ENode *left, ENode *right); +extern ENode *CExpr_New_ELESSEQU_Node(ENode *left, ENode *right); +extern ENode *CExpr_New_EGREATER_Node(ENode *left, ENode *right); +extern ENode *CExpr_New_EGREATEREQU_Node(ENode *left, ENode *right); extern ENode *memberpointercompare(ENodeType t, ENode *left, ENode *right); -extern void CExpr_New_EEQU_Node(); -extern void CExpr_New_ENOTEQU_Node(); -extern void CExpr_New_EAND_Node(); -extern void CExpr_New_EXOR_Node(); -extern void CExpr_New_EOR_Node(); -extern void CExpr_New_ELAND_Node(); -extern void CExpr_New_ELOR_Node(); -extern void CExpr_NewDyadicNode(); -extern void CExpr_New_ECOND_Node(); +extern ENode *CExpr_New_EEQU_Node(ENode *left, ENode *right); +extern ENode *CExpr_New_ENOTEQU_Node(ENode *left, ENode *right); +extern ENode *CExpr_New_EAND_Node(ENode *left, ENode *right); +extern ENode *CExpr_New_EXOR_Node(ENode *left, ENode *right); +extern ENode *CExpr_New_EOR_Node(ENode *left, ENode *right); +extern ENode *CExpr_New_ELAND_Node(ENode *left, ENode *right); +extern ENode *CExpr_New_ELOR_Node(ENode *left, ENode *right); +extern ENode *CExpr_NewDyadicNode(ENode *left, ENodeType nt, ENode *right); +extern ENode *CExpr_New_ECOND_Node(ENode *cond, ENode *expr1, ENode *expr2); extern ENode *assignment_expression(void); extern ENode *conv_assignment_expression(void); -extern void CExpr_CheckUnusedExpression(); -extern void s_expression(); +extern void CExpr_CheckUnusedExpression(ENode *expr); +extern ENode *s_expression(void); extern ENode *expression(void); extern CInt64 CExpr_IntegralConstExprType(Type **tint); extern ENode *CExpr_IntegralConstOrDepExpr(void); extern CInt64 CExpr_IntegralConstExpr(void); -extern void CExpr_CheckUnwantedAssignment(); -extern void CExpr_ParseAsmExpr(); +extern void CExpr_CheckUnwantedAssignment(ENode *expr); +extern Boolean CExpr_ParseAsmExpr(Object **objptr, CInt64 *valptr); // CExpr2.c typedef void (*CExprSearchCB)(ENode *expr); @@ -170,24 +177,24 @@ extern ENode *CExpr_GetClassAccessNode(BClassList *a, BClassList *b, ENode *expr extern ENode *CExpr_ConvertToBool(ENode *expr, Boolean flag); extern void CExpr_ConversionIteratorInit(ConversionIterator *iter, TypeClass *tclass); extern Object *CExpr_ConversionIteratorNext(ConversionIterator *iter); -extern void user_assign_check(); +extern short user_assign_check(ENode *expr, Type *type, UInt32 qual, Boolean flag1, Boolean flag2, Boolean flag3); extern ENode *CExpr_ConvertToCondition(ENode *expr); -extern void CExpr_ConvertToIntegral(); -extern void CExpr_CheckArithmConversion(); -extern void get_address_of_temp_copy(); +extern ENode *CExpr_ConvertToIntegral(ENode *expr); +extern void CExpr_CheckArithmConversion(ENode *expr, Type *type); +extern ENode *get_address_of_temp_copy(ENode *expr, Boolean flag); extern short assign_check(ENode *expr, Type *type, UInt32 qual, Boolean flag1, Boolean flag2, Boolean flag3); -extern void CExpr_MatchCompare(); -extern void CExpr_GetFuncMatchArgs(); +extern Boolean CExpr_MatchCompare(Object *obj, Match13 *a, Match13 *b); +extern Boolean CExpr_GetFuncMatchArgs(Object *obj, ENodeList *argexprs, ENode *expr, FuncMatchArgs *result); extern ENode *CExpr_GetDefaultArgument(ENode *funcexpr, FuncArg *arg); extern ENode *CExpr_VarArgPromotion(ENode *expr, Boolean flag); -extern void CExpr_GenericFuncCall(); -extern void CExpr_GenericPtmfCall(); -extern void CExpr_MakeFunctionCall(); -extern void CExpr_CheckOperatorConversion(); -extern void CExpr_CheckOperator(); +extern ENode *CExpr_GenericFuncCall(BClassList *path, ENode *funcexpr, Boolean flag1, Object *obj, NameSpaceObjectList *nsol, TemplArg *templargs, ENodeList *nodes, Boolean flag2, Boolean flag3, Boolean flag4); +extern ENode *CExpr_GenericPtmfCall(Object *obj, TypeFunc *tfunc, ENodeList *arg_exprs); +extern ENode *CExpr_MakeFunctionCall(ENode *funcexpr, ENodeList *arg_exprs); +extern Boolean CExpr_CheckOperatorConversion(short token, ENode *left, ENode *right, ENodeList *list, Conversion *conv); +extern Boolean CExpr_CheckOperator(short token, ENode *left, ENode *right, Conversion *conv); extern ENode *CExpr_ConstructObject(TypeClass *tclass, ENode *addr_expr, ENodeList *args, Boolean flag1, Boolean flag2, Boolean flag3, Boolean flag4, Boolean flag5); -extern void scannew(); -extern void scandelete(); +extern ENode *scannew(Boolean flag); +extern ENode *scandelete(Boolean flag); // CExprConvMatch.c // static void CExpr_GetImplictObjectParamType(); @@ -216,7 +223,7 @@ extern ENode *CExpr_AssignmentPromotion(ENode *expr, Type *type, UInt32 qual, Bo // static void CExpr_MatchArgs(); // static void CExpr_GetMatchObject(); // static void CExpr_FindBestMatch(); -extern void CExpr_FuncArgMatch(); +extern void CExpr_FuncArgMatch(NameSpaceObjectList *nsol, TemplArg *templargs, ENodeList *argexprs, Match13 *match, ENode *expr, Boolean flag); // static void CExpr_BuildConversionTypeList(); // static void CExpr_NextPromotedIntegralType(); // static void CExpr_NextArithmeticType(); @@ -226,8 +233,8 @@ extern void CExpr_FuncArgMatch(); // static void CExpr_CheckUnaryBuiltin(); // static void CExpr_CheckBinaryBuiltin(); // static void CExpr_MatchOperands(); -extern void CExpr_CondOperatorMatch(); -extern void CExpr_OperatorMatch(); +extern Boolean CExpr_CondOperatorMatch(ENode *left, ENode *right, Conversion *conv); +extern Boolean CExpr_OperatorMatch(short token, ENode *left, ENode *right, Conversion *conv); // static void CExpr_ClassCopyInit(); #ifdef __MWERKS__ diff --git a/includes/compiler/CFunc.h b/includes/compiler/CFunc.h index 2247e5e..a0fadad 100644 --- a/includes/compiler/CFunc.h +++ b/includes/compiler/CFunc.h @@ -47,9 +47,19 @@ typedef enum StatementType { } StatementType; enum { - StmtFlag_1 = 1 + StmtFlag_1 = 1, + StmtFlag_8 = 8, + StmtFlag_10 = 0x10 }; +// TODO: move me - ST_BEGINLOOP related? +typedef struct LoopInfo { + int x0; + int x4; + short x8; + Statement *stmt; +} LoopInfo; + struct Statement { Statement *next; StatementType type; diff --git a/includes/compiler/CIRTransform.h b/includes/compiler/CIRTransform.h new file mode 100644 index 0000000..b4d9227 --- /dev/null +++ b/includes/compiler/CIRTransform.h @@ -0,0 +1,6 @@ +#ifndef COMPILER_CIRTRANSFORM_H +#define COMPILER_CIRTRANSFORM_H + +#include "compiler/common.h" + +#endif diff --git a/includes/compiler/CInline.h b/includes/compiler/CInline.h index 1b5abd5..576f7e1 100644 --- a/includes/compiler/CInline.h +++ b/includes/compiler/CInline.h @@ -101,7 +101,7 @@ extern Boolean CInline_ExpressionHasSideEffect(ENode *expr); extern ENode *CInline_CopyExpression(ENode *expr, CInlineCopyMode mode); extern void CInline_SerializeStatement(Statement *stmt); extern Object *CInline_GetLocalObj(SInt32 id, Boolean flag); -extern SInt32 CInline_GetStatementNumber(Statement *first, Statement *stmt); +extern SInt16 CInline_GetStatementNumber(Statement *first, Statement *stmt); extern void CInline_PackIFunctionData(CI_FuncData *packed, Statement *stmt, Object *obj); extern void CInline_UnpackIFunctionData(Object *obj, CI_FuncData *packed, Statement *stmt); extern void CInline_AddDefaultFunctionAction(Object *obj); diff --git a/includes/compiler/CMachine.h b/includes/compiler/CMachine.h index a4bc1a5..be763d5 100644 --- a/includes/compiler/CMachine.h +++ b/includes/compiler/CMachine.h @@ -71,7 +71,7 @@ extern SInt32 CMach_StructLayoutGetOffset(Type *type, UInt32 qual); extern SInt32 CMach_StructLayoutBitfield(TypeBitfield *tbitfield, UInt32 qual); extern UInt8 CMach_GetFunctionResultClass(TypeFunc *tfunc); extern Boolean CMach_PassResultInHiddenArg(Type *type); -extern const char *CMach_GetCPU(void); +extern char *CMach_GetCPU(void); extern Boolean CMach_FloatIsPowerOf2(Float flt); extern Float CMach_FloatReciprocal(Float flt); extern SInt32 CMach_RoundedSizeOf(Object *object); diff --git a/includes/compiler/CObjC.h b/includes/compiler/CObjC.h new file mode 100644 index 0000000..92a4efa --- /dev/null +++ b/includes/compiler/CObjC.h @@ -0,0 +1,6 @@ +#ifndef COMPILER_COBJC_H +#define COMPILER_COBJC_H + +#include "compiler/common.h" + +#endif diff --git a/includes/compiler/CObjCModern.h b/includes/compiler/CObjCModern.h new file mode 100644 index 0000000..df21f56 --- /dev/null +++ b/includes/compiler/CObjCModern.h @@ -0,0 +1,6 @@ +#ifndef COMPILER_COBJCMODERN_H +#define COMPILER_COBJCMODERN_H + +#include "compiler/common.h" + +#endif diff --git a/includes/compiler/COptimizer.h b/includes/compiler/COptimizer.h new file mode 100644 index 0000000..4e01334 --- /dev/null +++ b/includes/compiler/COptimizer.h @@ -0,0 +1,55 @@ +#ifndef COMPILER_COPTIMIZER_H +#define COMPILER_COPTIMIZER_H + +#include "compiler/common.h" + +#ifdef __MWERKS__ +#pragma options align=mac68k +#endif +typedef struct COptBlockList { + struct COptBlockList *next; + struct COptBlock *block; +} COptBlockList; + +typedef struct COptBlock { + struct COptBlock *next; + COptBlockList *blocks; + COptBlockList *blocks2; + Statement *stmt; + short *set1; + short *set2; + UInt32 allocmask; + short x1C; + Boolean x1E; +} COptBlock; + +typedef struct COptCSE { + struct COptCSE *next; + struct COptCSE *left; + struct COptCSE *right; + COptBlock *block; + ENode *expr; + ENode *mexpr; + ENode *replaced; + short x1C; +} COptCSE; + +typedef struct COptCSEList { + struct COptCSEList *next; + COptCSE *cse; + ENode *expr; +} COptCSEList; +#ifdef __MWERKS__ +#pragma options align=reset +#endif + +extern COptBlock *basicblocks; +extern Boolean copt_isleaffunction; + +extern UInt32 RegAllocMask(short var); +extern void MarkRegAllocMask(short var, short bit, Boolean flag); +extern void SetVarUsage(Object *obj, Boolean noregister); +extern void COpt_SimpleOptimizer(Object *obj, Statement *stmt); +extern Statement *COpt_Optimizer(Object *obj, Statement *stmt); + +#endif diff --git a/includes/compiler/CParser.h b/includes/compiler/CParser.h index 21a3d59..4eb1abb 100644 --- a/includes/compiler/CParser.h +++ b/includes/compiler/CParser.h @@ -22,6 +22,37 @@ enum { AlignMode8_Packed }; +enum { + CPU_PPC401, + CPU_PPC403, + CPU_PPC505, + CPU_PPC509, + CPU_PPC555, + CPU_PPC601, + CPU_PPC602, + CPU_PPC603, + CPU_PPC603e, + CPU_PPC604, + CPU_PPC604e, + CPU_PPC740, + CPU_PPC750, + CPU_PPC801, + CPU_PPC821, + CPU_PPC823, + CPU_PPC850, + CPU_PPC860, + CPU_PPC8240, + CPU_PPC8260, + CPU_Generic, + CPU_PPC7400, + CPU_PPCGEKKO, + CPU_PPCELF, + CPU_PPC7450, + CPU_PPC556, + CPU_PPC565 +}; + + // not sure how many of these are char and how many are unsigned char or Boolean typedef struct COpts { Boolean little_endian; @@ -33,18 +64,18 @@ typedef struct COpts { char x06; // linker/objgen related short cpu; char schedule_cpu; - unsigned char schedule_mode; // may be an enum?? + char schedule_mode; // may be an enum?? SInt32 debuglisting; - char profile; - char traceback; + Boolean profile; + Boolean traceback; Boolean disable_registers; - char fp_contract; + Boolean fp_contract; Boolean no_register_save_helpers; char ppc_unroll_speculative; short ppc_unroll_instructions_limit; short ppc_unroll_factor_limit; Boolean altivec_model; - UInt8 x1B; // altivec/vrsave related + UInt8 altivec_vrsave; UInt8 code_alignment; char x1D; UInt8 x1E; // some register used in TOC_use_isel @@ -53,7 +84,7 @@ typedef struct COpts { Boolean use_lmw_stmw; char report_heap_info; char misaligned_mem_access; - char switch_tables; + Boolean switch_tables; char prepare_compress; char some_alignment; // used in CMach_AllocationAlignment Boolean asmsemicolcomment; @@ -80,7 +111,7 @@ typedef struct COpts { Boolean cpp_extensions; Boolean pointercast_lvalue; char useRTTI; - char delete_exception; + Boolean delete_exception; char _4B; Boolean oldalignment; Boolean unsignedchars; @@ -95,7 +126,7 @@ typedef struct COpts { Boolean longlong; Boolean longlong_enums; char no_tfuncinline; - char _59; + Boolean _59; Boolean flat_include; char syspath_once; Boolean always_import; @@ -110,7 +141,7 @@ typedef struct COpts { Boolean array_new_delete; Boolean dollar_identifiers; char def_inline_tfuncs; - char arg_dep_lookup; + Boolean arg_dep_lookup; Boolean simple_prepdump; char line_prepdump; char fullpath_prepdump; @@ -139,18 +170,18 @@ typedef struct COpts { Boolean supress_warnings; Boolean warn_illpragma; Boolean warn_emptydecl; - char warn_possunwant; + Boolean warn_possunwant; char warn_unusedvar; char warn_unusedarg; Boolean warn_extracomma; char warn_hidevirtual; Boolean warn_largeargs; - char warn_implicitconv; + Boolean warn_implicitconv; char warn_notinlined; Boolean warn_structclass; Boolean warn_padding; - char warn_no_side_effect; - char warn_resultnotused; + Boolean warn_no_side_effect; + Boolean warn_resultnotused; char warn_ptr_int_conv; char align_mode; Boolean align_array_members; @@ -163,7 +194,7 @@ typedef struct COpts { char dont_inline; char always_inline; Boolean peephole; - char global_optimizer; + Boolean global_optimizer; char side_effects; Boolean internal; Boolean import; @@ -173,7 +204,7 @@ typedef struct COpts { char force_active; char optimizationlevel; Boolean optimize_for_size; - char optimizewithasm; + Boolean optimizewithasm; Boolean crippled; char opt_common_subs; char opt_loop_invariants; diff --git a/includes/compiler/CPrep.h b/includes/compiler/CPrep.h index a681ec5..749303d 100644 --- a/includes/compiler/CPrep.h +++ b/includes/compiler/CPrep.h @@ -24,6 +24,15 @@ typedef struct TokenStack { Boolean macrocheck; } TokenStack; +//#define OPT_OFFSET(optname) ((short) (((char *) (&copts.optname)) - ((char *) &copts))) +#define OPT_OFFSET(optname) ((short) ( &((COpts *)0)->optname )) +enum { + OPT_OFFSET_MASK = 0x1FFF, + OPT_FLAG_2000 = 0x2000, + OPT_FLAG_4000 = 0x4000, + OPT_FLAG_8000 = 0x8000 +}; + extern CParams *cparamblkptr; extern short tk; extern CInt64 tkintconst; @@ -71,9 +80,12 @@ extern void CPrep_RemoveSpecialMacros(void); extern Boolean setupprep(void); extern void cleanupprep(void); extern void CPrep_TSBufferGrow(int amount); +// this is actually an arg of `PrepState *` extern void CPrep_TokenStreamGetState(SInt32 *state); +// this is actually an arg of `const PrepState *` extern void CPrep_TokenStreamSetState(SInt32 *state); extern void CPrep_UnLex(void); +// this is actually an arg of `const PrepState *` extern void CPrep_TokenStreamSetCurState(SInt32 *state); typedef void (*CPrepStreamFuncPtr)(TStreamElement *); extern void CPrep_StreamGetBlock(TStream *stream, CPrepStreamFuncPtr func, int arg); diff --git a/includes/compiler/CPreprocess.h b/includes/compiler/CPreprocess.h new file mode 100644 index 0000000..55ba280 --- /dev/null +++ b/includes/compiler/CPreprocess.h @@ -0,0 +1,6 @@ +#ifndef COMPILER_CPREPROCESS_H +#define COMPILER_CPREPROCESS_H + +#include "compiler/common.h" + +#endif diff --git a/includes/compiler/CRTTI.h b/includes/compiler/CRTTI.h new file mode 100644 index 0000000..6543e0f --- /dev/null +++ b/includes/compiler/CRTTI.h @@ -0,0 +1,6 @@ +#ifndef COMPILER_CRTTI_H +#define COMPILER_CRTTI_H + +#include "compiler/common.h" + +#endif diff --git a/includes/compiler/CSOM.h b/includes/compiler/CSOM.h new file mode 100644 index 0000000..560993b --- /dev/null +++ b/includes/compiler/CSOM.h @@ -0,0 +1,6 @@ +#ifndef COMPILER_CSOM_H +#define COMPILER_CSOM_H + +#include "compiler/common.h" + +#endif diff --git a/includes/compiler/CScope.h b/includes/compiler/CScope.h index 95266b1..b5c8348 100644 --- a/includes/compiler/CScope.h +++ b/includes/compiler/CScope.h @@ -20,6 +20,7 @@ typedef struct CScopeSave { Boolean is_member_func; } CScopeSave; // assumed name +// this might be called NameResult typedef struct CScopeParseResult { NameSpace *nspace_0; HashNameNode *name_4; diff --git a/includes/compiler/CTemplateClass.h b/includes/compiler/CTemplateClass.h new file mode 100644 index 0000000..747a944 --- /dev/null +++ b/includes/compiler/CTemplateClass.h @@ -0,0 +1,6 @@ +#ifndef COMPILER_CTEMPLATECLASS_H +#define COMPILER_CTEMPLATECLASS_H + +#include "compiler/common.h" + +#endif diff --git a/includes/compiler/CTemplateFunc.h b/includes/compiler/CTemplateFunc.h new file mode 100644 index 0000000..1461ee4 --- /dev/null +++ b/includes/compiler/CTemplateFunc.h @@ -0,0 +1,6 @@ +#ifndef COMPILER_CTEMPLATEFUNC_H +#define COMPILER_CTEMPLATEFUNC_H + +#include "compiler/common.h" + +#endif diff --git a/includes/compiler/CTemplateNew.h b/includes/compiler/CTemplateNew.h new file mode 100644 index 0000000..3fbdeb9 --- /dev/null +++ b/includes/compiler/CTemplateNew.h @@ -0,0 +1,6 @@ +#ifndef COMPILER_CTEMPLATENEW_H +#define COMPILER_CTEMPLATENEW_H + +#include "compiler/common.h" + +#endif diff --git a/includes/compiler/CTemplateTools.h b/includes/compiler/CTemplateTools.h new file mode 100644 index 0000000..df4ad30 --- /dev/null +++ b/includes/compiler/CTemplateTools.h @@ -0,0 +1,6 @@ +#ifndef COMPILER_CTEMPLATETOOLS_H +#define COMPILER_CTEMPLATETOOLS_H + +#include "compiler/common.h" + +#endif diff --git a/includes/compiler/CodeGen.h b/includes/compiler/CodeGen.h index 3954d51..fb8ff94 100644 --- a/includes/compiler/CodeGen.h +++ b/includes/compiler/CodeGen.h @@ -11,8 +11,8 @@ extern Macro vecM; extern Macro altivecM; extern Object *gFunction; -extern PCodeLabel *returnlabel; -extern PCodeLabel *cleanreturnlabel; +extern CLabel *returnlabel; +extern CLabel *cleanreturnlabel; extern Boolean needs_cleanup; extern Statement *current_statement; extern int has_catch_blocks; @@ -48,29 +48,29 @@ extern Object *maketemporary(Type *type); typedef void (*ArgumentProcessor)(Object *obj, short reg); extern void process_arguments(ArgumentProcessor func, Boolean flag); extern void move_assigned_argument(Object *obj, short reg); -extern void assign_labels(); -extern void CodeGen_Generator(); -extern void CodeGen_GenVDispatchThunk(); -extern void CodeGen_SetupRuntimeObjects(); +extern void assign_labels(Statement *stmt); +extern void CodeGen_Generator(Statement **statements, Object *func, UInt8 mysteryFlag, Boolean callOnModuleBind); +extern void CodeGen_GenVDispatchThunk(Object *thunkobj, Object *obj, SInt32 a, SInt32 b, SInt32 c); +extern void CodeGen_SetupRuntimeObjects(void); extern Boolean CodeGen_ReInitRuntimeObjects(Boolean is_precompiler); extern Boolean CodeGen_IsPublicRuntimeObject(Object *obj); -extern void CodeGen_SOMStub(); +extern void CodeGen_SOMStub(Object *a, Object *b, Object *c, SInt32 offset); extern void CodeGen_ParseDeclSpec(HashNameNode *identifier, DeclInfo *declinfo); extern void CodeGen_ParsePragma(HashNameNode *name); extern void CodeGen_UpdateObject(Object *object); -extern void CodeGen_UpdateBackEndOptions(); +extern void CodeGen_UpdateBackEndOptions(void); extern void CodeGen_objc_method_self_offset(); extern void CodeGen_objc_method_sel_offset(); extern void CodeGen_objc_method_arg_offset(); extern void CodeGen_objc_method_args_size(); -extern void CodeGen_HandleIntrinsicCall(); -extern void CodeGen_HandleTypeCast(); +extern ENode *CodeGen_HandleIntrinsicCall(Object *func, ENodeList *arg_exprs); +extern ENode *CodeGen_HandleTypeCast(ENode *expr, Type *type, UInt32 qual); extern short CodeGen_AssignCheck(ENode *expr, Type *type, Boolean flag1, Boolean flag2); -extern void CodeGen_CollapseVectorExpression(); -extern void CodeGen_InsertSpecialMacros(); +extern Boolean CodeGen_CollapseVectorExpression(ENode *expr, MWVector128 *vec, Type *type); +extern void CodeGen_InsertSpecialMacros(void); extern char *CodeGen_ExpandSpecialMacro(Macro *macro); -extern void CodeGen_reportheapinfo(); -extern void CodeGen_InitialSanityCheck(); +extern void CodeGen_reportheapinfo(Boolean release_flag, char *name, char *text); +extern void CodeGen_InitialSanityCheck(void); #ifdef __MWERKS__ #pragma options align=reset diff --git a/includes/compiler/CodeGenOptPPC.h b/includes/compiler/CodeGenOptPPC.h new file mode 100644 index 0000000..f51c49f --- /dev/null +++ b/includes/compiler/CodeGenOptPPC.h @@ -0,0 +1,11 @@ +#ifndef COMPILER_CODEGENOPTPPC_H +#define COMPILER_CODEGENOPTPPC_H + +#include "compiler/common.h" + +extern void CodeGen_InitCompiler(void); +extern void CodeGen_TermCompiler(void); +extern void CodeGen_InitBackEndOptions(void); +extern void Test_Version_Numbers(void); + +#endif diff --git a/includes/compiler/CodeMotion.h b/includes/compiler/CodeMotion.h new file mode 100644 index 0000000..5d25726 --- /dev/null +++ b/includes/compiler/CodeMotion.h @@ -0,0 +1,6 @@ +#ifndef COMPILER_CODEMOTION_H +#define COMPILER_CODEMOTION_H + +#include "compiler/common.h" + +#endif diff --git a/includes/compiler/Coloring.h b/includes/compiler/Coloring.h new file mode 100644 index 0000000..85bacf6 --- /dev/null +++ b/includes/compiler/Coloring.h @@ -0,0 +1,6 @@ +#ifndef COMPILER_COLORING_H +#define COMPILER_COLORING_H + +#include "compiler/common.h" + +#endif diff --git a/includes/compiler/ConstantPropagation.h b/includes/compiler/ConstantPropagation.h new file mode 100644 index 0000000..4b702ee --- /dev/null +++ b/includes/compiler/ConstantPropagation.h @@ -0,0 +1,6 @@ +#ifndef COMPILER_CONSTANTPROPAGATION_H +#define COMPILER_CONSTANTPROPAGATION_H + +#include "compiler/common.h" + +#endif diff --git a/includes/compiler/CopyPropagation.h b/includes/compiler/CopyPropagation.h new file mode 100644 index 0000000..841f8dc --- /dev/null +++ b/includes/compiler/CopyPropagation.h @@ -0,0 +1,6 @@ +#ifndef COMPILER_COPYPROPAGATION_H +#define COMPILER_COPYPROPAGATION_H + +#include "compiler/common.h" + +#endif diff --git a/includes/compiler/Exceptions.h b/includes/compiler/Exceptions.h new file mode 100644 index 0000000..f1096c8 --- /dev/null +++ b/includes/compiler/Exceptions.h @@ -0,0 +1,122 @@ +#ifndef COMPILER_EXCEPTIONS_H +#define COMPILER_EXCEPTIONS_H + +#include "compiler/common.h" + +#ifdef __MWERKS__ +#pragma options align=mac68k +#endif + +typedef enum ExceptionActionType { + EAT_NOP, + EAT_DESTROYLOCAL, + EAT_DESTROYLOCALCOND, + EAT_DESTROYLOCALOFFSET, + EAT_DESTROYLOCALPOINTER, + EAT_DESTROYLOCALARRAY, + EAT_DESTROYPARTIALARRAY, + EAT_DESTROYMEMBER, + EAT_DESTROYMEMBERCOND, + EAT_DESTROYMEMBERARRAY, + EAT_DELETEPOINTER, + EAT_DELETELOCALPOINTER, + EAT_DELETEPOINTERCOND, + EAT_CATCHBLOCK, + EAT_ACTIVECATCHBLOCK, + EAT_SPECIFICATION, + EAT_TERMINATE, + EAT_DESTROYBASE, + EAT_NACTIONS +} ExceptionActionType; + +struct ExceptionAction { + ExceptionAction *prev; + union { + struct { + Object *local; + Object *dtor; + } destroy_local; + struct { + Object *local; + Object *cond; + Object *dtor; + } destroy_local_cond; + struct { + Object *local; + Object *dtor; + SInt32 offset; + } destroy_local_offset; + struct { + Object *pointer; + Object *dtor; + } destroy_local_pointer; + struct { + Object *localarray; + Object *dtor; + SInt32 elements; + SInt32 element_size; + } destroy_local_array; + struct { + Object *arraypointer; + Object *arraycounter; + Object *dtor; + Object *element_size; + } destroy_partial_array; + struct { + Object *objectptr; + Object *dtor; + SInt32 offset; + } destroy_member; + struct { + Object *objectptr; + Object *cond; + Object *dtor; + SInt32 offset; + } destroy_member_cond; + struct { + Object *objectptr; + Object *dtor; + SInt32 offset; + SInt32 elements; + SInt32 element_size; + } destroy_member_array; + struct { + Object *pointerobject; + Object *deletefunc; + } delete_pointer; + struct { + Object *pointerobject; + Object *deletefunc; + Object *cond; + } delete_pointer_cond; + struct { + Object *catch_object; + Object *catch_info_object; + CLabel *catch_label; + Object *catch_typeid; + Type *catch_type; + UInt32 catch_qual; + } catch_block; + struct { + Object *catch_info_object; + Boolean call_dtor; + } active_catch_block; + struct { + SInt32 unexp_ids; + Object **unexp_id; + CLabel *unexp_label; + Object *unexp_info_object; + } specification; + struct { + Object *object; + Boolean is_dep; + } local; + } data; + ExceptionActionType type; +}; + +#ifdef __MWERKS__ +#pragma options align=reset +#endif + +#endif diff --git a/includes/compiler/FuncLevelAsmPPC.h b/includes/compiler/FuncLevelAsmPPC.h new file mode 100644 index 0000000..45c1727 --- /dev/null +++ b/includes/compiler/FuncLevelAsmPPC.h @@ -0,0 +1,12 @@ +#ifndef COMPILER_FUNCLEVELASMPPC_H +#define COMPILER_FUNCLEVELASMPPC_H + +#include "compiler/common.h" + +extern void setup_assembly_argument(Object *obj, short i); +extern void assign_local_addresses(); +extern void Assembler(); +extern void SetupAssembler(); +extern void CleanupAssembler(); + +#endif diff --git a/includes/compiler/FunctionCalls.h b/includes/compiler/FunctionCalls.h new file mode 100644 index 0000000..b915a39 --- /dev/null +++ b/includes/compiler/FunctionCalls.h @@ -0,0 +1,6 @@ +#ifndef COMPILER_FUNCTIONCALLS_H +#define COMPILER_FUNCTIONCALLS_H + +#include "compiler/common.h" + +#endif diff --git a/includes/compiler/GCCInlineAsm.h b/includes/compiler/GCCInlineAsm.h new file mode 100644 index 0000000..0b61384 --- /dev/null +++ b/includes/compiler/GCCInlineAsm.h @@ -0,0 +1,11 @@ +#ifndef COMPILER_GCCINLINEASM_H +#define COMPILER_GCCINLINEASM_H + +#include "compiler/common.h" + +extern void InlineAsm_SkipComment(); +extern void InlineAsm_gcc_parse(void); + +extern Statement *first_ST_ASM; + +#endif diff --git a/includes/compiler/GenStabs.h b/includes/compiler/GenStabs.h new file mode 100644 index 0000000..16fd204 --- /dev/null +++ b/includes/compiler/GenStabs.h @@ -0,0 +1,6 @@ +#ifndef COMPILER_GENSTABS_H +#define COMPILER_GENSTABS_H + +#include "compiler/common.h" + +#endif diff --git a/includes/compiler/GlobalOptimizer.h b/includes/compiler/GlobalOptimizer.h new file mode 100644 index 0000000..5460edd --- /dev/null +++ b/includes/compiler/GlobalOptimizer.h @@ -0,0 +1,6 @@ +#ifndef COMPILER_GLOBALOPTIMIZER_H +#define COMPILER_GLOBALOPTIMIZER_H + +#include "compiler/common.h" + +#endif diff --git a/includes/compiler/IROUseDef.h b/includes/compiler/IROUseDef.h new file mode 100644 index 0000000..5a13581 --- /dev/null +++ b/includes/compiler/IROUseDef.h @@ -0,0 +1,6 @@ +#ifndef COMPILER_IROUSEDEF_H +#define COMPILER_IROUSEDEF_H + +#include "compiler/common.h" + +#endif diff --git a/includes/compiler/InlineAsm.h b/includes/compiler/InlineAsm.h new file mode 100644 index 0000000..aadbc1f --- /dev/null +++ b/includes/compiler/InlineAsm.h @@ -0,0 +1,239 @@ +#ifndef COMPILER_INLINEASM_H +#define COMPILER_INLINEASM_H + +#include "compiler/common.h" +#include "compiler/PCodeInfo.h" + +#ifdef __MWERKS__ +#pragma options align=mac68k +#endif +typedef struct IAMnemonic { + char *name; + UInt32 x4; + char *format; + UInt32 cpu; + UInt32 x10; +} IAMnemonic; + +typedef struct IARegister { + char *name; + char rclass; + SInt32 num; + Object *object; +} IARegister; + +typedef enum IAOperandType { + IAOpnd_0, + IAOpnd_Imm, + IAOpnd_Reg, + IAOpnd_3, + IAOpnd_4, + IAOpnd_Lab, + IAOpnd_6, + IAOpnd_7, + IAOpnd_LabDiff +} IAOperandType; +typedef struct IAOperand { + IAOperandType type; + Boolean negated; + union { + // type 1 + struct { + SInt32 value; + } imm; + // type 2 + struct { + SInt32 num; + Object *object; + short effect; + short rclass; + } reg; + // type 3, 4 + struct { + SInt32 offset; + Object *obj; + short unk; + } obj; + // type 5 + struct { + CLabel *label; + } lab; + // type 6 + struct { + SInt32 num; + UInt8 unk4; + short effect; + short rclass; + } unk6; + // type 7 + struct { + SInt32 value; + Boolean unk1; + short unk2; + short unk3; + } unk7; + // type 8 + struct { + CLabel *label1; + CLabel *label2; + SInt32 offset; + } labdiff; + } u; +} IAOperand; + +typedef enum IAExprType { + IAExpr_0, + IAExpr_1, + IAExpr_2, + IAExpr_3, + IAExpr_4, + IAExpr_5, + IAExpr_6, + IAExpr_7, + IAExpr_8, + IAExpr_9, + IAExpr_10 +} IAExprType; + +typedef struct IAExpr { + IAExprType type; + UInt8 flags; + short reg; + SInt32 value; + Object *object; + Object *xC; + Object *x10; + CLabel *label; + CLabel *x18; +} IAExpr; + +enum { + IAFlag1 = 1, + IAFlag2 = 2 +}; +enum { + IAFlagsB_1 = 1, + IAFlagsB_2 = 2, + IAFlagsB_4 = 4, + IAFlagsB_8 = 8, + IAFlagsB_10 = 0x10, + IAFlagsB_20 = 0x20, + IAFlagsB_40 = 0x40 +}; + +typedef struct InlineAsm { + Opcode opcode; + unsigned char flags; + unsigned char flags2; + short argcount; + IAOperand args[0]; +} InlineAsm; + +typedef struct IALookupResult { + HashNameNode *name; + CLabel *label; + Object *object; + Type *type; + UInt32 value; + Boolean has_value; +} IALookupResult; + +typedef struct IAEntryPoint { + short x0; + char x2; + int x4; + Object *x8; + SInt32 size; +} IAEntryPoint; + +typedef enum IAEffectType { + IAEffect_0, + IAEffect_1, + IAEffect_2, + IAEffect_3 +} IAEffectType; +typedef struct IAEffect { + IAEffectType type; + Object *object; + SInt32 offset; + SInt32 size; +} IAEffect; + +typedef struct IAEffects { + Boolean x0; + Boolean x1; + Boolean x2; + Boolean x3; + Boolean x4; + Boolean x5; + UInt32 numoperands; + UInt32 numlabels; + IAEffect operands[16]; + CLabel *labels[16]; +} IAEffects; + +#ifdef __MWERKS__ +#pragma options align=reset +#endif + +extern int backtracking; +extern jmp_buf backtrack; +extern jmp_buf InlineAsm_assemblererror; + +extern int allow_array_expressions; + +extern void AssemblerError(void); +extern void InlineAsm_SyntaxError(short code); +extern CLabel *InlineAsm_LookupLabel(HashNameNode *name); +extern CLabel *InlineAsm_DeclareLabel(HashNameNode *name); +extern Boolean InlineAsm_LookupSymbolOrTag(HashNameNode *name, IALookupResult *result, Boolean allow_tag); +extern Boolean InlineAsm_LookupSymbol(HashNameNode *name, IALookupResult *result); +extern SInt32 InlineAsm_StructMemberOffset(Type *type); +extern SInt32 InlineAsm_StructArrayMemberOffset(Type *type); +extern SInt32 InlineAsm_StructPointerMemberOffset(Type *type); +extern SInt32 InlineAsm_ConstantExpression(void); +extern HashNameNode *MakeLocalLabel(CInt64 num); +extern void InlineAsm_ScanStatements(volatile short endToken); +extern void InlineAsm_ScanFunction(volatile short endToken); +extern void InlineAsm_Assemble(void); +extern void InlineAsm_PackAsmStatement(Statement *stmt, Statement *first, void **output, SInt32 *outsize); +extern void InlineAsm_UnpackAsmStatement(Statement *stmt, CLabel **labelArray, Boolean flag, void *data, SInt32 size); +extern void InlineAsm_CheckLocalUsage(Statement *stmt); +extern CLabel *InlineAsm_GetReferencedLabel(Statement *stmt); +extern CLabel *InlineAsm_GetReferencedLabel2(Statement *stmt); +extern Object *InlineAsm_GetObjectOffset(InlineAsm *ia, SInt32 index, SInt32 *offset); +extern char *InlineAsm_DumpStatement(Statement *stmt); + +// unknown name +inline void InlineAsm_InitExpr5(IAExpr *expr, SInt32 value) { + expr->type = IAExpr_5; + expr->flags = 0; + expr->value = value; + expr->reg = 0; + expr->object = NULL; + expr->xC = NULL; + expr->x10 = NULL; + expr->label = NULL; + expr->x18 = NULL; +} + +// unknown name +inline int InlineAsm_CheckExpr(IAExpr *expr) { + return (expr->xC == NULL && expr->object == NULL && expr->label == NULL); +} + +// unknown name +inline SInt32 InlineAsm_GetExprValue(IAExpr *expr) { + switch (expr->type) { + case IAExpr_8: + return HIGH_PART(expr->value); + case IAExpr_7: + return (short) (expr->value >> 16); + case IAExpr_6: + return (short) expr->value; + default: + return expr->value; + } +} + +#endif diff --git a/includes/compiler/InlineAsmMnemonicsPPC.h b/includes/compiler/InlineAsmMnemonicsPPC.h new file mode 100644 index 0000000..9f87910 --- /dev/null +++ b/includes/compiler/InlineAsmMnemonicsPPC.h @@ -0,0 +1,10 @@ +#ifndef COMPILER_INLINEASMMNEMONICSPPC_H +#define COMPILER_INLINEASMMNEMONICSPPC_H + +#include "compiler/common.h" +#include "compiler/InlineAsm.h" + +extern void InlineAsm_InitializeMnemonicsPPC(void); +extern IAMnemonic *InlineAsm_LookupMnemonicPPC(char *name); + +#endif diff --git a/includes/compiler/InlineAsmPPC.h b/includes/compiler/InlineAsmPPC.h new file mode 100644 index 0000000..feb5132 --- /dev/null +++ b/includes/compiler/InlineAsmPPC.h @@ -0,0 +1,82 @@ +#ifndef COMPILER_INLINEASMPPC_H +#define COMPILER_INLINEASMPPC_H + +#include "compiler/common.h" +#include "compiler/InlineAsm.h" + +extern char asm_alloc_flags[10]; +extern unsigned char sm_section; +extern UInt32 cpu; +extern SInt32 fralloc_parameter_area_size; +extern Boolean user_responsible_for_frame; +extern Boolean supports_hardware_fpu; +extern UInt32 assembledinstructions; +extern UInt8 assembler_type; +extern char volatileasm; +extern Boolean InlineAsm_gccmode; +extern Boolean InlineAsm_labelref; +extern CLabel *pic_base_label; + +enum { + IADirective_Null, + IADirective_Entry, + IADirective_FrAlloc, + IADirective_NoFrAlloc, + IADirective_FrFree, + IADirective_Machine, + IADirective_SmClass, + IADirective_PicBase +}; + +enum { + CPUFLAG_LOW_MASK = 0xFFFFF, + CPUFLAG_100000 = 0x100000, + CPUFLAG_200000 = 0x200000, + CPUFLAG_400000 = 0x400000, + CPUFLAG_800000 = 0x800000, + CPUFLAG_1000000 = 0x1000000, + CPUFLAG_2000000 = 0x2000000, + CPUFLAG_4000000 = 0x4000000, + CPUFLAG_8000000 = 0x8000000, + CPUFLAG_10000000 = 0x10000000, + CPUFLAG_20000000 = 0x20000000, + CPUFLAG_40000000 = 0x40000000, + CPUFLAG_80000000 = 0x80000000 +}; + +#define OPCODE_PART_1(opcode) ( (opcode) >> 26 ) +#define OPCODE_PART_2(opcode) ( ((opcode) >> 21) & 0x1F ) +#define OPCODE_PART_3(opcode) ( ((opcode) >> 1) & 0x3FF ) + +enum { + CPUMask_401 = CPUFLAG_8000000 | 0x40, + CPUMask_403 = CPUFLAG_8000000 | 0x80, + CPUMask_50x = CPUFLAG_10000000 | CPUFLAG_80000000 | 0x800, + CPUMask_55x_56x = CPUFLAG_10000000 | CPUFLAG_80000000 | 0x1000, + CPUMask_601 = CPUFLAG_1000000 | CPUFLAG_2000000 | CPUFLAG_4000000 | CPUFLAG_8000000 | CPUFLAG_80000000 | 1, + CPUMask_602 = CPUFLAG_800000 | CPUFLAG_1000000 | CPUFLAG_4000000 | CPUFLAG_8000000 | CPUFLAG_10000000 | CPUFLAG_80000000 | 2, + CPUMask_8240 = CPUFLAG_800000 | CPUFLAG_1000000 | CPUFLAG_2000000 | CPUFLAG_4000000 | CPUFLAG_8000000 | CPUFLAG_10000000 | CPUFLAG_80000000 | 0x10000, + CPUMask_8260 = CPUFLAG_1000000 | CPUFLAG_2000000 | CPUFLAG_4000000 | CPUFLAG_8000000 | CPUFLAG_10000000 | 0x10000, + CPUMask_603 = CPUFLAG_800000 | CPUFLAG_1000000 | CPUFLAG_2000000 | CPUFLAG_4000000 | CPUFLAG_8000000 | CPUFLAG_10000000 | CPUFLAG_80000000 | 4, + CPUMask_604 = CPUFLAG_800000 | CPUFLAG_1000000 | CPUFLAG_2000000 | CPUFLAG_4000000 | CPUFLAG_8000000 | CPUFLAG_10000000 | CPUFLAG_80000000 | 8, + CPUMask_740_750 = CPUFLAG_800000 | CPUFLAG_1000000 | CPUFLAG_2000000 | CPUFLAG_4000000 | CPUFLAG_8000000 | CPUFLAG_10000000 | CPUFLAG_80000000 | 0x2000, + CPUMask_801_821_860 = CPUFLAG_4000000 | CPUFLAG_8000000 | CPUFLAG_10000000 | 0x10, + CPUMask_823_850 = CPUFLAG_4000000 | CPUFLAG_8000000 | CPUFLAG_10000000 | 0x20, + CPUMask_74xx = CPUFLAG_800000 | CPUFLAG_1000000 | CPUFLAG_2000000 | CPUFLAG_4000000 | CPUFLAG_8000000 | CPUFLAG_10000000 | CPUFLAG_40000000 | CPUFLAG_80000000 | 0x6000, + CPUMask_All = CPUFLAG_800000 | CPUFLAG_1000000 | CPUFLAG_2000000 | CPUFLAG_4000000 | CPUFLAG_8000000 | CPUFLAG_10000000 | CPUFLAG_40000000 | CPUFLAG_80000000 | 0xFFFFF, + CPUMask_Generic = CPUFLAG_800000 | CPUFLAG_1000000 | CPUFLAG_2000000 | CPUFLAG_4000000 | CPUFLAG_8000000 | CPUFLAG_10000000 | CPUFLAG_40000000 | CPUFLAG_80000000 | 0xE00E +}; + +extern void InlineAsm_InitializePPC(void); +extern void InlineAsm_Initialize(UInt8 assemblertype); +extern SInt32 InlineAsm_IsDirective(UInt8 assemblertype); +extern void InlineAsm_ProcessDirective(SInt32 directive); +extern void InlineAsm_ScanAssemblyDirective(void); +extern void InlineAsm_ScanAssemblyInstruction(void); +extern void InlineAsm_TranslateIRtoPCode(Statement *stmt); +extern const char *InlineAsm_GetMnemonic(InlineAsm *ia); +extern void CodeGen_GetAsmEffects(Statement *stmt, IAEffects *effects); +extern void CodeGen_PropagateIntoAsm(Statement *stmt, Object *obj, ENode *expr); +extern Statement *CodeGen_CopyAsmStat(Statement *stmt); + +#endif diff --git a/includes/compiler/InlineAsmRegisters.h b/includes/compiler/InlineAsmRegisters.h new file mode 100644 index 0000000..6cd8ef7 --- /dev/null +++ b/includes/compiler/InlineAsmRegisters.h @@ -0,0 +1,11 @@ +#ifndef COMPILER_INLINEASMREGISTERS_H +#define COMPILER_INLINEASMREGISTERS_H + +#include "compiler/common.h" +#include "compiler/InlineAsm.h" + +extern void InlineAsm_InitializeRegisters(void); +extern void InlineAsm_InsertRegister(char *name, char rclass, short num, Object *object); +extern IARegister *InlineAsm_LookupRegister(char *name); + +#endif diff --git a/includes/compiler/InlineAsmRegistersPPC.h b/includes/compiler/InlineAsmRegistersPPC.h new file mode 100644 index 0000000..dd65644 --- /dev/null +++ b/includes/compiler/InlineAsmRegistersPPC.h @@ -0,0 +1,12 @@ +#ifndef COMPILER_INLINEASMREGISTERSPPC_H +#define COMPILER_INLINEASMREGISTERSPPC_H + +#include "compiler/common.h" +#include "compiler/InlineAsm.h" + +extern IARegister *InlineAsm_LookupRegisterPPCName(HashNameNode *name); +extern IARegister *InlineAsm_LookupRegisterPPC(char *name); +extern IARegister *InlineAsm_LookupDCRRegister(char *name); +extern void InlineAsm_InitializeRegistersPPC(void); + +#endif diff --git a/includes/compiler/InstrSelection.h b/includes/compiler/InstrSelection.h new file mode 100644 index 0000000..a3b90b3 --- /dev/null +++ b/includes/compiler/InstrSelection.h @@ -0,0 +1,128 @@ +#ifndef COMPILER_INSTRSELECTION_H +#define COMPILER_INSTRSELECTION_H + +#include "compiler/common.h" +#include "compiler/enode.h" +#include "compiler/Operands.h" +#include "compiler/PCodeInfo.h" + +typedef struct PrecomputedOperand { + struct PrecomputedOperand *next; + SInt32 precompid; + Operand operand; +} PrecomputedOperand; + +extern PrecomputedOperand *precomputedoperands; +extern void (*cgdispatch[MAXEXPR + 1])(ENode *, short, short, Operand *); + +extern void init_cgdispatch(void); +extern void gen_DEFINE(ENode *expr, short outputReg, short outputRegHi, Operand *output); +extern void gen_REUSE(ENode *expr, short outputReg, short outputRegHi, Operand *output); +extern void gen_POSTINCDEC(ENode *expr, short outputReg, short outputRegHi, Operand *output); +extern void gen_INDIRECT(ENode *expr, short outputReg, short outputRegHi, Operand *output); +extern void gen_MONMIN(ENode *expr, short outputReg, short outputRegHi, Operand *output); +extern void gen_BINNOT(ENode *expr, short outputReg, short outputRegHi, Operand *output); +extern void gen_FORCELOAD(ENode *expr, short outputReg, short outputRegHi, Operand *output); +extern void gen_MUL(ENode *expr, short outputReg, short outputRegHi, Operand *output); +extern void gen_DIV(ENode *expr, short outputReg, short outputRegHi, Operand *output); +extern void gen_MODULO(ENode *expr, short outputReg, short outputRegHi, Operand *output); +extern void gen_ADD(ENode *expr, short outputReg, short outputRegHi, Operand *output); +extern void gen_SUB(ENode *expr, short outputReg, short outputRegHi, Operand *output); +extern void gen_SHL(ENode *expr, short outputReg, short outputRegHi, Operand *output); +extern void gen_SHR(ENode *expr, short outputReg, short outputRegHi, Operand *output); +extern void gen_AND(ENode *expr, short outputReg, short outputRegHi, Operand *output); +extern void gen_XOR(ENode *expr, short outputReg, short outputRegHi, Operand *output); +extern void gen_OR(ENode *expr, short outputReg, short outputRegHi, Operand *output); +extern void gen_ASS(ENode *expr, short outputReg, short outputRegHi, Operand *output); +extern ENode *evaluate_and_skip_comma(ENode *expr); +extern void gen_COMMA(ENode *expr, short outputReg, short outputRegHi, Operand *output); +extern void gen_TYPCON(ENode *expr, short outputReg, short outputRegHi, Operand *output); +extern void gen_BITFIELD(ENode *expr, short outputReg, short outputRegHi, Operand *output); +extern void gen_INTCONST(ENode *expr, short outputReg, short outputRegHi, Operand *output); +extern void gen_FLOATCONST(ENode *expr, short outputReg, short outputRegHi, Operand *output); +extern void gen_STRINGCONST(ENode *expr, short outputReg, short outputRegHi, Operand *output); +extern void gen_COND(ENode *expr, short outputReg, short outputRegHi, Operand *output); +extern void gen_CONDASS(ENode *expr, short outputReg, short outputRegHi, Operand *output); +extern void gen_FUNCCALL(ENode *expr, short outputReg, short outputRegHi, Operand *output); +extern void gen_OBJREF(ENode *expr, short outputReg, short outputRegHi, Operand *output); +extern void gen_UNEXPECTED(ENode *expr, short outputReg, short outputRegHi, Operand *output); +extern void binary_operator(Opcode opcode, ENode *left, ENode *right, short outputReg, Operand *output); +extern void unary_operator(Opcode opcode, ENode *expr, short outputReg, Operand *output); +extern void fp_unary_operator(Opcode opcode, ENode *expr, short outputReg, Operand *output); +extern void fp_multiply_add(Opcode opcode, ENode *a, ENode *b, ENode *c, short outputReg, Operand *output); +extern void gen_COMPARE(ENode *expr, short outputReg, short outputRegHi, Operand *output); +extern void gen_LOGICAL(ENode *expr, short outputReg, short outputRegHi, Operand *output); +extern void gen_NULLCHECK(ENode *expr, short outputReg, short outputRegHi, Operand *output); +extern void gen_PRECOMP(ENode *expr, short outputReg, short outputRegHi, Operand *output); +extern void logical_expression(ENode *cond, PCodeLabel *a, PCodeLabel *b, PCodeLabel *c); +extern void gen_condition(ENode *cond, Operand *output); +extern void gen_condition_gpr(ENode *cond, Operand *output, short outputReg); +extern void gen_negated_condition_gpr(ENode *cond, Operand *output, short outputReg); +extern void compare_floating(short nt, ENode *left, ENode *right, Operand *output); +extern void compare_integer(short nt, ENode *left, ENode *right, Operand *output); +extern void compare_immediate(short nt, ENode *left, SInt32 value, Operand *output); +extern void compare_immediate_long(short nt, ENode *left, SInt32 value, Operand *output); +extern int ismaskconstant(SInt32 value, short *first, short *last); +extern int ispostincrementopportunity(ENode *expr, Operand *op, SInt32 *value); +extern void add_register_immediate(short regA, short regB, SInt32 value); +extern void I8_gen_ADD(ENode *expr, short outputReg, short outputRegHi, Operand *output); +extern void I8_gen_INTCONST(ENode *expr, short outputReg, short outputRegHi, Operand *output); +extern void I8_gen_SUB(ENode *expr, short outputReg, short outputRegHi, Operand *output); +extern void I8_gen_XOR(ENode *expr, short outputReg, short outputRegHi, Operand *output); +extern void I8_gen_OR(ENode *expr, short outputReg, short outputRegHi, Operand *output); +extern void I8_gen_AND(ENode *expr, short outputReg, short outputRegHi, Operand *output); +extern int I8_getbit(UInt64 val); +extern int I8_log2n(UInt64 val); +extern void I8_ShiftLeftImmediate(Operand opnd, SInt32 value, int is_unsigned, SInt32 size, short reg, short regHi); +extern void I8_ShiftRightImmediate(Operand opnd, SInt32 value, int is_unsigned, short reg, short regHi, int unk); +extern void I8_gen_MUL(ENode *expr, short outputReg, short outputRegHi, Operand *output); +extern void I8_gen_BINNOT(ENode *expr, short outputReg, short outputRegHi, Operand *output); +extern void I8_gen_MONMIN(ENode *expr, short outputReg, short outputRegHi, Operand *output); +extern void I8_gen_ASS(ENode *expr, short outputReg, short outputRegHi, Operand *output); +extern void I8_gen_POSTINCDEC(ENode *expr, short outputReg, short outputRegHi, Operand *output); +extern void I8_gen_INDIRECT(ENode *expr, short outputReg, short outputRegHi, Operand *output); +extern void I8_gen_condition(ENode *cond, Operand *output, int write_to_gpr); +extern void I8_gen_SHL_SHR(ENode *expr, short outputReg, short outputRegHi, Operand *output); +extern void I8_gen_DIV_MOD(ENode *expr, short outputReg, short outputRegHi, Operand *output); +extern void I8_gen_TYPCON(ENode *expr, short outputReg, short outputRegHi, Operand *output); +extern void gen_VECTOR128CONST(ENode *expr, short outputReg, short outputRegHi, Operand *output); + +#define GEN_NODE(node, opnd) cgdispatch[(node)->type]((node), 0, 0, (opnd)) +#define GEN_NODE_TO_REG(node, reg, regHi, opnd) cgdispatch[(node)->type]((node), (reg), (regHi), (opnd)) + +#define ENSURE_GPR(opnd, type, reg) \ +do { \ + if ((opnd)->optype != OpndType_GPR) \ + Coerce_to_register((opnd), (type), (reg)); \ +} while (0) +#define ENSURE_FPR(opnd, type, reg) \ +do { \ + if ((opnd)->optype != OpndType_FPR) \ + Coerce_to_fp_register((opnd), (type), (reg)); \ +} while (0) +#define ENSURE_VR(opnd, type, reg) \ +do { \ + if ((opnd)->optype != OpndType_VR) \ + Coerce_to_v_register((opnd), (type), (reg)); \ +} while (0) + +#define GEN_NODE_TO_GPR(node, opnd, type, reg) \ +do { \ + GEN_NODE((node), (opnd)); \ + ENSURE_GPR((opnd), (type), (reg)); \ +} while (0) + +#define GEN_NODE_TO_FPR(node, opnd, type, reg) \ +do { \ + GEN_NODE((node), (opnd)); \ + ENSURE_FPR((opnd), (type), (reg)); \ +} while (0) + +#define GEN_NODE_TO_VR(node, opnd, type, reg) \ +do { \ + GEN_NODE((node), (opnd)); \ + ENSURE_VR((opnd), (type), (reg)); \ +} while (0) + + +#endif diff --git a/includes/compiler/InterferenceGraph.h b/includes/compiler/InterferenceGraph.h new file mode 100644 index 0000000..588450c --- /dev/null +++ b/includes/compiler/InterferenceGraph.h @@ -0,0 +1,6 @@ +#ifndef COMPILER_INTERFERENCEGRAPH_H +#define COMPILER_INTERFERENCEGRAPH_H + +#include "compiler/common.h" + +#endif diff --git a/includes/compiler/Intrinsics.h b/includes/compiler/Intrinsics.h new file mode 100644 index 0000000..19150f7 --- /dev/null +++ b/includes/compiler/Intrinsics.h @@ -0,0 +1,6 @@ +#ifndef COMPILER_INTRINSICS_H +#define COMPILER_INTRINSICS_H + +#include "compiler/common.h" + +#endif diff --git a/includes/compiler/IrOptimizer.h b/includes/compiler/IrOptimizer.h new file mode 100644 index 0000000..ef86286 --- /dev/null +++ b/includes/compiler/IrOptimizer.h @@ -0,0 +1,9 @@ +#ifndef COMPILER_IROPTIMIZER_H +#define COMPILER_IROPTIMIZER_H + +#include "compiler/common.h" + +// do me +extern Statement *IRO_Optimizer(Object *obj, Statement *stmt); + +#endif diff --git a/includes/compiler/IroBitVect.h b/includes/compiler/IroBitVect.h new file mode 100644 index 0000000..7bbca22 --- /dev/null +++ b/includes/compiler/IroBitVect.h @@ -0,0 +1,35 @@ +#ifndef COMPILER_IROBITVECT_H +#define COMPILER_IROBITVECT_H + +#include "compiler/common.h" +#include "compiler/CError.h" + +typedef struct BitVector { + UInt32 size; + UInt32 data[0]; +} BitVector; + +extern void Bv_AllocVector(BitVector **bv, UInt32 size); +extern void Bv_AllocVectorLocal(BitVector **bv, UInt32 size); +extern void Bv_ClearBit(UInt32 bit, BitVector *bv); +extern void Bv_And(const BitVector *a, BitVector *b); +extern void Bv_Or(const BitVector *a, BitVector *b); +extern Boolean Bv_BitsInCommon(const BitVector *a, const BitVector *b); +extern Boolean Bv_Compare(const BitVector *a, const BitVector *b); +extern void Bv_Minus(const BitVector *a, BitVector *b); +extern void Bv_Copy(const BitVector *src, BitVector *dst); +extern void Bv_Clear(BitVector *bv); +extern void Bv_Set(BitVector *bv); +extern Boolean Bv_IsSubset(const BitVector *a, const BitVector *b); +extern Boolean Bv_IsEmpty(const BitVector *bv); + +inline void Bv_SetBit(UInt32 bit, BitVector *bv) { + if ((bit / 32) < bv->size) { + bv->data[bit / 32] |= ~(1 << (bit & 31)); + } else { +#line 56 + CError_FATAL(); + } +} + +#endif diff --git a/includes/compiler/IroCSE.h b/includes/compiler/IroCSE.h new file mode 100644 index 0000000..2030e5b --- /dev/null +++ b/includes/compiler/IroCSE.h @@ -0,0 +1,6 @@ +#ifndef COMPILER_IROCSE_H +#define COMPILER_IROCSE_H + +#include "compiler/common.h" + +#endif diff --git a/includes/compiler/IroDump.h b/includes/compiler/IroDump.h new file mode 100644 index 0000000..a2f74ff --- /dev/null +++ b/includes/compiler/IroDump.h @@ -0,0 +1,6 @@ +#ifndef COMPILER_IRODUMP_H +#define COMPILER_IRODUMP_H + +#include "compiler/common.h" + +#endif diff --git a/includes/compiler/IroEmptyLoop.h b/includes/compiler/IroEmptyLoop.h new file mode 100644 index 0000000..6eb4edc --- /dev/null +++ b/includes/compiler/IroEmptyLoop.h @@ -0,0 +1,6 @@ +#ifndef COMPILER_IROEMPTYLOOP_H +#define COMPILER_IROEMPTYLOOP_H + +#include "compiler/common.h" + +#endif diff --git a/includes/compiler/IroEval.h b/includes/compiler/IroEval.h new file mode 100644 index 0000000..2d650b7 --- /dev/null +++ b/includes/compiler/IroEval.h @@ -0,0 +1,6 @@ +#ifndef COMPILER_IROEVAL_H +#define COMPILER_IROEVAL_H + +#include "compiler/common.h" + +#endif diff --git a/includes/compiler/IroExprRegeneration.h b/includes/compiler/IroExprRegeneration.h new file mode 100644 index 0000000..2012c2d --- /dev/null +++ b/includes/compiler/IroExprRegeneration.h @@ -0,0 +1,6 @@ +#ifndef COMPILER_IROEXPRREGENERATION_H +#define COMPILER_IROEXPRREGENERATION_H + +#include "compiler/common.h" + +#endif diff --git a/includes/compiler/IroFlowgraph.h b/includes/compiler/IroFlowgraph.h new file mode 100644 index 0000000..1faf2d9 --- /dev/null +++ b/includes/compiler/IroFlowgraph.h @@ -0,0 +1,6 @@ +#ifndef COMPILER_IROFLOWGRAPH_H +#define COMPILER_IROFLOWGRAPH_H + +#include "compiler/common.h" + +#endif diff --git a/includes/compiler/IroJump.h b/includes/compiler/IroJump.h new file mode 100644 index 0000000..a2368c9 --- /dev/null +++ b/includes/compiler/IroJump.h @@ -0,0 +1,6 @@ +#ifndef COMPILER_IROJUMP_H +#define COMPILER_IROJUMP_H + +#include "compiler/common.h" + +#endif diff --git a/includes/compiler/IroLinearForm.h b/includes/compiler/IroLinearForm.h new file mode 100644 index 0000000..9f2ece1 --- /dev/null +++ b/includes/compiler/IroLinearForm.h @@ -0,0 +1,6 @@ +#ifndef COMPILER_IROLINEARFORM_H +#define COMPILER_IROLINEARFORM_H + +#include "compiler/common.h" + +#endif diff --git a/includes/compiler/IroLoop.h b/includes/compiler/IroLoop.h new file mode 100644 index 0000000..10bc36a --- /dev/null +++ b/includes/compiler/IroLoop.h @@ -0,0 +1,6 @@ +#ifndef COMPILER_IROLOOP_H +#define COMPILER_IROLOOP_H + +#include "compiler/common.h" + +#endif diff --git a/includes/compiler/IroMalloc.h b/includes/compiler/IroMalloc.h new file mode 100644 index 0000000..bc7df31 --- /dev/null +++ b/includes/compiler/IroMalloc.h @@ -0,0 +1,6 @@ +#ifndef COMPILER_IROMALLOC_H +#define COMPILER_IROMALLOC_H + +#include "compiler/common.h" + +#endif diff --git a/includes/compiler/IroPointerAnalysis.h b/includes/compiler/IroPointerAnalysis.h new file mode 100644 index 0000000..f6912cb --- /dev/null +++ b/includes/compiler/IroPointerAnalysis.h @@ -0,0 +1,6 @@ +#ifndef COMPILER_IROPOINTERANALYSIS_H +#define COMPILER_IROPOINTERANALYSIS_H + +#include "compiler/common.h" + +#endif diff --git a/includes/compiler/IroPropagate.h b/includes/compiler/IroPropagate.h new file mode 100644 index 0000000..689b5fa --- /dev/null +++ b/includes/compiler/IroPropagate.h @@ -0,0 +1,6 @@ +#ifndef COMPILER_IROPROPAGATE_H +#define COMPILER_IROPROPAGATE_H + +#include "compiler/common.h" + +#endif diff --git a/includes/compiler/IroRangePropagation.h b/includes/compiler/IroRangePropagation.h new file mode 100644 index 0000000..210cd9e --- /dev/null +++ b/includes/compiler/IroRangePropagation.h @@ -0,0 +1,6 @@ +#ifndef COMPILER_IRORANGEPROPAGATION_H +#define COMPILER_IRORANGEPROPAGATION_H + +#include "compiler/common.h" + +#endif diff --git a/includes/compiler/IroSubable.h b/includes/compiler/IroSubable.h new file mode 100644 index 0000000..ff0cbd9 --- /dev/null +++ b/includes/compiler/IroSubable.h @@ -0,0 +1,6 @@ +#ifndef COMPILER_IROSUBABLE_H +#define COMPILER_IROSUBABLE_H + +#include "compiler/common.h" + +#endif diff --git a/includes/compiler/IroUnrollLoop.h b/includes/compiler/IroUnrollLoop.h new file mode 100644 index 0000000..b48510f --- /dev/null +++ b/includes/compiler/IroUnrollLoop.h @@ -0,0 +1,6 @@ +#ifndef COMPILER_IROUNROLLLOOP_H +#define COMPILER_IROUNROLLLOOP_H + +#include "compiler/common.h" + +#endif diff --git a/includes/compiler/IroUtil.h b/includes/compiler/IroUtil.h new file mode 100644 index 0000000..b4c71e7 --- /dev/null +++ b/includes/compiler/IroUtil.h @@ -0,0 +1,6 @@ +#ifndef COMPILER_IROUTIL_H +#define COMPILER_IROUTIL_H + +#include "compiler/common.h" + +#endif diff --git a/includes/compiler/IroVars.h b/includes/compiler/IroVars.h new file mode 100644 index 0000000..3fbfc2f --- /dev/null +++ b/includes/compiler/IroVars.h @@ -0,0 +1,6 @@ +#ifndef COMPILER_IROVARS_H +#define COMPILER_IROVARS_H + +#include "compiler/common.h" + +#endif diff --git a/includes/compiler/LoadDeletion.h b/includes/compiler/LoadDeletion.h new file mode 100644 index 0000000..743d5bb --- /dev/null +++ b/includes/compiler/LoadDeletion.h @@ -0,0 +1,6 @@ +#ifndef COMPILER_LOADDELETION_H +#define COMPILER_LOADDELETION_H + +#include "compiler/common.h" + +#endif diff --git a/includes/compiler/LoopDetection.h b/includes/compiler/LoopDetection.h new file mode 100644 index 0000000..7f27467 --- /dev/null +++ b/includes/compiler/LoopDetection.h @@ -0,0 +1,6 @@ +#ifndef COMPILER_LOOPDETECTION_H +#define COMPILER_LOOPDETECTION_H + +#include "compiler/common.h" + +#endif diff --git a/includes/compiler/LoopOptimization.h b/includes/compiler/LoopOptimization.h new file mode 100644 index 0000000..5911b03 --- /dev/null +++ b/includes/compiler/LoopOptimization.h @@ -0,0 +1,6 @@ +#ifndef COMPILER_LOOPOPTIMIZATION_H +#define COMPILER_LOOPOPTIMIZATION_H + +#include "compiler/common.h" + +#endif diff --git a/includes/compiler/MachO.h b/includes/compiler/MachO.h new file mode 100644 index 0000000..eb8ad57 --- /dev/null +++ b/includes/compiler/MachO.h @@ -0,0 +1,6 @@ +#ifndef COMPILER_MACHO_H +#define COMPILER_MACHO_H + +#include "compiler/common.h" + +#endif diff --git a/includes/compiler/ObjGenMachO.h b/includes/compiler/ObjGenMachO.h new file mode 100644 index 0000000..ba06522 --- /dev/null +++ b/includes/compiler/ObjGenMachO.h @@ -0,0 +1,6 @@ +#ifndef COMPILER_OBJGENMACHO_H +#define COMPILER_OBJGENMACHO_H + +#include "compiler/common.h" + +#endif diff --git a/includes/compiler/Operands.h b/includes/compiler/Operands.h index 8c6aa93..cd9c035 100644 --- a/includes/compiler/Operands.h +++ b/includes/compiler/Operands.h @@ -18,7 +18,7 @@ enum OperandType { OpndType_GPR_Indexed = 2, // Value in two registers (identified by 'reg' and 'regHi') OpndType_GPRPair = 3, - // Value at an absolute address (identified by 'abs_address') + // Immediate 32-bit value OpndType_Absolute = 4, // Value in a float register (identified by 'reg') OpndType_FPR = 5, @@ -49,7 +49,7 @@ struct Operand { SInt16 regHi; SInt16 regOffset; SInt32 immOffset; - SInt32 abs_address; + SInt32 immediate; Object *object; UInt32 flags; }; @@ -61,15 +61,15 @@ extern void combine(Operand *opA, Operand *opB, short output_reg, Operand *opOut extern void coerce_to_addressable(Operand *op); extern void Coerce_to_register(Operand *op, Type *type, short output_reg); extern void coerce_to_register_pair(Operand *op, Type *type, short output_reg, short output_regHi); -extern void Coerce_to_fp_register(Operand *op, TypeIntegral *tint, short output_reg); -extern void Coerce_to_v_register(Operand *op, TypeStruct *tstruct, short output_reg); +extern void Coerce_to_fp_register(Operand *op, Type *tint, short output_reg); +extern void Coerce_to_v_register(Operand *op, Type *tstruct, short output_reg); extern void store(short reg, Operand *op, Type *type); extern void store_pair(short reg, short regHi, Operand *op, Type *type); -extern void store_fp(short reg, Operand *op, TypeIntegral *tint); -extern void store_v(short reg, Operand *op, TypeStruct *tstruct); +extern void store_fp(short reg, Operand *op, Type *tint); +extern void store_v(short reg, Operand *op, Type *tstruct); extern void extend32(Operand *op, Type *type, short output_reg); extern void extend64(Operand *op, Type *type, short output_reg, short output_regHi); -extern void load_floating_constant(short reg, TypeIntegral *type, double *data); +extern void load_floating_constant(short reg, Type *type, double *data); extern void convert_integer_to_floating(Operand *op, Boolean is_single, short output_reg); extern void convert_unsigned_to_floating(Operand *op, Boolean is_single, short output_reg); extern void convert_floating_to_integer(Operand *op, short output_reg); diff --git a/includes/compiler/PCode.h b/includes/compiler/PCode.h index 55aac38..b56ed2f 100644 --- a/includes/compiler/PCode.h +++ b/includes/compiler/PCode.h @@ -2,11 +2,15 @@ #define COMPILER_PCODE_H #include "compiler/common.h" +#include "compiler/PCodeInfo.h" #ifdef __MWERKS__ #pragma options align=mac68k #endif +#define FLAG_SET_T(flags) (((flags) & (fPCodeFlag1 | fPCodeFlag8)) ? (flags) : 0) +#define FLAG_SET_F(flags) (((flags) & (fPCodeFlag1 | fPCodeFlag8)) ? 0 : (flags)) + #define PCODE_FLAG_SET_T(pcode) (((pcode)->flags & (fPCodeFlag1 | fPCodeFlag8)) ? (pcode)->flags : 0) #define PCODE_FLAG_SET_F(pcode) (((pcode)->flags & (fPCodeFlag1 | fPCodeFlag8)) ? 0 : (pcode)->flags) @@ -15,7 +19,7 @@ enum { EffectWrite = 2 }; -typedef enum { +/*typedef enum { PCOp_REGISTER, PCOp_SYSREG, PCOp_IMMEDIATE, @@ -23,7 +27,7 @@ typedef enum { PCOp_LABEL, PCOp_LABELDIFF, PCOp_PLACEHOLDEROPERAND -} PCOpKind; +} PCOpKind;*/ typedef enum { RefType_0, @@ -142,6 +146,8 @@ enum { fOverflow = 0x800000, fSetsCarry = 0x10000000, // ?? + fPCodeFlag2000000 = 0x2000000, + fPCodeFlag4000000 = 0x4000000, fPCodeFlag8000000 = 0x8000000, fPCodeFlag10000000 = 0x10000000, fPCodeFlag20000000 = 0x20000000, @@ -167,25 +173,25 @@ extern PCodeBlock **depthfirstordering; extern int pcblockcount; extern int pcloopweight; -extern void initpcode(); -extern PCode *makepcode(short op, ...); -extern void emitpcode(short op, ...); +extern void initpcode(void); +extern PCode *makepcode(Opcode op, ...); +extern void emitpcode(Opcode op, ...); extern PCode *copypcode(PCode *pcode); -extern PCodeLabel *makepclabel(); -extern PCodeBlock *makepcblock(); +extern PCodeLabel *makepclabel(void); +extern PCodeBlock *makepcblock(void); extern void pclabel(PCodeBlock *block, PCodeLabel *label); extern void pcbranch(PCodeBlock *block, PCodeLabel *label); -extern void pccomputepredecessors(); +extern void pccomputepredecessors(void); extern void deleteblock(PCodeBlock *block); -extern void deleteunreachableblocks(); +extern void deleteunreachableblocks(void); extern void appendpcode(PCodeBlock *block, PCode *pcode); extern void deletepcode(PCode *pcode); extern void insertpcodebefore(PCode *anchor, PCode *newpcode); extern void insertpcodeafter(PCode *anchor, PCode *newpcode); extern void setpcodeflags(int flags); extern void clearpcodeflags(int flags); -extern int pccomputeoffsets(); -extern void computedepthfirstordering(); +extern int pccomputeoffsets(void); +extern void computedepthfirstordering(void); #ifdef __MWERKS__ #pragma options align=reset diff --git a/includes/compiler/PCodeAssembly.h b/includes/compiler/PCodeAssembly.h new file mode 100644 index 0000000..682482c --- /dev/null +++ b/includes/compiler/PCodeAssembly.h @@ -0,0 +1,6 @@ +#ifndef COMPILER_PCODEASSEMBLY_H +#define COMPILER_PCODEASSEMBLY_H + +#include "compiler/common.h" + +#endif diff --git a/includes/compiler/PCodeInfo.h b/includes/compiler/PCodeInfo.h index 137e10a..c7cee47 100644 --- a/includes/compiler/PCodeInfo.h +++ b/includes/compiler/PCodeInfo.h @@ -1,22 +1,33 @@ #ifndef COMPILER_PCODEINFO_H #define COMPILER_PCODEINFO_H -#include "compiler/PCode.h" +#include "compiler/common.h" #ifdef __MWERKS__ #pragma options align=mac68k #endif +typedef enum { + PCOp_REGISTER, + PCOp_SYSREG, + PCOp_IMMEDIATE, + PCOp_MEMORY, + PCOp_LABEL, + PCOp_LABELDIFF, + PCOp_PLACEHOLDEROPERAND +} PCOpKind; + typedef struct _OpcodeInfo { const char *name; const char *format; unsigned char x8; unsigned char x9; - int flags; - unsigned int insn; + UInt32 flags; + SInt32 insn; } OpcodeInfo; -/*enum { +typedef enum Opcode { + PC_INVALID = -1, PC_B = 0x0, PC_BL = 0x1, PC_BC = 0x2, @@ -448,7 +459,7 @@ typedef struct _OpcodeInfo { PC_PENTRY = 0x1AC, PC_PEXIT = 0x1AD, OPCODE_MAX = 0x1AE -};*/ +} Opcode; //#define PC_B 0x0 //#define PC_BL 0x1 //#define PC_BC 0x2 @@ -880,443 +891,443 @@ typedef struct _OpcodeInfo { //#define PC_PENTRY 0x1AC //#define PC_PEXIT 0x1AD //#define OPCODE_MAX 0x1AE -const short PC_B = 0x0; -const short PC_BL = 0x1; -const short PC_BC = 0x2; -const short PC_BCLR = 0x3; -const short PC_BCCTR = 0x4; -const short PC_BT = 0x5; -const short PC_BTLR = 0x6; -const short PC_BTCTR = 0x7; -const short PC_BF = 0x8; -const short PC_BFLR = 0x9; -const short PC_BFCTR = 0xA; -const short PC_BDNZ = 0xB; -const short PC_BDNZT = 0xC; -const short PC_BDNZF = 0xD; -const short PC_BDZ = 0xE; -const short PC_BDZT = 0xF; -const short PC_BDZF = 0x10; -const short PC_BLR = 0x11; -const short PC_BCTR = 0x12; -const short PC_BCTRL = 0x13; -const short PC_BLRL = 0x14; -const short PC_LBZ = 0x15; -const short PC_LBZU = 0x16; -const short PC_LBZX = 0x17; -const short PC_LBZUX = 0x18; -const short PC_LHZ = 0x19; -const short PC_LHZU = 0x1A; -const short PC_LHZX = 0x1B; -const short PC_LHZUX = 0x1C; -const short PC_LHA = 0x1D; -const short PC_LHAU = 0x1E; -const short PC_LHAX = 0x1F; -const short PC_LHAUX = 0x20; -const short PC_LHBRX = 0x21; -const short PC_LWZ = 0x22; -const short PC_LWZU = 0x23; -const short PC_LWZX = 0x24; -const short PC_LWZUX = 0x25; -const short PC_LWBRX = 0x26; -const short PC_LMW = 0x27; -const short PC_STB = 0x28; -const short PC_STBU = 0x29; -const short PC_STBX = 0x2A; -const short PC_STBUX = 0x2B; -const short PC_STH = 0x2C; -const short PC_STHU = 0x2D; -const short PC_STHX = 0x2E; -const short PC_STHUX = 0x2F; -const short PC_STHBRX = 0x30; -const short PC_STW = 0x31; -const short PC_STWU = 0x32; -const short PC_STWX = 0x33; -const short PC_STWUX = 0x34; -const short PC_STWBRX = 0x35; -const short PC_STMW = 0x36; -const short PC_DCBF = 0x37; -const short PC_DCBST = 0x38; -const short PC_DCBT = 0x39; -const short PC_DCBTST = 0x3A; -const short PC_DCBZ = 0x3B; -const short PC_ADD = 0x3C; -const short PC_ADDC = 0x3D; -const short PC_ADDE = 0x3E; -const short PC_ADDI = 0x3F; -const short PC_ADDIC = 0x40; -const short PC_ADDICR = 0x41; -const short PC_ADDIS = 0x42; -const short PC_ADDME = 0x43; -const short PC_ADDZE = 0x44; -const short PC_DIVW = 0x45; -const short PC_DIVWU = 0x46; -const short PC_MULHW = 0x47; -const short PC_MULHWU = 0x48; -const short PC_MULLI = 0x49; -const short PC_MULLW = 0x4A; -const short PC_NEG = 0x4B; -const short PC_SUBF = 0x4C; -const short PC_SUBFC = 0x4D; -const short PC_SUBFE = 0x4E; -const short PC_SUBFIC = 0x4F; -const short PC_SUBFME = 0x50; -const short PC_SUBFZE = 0x51; -const short PC_CMPI = 0x52; -const short PC_CMP = 0x53; -const short PC_CMPLI = 0x54; -const short PC_CMPL = 0x55; -const short PC_ANDI = 0x56; -const short PC_ANDIS = 0x57; -const short PC_ORI = 0x58; -const short PC_ORIS = 0x59; -const short PC_XORI = 0x5A; -const short PC_XORIS = 0x5B; -const short PC_AND = 0x5C; -const short PC_OR = 0x5D; -const short PC_XOR = 0x5E; -const short PC_NAND = 0x5F; -const short PC_NOR = 0x60; -const short PC_EQV = 0x61; -const short PC_ANDC = 0x62; -const short PC_ORC = 0x63; -const short PC_EXTSB = 0x64; -const short PC_EXTSH = 0x65; -const short PC_CNTLZW = 0x66; -const short PC_RLWINM = 0x67; -const short PC_RLWNM = 0x68; -const short PC_RLWIMI = 0x69; -const short PC_SLW = 0x6A; -const short PC_SRW = 0x6B; -const short PC_SRAWI = 0x6C; -const short PC_SRAW = 0x6D; -const short PC_CRAND = 0x6E; -const short PC_CRANDC = 0x6F; -const short PC_CREQV = 0x70; -const short PC_CRNAND = 0x71; -const short PC_CRNOR = 0x72; -const short PC_CROR = 0x73; -const short PC_CRORC = 0x74; -const short PC_CRXOR = 0x75; -const short PC_MCRF = 0x76; -const short PC_MTXER = 0x77; -const short PC_MTCTR = 0x78; -const short PC_MTLR = 0x79; -const short PC_MTCRF = 0x7A; -const short PC_MTMSR = 0x7B; -const short PC_MTSPR = 0x7C; -const short PC_MFMSR = 0x7D; -const short PC_MFSPR = 0x7E; -const short PC_MFXER = 0x7F; -const short PC_MFCTR = 0x80; -const short PC_MFLR = 0x81; -const short PC_MFCR = 0x82; -const short PC_MFFS = 0x83; -const short PC_MTFSF = 0x84; -const short PC_EIEIO = 0x85; -const short PC_ISYNC = 0x86; -const short PC_SYNC = 0x87; -const short PC_RFI = 0x88; -const short PC_LI = 0x89; -const short PC_LIS = 0x8A; -const short PC_MR = 0x8B; -const short PC_NOP = 0x8C; -const short PC_NOT = 0x8D; -const short PC_LFS = 0x8E; -const short PC_LFSU = 0x8F; -const short PC_LFSX = 0x90; -const short PC_LFSUX = 0x91; -const short PC_LFD = 0x92; -const short PC_LFDU = 0x93; -const short PC_LFDX = 0x94; -const short PC_LFDUX = 0x95; -const short PC_STFS = 0x96; -const short PC_STFSU = 0x97; -const short PC_STFSX = 0x98; -const short PC_STFSUX = 0x99; -const short PC_STFD = 0x9A; -const short PC_STFDU = 0x9B; -const short PC_STFDX = 0x9C; -const short PC_STFDUX = 0x9D; -const short PC_FMR = 0x9E; -const short PC_FABS = 0x9F; -const short PC_FNEG = 0xA0; -const short PC_FNABS = 0xA1; -const short PC_FADD = 0xA2; -const short PC_FADDS = 0xA3; -const short PC_FSUB = 0xA4; -const short PC_FSUBS = 0xA5; -const short PC_FMUL = 0xA6; -const short PC_FMULS = 0xA7; -const short PC_FDIV = 0xA8; -const short PC_FDIVS = 0xA9; -const short PC_FMADD = 0xAA; -const short PC_FMADDS = 0xAB; -const short PC_FMSUB = 0xAC; -const short PC_FMSUBS = 0xAD; -const short PC_FNMADD = 0xAE; -const short PC_FNMADDS = 0xAF; -const short PC_FNMSUB = 0xB0; -const short PC_FNMSUBS = 0xB1; -const short PC_FRES = 0xB2; -const short PC_FRSQRTE = 0xB3; -const short PC_FSEL = 0xB4; -const short PC_FRSP = 0xB5; -const short PC_FCTIW = 0xB6; -const short PC_FCTIWZ = 0xB7; -const short PC_FCMPU = 0xB8; -const short PC_FCMPO = 0xB9; -const short PC_LWARX = 0xBA; -const short PC_LSWI = 0xBB; -const short PC_LSWX = 0xBC; -const short PC_STFIWX = 0xBD; -const short PC_STSWI = 0xBE; -const short PC_STSWX = 0xBF; -const short PC_STWCX = 0xC0; -const short PC_ECIWX = 0xC1; -const short PC_ECOWX = 0xC2; -const short PC_DCBI = 0xC3; -const short PC_ICBI = 0xC4; -const short PC_MCRFS = 0xC5; -const short PC_MCRXR = 0xC6; -const short PC_MFTB = 0xC7; -const short PC_MFSR = 0xC8; -const short PC_MTSR = 0xC9; -const short PC_MFSRIN = 0xCA; -const short PC_MTSRIN = 0xCB; -const short PC_MTFSB0 = 0xCC; -const short PC_MTFSB1 = 0xCD; -const short PC_MTFSFI = 0xCE; -const short PC_SC = 0xCF; -const short PC_FSQRT = 0xD0; -const short PC_FSQRTS = 0xD1; -const short PC_TLBIA = 0xD2; -const short PC_TLBIE = 0xD3; -const short PC_TLBLD = 0xD4; -const short PC_TLBLI = 0xD5; -const short PC_TLBSYNC = 0xD6; -const short PC_TW = 0xD7; -const short PC_TRAP = 0xD8; -const short PC_TWI = 0xD9; -const short PC_OPWORD = 0xDA; -const short PC_MFROM = 0xDB; -const short PC_DSA = 0xDC; -const short PC_ESA = 0xDD; -const short PC_DCCCI = 0xDE; -const short PC_DCREAD = 0xDF; -const short PC_ICBT = 0xE0; -const short PC_ICCCI = 0xE1; -const short PC_ICREAD = 0xE2; -const short PC_RFCI = 0xE3; -const short PC_TLBRE = 0xE4; -const short PC_TLBSX = 0xE5; -const short PC_TLBWE = 0xE6; -const short PC_WRTEE = 0xE7; -const short PC_WRTEEI = 0xE8; -const short PC_MFDCR = 0xE9; -const short PC_MTDCR = 0xEA; -const short PC_DCBA = 0xEB; -const short PC_DSS = 0xEC; -const short PC_DSSALL = 0xED; -const short PC_DST = 0xEE; -const short PC_DSTT = 0xEF; -const short PC_DSTST = 0xF0; -const short PC_DSTSTT = 0xF1; -const short PC_LVEBX = 0xF2; -const short PC_LVEHX = 0xF3; -const short PC_LVEWX = 0xF4; -const short PC_LVSL = 0xF5; -const short PC_LVSR = 0xF6; -const short PC_LVX = 0xF7; -const short PC_LVXL = 0xF8; -const short PC_STVEBX = 0xF9; -const short PC_STVEHX = 0xFA; -const short PC_STVEWX = 0xFB; -const short PC_STVX = 0xFC; -const short PC_STVXL = 0xFD; -const short PC_MFVSCR = 0xFE; -const short PC_MTVSCR = 0xFF; -const short PC_VADDCUW = 0x100; -const short PC_VADDFP = 0x101; -const short PC_VADDSBS = 0x102; -const short PC_VADDSHS = 0x103; -const short PC_VADDSWS = 0x104; -const short PC_VADDUBM = 0x105; -const short PC_VADDUBS = 0x106; -const short PC_VADDUHM = 0x107; -const short PC_VADDUHS = 0x108; -const short PC_VADDUWM = 0x109; -const short PC_VADDUWS = 0x10A; -const short PC_VAND = 0x10B; -const short PC_VANDC = 0x10C; -const short PC_VAVGSB = 0x10D; -const short PC_VAVGSH = 0x10E; -const short PC_VAVGSW = 0x10F; -const short PC_VAVGUB = 0x110; -const short PC_VAVGUH = 0x111; -const short PC_VAVGUW = 0x112; -const short PC_VCFSX = 0x113; -const short PC_VCFUX = 0x114; -const short PC_VCMPBFP = 0x115; -const short PC_VCMPEQFP = 0x116; -const short PC_VCMPEQUB = 0x117; -const short PC_VCMPEQUH = 0x118; -const short PC_VCMPEQUW = 0x119; -const short PC_VCMPGEFP = 0x11A; -const short PC_VCMPGTFP = 0x11B; -const short PC_VCMPGTSB = 0x11C; -const short PC_VCMPGTSH = 0x11D; -const short PC_VCMPGTSW = 0x11E; -const short PC_VCMPGTUB = 0x11F; -const short PC_VCMPGTUH = 0x120; -const short PC_VCMPGTUW = 0x121; -const short PC_VCTSXS = 0x122; -const short PC_VCTUXS = 0x123; -const short PC_VEXPTEFP = 0x124; -const short PC_VLOGEFP = 0x125; -const short PC_VMAXFP = 0x126; -const short PC_VMAXSB = 0x127; -const short PC_VMAXSH = 0x128; -const short PC_VMAXSW = 0x129; -const short PC_VMAXUB = 0x12A; -const short PC_VMAXUH = 0x12B; -const short PC_VMAXUW = 0x12C; -const short PC_VMINFP = 0x12D; -const short PC_VMINSB = 0x12E; -const short PC_VMINSH = 0x12F; -const short PC_VMINSW = 0x130; -const short PC_VMINUB = 0x131; -const short PC_VMINUH = 0x132; -const short PC_VMINUW = 0x133; -const short PC_VMRGHB = 0x134; -const short PC_VMRGHH = 0x135; -const short PC_VMRGHW = 0x136; -const short PC_VMRGLB = 0x137; -const short PC_VMRGLH = 0x138; -const short PC_VMRGLW = 0x139; -const short PC_VMULESB = 0x13A; -const short PC_VMULESH = 0x13B; -const short PC_VMULEUB = 0x13C; -const short PC_VMULEUH = 0x13D; -const short PC_VMULOSB = 0x13E; -const short PC_VMULOSH = 0x13F; -const short PC_VMULOUB = 0x140; -const short PC_VMULOUH = 0x141; -const short PC_VNOR = 0x142; -const short PC_VOR = 0x143; -const short PC_VPKPX = 0x144; -const short PC_VPKSHSS = 0x145; -const short PC_VPKSHUS = 0x146; -const short PC_VPKSWSS = 0x147; -const short PC_VPKSWUS = 0x148; -const short PC_VPKUHUM = 0x149; -const short PC_VPKUHUS = 0x14A; -const short PC_VPKUWUM = 0x14B; -const short PC_VPKUWUS = 0x14C; -const short PC_VREFP = 0x14D; -const short PC_VRFIM = 0x14E; -const short PC_VRFIN = 0x14F; -const short PC_VRFIP = 0x150; -const short PC_VRFIZ = 0x151; -const short PC_VRLB = 0x152; -const short PC_VRLH = 0x153; -const short PC_VRLW = 0x154; -const short PC_VRSQRTEFP = 0x155; -const short PC_VSL = 0x156; -const short PC_VSLB = 0x157; -const short PC_VSLH = 0x158; -const short PC_VSLO = 0x159; -const short PC_VSLW = 0x15A; -const short PC_VSPLTB = 0x15B; -const short PC_VSPLTH = 0x15C; -const short PC_VSPLTW = 0x15D; -const short PC_VSPLTISB = 0x15E; -const short PC_VSPLTISH = 0x15F; -const short PC_VSPLTISW = 0x160; -const short PC_VSR = 0x161; -const short PC_VSRAB = 0x162; -const short PC_VSRAH = 0x163; -const short PC_VSRAW = 0x164; -const short PC_VSRB = 0x165; -const short PC_VSRH = 0x166; -const short PC_VSRO = 0x167; -const short PC_VSRW = 0x168; -const short PC_VSUBCUW = 0x169; -const short PC_VSUBFP = 0x16A; -const short PC_VSUBSBS = 0x16B; -const short PC_VSUBSHS = 0x16C; -const short PC_VSUBSWS = 0x16D; -const short PC_VSUBUBM = 0x16E; -const short PC_VSUBUBS = 0x16F; -const short PC_VSUBUHM = 0x170; -const short PC_VSUBUHS = 0x171; -const short PC_VSUBUWM = 0x172; -const short PC_VSUBUWS = 0x173; -const short PC_VSUMSWS = 0x174; -const short PC_VSUM2SWS = 0x175; -const short PC_VSUM4SBS = 0x176; -const short PC_VSUM4SHS = 0x177; -const short PC_VSUM4UBS = 0x178; -const short PC_VUPKHPX = 0x179; -const short PC_VUPKHSB = 0x17A; -const short PC_VUPKHSH = 0x17B; -const short PC_VUPKLPX = 0x17C; -const short PC_VUPKLSB = 0x17D; -const short PC_VUPKLSH = 0x17E; -const short PC_VXOR = 0x17F; -const short PC_VMADDFP = 0x180; -const short PC_VMHADDSHS = 0x181; -const short PC_VMHRADDSHS = 0x182; -const short PC_VMLADDUHM = 0x183; -const short PC_VMSUMMBM = 0x184; -const short PC_VMSUMSHM = 0x185; -const short PC_VMSUMSHS = 0x186; -const short PC_VMSUMUBM = 0x187; -const short PC_VMSUMUHM = 0x188; -const short PC_VMSUMUHS = 0x189; -const short PC_VNMSUBFP = 0x18A; -const short PC_VPERM = 0x18B; -const short PC_VSEL = 0x18C; -const short PC_VSLDOI = 0x18D; -const short PC_VMR = 0x18E; -const short PC_VMRP = 0x18F; -const short PC_SLE = 0x190; -const short PC_SLEQ = 0x191; -const short PC_SLIQ = 0x192; -const short PC_SLLIQ = 0x193; -const short PC_SLLQ = 0x194; -const short PC_SLQ = 0x195; -const short PC_SRAIQ = 0x196; -const short PC_SRAQ = 0x197; -const short PC_SRE = 0x198; -const short PC_SREA = 0x199; -const short PC_SREQ = 0x19A; -const short PC_SRIQ = 0x19B; -const short PC_SRLIQ = 0x19C; -const short PC_SRLQ = 0x19D; -const short PC_SRQ = 0x19E; -const short PC_MASKG = 0x19F; -const short PC_MASKIR = 0x1A0; -const short PC_LSCBX = 0x1A1; -const short PC_DIV = 0x1A2; -const short PC_DIVS = 0x1A3; -const short PC_DOZ = 0x1A4; -const short PC_MUL = 0x1A5; -const short PC_NABS = 0x1A6; -const short PC_ABS = 0x1A7; -const short PC_CLCS = 0x1A8; -const short PC_DOZI = 0x1A9; -const short PC_RLMI = 0x1AA; -const short PC_RRIB = 0x1AB; -const short PC_PENTRY = 0x1AC; -const short PC_PEXIT = 0x1AD; -const short OPCODE_MAX = 0x1AE; +//const short PC_B = 0x0; +//const short PC_BL = 0x1; +//const short PC_BC = 0x2; +//const short PC_BCLR = 0x3; +//const short PC_BCCTR = 0x4; +//const short PC_BT = 0x5; +//const short PC_BTLR = 0x6; +//const short PC_BTCTR = 0x7; +//const short PC_BF = 0x8; +//const short PC_BFLR = 0x9; +//const short PC_BFCTR = 0xA; +//const short PC_BDNZ = 0xB; +//const short PC_BDNZT = 0xC; +//const short PC_BDNZF = 0xD; +//const short PC_BDZ = 0xE; +//const short PC_BDZT = 0xF; +//const short PC_BDZF = 0x10; +//const short PC_BLR = 0x11; +//const short PC_BCTR = 0x12; +//const short PC_BCTRL = 0x13; +//const short PC_BLRL = 0x14; +//const short PC_LBZ = 0x15; +//const short PC_LBZU = 0x16; +//const short PC_LBZX = 0x17; +//const short PC_LBZUX = 0x18; +//const short PC_LHZ = 0x19; +//const short PC_LHZU = 0x1A; +//const short PC_LHZX = 0x1B; +//const short PC_LHZUX = 0x1C; +//const short PC_LHA = 0x1D; +//const short PC_LHAU = 0x1E; +//const short PC_LHAX = 0x1F; +//const short PC_LHAUX = 0x20; +//const short PC_LHBRX = 0x21; +//const short PC_LWZ = 0x22; +//const short PC_LWZU = 0x23; +//const short PC_LWZX = 0x24; +//const short PC_LWZUX = 0x25; +//const short PC_LWBRX = 0x26; +//const short PC_LMW = 0x27; +//const short PC_STB = 0x28; +//const short PC_STBU = 0x29; +//const short PC_STBX = 0x2A; +//const short PC_STBUX = 0x2B; +//const short PC_STH = 0x2C; +//const short PC_STHU = 0x2D; +//const short PC_STHX = 0x2E; +//const short PC_STHUX = 0x2F; +//const short PC_STHBRX = 0x30; +//const short PC_STW = 0x31; +//const short PC_STWU = 0x32; +//const short PC_STWX = 0x33; +//const short PC_STWUX = 0x34; +//const short PC_STWBRX = 0x35; +//const short PC_STMW = 0x36; +//const short PC_DCBF = 0x37; +//const short PC_DCBST = 0x38; +//const short PC_DCBT = 0x39; +//const short PC_DCBTST = 0x3A; +//const short PC_DCBZ = 0x3B; +//const short PC_ADD = 0x3C; +//const short PC_ADDC = 0x3D; +//const short PC_ADDE = 0x3E; +//const short PC_ADDI = 0x3F; +//const short PC_ADDIC = 0x40; +//const short PC_ADDICR = 0x41; +//const short PC_ADDIS = 0x42; +//const short PC_ADDME = 0x43; +//const short PC_ADDZE = 0x44; +//const short PC_DIVW = 0x45; +//const short PC_DIVWU = 0x46; +//const short PC_MULHW = 0x47; +//const short PC_MULHWU = 0x48; +//const short PC_MULLI = 0x49; +//const short PC_MULLW = 0x4A; +//const short PC_NEG = 0x4B; +//const short PC_SUBF = 0x4C; +//const short PC_SUBFC = 0x4D; +//const short PC_SUBFE = 0x4E; +//const short PC_SUBFIC = 0x4F; +//const short PC_SUBFME = 0x50; +//const short PC_SUBFZE = 0x51; +//const short PC_CMPI = 0x52; +//const short PC_CMP = 0x53; +//const short PC_CMPLI = 0x54; +//const short PC_CMPL = 0x55; +//const short PC_ANDI = 0x56; +//const short PC_ANDIS = 0x57; +//const short PC_ORI = 0x58; +//const short PC_ORIS = 0x59; +//const short PC_XORI = 0x5A; +//const short PC_XORIS = 0x5B; +//const short PC_AND = 0x5C; +//const short PC_OR = 0x5D; +//const short PC_XOR = 0x5E; +//const short PC_NAND = 0x5F; +//const short PC_NOR = 0x60; +//const short PC_EQV = 0x61; +//const short PC_ANDC = 0x62; +//const short PC_ORC = 0x63; +//const short PC_EXTSB = 0x64; +//const short PC_EXTSH = 0x65; +//const short PC_CNTLZW = 0x66; +//const short PC_RLWINM = 0x67; +//const short PC_RLWNM = 0x68; +//const short PC_RLWIMI = 0x69; +//const short PC_SLW = 0x6A; +//const short PC_SRW = 0x6B; +//const short PC_SRAWI = 0x6C; +//const short PC_SRAW = 0x6D; +//const short PC_CRAND = 0x6E; +//const short PC_CRANDC = 0x6F; +//const short PC_CREQV = 0x70; +//const short PC_CRNAND = 0x71; +//const short PC_CRNOR = 0x72; +//const short PC_CROR = 0x73; +//const short PC_CRORC = 0x74; +//const short PC_CRXOR = 0x75; +//const short PC_MCRF = 0x76; +//const short PC_MTXER = 0x77; +//const short PC_MTCTR = 0x78; +//const short PC_MTLR = 0x79; +//const short PC_MTCRF = 0x7A; +//const short PC_MTMSR = 0x7B; +//const short PC_MTSPR = 0x7C; +//const short PC_MFMSR = 0x7D; +//const short PC_MFSPR = 0x7E; +//const short PC_MFXER = 0x7F; +//const short PC_MFCTR = 0x80; +//const short PC_MFLR = 0x81; +//const short PC_MFCR = 0x82; +//const short PC_MFFS = 0x83; +//const short PC_MTFSF = 0x84; +//const short PC_EIEIO = 0x85; +//const short PC_ISYNC = 0x86; +//const short PC_SYNC = 0x87; +//const short PC_RFI = 0x88; +//const short PC_LI = 0x89; +//const short PC_LIS = 0x8A; +//const short PC_MR = 0x8B; +//const short PC_NOP = 0x8C; +//const short PC_NOT = 0x8D; +//const short PC_LFS = 0x8E; +//const short PC_LFSU = 0x8F; +//const short PC_LFSX = 0x90; +//const short PC_LFSUX = 0x91; +//const short PC_LFD = 0x92; +//const short PC_LFDU = 0x93; +//const short PC_LFDX = 0x94; +//const short PC_LFDUX = 0x95; +//const short PC_STFS = 0x96; +//const short PC_STFSU = 0x97; +//const short PC_STFSX = 0x98; +//const short PC_STFSUX = 0x99; +//const short PC_STFD = 0x9A; +//const short PC_STFDU = 0x9B; +//const short PC_STFDX = 0x9C; +//const short PC_STFDUX = 0x9D; +//const short PC_FMR = 0x9E; +//const short PC_FABS = 0x9F; +//const short PC_FNEG = 0xA0; +//const short PC_FNABS = 0xA1; +//const short PC_FADD = 0xA2; +//const short PC_FADDS = 0xA3; +//const short PC_FSUB = 0xA4; +//const short PC_FSUBS = 0xA5; +//const short PC_FMUL = 0xA6; +//const short PC_FMULS = 0xA7; +//const short PC_FDIV = 0xA8; +//const short PC_FDIVS = 0xA9; +//const short PC_FMADD = 0xAA; +//const short PC_FMADDS = 0xAB; +//const short PC_FMSUB = 0xAC; +//const short PC_FMSUBS = 0xAD; +//const short PC_FNMADD = 0xAE; +//const short PC_FNMADDS = 0xAF; +//const short PC_FNMSUB = 0xB0; +//const short PC_FNMSUBS = 0xB1; +//const short PC_FRES = 0xB2; +//const short PC_FRSQRTE = 0xB3; +//const short PC_FSEL = 0xB4; +//const short PC_FRSP = 0xB5; +//const short PC_FCTIW = 0xB6; +//const short PC_FCTIWZ = 0xB7; +//const short PC_FCMPU = 0xB8; +//const short PC_FCMPO = 0xB9; +//const short PC_LWARX = 0xBA; +//const short PC_LSWI = 0xBB; +//const short PC_LSWX = 0xBC; +//const short PC_STFIWX = 0xBD; +//const short PC_STSWI = 0xBE; +//const short PC_STSWX = 0xBF; +//const short PC_STWCX = 0xC0; +//const short PC_ECIWX = 0xC1; +//const short PC_ECOWX = 0xC2; +//const short PC_DCBI = 0xC3; +//const short PC_ICBI = 0xC4; +//const short PC_MCRFS = 0xC5; +//const short PC_MCRXR = 0xC6; +//const short PC_MFTB = 0xC7; +//const short PC_MFSR = 0xC8; +//const short PC_MTSR = 0xC9; +//const short PC_MFSRIN = 0xCA; +//const short PC_MTSRIN = 0xCB; +//const short PC_MTFSB0 = 0xCC; +//const short PC_MTFSB1 = 0xCD; +//const short PC_MTFSFI = 0xCE; +//const short PC_SC = 0xCF; +//const short PC_FSQRT = 0xD0; +//const short PC_FSQRTS = 0xD1; +//const short PC_TLBIA = 0xD2; +//const short PC_TLBIE = 0xD3; +//const short PC_TLBLD = 0xD4; +//const short PC_TLBLI = 0xD5; +//const short PC_TLBSYNC = 0xD6; +//const short PC_TW = 0xD7; +//const short PC_TRAP = 0xD8; +//const short PC_TWI = 0xD9; +//const short PC_OPWORD = 0xDA; +//const short PC_MFROM = 0xDB; +//const short PC_DSA = 0xDC; +//const short PC_ESA = 0xDD; +//const short PC_DCCCI = 0xDE; +//const short PC_DCREAD = 0xDF; +//const short PC_ICBT = 0xE0; +//const short PC_ICCCI = 0xE1; +//const short PC_ICREAD = 0xE2; +//const short PC_RFCI = 0xE3; +//const short PC_TLBRE = 0xE4; +//const short PC_TLBSX = 0xE5; +//const short PC_TLBWE = 0xE6; +//const short PC_WRTEE = 0xE7; +//const short PC_WRTEEI = 0xE8; +//const short PC_MFDCR = 0xE9; +//const short PC_MTDCR = 0xEA; +//const short PC_DCBA = 0xEB; +//const short PC_DSS = 0xEC; +//const short PC_DSSALL = 0xED; +//const short PC_DST = 0xEE; +//const short PC_DSTT = 0xEF; +//const short PC_DSTST = 0xF0; +//const short PC_DSTSTT = 0xF1; +//const short PC_LVEBX = 0xF2; +//const short PC_LVEHX = 0xF3; +//const short PC_LVEWX = 0xF4; +//const short PC_LVSL = 0xF5; +//const short PC_LVSR = 0xF6; +//const short PC_LVX = 0xF7; +//const short PC_LVXL = 0xF8; +//const short PC_STVEBX = 0xF9; +//const short PC_STVEHX = 0xFA; +//const short PC_STVEWX = 0xFB; +//const short PC_STVX = 0xFC; +//const short PC_STVXL = 0xFD; +//const short PC_MFVSCR = 0xFE; +//const short PC_MTVSCR = 0xFF; +//const short PC_VADDCUW = 0x100; +//const short PC_VADDFP = 0x101; +//const short PC_VADDSBS = 0x102; +//const short PC_VADDSHS = 0x103; +//const short PC_VADDSWS = 0x104; +//const short PC_VADDUBM = 0x105; +//const short PC_VADDUBS = 0x106; +//const short PC_VADDUHM = 0x107; +//const short PC_VADDUHS = 0x108; +//const short PC_VADDUWM = 0x109; +//const short PC_VADDUWS = 0x10A; +//const short PC_VAND = 0x10B; +//const short PC_VANDC = 0x10C; +//const short PC_VAVGSB = 0x10D; +//const short PC_VAVGSH = 0x10E; +//const short PC_VAVGSW = 0x10F; +//const short PC_VAVGUB = 0x110; +//const short PC_VAVGUH = 0x111; +//const short PC_VAVGUW = 0x112; +//const short PC_VCFSX = 0x113; +//const short PC_VCFUX = 0x114; +//const short PC_VCMPBFP = 0x115; +//const short PC_VCMPEQFP = 0x116; +//const short PC_VCMPEQUB = 0x117; +//const short PC_VCMPEQUH = 0x118; +//const short PC_VCMPEQUW = 0x119; +//const short PC_VCMPGEFP = 0x11A; +//const short PC_VCMPGTFP = 0x11B; +//const short PC_VCMPGTSB = 0x11C; +//const short PC_VCMPGTSH = 0x11D; +//const short PC_VCMPGTSW = 0x11E; +//const short PC_VCMPGTUB = 0x11F; +//const short PC_VCMPGTUH = 0x120; +//const short PC_VCMPGTUW = 0x121; +//const short PC_VCTSXS = 0x122; +//const short PC_VCTUXS = 0x123; +//const short PC_VEXPTEFP = 0x124; +//const short PC_VLOGEFP = 0x125; +//const short PC_VMAXFP = 0x126; +//const short PC_VMAXSB = 0x127; +//const short PC_VMAXSH = 0x128; +//const short PC_VMAXSW = 0x129; +//const short PC_VMAXUB = 0x12A; +//const short PC_VMAXUH = 0x12B; +//const short PC_VMAXUW = 0x12C; +//const short PC_VMINFP = 0x12D; +//const short PC_VMINSB = 0x12E; +//const short PC_VMINSH = 0x12F; +//const short PC_VMINSW = 0x130; +//const short PC_VMINUB = 0x131; +//const short PC_VMINUH = 0x132; +//const short PC_VMINUW = 0x133; +//const short PC_VMRGHB = 0x134; +//const short PC_VMRGHH = 0x135; +//const short PC_VMRGHW = 0x136; +//const short PC_VMRGLB = 0x137; +//const short PC_VMRGLH = 0x138; +//const short PC_VMRGLW = 0x139; +//const short PC_VMULESB = 0x13A; +//const short PC_VMULESH = 0x13B; +//const short PC_VMULEUB = 0x13C; +//const short PC_VMULEUH = 0x13D; +//const short PC_VMULOSB = 0x13E; +//const short PC_VMULOSH = 0x13F; +//const short PC_VMULOUB = 0x140; +//const short PC_VMULOUH = 0x141; +//const short PC_VNOR = 0x142; +//const short PC_VOR = 0x143; +//const short PC_VPKPX = 0x144; +//const short PC_VPKSHSS = 0x145; +//const short PC_VPKSHUS = 0x146; +//const short PC_VPKSWSS = 0x147; +//const short PC_VPKSWUS = 0x148; +//const short PC_VPKUHUM = 0x149; +//const short PC_VPKUHUS = 0x14A; +//const short PC_VPKUWUM = 0x14B; +//const short PC_VPKUWUS = 0x14C; +//const short PC_VREFP = 0x14D; +//const short PC_VRFIM = 0x14E; +//const short PC_VRFIN = 0x14F; +//const short PC_VRFIP = 0x150; +//const short PC_VRFIZ = 0x151; +//const short PC_VRLB = 0x152; +//const short PC_VRLH = 0x153; +//const short PC_VRLW = 0x154; +//const short PC_VRSQRTEFP = 0x155; +//const short PC_VSL = 0x156; +//const short PC_VSLB = 0x157; +//const short PC_VSLH = 0x158; +//const short PC_VSLO = 0x159; +//const short PC_VSLW = 0x15A; +//const short PC_VSPLTB = 0x15B; +//const short PC_VSPLTH = 0x15C; +//const short PC_VSPLTW = 0x15D; +//const short PC_VSPLTISB = 0x15E; +//const short PC_VSPLTISH = 0x15F; +//const short PC_VSPLTISW = 0x160; +//const short PC_VSR = 0x161; +//const short PC_VSRAB = 0x162; +//const short PC_VSRAH = 0x163; +//const short PC_VSRAW = 0x164; +//const short PC_VSRB = 0x165; +//const short PC_VSRH = 0x166; +//const short PC_VSRO = 0x167; +//const short PC_VSRW = 0x168; +//const short PC_VSUBCUW = 0x169; +//const short PC_VSUBFP = 0x16A; +//const short PC_VSUBSBS = 0x16B; +//const short PC_VSUBSHS = 0x16C; +//const short PC_VSUBSWS = 0x16D; +//const short PC_VSUBUBM = 0x16E; +//const short PC_VSUBUBS = 0x16F; +//const short PC_VSUBUHM = 0x170; +//const short PC_VSUBUHS = 0x171; +//const short PC_VSUBUWM = 0x172; +//const short PC_VSUBUWS = 0x173; +//const short PC_VSUMSWS = 0x174; +//const short PC_VSUM2SWS = 0x175; +//const short PC_VSUM4SBS = 0x176; +//const short PC_VSUM4SHS = 0x177; +//const short PC_VSUM4UBS = 0x178; +//const short PC_VUPKHPX = 0x179; +//const short PC_VUPKHSB = 0x17A; +//const short PC_VUPKHSH = 0x17B; +//const short PC_VUPKLPX = 0x17C; +//const short PC_VUPKLSB = 0x17D; +//const short PC_VUPKLSH = 0x17E; +//const short PC_VXOR = 0x17F; +//const short PC_VMADDFP = 0x180; +//const short PC_VMHADDSHS = 0x181; +//const short PC_VMHRADDSHS = 0x182; +//const short PC_VMLADDUHM = 0x183; +//const short PC_VMSUMMBM = 0x184; +//const short PC_VMSUMSHM = 0x185; +//const short PC_VMSUMSHS = 0x186; +//const short PC_VMSUMUBM = 0x187; +//const short PC_VMSUMUHM = 0x188; +//const short PC_VMSUMUHS = 0x189; +//const short PC_VNMSUBFP = 0x18A; +//const short PC_VPERM = 0x18B; +//const short PC_VSEL = 0x18C; +//const short PC_VSLDOI = 0x18D; +//const short PC_VMR = 0x18E; +//const short PC_VMRP = 0x18F; +//const short PC_SLE = 0x190; +//const short PC_SLEQ = 0x191; +//const short PC_SLIQ = 0x192; +//const short PC_SLLIQ = 0x193; +//const short PC_SLLQ = 0x194; +//const short PC_SLQ = 0x195; +//const short PC_SRAIQ = 0x196; +//const short PC_SRAQ = 0x197; +//const short PC_SRE = 0x198; +//const short PC_SREA = 0x199; +//const short PC_SREQ = 0x19A; +//const short PC_SRIQ = 0x19B; +//const short PC_SRLIQ = 0x19C; +//const short PC_SRLQ = 0x19D; +//const short PC_SRQ = 0x19E; +//const short PC_MASKG = 0x19F; +//const short PC_MASKIR = 0x1A0; +//const short PC_LSCBX = 0x1A1; +//const short PC_DIV = 0x1A2; +//const short PC_DIVS = 0x1A3; +//const short PC_DOZ = 0x1A4; +//const short PC_MUL = 0x1A5; +//const short PC_NABS = 0x1A6; +//const short PC_ABS = 0x1A7; +//const short PC_CLCS = 0x1A8; +//const short PC_DOZI = 0x1A9; +//const short PC_RLMI = 0x1AA; +//const short PC_RRIB = 0x1AB; +//const short PC_PENTRY = 0x1AC; +//const short PC_PEXIT = 0x1AD; +//const short OPCODE_MAX = 0x1AE; extern OpcodeInfo opcodeinfo[OPCODE_MAX]; extern void pcode_get_hi_lo(int bits, char typechar, SInt32 *hi, SInt32 *lo); extern int pcode_check_imm_bits(SInt32 value, int bits, char typechar); -extern int pcode_const_from_format(const char *format, int *pResult); +extern int pcode_const_from_format(const char *format, SInt32 *pResult); extern PCode *vformatpcode(short opcode, va_list argList); extern int expectandformatoperand(PCodeArg *operand, PCOpKind expectedKind, char a3, int bitCount, char *buf); extern int formatoperand(PCodeArg *operand, char *buf); diff --git a/includes/compiler/PCodeListing.h b/includes/compiler/PCodeListing.h new file mode 100644 index 0000000..32390ac --- /dev/null +++ b/includes/compiler/PCodeListing.h @@ -0,0 +1,6 @@ +#ifndef COMPILER_PCODELISTING_H +#define COMPILER_PCODELISTING_H + +#include "compiler/common.h" + +#endif diff --git a/includes/compiler/PPCError.h b/includes/compiler/PPCError.h new file mode 100644 index 0000000..c211912 --- /dev/null +++ b/includes/compiler/PPCError.h @@ -0,0 +1,11 @@ +#ifndef COMPILER_PPCERROR_H +#define COMPILER_PPCERROR_H + +#include "compiler/common.h" + +extern void PPCError_Error(int code, ...); +extern void PPCError_Warning(int code, ...); +extern void PPCError_Message(char *format, ...); +extern void PPCError_ErrorTerm(short code, ...); + +#endif diff --git a/includes/compiler/Peephole.h b/includes/compiler/Peephole.h new file mode 100644 index 0000000..d391c09 --- /dev/null +++ b/includes/compiler/Peephole.h @@ -0,0 +1,6 @@ +#ifndef COMPILER_PEEPHOLE_H +#define COMPILER_PEEPHOLE_H + +#include "compiler/common.h" + +#endif diff --git a/includes/compiler/RegisterInfo.h b/includes/compiler/RegisterInfo.h new file mode 100644 index 0000000..2ef2a82 --- /dev/null +++ b/includes/compiler/RegisterInfo.h @@ -0,0 +1,42 @@ +#ifndef COMPILER_REGISTERINFO_H +#define COMPILER_REGISTERINFO_H + +#include "compiler/common.h" +#include "compiler/Registers.h" + +extern short last_exception_register[RegClassMax]; +extern short first_fe_temporary_register[RegClassMax]; +extern short last_argument_register[RegClassMax]; +extern short _FP_; +extern short _CALLER_SP_; +extern char *special_register_names[RegClassMax][RegisterMax]; +extern short spr_to_sysreg[4]; + +extern void asm_used_register(char rclass, short reg); +extern void retain_register(Object *obj, char rclass, short reg); +extern void retain_GPR_pair(Object *obj, short reg, short regHi); +extern int is_register_object(Object *obj); +extern int GetABIFirstNonVolatile(char rclass); +extern char GetRegisterClassName(char rclass); +extern void setup_diagnostic_reg_strings(void); +extern void init_target_registers(void); +extern void assign_register_by_type(Object *obj); +extern void assign_GPR_pair(Object *obj); +extern void open_fe_temp_registers(void); +extern void set_last_exception_registers(void); +extern VarInfo *Registers_GetVarInfo(Object *obj); +extern int used_vrstate_VRs(void); +extern UInt32 colored_vrs_as_vrsave(PCodeBlock *block); +extern void save_before_coloring_nonvolatile_registers(char rclass); +extern void reset_nonvolatile_registers(char rclass); +extern int is_nonvolatile_register(char rclass, int reg); +extern void init_endian(void); +extern void update_asm_nonvolatile_registers(void); + +#define OBJECT_REG(obj) ( Registers_GetVarInfo((obj)) ? (Registers_GetVarInfo((obj))->reg) : 0 ) +#define OBJECT_REG_HI(obj) ( Registers_GetVarInfo((obj)) ? (Registers_GetVarInfo((obj))->regHi) : 0 ) +#define ALLOC_GPR() (used_virtual_registers[RegClass_GPR]++) +#define ALLOC_FPR() (used_virtual_registers[RegClass_FPR]++) +#define ALLOC_VR() (used_virtual_registers[RegClass_VR]++) + +#endif diff --git a/includes/compiler/Registers.h b/includes/compiler/Registers.h new file mode 100644 index 0000000..692d9dc --- /dev/null +++ b/includes/compiler/Registers.h @@ -0,0 +1,54 @@ +#ifndef COMPILER_REGISTERS_H +#define COMPILER_REGISTERS_H + +#include "compiler/common.h" + +enum { + RegisterMax = 32 +}; +const char RegClass_SPR = 0; +const char RegClass_CRFIELD = 1; +const char RegClass_VR = 2; +const char RegClass_FPR = 3; +const char RegClass_GPR = 4; +const char RegClassMax = 5; +const char RegClass_6 = 6; +const char RegClass_DCR = 7; + +enum { + RegState0 = 0, + RegState1 = 1, + RegState2 = 2 +}; + +extern int used_virtual_registers[RegClassMax]; +extern int used_nonvolatile_registers[RegClassMax]; +extern int assignable_registers[RegClassMax]; +extern int n_real_registers[RegClassMax]; +extern int n_scratch_registers[RegClassMax]; +extern int scratch_registers[RegClassMax][RegisterMax]; +extern int n_nonvolatile_registers[RegClassMax]; +extern int nonvolatile_registers[RegClassMax][RegisterMax]; +extern UInt8 reg_state[RegClassMax][RegisterMax]; +extern int first_temporary_register[RegClassMax]; +extern int last_temporary_register[RegClassMax]; +extern char *register_class_name[RegClassMax]; +extern char *register_class_format[RegClassMax]; +extern int coloring; +extern int optimizing; + +extern void init_registers(void); +extern void assign_register_to_variable(Object *obj, char rclass); +extern void retain_register_for_argument(Object *obj, char rclass, short reg); +extern int available_registers(char rclass); +extern UInt32 volatile_registers(char rclass); +extern short obtain_nonvolatile_register(char rclass); +extern void open_temp_registers(void); +extern void check_temp_registers(void); +extern void close_temp_registers(void); +extern int count_scratch_registers(void); +extern void init_modified_registers(void); +extern void note_modified_registers(Object *obj); +extern void find_modified_registers(Object *obj, UInt32 *masks); + +#endif diff --git a/includes/compiler/Scheduler.h b/includes/compiler/Scheduler.h new file mode 100644 index 0000000..535bab5 --- /dev/null +++ b/includes/compiler/Scheduler.h @@ -0,0 +1,6 @@ +#ifndef COMPILER_SCHEDULER_H +#define COMPILER_SCHEDULER_H + +#include "compiler/common.h" + +#endif diff --git a/includes/compiler/SpillCode.h b/includes/compiler/SpillCode.h new file mode 100644 index 0000000..3d6b911 --- /dev/null +++ b/includes/compiler/SpillCode.h @@ -0,0 +1,6 @@ +#ifndef COMPILER_SPILLCODE_H +#define COMPILER_SPILLCODE_H + +#include "compiler/common.h" + +#endif diff --git a/includes/compiler/StackFrame.h b/includes/compiler/StackFrame.h index 3145bdb..04ebb0d 100644 --- a/includes/compiler/StackFrame.h +++ b/includes/compiler/StackFrame.h @@ -22,12 +22,12 @@ extern Boolean large_stack; extern Object *dummyvaparam; extern void *dummyprofiler; -extern void init_stack_globals(void); -extern void init_frame_sizes(void); +extern void init_stack_globals(Object *funcobj); +extern void init_frame_sizes(Boolean has_varargs); extern void assign_local_memory(Object *obj); extern void assign_locals_to_memory(ObjectList *first); extern void compute_frame_sizes(void); -extern void generate_prologue(PCodeBlock *block); +extern void generate_prologue(PCodeBlock *block, Boolean has_varargs); extern void generate_epilogue(PCodeBlock *block, Boolean add_blr); extern void allocate_dynamic_stack_space(Boolean flag1, int reg1, int reg2, SInt32 size); extern char *generate_traceback(SInt32 funcsize, char *funcname, SInt32 *tbsize, Object *func); diff --git a/includes/compiler/StrengthReduction.h b/includes/compiler/StrengthReduction.h new file mode 100644 index 0000000..3686c4b --- /dev/null +++ b/includes/compiler/StrengthReduction.h @@ -0,0 +1,6 @@ +#ifndef COMPILER_STRENGTHREDUCTION_H +#define COMPILER_STRENGTHREDUCTION_H + +#include "compiler/common.h" + +#endif diff --git a/includes/compiler/StructMoves.h b/includes/compiler/StructMoves.h new file mode 100644 index 0000000..3a1107b --- /dev/null +++ b/includes/compiler/StructMoves.h @@ -0,0 +1,6 @@ +#ifndef COMPILER_STRUCTMOVES_H +#define COMPILER_STRUCTMOVES_H + +#include "compiler/common.h" + +#endif diff --git a/includes/compiler/Switch.h b/includes/compiler/Switch.h new file mode 100644 index 0000000..4d2c2b3 --- /dev/null +++ b/includes/compiler/Switch.h @@ -0,0 +1,28 @@ +#ifndef COMPILER_SWITCH_H +#define COMPILER_SWITCH_H + +#include "compiler/common.h" + +typedef struct SwitchCase { + struct SwitchCase *next; + CLabel *label; + CInt64 min; + CInt64 max; +} SwitchCase; +typedef struct CaseRange { + CInt64 min; + CInt64 range; + PCodeLabel *label; +} CaseRange; + +typedef struct SwitchInfo { + SwitchCase *cases; + CLabel *defaultlabel; +} SwitchInfo; + +extern ObjectList *switchtables; + +extern void switchstatement(ENode *expr, SwitchInfo *info); +extern void dumpswitchtables(Object *funcobj); + +#endif diff --git a/includes/compiler/TOC.h b/includes/compiler/TOC.h index 59ec8a1..c5eabb0 100644 --- a/includes/compiler/TOC.h +++ b/includes/compiler/TOC.h @@ -41,7 +41,7 @@ typedef struct COVCResult { // this struct might be used in other places too??? short op1; short op2; - unsigned char arg; + char arg; } COVCResult; extern Boolean canoptimizevectorconst(MWVector128 *vecp, Type *type, COVCResult *result); extern Boolean TOC_use_fsel(ENode *expr); diff --git a/includes/compiler/Unmangle.h b/includes/compiler/Unmangle.h new file mode 100644 index 0000000..5e230b0 --- /dev/null +++ b/includes/compiler/Unmangle.h @@ -0,0 +1,6 @@ +#ifndef COMPILER_UNMANGLE_H +#define COMPILER_UNMANGLE_H + +#include "compiler/common.h" + +#endif diff --git a/includes/compiler/UseDefChains.h b/includes/compiler/UseDefChains.h new file mode 100644 index 0000000..bcdbfe0 --- /dev/null +++ b/includes/compiler/UseDefChains.h @@ -0,0 +1,6 @@ +#ifndef COMPILER_USEDEFCHAINS_H +#define COMPILER_USEDEFCHAINS_H + +#include "compiler/common.h" + +#endif diff --git a/includes/compiler/ValueNumbering.h b/includes/compiler/ValueNumbering.h new file mode 100644 index 0000000..0d15e5a --- /dev/null +++ b/includes/compiler/ValueNumbering.h @@ -0,0 +1,6 @@ +#ifndef COMPILER_VALUENUMBERING_H +#define COMPILER_VALUENUMBERING_H + +#include "compiler/common.h" + +#endif diff --git a/includes/compiler/VectorArraysToRegs.h b/includes/compiler/VectorArraysToRegs.h new file mode 100644 index 0000000..ab0a966 --- /dev/null +++ b/includes/compiler/VectorArraysToRegs.h @@ -0,0 +1,6 @@ +#ifndef COMPILER_VECTORARRAYSTOREGS_H +#define COMPILER_VECTORARRAYSTOREGS_H + +#include "compiler/common.h" + +#endif diff --git a/includes/compiler/common.h b/includes/compiler/common.h index 15043f5..48a33dc 100644 --- a/includes/compiler/common.h +++ b/includes/compiler/common.h @@ -204,14 +204,15 @@ typedef struct TemplParamID { typedef enum TemplDepSubType { TDE_PARAM, TDE_TYPEEXPR, + TDE_unk2, // may actually be 1? TDE_CAST, TDE_QUALNAME, TDE_QUALTEMPL, - TDE_OBJACCESS, - TDE_SOURCEREF, - TDE_FUNCCALL, - TDE_LOCAL, - TDE_MONAND, + //TDE_OBJACCESS, + //TDE_SOURCEREF, + //TDE_FUNCCALL, + //TDE_LOCAL, + TDE_MONAND = 7, TDE_MONPLUS, TDE_MONMUL, TDE_NEW, @@ -333,6 +334,14 @@ struct CParams { CWDataType targetCPU; char *targetName; }; + +#define FITS_IN_SHORT(value) ( (value) == ((short) (value)) ) +#define FITS_IN_USHORT(value) ( (value) == ((unsigned short) (value)) ) +#define FITS_IN_HI_SHORT(value) ( (value) == (value & 0xFFFF0000) ) +#define FITS_IN_SHORT2(value) ( ((short) (value)) == (value) ) +#define HIGH_PART(value) ( (short) (((value) >> 16) + (((value) & 0x8000) >> 15)) ) +#define LOW_PART(value) ( (short) (value) ) + #ifdef __MWERKS__ #pragma options align=reset #endif diff --git a/includes/compiler/enode.h b/includes/compiler/enode.h index e12b1ae..92c7d2c 100644 --- a/includes/compiler/enode.h +++ b/includes/compiler/enode.h @@ -91,10 +91,12 @@ typedef enum ENodeType { struct EMemberInfo { BClassList *path; - ENodeList *nodes; - void *x8; - void *xC; - void *x10; + ENode *expr; + NameSpaceObjectList *list; + TemplArg *templargs; + Boolean pr_1D; + Boolean x11; + Boolean isambig; }; @@ -172,7 +174,9 @@ typedef union ENodeUnion { struct { NameSpaceObjectList *list; TemplArg *templargs; + HashNameNode *name; } objlist; + EMemberInfo *emember; void *inst; MemInitializer *ctorinit; Statement *stmt; @@ -275,9 +279,13 @@ enum { }; #define ENODE_IS(_enode, _etype) ( (_enode)->type == (_etype) ) -#define ENODE_IS2(_enode, _etype1, _etype2) ( ENODE_IS(_enode, (_etype1)) || ENODE_IS(_enode, (_etype2)) ) -#define ENODE_IS3(_enode, _etype1, _etype2, _etype3) ( ENODE_IS(_enode, (_etype1)) || ENODE_IS(_enode, (_etype2)) || ENODE_IS(_enode, (_etype3)) ) +#define ENODE_IS2(_enode, _etype1, _etype2) ( ENODE_IS((_enode), (_etype1)) || ENODE_IS(_enode, (_etype2)) ) +#define ENODE_IS3(_enode, _etype1, _etype2, _etype3) ( ENODE_IS((_enode), (_etype1)) || ENODE_IS(_enode, (_etype2)) || ENODE_IS(_enode, (_etype3)) ) #define ENODE_IS_RANGE(_enode, _lo, _hi) ( ((_enode)->type >= (_lo)) && ((_enode)->type <= (_hi)) ) +#define ENODE_QUALS(_enode) ( (UInt32) ( (_enode)->flags & ENODE_FLAG_QUALS ) ) +#define ENODE_IS_INDIRECT_TO(_enode, _etype) ( ENODE_IS((_enode), EINDIRECT) && ENODE_IS((_enode)->data.monadic, (_etype)) ) +#define ENODE_IS_ASSIGN(_enode) ( ENODE_IS_RANGE((_enode), EASS, EORASS) ) +#define ENODE_IS_ASSIGN_TO(_enode, _etype) ( ENODE_IS_RANGE((_enode), EASS, EORASS) && ENODE_IS((_enode)->data.diadic.left->data.monadic, (_etype)) ) #ifdef __MWERKS__ #pragma options align=reset diff --git a/includes/compiler/objects.h b/includes/compiler/objects.h index 5f01d26..a6a170b 100644 --- a/includes/compiler/objects.h +++ b/includes/compiler/objects.h @@ -2,6 +2,7 @@ #define COMPILER_OBJECTS_H #include "compiler/common.h" +#include "compiler/tokens.h" #ifdef __MWERKS__ #pragma options align=mac68k diff --git a/includes/compiler/templates.h b/includes/compiler/templates.h index 85bc5ec..227dd7b 100644 --- a/includes/compiler/templates.h +++ b/includes/compiler/templates.h @@ -160,6 +160,7 @@ struct TemplClassInst { #define TEMPL_CLASS(ty) ( (TemplClass *) (ty) ) #define TEMPL_CLASS_INST(ty) ( (TemplClassInst *) (ty) ) +#define IS_TEMPL_CLASS(ty) ( IS_TYPE_CLASS(ty) && (TYPE_CLASS(ty)->flags & CLASS_FLAGS_100) ) /*************/ /* Functions */ @@ -189,6 +190,10 @@ struct TemplFuncInstance { // verified via CPrec Boolean static_instantiated; }; +#define TEMPL_FUNC(ty) ( (TemplateFunction *) (ty) ) +#define TEMPL_FUNC_INST(ty) ( (TemplFuncInstance *) (ty) ) +#define IS_TEMPL_FUNC(ty) ( IS_TYPE_FUNC(ty) && (TYPE_FUNC(ty)->flags & FUNC_FLAGS_100000) ) + /***********/ /* Actions */ /***********/ diff --git a/includes/compiler/tokens.h b/includes/compiler/tokens.h index 2f49f98..9a3a258 100644 --- a/includes/compiler/tokens.h +++ b/includes/compiler/tokens.h @@ -180,6 +180,7 @@ struct TStreamElement { TData data; }; +// this is actually called TokenStream struct TStream { SInt32 tokens; TStreamElement *firsttoken; diff --git a/includes/compiler/types.h b/includes/compiler/types.h index e5b4d94..47f6421 100644 --- a/includes/compiler/types.h +++ b/includes/compiler/types.h @@ -51,9 +51,18 @@ typedef enum IntegralType { IT_FLOAT = 13, IT_SHORTDOUBLE = 14, IT_DOUBLE = 15, - IT_LONGDOUBLE = 16 + IT_LONGDOUBLE = 16, + IT_17 = 17, + IT_18 = 18, + IT_19 = 19, + IT_20 = 20, + IT_21 = 21, + IT_22 = 22, + IT_23 = 23, + IT_24 = 24 } IntegralType; +// This is probably actually called AtomType / TypeAtom struct TypeIntegral { TypeType type; SInt32 size; @@ -87,10 +96,11 @@ struct StructMember { UInt32 qual; }; -enum { +/*enum { STRUCT_TYPE_STRUCT = 0, STRUCT_TYPE_UNION = 1, STRUCT_TYPE_CLASS = 2, + STRUCT_TYPE_3 = 3, STRUCT_TYPE_4 = 4, STRUCT_TYPE_5 = 5, STRUCT_TYPE_6 = 6, @@ -102,7 +112,22 @@ enum { STRUCT_TYPE_C = 12, STRUCT_TYPE_D = 13, STRUCT_TYPE_E = 14 -}; +};*/ +const char STRUCT_TYPE_STRUCT = 0; +const char STRUCT_TYPE_UNION = 1; +const char STRUCT_TYPE_CLASS = 2; +const char STRUCT_TYPE_3 = 3; +const char STRUCT_TYPE_4 = 4; +const char STRUCT_TYPE_5 = 5; +const char STRUCT_TYPE_6 = 6; +const char STRUCT_TYPE_7 = 7; +const char STRUCT_TYPE_8 = 8; +const char STRUCT_TYPE_9 = 9; +const char STRUCT_TYPE_A = 10; +const char STRUCT_TYPE_B = 11; +const char STRUCT_TYPE_C = 12; +const char STRUCT_TYPE_D = 13; +const char STRUCT_TYPE_E = 14; struct ClassList { // checked via CPrec @@ -235,7 +260,7 @@ enum { FUNC_FLAGS_40 = 0x40, // func that's like "operator SomeOtherType()" FUNC_FLAGS_80 = 0x80, FUNC_FLAGS_100 = 0x100, - FUNC_FLAGS_200 = 0x200, + FUNC_FLAGS_200 = 0x200, // intrinsic? FUNC_FLAGS_NOTHROW = 0x400, FUNC_FLAGS_800 = 0x800, FUNC_FLAGS_1000 = 0x1000, @@ -367,16 +392,22 @@ struct TypeList { #define TYPE_TEMPLATE(ty) ((TypeTemplDep *) (ty)) #define TYPE_MEMBER_POINTER(ty) ((TypeMemberPointer *) (ty)) #define TYPE_POINTER(ty) ((TypePointer *) (ty)) +#define TPTR_TARGET(ty) (TYPE_POINTER(ty)->target) +#define TPTR_QUAL(ty) (TYPE_POINTER(ty)->qual) #define IS_TYPE_VOID(ty) ( (ty)->type == TYPEVOID ) #define IS_TYPE_INT(ty) ( (ty)->type == TYPEINT ) #define IS_TYPE_ENUM(ty) ( (ty)->type == TYPEENUM ) #define IS_TYPE_INT_OR_ENUM(ty) ( IS_TYPE_INT(ty) || IS_TYPE_ENUM(ty) ) #define IS_TYPE_FLOAT(ty) ( (ty)->type == TYPEFLOAT ) +#define IS_TYPE_INT_OR_FLOAT(ty) ( IS_TYPE_INT(ty) || IS_TYPE_FLOAT(ty) ) #define IS_TYPE_STRUCT(ty) ( (ty)->type == TYPESTRUCT ) #define IS_TYPE_CLASS(ty) ( (ty)->type == TYPECLASS ) #define IS_TYPE_FUNC(ty) ( (ty)->type == TYPEFUNC ) #define IS_TYPEFUNC_METHOD(ty) ( (ty)->flags & FUNC_FLAGS_METHOD ) +#define IS_TYPE_METHOD(ty) ( IS_TYPE_FUNC(ty) && IS_TYPEFUNC_METHOD(TYPE_FUNC(ty)) ) +#define IS_TYPE_NONSTATIC_METHOD(ty) ( IS_TYPE_FUNC(ty) && IS_TYPEFUNC_METHOD(TYPE_FUNC(ty)) && !TYPE_METHOD(ty)->x26 ) +#define IS_TYPE_STATIC_METHOD(ty) ( IS_TYPE_FUNC(ty) && IS_TYPEFUNC_METHOD(TYPE_FUNC(ty)) && TYPE_METHOD(ty)->x26 ) #define IS_TYPE_TEMPLATE(ty) ( (ty)->type == TYPETEMPLATE ) #define IS_TYPE_POINTER(ty) ( (ty)->type == TYPEPOINTER || (ty)->type == TYPEARRAY ) #define IS_TYPE_POINTER_ONLY(ty) ( (ty)->type == TYPEPOINTER ) @@ -384,7 +415,8 @@ struct TypeList { #define IS_TYPEPOINTER_REFERENCE(ty) ( (ty)->qual & Q_REFERENCE ) #define IS_TYPE_ARRAY(ty) ( (ty)->type == TYPEARRAY ) #define IS_TYPE_BITFIELD(ty) ( (ty)->type == TYPEBITFIELD ) -#define IS_TYPESTRUCT_VECTOR(ty) ( (ty)->stype >= STRUCT_TYPE_4 && (ty)->stype <= STRUCT_TYPE_E ) +#define IS_TYPE_TEMPLDEPEXPR(ty) ( (ty)->type == TYPETEMPLDEPEXPR ) +#define IS_TYPESTRUCT_VECTOR(ty) ( TYPE_STRUCT(ty)->stype >= STRUCT_TYPE_4 && TYPE_STRUCT(ty)->stype <= STRUCT_TYPE_E ) #define IS_TYPE_VECTOR(ty) ( (ty)->type == TYPESTRUCT && IS_TYPESTRUCT_VECTOR(TYPE_STRUCT(ty)) ) #define IS_TYPE_NONVECTOR_STRUCT(ty) ( (ty)->type == TYPESTRUCT && !IS_TYPESTRUCT_VECTOR(TYPE_STRUCT(ty)) ) #define IS_TYPE_MEMBERPOINTER(ty) ( (ty)->type == TYPEMEMBERPOINTER ) @@ -393,6 +425,8 @@ struct TypeList { #define TYPE_FITS_IN_REGISTER(ty) ( ((ty)->type == TYPEINT) || ((ty)->type == TYPEENUM) || (IS_TYPE_POINTER(ty) && ((ty)->type != TYPEARRAY)) || IS_TYPE_4BYTES_MEMBERPOINTER(ty) ) #define TYPE_IS_8BYTES(ty) ( (((ty)->type == TYPEINT) || ((ty)->type == TYPEENUM)) && ((ty)->size == 8) ) +#define TYPE_FITS_IN_REGISTER_2(ty) ( ((ty)->type == TYPEINT) || ((ty)->type == TYPEENUM) || IS_TYPE_POINTER(ty) || IS_TYPE_4BYTES_MEMBERPOINTER(ty) ) + #define OBJ_GET_TARGET_VOLATILE(obj) ( IS_TYPE_POINTER((obj)->type) ? (TYPE_POINTER((obj)->type)->qual & Q_VOLATILE) : ((obj)->qual & Q_VOLATILE) ) #define OBJ_GET_TARGET_CONST(obj) ( IS_TYPE_POINTER((obj)->type) ? (TYPE_POINTER((obj)->type)->qual & Q_CONST) : ((obj)->qual & Q_CONST) ) @@ -90,7 +90,7 @@ PART CPrepTokenizer.c ---- IroCSE.c ---- IroPropagate.c ---- IROUseDef.c ----- InlineAsmPPC.c +MOST InlineAsmPPC.c ---- IroDump.c ---- IroTransform.c ---- IroVars.c @@ -121,7 +121,7 @@ MOST Operands.c ---- Coloring.c ---- PCodeAssembly.c ---- Intrinsics.c ----- PPCError.c +DONE PPCError.c STUB CExpr2.c DONE* CInt64.c PART CPrec.c @@ -134,7 +134,7 @@ PART CPrec.c ---- CExprConvMatch.c ---- CRTTI.c ---- CObjCModern.c ----- InlineAsm.c +DONE InlineAsm.c ---- Unmangle.c ---- MachO.c ---- GenStabs.c @@ -143,10 +143,10 @@ PART CPrec.c PART PCodeInfo.c ---- StructMoves.c ---- FunctionCalls.c ----- IroBitVect.c ----- InlineAsmRegistersPPC.c ----- InlineAsmMnemonicsPPC.c ----- InlineAsmRegisters.c +DONE IroBitVect.c +MOST InlineAsmRegistersPPC.c +DONE InlineAsmMnemonicsPPC.c +DONE InlineAsmRegisters.c ---- Alias.c ---- LoopDetection.c ---- CopyPropagation.c |