diff --git a/src/bin/jbc2mpl b/src/bin/jbc2mpl index 2261301b01ca270c942335418b431966cb9eecc2..456b855bb4c98a194f0bdbce712314e7c43a9549 100755 Binary files a/src/bin/jbc2mpl and b/src/bin/jbc2mpl differ diff --git a/src/bin/maple b/src/bin/maple index 9027ae5185fe82a3ae64a834c1d1ae3814af3b5e..1dd03cc9609bb2460bf8f3730358bf46a65586d2 100755 Binary files a/src/bin/maple and b/src/bin/maple differ diff --git a/src/bin/mplcg b/src/bin/mplcg index cdc16d24668b2471992f42394b5837ed5841f34e..cc26b18e65b84173b4a2dd65a86e9745a4094cb3 100755 Binary files a/src/bin/mplcg and b/src/bin/mplcg differ diff --git a/src/deplibs/libmaple_driverutil.a b/src/deplibs/libmaple_driverutil.a index 28c0f2b1e7fb1eb096e5a4b026ded1b21976a85b..68d099810f58575d672ee6d354d20c646a2ee09a 100644 Binary files a/src/deplibs/libmaple_driverutil.a and b/src/deplibs/libmaple_driverutil.a differ diff --git a/src/deplibs/libmempool.a b/src/deplibs/libmempool.a index 65f58630fd2a222971410c793cb1db51fa5b09be..1a9db36584e163516526ff5a8e70223dce58fa7d 100644 Binary files a/src/deplibs/libmempool.a and b/src/deplibs/libmempool.a differ diff --git a/src/deplibs/libmplutil.a b/src/deplibs/libmplutil.a index 3fe193a96da64a6f346f8975d31437e23f154f25..f43e2b5a08bd05134220d390c307a52f7f79001e 100644 Binary files a/src/deplibs/libmplutil.a and b/src/deplibs/libmplutil.a differ diff --git a/src/maple_driver/include/mpl_options.h b/src/maple_driver/include/mpl_options.h index 97a05ae6c38e9e04e8523dbb3f139e5c662a56d0..7c3c09b9f5780cbce62a9b9f9b481b456f5d0d50 100644 --- a/src/maple_driver/include/mpl_options.h +++ b/src/maple_driver/include/mpl_options.h @@ -101,30 +101,7 @@ struct DefaultOption { class MplOptions { public: - MplOptions() - : optionParser(nullptr), - options({}), - exeOptions({}), - inputFiles(""), - inputFolder(""), - outputFolder(""), - outputName("maple"), - exeFolder(""), - inputFileType(InputFileType::kNone), - optimizationLevel(OptimizationLevel::kO0), - runMode(RunMode::kUnkownRun), - setDefaultLevel(false), - isSaveTmps(false), - saveFiles({}), - splitsInputFiles({}), - extras({}), - runningExes({}), - printCommandStr(""), - debugFlag(false), - timePhases(false), - genMeMpl(false), - genVtableImpl(false), - verify(false) {} + MplOptions() = default; ~MplOptions() = default; int Parse(int argc, char **argv); @@ -211,29 +188,29 @@ class MplOptions { } private: - std::unique_ptr optionParser; - std::map> options; - std::map> exeOptions; - std::string inputFiles; - std::string inputFolder; - std::string outputFolder; - std::string outputName; - std::string exeFolder; - InputFileType inputFileType; - OptimizationLevel optimizationLevel; - RunMode runMode; - bool setDefaultLevel; - bool isSaveTmps; - std::vector saveFiles; - std::vector splitsInputFiles; - std::map> extras; - std::vector runningExes; - std::string printCommandStr; - bool debugFlag; - bool timePhases; - bool genMeMpl; - bool genVtableImpl; - bool verify; + std::unique_ptr optionParser = nullptr; + std::map> options = {}; + std::map> exeOptions = {}; + std::string inputFiles = ""; + std::string inputFolder = ""; + std::string outputFolder = ""; + std::string outputName = "maple"; + std::string exeFolder = ""; + InputFileType inputFileType = InputFileType::kNone; + OptimizationLevel optimizationLevel = OptimizationLevel::kO0; + RunMode runMode = RunMode::kUnkownRun; + bool setDefaultLevel = false; + bool isSaveTmps = false; + std::vector saveFiles = {}; + std::vector splitsInputFiles = {}; + std::map> extras = {}; + std::vector runningExes = {}; + std::string printCommandStr = ""; + bool debugFlag = false; + bool timePhases = false; + bool genMeMpl = false; + bool genVtableImpl = false; + bool verify = false; bool Init(const std::string &inputFile); ErrorCode HandleGeneralOptions(); ErrorCode DecideRunType(); diff --git a/src/maple_driver/src/mpl_options.cpp b/src/maple_driver/src/mpl_options.cpp index f847d04ec1a73fbe3a7a176b41e3194d5203682d..016d7564617d35dd3312fa99be8ed9cf1aa9dab2 100644 --- a/src/maple_driver/src/mpl_options.cpp +++ b/src/maple_driver/src/mpl_options.cpp @@ -821,7 +821,7 @@ using namespace mapleOption; const std::string kMapleDriverVersion = "mapledriver " + std::to_string(Version::kMajorMplVersion) + "." + std::to_string(Version::kMinorCompilerVersion) + " 20190712"; int MplOptions::Parse(int argc, char **argv) { - this->optionParser.reset(new OptionParser(USAGES)); + optionParser.reset(new OptionParser(USAGES)); exeFolder = FileUtils::GetFileFolder(*argv); int ret = optionParser->Parse(argc, argv); if (ret != ErrorCode::kErrorNoError) { @@ -893,37 +893,37 @@ ErrorCode MplOptions::HandleGeneralOptions() { optionParser->PrintUsage(kBinNameMpl2mpl); return ErrorCode::kErrorExitHelp; case kCombTimePhases: - this->timePhases = true; - this->printCommandStr += " -time-phases"; + timePhases = true; + printCommandStr += " -time-phases"; break; case kGenMeMpl: - this->genMeMpl = true; - this->printCommandStr += " --genmempl"; + genMeMpl = true; + printCommandStr += " --genmempl"; break; case kGenVtableImpl: - this->genVtableImpl = true; - this->printCommandStr += " --genVtableImpl"; + genVtableImpl = true; + printCommandStr += " --genVtableImpl"; break; case kVerify: - this->verify = true; - this->printCommandStr += " --verify"; + verify = true; + printCommandStr += " --verify"; break; case kSaveTemps: - this->isSaveTmps = true; - this->genMeMpl = true; - this->genVtableImpl = true; - StringUtils::Split(opt.Args(), this->saveFiles, ','); - this->printCommandStr += " --save-temps"; + isSaveTmps = true; + genMeMpl = true; + genVtableImpl = true; + StringUtils::Split(opt.Args(), saveFiles, ','); + printCommandStr += " --save-temps"; break; case kOption: - if (this->UpdateExtraOptionOpt(opt.Args()) != ErrorCode::kErrorNoError) { + if (UpdateExtraOptionOpt(opt.Args()) != ErrorCode::kErrorNoError) { return ErrorCode::kErrorInvalidParameter; } break; case kInMplt: break; case kAllDebug: - this->debugFlag = true; + debugFlag = true; break; default: // I do not care @@ -952,7 +952,7 @@ ErrorCode MplOptions::DecideRunType() { runModeConflict = true; } else { runMode = RunMode::kCustomRun; - this->UpdateRunningExe(opt.Args()); + UpdateRunningExe(opt.Args()); } break; case kInFile: { @@ -980,7 +980,7 @@ ErrorCode MplOptions::DecideRunningPhases() { case InputFileType::kJar: /* fall-through */ case InputFileType::kClass: - this->UpdateRunningExe(kBinNameJbc2mpl); + UpdateRunningExe(kBinNameJbc2mpl); break; case InputFileType::kMpl: break; @@ -1016,7 +1016,7 @@ ErrorCode MplOptions::CheckInputFileValidity() { if (optionParser->GetNonOptionsCount() > 0) { std::string optionString; const std::vector inputs = optionParser->GetNonOptions(); - for (unsigned int i = 0; i < inputs.size(); i++) { + for (size_t i = 0; i < inputs.size(); i++) { if (i == 0) { optionString = inputs[i]; } else { @@ -1051,8 +1051,8 @@ ErrorCode MplOptions::CheckFileExits() { void MplOptions::AddOption(const mapleOption::Option &option) { if (option.HasExtra()) { for (auto &extra : option.GetExtras()) { - auto iter = std::find(this->runningExes.begin(), this->runningExes.end(), extra.exeName); - if (iter == this->runningExes.end()) { + auto iter = std::find(runningExes.begin(), runningExes.end(), extra.exeName); + if (iter == runningExes.end()) { continue; } options[extra.exeName].push_back(option); @@ -1064,26 +1064,26 @@ bool MplOptions::Init(const std::string &inputFile) { if (StringUtils::Trim(inputFile).empty()) { return false; } - this->inputFiles = inputFile; - StringUtils::Split(inputFile, this->splitsInputFiles, ','); + inputFiles = inputFile; + StringUtils::Split(inputFile, splitsInputFiles, ','); std::string firstInputFile = splitsInputFiles[0]; - this->inputFolder = FileUtils::GetFileFolder(firstInputFile); - this->outputFolder = this->inputFolder; - this->outputName = FileUtils::GetFileName(firstInputFile, false); + inputFolder = FileUtils::GetFileFolder(firstInputFile); + outputFolder = inputFolder; + outputName = FileUtils::GetFileName(firstInputFile, false); std::string extensionName = FileUtils::GetFileExtension(firstInputFile); if (extensionName == "class") { - this->inputFileType = InputFileType::kClass; + inputFileType = InputFileType::kClass; } else if (extensionName == "jar") { - this->inputFileType = InputFileType::kJar; + inputFileType = InputFileType::kJar; } else if (extensionName == "mpl") { if (firstInputFile.find("VtableImpl") == std::string::npos) { - this->inputFileType = InputFileType::kMpl; + inputFileType = InputFileType::kMpl; } else { - this->inputFileType = InputFileType::kVtableImplMpl; + inputFileType = InputFileType::kVtableImplMpl; } } else if (extensionName == "s") { - this->inputFileType = InputFileType::kS; + inputFileType = InputFileType::kS; } else { return false; } @@ -1091,7 +1091,7 @@ bool MplOptions::Init(const std::string &inputFile) { } std::string MplOptions::OptimizationLevelStr() const { - switch (this->optimizationLevel) { + switch (optimizationLevel) { case OptimizationLevel::kO0: { return "-O0"; } @@ -1123,30 +1123,30 @@ ErrorCode MplOptions::AppendDefaultCombOptions() { ErrorCode MplOptions::AppendDefaultCgOptions() { ErrorCode ret = ErrorCode::kErrorNoError; if (optimizationLevel == kO0) { - this->UpdateRunningExe(kBinNameMplcg); + UpdateRunningExe(kBinNameMplcg); } return ret; } ErrorCode MplOptions::AppendDefaultOptions(const std::string &exeName, MplOption mplOptions[], unsigned int length) { auto &exeOption = exeOptions[exeName]; - for (unsigned int i = 0; i < length; i++) { + for (size_t i = 0; i < length; i++) { bool ret = optionParser->SetOption(mplOptions[i].GetKey(), mplOptions[i].GetValue(), exeName, exeOption); if (!ret) { return ErrorCode::kErrorInvalidParameter; } } - auto iter = std::find(this->runningExes.begin(), this->runningExes.end(), exeName.c_str()); - if (iter == this->runningExes.end()) { - this->runningExes.push_back(exeName); + auto iter = std::find(runningExes.begin(), runningExes.end(), exeName.c_str()); + if (iter == runningExes.end()) { + runningExes.push_back(exeName); } return ErrorCode::kErrorNoError; } ErrorCode MplOptions::UpdatePhaseOption(const std::string &args, const std::string &exeName) { - auto iter = std::find(this->runningExes.begin(), this->runningExes.end(), exeName.c_str()); - if (iter == this->runningExes.end()) { - LogInfo::MapleLogger(kLlErr) << "Cannot find phase " << exeName << std::endl; + auto iter = std::find(runningExes.begin(), runningExes.end(), exeName.c_str()); + if (iter == runningExes.end()) { + LogInfo::MapleLogger(kLlErr) << "Cannot find phase " << exeName << '\n'; return ErrorCode::kErrorExit; } std::vector tmpArgs; @@ -1195,10 +1195,10 @@ ErrorCode MplOptions::UpdateExtraOptionOpt(const std::string &args) { void MplOptions::UpdateRunningExe(const std::string &args) { std::vector results; StringUtils::Split(args, results, ':'); - for (unsigned int i = 0; i < results.size(); i++) { - auto iter = std::find(this->runningExes.begin(), this->runningExes.end(), results[i].c_str()); - if (iter == this->runningExes.end()) { - this->runningExes.push_back(results[i]); + for (size_t i = 0; i < results.size(); i++) { + auto iter = std::find(runningExes.begin(), runningExes.end(), results[i].c_str()); + if (iter == runningExes.end()) { + runningExes.push_back(results[i]); } } } diff --git a/src/maple_ir/include/bin_mpl_export.h b/src/maple_ir/include/bin_mpl_export.h index 2a189c9c64d4a3cce8db5cb8b10b169e684bd708..24d85cdf1734a062a08313760b15d0cb8ceb0f3b 100644 --- a/src/maple_ir/include/bin_mpl_export.h +++ b/src/maple_ir/include/bin_mpl_export.h @@ -28,11 +28,6 @@ enum : uint8 { kBinInitConst = 2, kBinSymbol = 3, kBinFunction = 4, - kBinEaCgNode, - kBinEaCgActNode, - kBinEaCgFieldNode, - kBinEaCgRefNode, - kBinEaCgObjNode, kBinCallinfo = 5, kBinKindTypeScalar = 6, kBinKindTypeByName = 7, @@ -62,10 +57,15 @@ enum : uint8 { kBinTypeStart = 31, kBinCgStart = 32, kBinSeStart = 33, - kBinEaCgStart, - kBinEaStart, kBinFinish = 34, kStartMethod = 35, + kBinEaCgNode = 36, + kBinEaCgActNode = 37, + kBinEaCgFieldNode = 38, + kBinEaCgRefNode = 39, + kBinEaCgObjNode = 40, + kBinEaCgStart = 41, + kBinEaStart = 42, }; // this value is used to check wether a file is a binary mplt file @@ -73,7 +73,7 @@ constexpr int32 kMpltMagicNumber = 0xC0FFEE; class BinaryMplExport { public: explicit BinaryMplExport(MIRModule &md); - virtual ~BinaryMplExport() {} + virtual ~BinaryMplExport() = default; void Export(const std::string &fname); void WriteContentField(int fieldNum, uint64 &fieldStartP); diff --git a/src/maple_ir/include/bin_mplt.h b/src/maple_ir/include/bin_mplt.h index 8b261d143842db408c15f12c45923585307c8dcd..9fc9ccc0e55990035c1d11a40e44bbee2ad71986 100644 --- a/src/maple_ir/include/bin_mplt.h +++ b/src/maple_ir/include/bin_mplt.h @@ -27,7 +27,7 @@ class BinaryMplt { explicit BinaryMplt(MIRModule &md) : mirModule(md), binImport(md), binExport(md) {} - virtual ~BinaryMplt() {} + virtual ~BinaryMplt() = default; void Export(const std::string &suffix) { binExport.Export(suffix); diff --git a/src/maple_ir/include/global_tables.h b/src/maple_ir/include/global_tables.h index 7c3025e873bdc266fff2d5119e19c8d6fca093c5..0a02013c80f7129ba0febac522cf1e803ba2c514 100644 --- a/src/maple_ir/include/global_tables.h +++ b/src/maple_ir/include/global_tables.h @@ -487,8 +487,8 @@ class GSymbolTable { return idx < symbolTable.size(); } - MIRSymbol *GetSymbolFromStidx(uint32 idx, bool checkfirst = false) const { - if (checkfirst && idx >= symbolTable.size()) { + MIRSymbol *GetSymbolFromStidx(uint32 idx, bool checkFirst = false) const { + if (checkFirst && idx >= symbolTable.size()) { return nullptr; } ASSERT(IsValidIdx(idx), "symbol table index out of range"); diff --git a/src/maple_ir/include/metadata_layout.h b/src/maple_ir/include/metadata_layout.h index 19f739d682eefc4fee8bedbae727cefef1dd28a4..2f697fe05add3cba1b2141167311097a492dbeab 100644 --- a/src/maple_ir/include/metadata_layout.h +++ b/src/maple_ir/include/metadata_layout.h @@ -189,8 +189,8 @@ struct ClassMetadata { uint16_t numOfSuperclasses; #endif // USE_32BIT_REF - void *iTable; // iTable of current class, used for virtual call, will insert the content into classinfo - void *vTable; // vTable of current class, used for interface call, will insert the content into classinfo + DataRef iTable; // iTable of current class, used for virtual call, will insert the content into classinfo + DataRef vTable; // vTable of current class, used for interface call, will insert the content into classinfo void *gctib; // for rc union { diff --git a/src/maple_ir/include/mir_builder.h b/src/maple_ir/include/mir_builder.h index f775abc7750df56c7631a3da1b2cc13b20fb8625..159c7223f58e23509058f872dc4b4c79008ac4d3 100644 --- a/src/maple_ir/include/mir_builder.h +++ b/src/maple_ir/include/mir_builder.h @@ -53,7 +53,7 @@ class MIRBuilder { incompleteTypeRefedSet(std::less(), mirModule->GetMPAllocator().Adapter()), lineNum(0) {} - virtual ~MIRBuilder() {} + virtual ~MIRBuilder() = default; virtual void SetCurrentFunction(MIRFunction &fun) { mirModule->SetCurFunction(&fun); @@ -68,7 +68,7 @@ class MIRBuilder { return func; } - MIRModule &GetMirModule() const { + MIRModule &GetMirModule() { return *mirModule; } @@ -111,16 +111,18 @@ class MIRBuilder { void AddAddrofFieldConst(const MIRStructType &sType, MIRAggConst &newConst, uint32 fieldID, const MIRSymbol &fieldSt); void AddAddroffuncFieldConst(const MIRStructType &sType, MIRAggConst &newConst, uint32 fieldID, const MIRSymbol &funcSt); + bool TraverseToNamedField(MIRStructType &structType, GStrIdx nameIdx, uint32 &fieldID); - bool IsOfSameType(MIRType &type1, MIRType &type2); bool TraverseToNamedFieldWithTypeAndMatchStyle(MIRStructType &structType, GStrIdx nameIdx, TyIdx typeIdx, uint32 &fieldID, unsigned int matchStyle); void TraverseToNamedFieldWithType(MIRStructType &structType, GStrIdx nameIdx, TyIdx typeIdx, uint32 &fieldID, uint32 &idx); + FieldID GetStructFieldIDFromNameAndType(MIRType &type, const std::string &name, TyIdx idx, unsigned int matchStyle); FieldID GetStructFieldIDFromNameAndType(MIRType &type, const std::string &name, TyIdx idx); FieldID GetStructFieldIDFromNameAndTypeParentFirst(MIRType &type, const std::string &name, TyIdx idx); FieldID GetStructFieldIDFromNameAndTypeParentFirstFoundInChild(MIRType &type, const std::string &name, TyIdx idx); + FieldID GetStructFieldIDFromFieldName(MIRType &type, const std::string &name); FieldID GetStructFieldIDFromFieldNameParentFirst(MIRType *type, const std::string &name); @@ -135,18 +137,18 @@ class MIRBuilder { MIRFunction *CreateFunction(const std::string &name, const MIRType &returnType, const ArgVector &arguments, bool isvarg = false, bool createBody = true) const; MIRFunction *CreateFunction(const StIdx stIdx, bool addToTable = true) const; - virtual void UpdateFunction(MIRFunction &func, MIRType *returnType, const ArgVector &arguments) { - return; - } + virtual void UpdateFunction(MIRFunction &func, MIRType *returnType, const ArgVector &arguments) {} MIRSymbol *GetSymbolFromEnclosingScope(StIdx stIdx) const; - virtual MIRSymbol *GetOrCreateLocalDecl(const std::string &str, MIRType &type); + virtual MIRSymbol *GetOrCreateLocalDecl(const std::string &str, const MIRType &type); MIRSymbol *GetLocalDecl(const std::string &str); MIRSymbol *CreateLocalDecl(const std::string &str, const MIRType &type); MIRSymbol *GetOrCreateGlobalDecl(const std::string &str, const MIRType &type); MIRSymbol *GetGlobalDecl(const std::string &str); MIRSymbol *GetDecl(const std::string &str); - MIRSymbol *CreateGlobalDecl(const std::string &str, const MIRType &type, MIRStorageClass sc = kScGlobal); + MIRSymbol *CreateGlobalDecl(const std::string &str, + const MIRType &type, + MIRStorageClass sc = kScGlobal); MIRSymbol *GetOrCreateDeclInFunc(const std::string &str, const MIRType &type, MIRFunction &func); // for creating Expression ConstvalNode *CreateIntConst(int64, PrimType); @@ -276,7 +278,7 @@ class MIRBuilder { MIRSymbol *GetOrCreateSymbol(TyIdx, GStrIdx, MIRSymKind, MIRStorageClass, MIRFunction*, uint8, bool) const; MIRSymbol *CreatePregFormalSymbol(TyIdx, PregIdx, MIRFunction&) const; // for creating symbol - MIRSymbol *CreateSymbol(TyIdx, const std::string&, MIRSymKind, MIRStorageClass, MIRFunction*, uint8) const; + MIRSymbol *CreateSymbol(TyIdx,const std::string&, MIRSymKind, MIRStorageClass, MIRFunction*, uint8) const; MIRSymbol *CreateSymbol(TyIdx, GStrIdx, MIRSymKind, MIRStorageClass, MIRFunction*, uint8) const; // for creating nodes AddrofNode *CreateAddrof(const MIRSymbol &st, PrimType pty = PTY_ptr); @@ -284,6 +286,7 @@ class MIRBuilder { virtual MemPool *GetCurrentFuncCodeMp(); virtual MapleAllocator *GetCurrentFuncCodeMpAllocator(); + private: MIRSymbol *GetOrCreateGlobalDecl(const std::string &str, const TyIdx &tyIdx, bool &created) const; MIRSymbol *GetOrCreateLocalDecl(const std::string &str, const TyIdx &tyIdx, MIRSymbolTable &symbolTable, diff --git a/src/maple_ir/include/mir_function.h b/src/maple_ir/include/mir_function.h index aa6f59a9911ecacbc366c77b13a04fc676fd9d49..a7d1bf73f790bc858432704685edae6c89a1cfcb 100644 --- a/src/maple_ir/include/mir_function.h +++ b/src/maple_ir/include/mir_function.h @@ -20,27 +20,11 @@ #include "mir_symbol.h" #include "mir_preg.h" #include "intrinsics.h" -#include "global_tables.h" #include "file_layout.h" #include "mir_nodes.h" namespace maple { -enum MIRFuncProp { - kFuncPropNone, - kFuncPropHasCall, // the function has call - kFuncPropRetStruct, // the function returns struct - kFuncPropUserFunc, // the function is a user func - kFuncPropInfoPrinted, // to avoid printing framesize/moduleid/funcSize info more than once per function since they - // can only be printed at the beginning of a block - kFuncPropNeverReturn, // the function when called never returns -}; - -#define FUNCHASCALL (1U << kFuncPropHasCall) -#define FUNCRETSTRUCT (1U << kFuncPropRetStruct) -#define FUNCUSER (1U << kFuncPropUserFunc) -#define FUNCINFOPRINTED (1U << kFuncPropInfoPrinted) -#define FUNCNEVERRETURN (1U << kFuncPropNeverReturn) // mapping src (java) variable to mpl variables to display debug info struct MIRAliasVars { GStrIdx memPoolStrIdx; @@ -48,106 +32,47 @@ struct MIRAliasVars { GStrIdx sigStrIdx; }; -constexpr uint8 kDefEffect = 0x80; -constexpr uint8 kUseEffect = 0x40; -constexpr uint8 kIpaSeen = 0x20; -constexpr uint8 kPureFunc = 0x10; -constexpr uint8 kNoDefArgEffect = 0x8; -constexpr uint8 kNoDefEffect = 0x4; -constexpr uint8 kNoRetNewlyAllocObj = 0x2; -constexpr uint8 kNoThrowException = 0x1; - class MeFunction; // circular dependency exists, no other choice class EAConnectionGraph; // circular dependency exists, no other choice class MIRFunction { public: - MIRFunction(MIRModule *mod, const StIdx sidx) + MIRFunction(MIRModule *mod, StIdx idx) : module(mod), - puIdx(0), - symbolTableIdx(sidx), - formals(mod->GetMPAllocator().Adapter()), - retRefSym(mod->GetMPAllocator().Adapter()), - argumentsTyIdx(mod->GetMPAllocator().Adapter()), - argumentsAttrs(mod->GetMPAllocator().Adapter()), - dataMemPool(memPoolCtrler.NewMemPool("func data mempool")), - dataMPAllocator(dataMemPool), - codeMemPool(memPoolCtrler.NewMemPool("func code mempool")), - codeMemPoolAllocator(codeMemPool), - info(mod->GetMPAllocator().Adapter()), - infoIsString(mod->GetMPAllocator().Adapter()), - aliasVarMap(std::less(), mod->GetMPAllocator().Adapter()), - withLocInfo(true) - { - frameSize = 0; - upFormalSize = 0; - moduleID = 0; - funcSize = 0; - tempCount = 0; - puIdxOrigin = 0; - baseFuncStrIdx = GStrIdx(0); - baseClassStrIdx = GStrIdx(0); - baseFuncWithTypeStrIdx = GStrIdx(0); - signatureStrIdx = GStrIdx(0); - hashCode = 0; - layoutType = kLayoutUnused; - mefunc = nullptr; - eacg = nullptr; - } + symbolTableIdx(idx) {} ~MIRFunction() = default; - void Init() { - // Initially allocate symTab and pregTab on the module mempool for storing - // parameters. If later mirfunction turns out to be a definition, new - // tables will be allocated on the local data mempool. - symTab = module->GetMemPool()->New(module->GetMPAllocator()); - pregTab = module->GetMemPool()->New(module, &module->GetMPAllocator()); - typeNameTab = module->GetMemPool()->New(module->GetMPAllocator()); - labelTab = module->GetMemPool()->New(module->GetMPAllocator()); - } + void Init(); void Dump(bool withoutBody = false); void DumpUpFormal(int32 indent) const; void DumpFrame(int32 indent) const; void DumpFuncBody(int32 indent); - MIRSymbol *GetFuncSymbol() const { - return GlobalTables::GetGsymTable().GetSymbolFromStidx(symbolTableIdx.Idx()); - } + const MIRSymbol *GetFuncSymbol() const; + MIRSymbol *GetFuncSymbol(); - void SetBaseClassFuncNames(GStrIdx stridx); + void SetBaseClassFuncNames(GStrIdx strIdx); void SetMemPool(MemPool *memPool) { SetCodeMemPool(memPool); codeMemPoolAllocator.SetMemPool(codeMemPool); } - /// update signature_stridx, basefunc_stridx, baseclass_stridx, basefunc_withtype_stridx - /// without considering baseclass_stridx, basefunc_stridx's original non-zero values - /// \param stridx full_name stridx of the new function name - void OverrideBaseClassFuncNames(GStrIdx stridx); - const std::string &GetName() const { - return GlobalTables::GetGsymTable().GetSymbolFromStidx(symbolTableIdx.Idx())->GetName(); - } + /// update signature_strIdx, basefunc_strIdx, baseclass_strIdx, basefunc_withtype_strIdx + /// without considering baseclass_strIdx, basefunc_strIdx's original non-zero values + /// \param strIdx full_name strIdx of the new function name + void OverrideBaseClassFuncNames(GStrIdx strIdx); + const std::string &GetName() const; - GStrIdx GetNameStrIdx() const { - return GlobalTables::GetGsymTable().GetSymbolFromStidx(symbolTableIdx.Idx())->GetNameStrIdx(); - } + GStrIdx GetNameStrIdx() const; - const std::string &GetBaseClassName() const { - return GlobalTables::GetStrTable().GetStringFromStrIdx(baseClassStrIdx); - } + const std::string &GetBaseClassName() const; - const std::string &GetBaseFuncName() const { - return GlobalTables::GetStrTable().GetStringFromStrIdx(baseFuncStrIdx); - } + const std::string &GetBaseFuncName() const; - const std::string &GetBaseFuncNameWithType() const { - return GlobalTables::GetStrTable().GetStringFromStrIdx(baseFuncWithTypeStrIdx); - } + const std::string &GetBaseFuncNameWithType() const; - const std::string &GetSignature() const { - return GlobalTables::GetStrTable().GetStringFromStrIdx(signatureStrIdx); - } + const std::string &GetSignature() const; GStrIdx GetBaseClassNameStrIdx() const { return baseClassStrIdx; @@ -163,33 +88,30 @@ class MIRFunction { void SetBaseClassNameStrIdx(GStrIdx id) { - baseClassStrIdx.SetIdx(id.GetIdx()); + baseClassStrIdx = id; } void SetBaseFuncNameStrIdx(GStrIdx id) { - baseFuncStrIdx.SetIdx(id.GetIdx()); + baseFuncStrIdx = id; } void SetBaseFuncNameWithTypeStrIdx(GStrIdx id) { - baseFuncWithTypeStrIdx.SetIdx(id.GetIdx()); - } - - MIRType *GetReturnType() const { - return GlobalTables::GetTypeTable().GetTypeFromTyIdx(funcType->GetRetTyIdx()); + baseFuncWithTypeStrIdx = id; } + const MIRType *GetReturnType() const; + MIRType *GetReturnType(); bool IsReturnVoid() const { return GetReturnType()->GetPrimType() == PTY_void; } - TyIdx GetReturnTyIdx() const { return funcType->GetRetTyIdx(); } - - MIRType *GetClassType() const { - return GlobalTables::GetTypeTable().GetTypeFromTyIdx(classTyIdx); + void SetReturnTyIdx(TyIdx tyidx) { + funcType->SetRetTyIdx(tyidx); } + const MIRType *GetClassType() const; TyIdx GetClassTyIdx() const { return classTyIdx; } @@ -197,110 +119,54 @@ class MIRFunction { classTyIdx = tyIdx; } void SetClassTyIdx(uint32 idx) { - classTyIdx.SetIdx(idx); - } - - void SetReturnTyIdx(TyIdx tyidx) { - funcType->SetRetTyIdx(tyidx); + classTyIdx = idx; } size_t GetParamSize() const { return funcType->GetParamTypeList().size(); } - const std::vector &GetParamTypes() const { return funcType->GetParamTypeList(); } - TyIdx GetNthParamTyIdx(size_t i) const { - CHECK_FATAL(i < funcType->GetParamTypeList().size(), "array index out of range"); + ASSERT(i < funcType->GetParamTypeList().size(), "array index out of range"); return funcType->GetParamTypeList()[i]; } - - MIRType *GetNthParamType(size_t i) const { - CHECK_FATAL(i < funcType->GetParamTypeList().size(), "array index out of range"); - return GlobalTables::GetTypeTable().GetTypeFromTyIdx(funcType->GetParamTypeList()[i]); - } - + const MIRType *GetNthParamType(size_t i) const; + MIRType *GetNthParamType(size_t i); const TypeAttrs &GetNthParamAttr(size_t i) const { - CHECK_FATAL(i < funcType->GetParamAttrsList().size(), "array index out of range"); + ASSERT(i < funcType->GetParamAttrsList().size(), "array index out of range"); return funcType->GetParamAttrsList()[i]; } - - void SetNthParamAttr(size_t i, TypeAttrs ta) const { - CHECK_FATAL(i < funcType->GetParamAttrsList().size(), "array index out of range"); - funcType->GetParamAttrsList()[i] = ta; + void SetNthParamAttr(size_t i, TypeAttrs attrs) { + ASSERT(i < funcType->GetParamAttrsList().size(), "array index out of range"); + funcType->GetParamAttrsList()[i] = attrs; } - - void AddArgument(MIRSymbol *st) { - formals.push_back(st); - funcType->GetParamTypeList().push_back(st->GetTyIdx()); - funcType->GetParamAttrsList().push_back(st->GetAttrs()); + void AddArgument(MIRSymbol *symbol) { + formals.push_back(symbol); + funcType->GetParamTypeList().push_back(symbol->GetTyIdx()); + funcType->GetParamAttrsList().push_back(symbol->GetAttrs()); } - LabelIdx GetOrCreateLableIdxFromName(const std::string &name) { - // TODO: this function should never be used after parsing, so move to parser? - GStrIdx stridx = GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(name); - LabelIdx labidx = GetLabelTab()->GetStIdxFromStrIdx(stridx); - if (labidx == 0) { - labidx = GetLabelTab()->CreateLabel(); - GetLabelTab()->SetSymbolFromStIdx(labidx, stridx); - GetLabelTab()->AddToStringLabelMap(labidx); - } - return labidx; + LabelIdx GetOrCreateLableIdxFromName(const std::string &name); + GStrIdx GetLabelStringIndex(LabelIdx labelIdx) const { + ASSERT(labelIdx < labelTab->Size(), "index out of range in GetLabelStringIndex"); + return labelTab->GetSymbolFromStIdx(labelIdx); } - - const GStrIdx GetLabelStringIndex(LabelIdx lbidx) const { - CHECK(lbidx < labelTab->Size(), "index out of range in GetLabelStringIndex"); - return labelTab->GetSymbolFromStIdx(lbidx); - } - - const std::string &GetLabelName(LabelIdx lbidx) const { - GStrIdx stridx = GetLabelStringIndex(lbidx); - return GlobalTables::GetStrTable().GetStringFromStrIdx(stridx); + const std::string &GetLabelName(LabelIdx labelIdx) const { + GStrIdx strIdx = GetLabelStringIndex(labelIdx); + return GlobalTables::GetStrTable().GetStringFromStrIdx(strIdx); } - MIRSymbol *GetLocalOrGlobalSymbol(const StIdx &idx, bool checkfirst = false) const; + const MIRSymbol *GetLocalOrGlobalSymbol(const StIdx &idx, bool checkFirst = false) const; + MIRSymbol *GetLocalOrGlobalSymbol(const StIdx &idx, bool checkFirst = false); - void SetAttrsFromSe(uint8 se) { - // NoPrivateDefEffect - if ((se & kDefEffect) == kDefEffect) { - funcAttrs.SetAttr(FUNCATTR_noprivate_defeffect); - } - // NoPrivateUseEffect - if ((se & kUseEffect) == kUseEffect) { - funcAttrs.SetAttr(FUNCATTR_noprivate_useeffect); - } - // IpaSeen - if ((se & kIpaSeen) == kIpaSeen) { - funcAttrs.SetAttr(FUNCATTR_ipaseen); - } - // Pure - if ((se & kPureFunc) == kPureFunc) { - funcAttrs.SetAttr(FUNCATTR_pure); - } - // NoDefArgEffect - if ((se & kNoDefArgEffect) == kNoDefArgEffect) { - funcAttrs.SetAttr(FUNCATTR_nodefargeffect); - } - // NoDefEffect - if ((se & kNoDefEffect) == kNoDefEffect) { - funcAttrs.SetAttr(FUNCATTR_nodefeffect); - } - // NoRetNewlyAllocObj - if ((se & kNoRetNewlyAllocObj) == kNoRetNewlyAllocObj) { - funcAttrs.SetAttr(FUNCATTR_noret_newly_alloc_obj); - } - // NoThrowException - if ((se & kNoThrowException) == kNoThrowException) { - funcAttrs.SetAttr(FUNCATTR_nothrow_exception); - } - } - bool GetAttr(FuncAttrKind x) const { - return funcAttrs.GetAttr(x); + void SetAttrsFromSe(uint8 specialEffect); + bool GetAttr(FuncAttrKind attrKind) const { + return funcAttrs.GetAttr(attrKind); } - void SetAttr(FuncAttrKind x) { - funcAttrs.SetAttr(x); + void SetAttr(FuncAttrKind attrKind) { + funcAttrs.SetAttr(attrKind); } bool IsVarargs() const { @@ -447,81 +313,39 @@ class MIRFunction { funcAttrs.SetAttr(FUNCATTR_noprivate_defeffect, true); } - bool HasCall() const { - return flag & FUNCHASCALL; - } + bool HasCall() const; + void SetHasCall(); - void SetHasCall() { - flag |= FUNCHASCALL; - } + bool IsReturnStruct() const; + void SetReturnStruct(); + void SetReturnStruct(MIRType &retType); - bool IsReturnStruct() const { - return flag & FUNCRETSTRUCT; - } - - void SetReturnStruct() { - flag |= FUNCRETSTRUCT; - } - - bool IsUserFunc() const { - return flag & FUNCUSER; - } - - void SetUserFunc() { - flag |= FUNCUSER; - } - - bool IsInfoPrinted() const { - return flag & FUNCINFOPRINTED; - } - - void SetInfoPrinted() { - flag |= FUNCINFOPRINTED; - } - - void ResetInfoPrinted() { - flag &= ~FUNCINFOPRINTED; - } - - void SetNoReturn() { - flag |= FUNCNEVERRETURN; - } + bool IsUserFunc() const; + void SetUserFunc(); - bool NeverReturns() const { - return flag & FUNCNEVERRETURN; - } + bool IsInfoPrinted() const; + void SetInfoPrinted(); + void ResetInfoPrinted(); - void SetReturnStruct(MIRType &retType) { - switch (retType.GetKind()) { - case kTypeUnion: - case kTypeStruct: - case kTypeStructIncomplete: - case kTypeClass: - case kTypeClassIncomplete: - case kTypeInterface: - case kTypeInterfaceIncomplete: - flag |= FUNCRETSTRUCT; - break; - default:; - } - } + void SetNoReturn(); + bool NeverReturns() const; bool IsEmpty() const; bool IsClinit() const; uint32 GetInfo(GStrIdx strIdx) const; - uint32 GetInfo(const std::string &string) const; - bool IsAFormal(const MIRSymbol *st) const { - for (MapleVector::const_iterator it = formals.begin(); it != formals.end(); it++) { - if (st == *it) { + uint32 GetInfo(const std::string &str) const; + bool IsAFormal(const MIRSymbol *symbol) const { + for (const MIRSymbol *fSymbol : formals) { + if (symbol == fSymbol) { return true; } } return false; } - uint32 GetFormalIndex(const MIRSymbol *st) const { + uint32 GetFormalIndex(const MIRSymbol *symbol) const { for (size_t i = 0; i < formals.size(); i++) - if (formals[i] == st) { + if (formals[i] == symbol) { return i; } return 0xffffffff; @@ -532,19 +356,21 @@ class MIRFunction { return classTyIdx.GetIdx(); } - MIRType *GetNodeType(BaseNode &node); + const MIRType *GetNodeType(const BaseNode &node) const; + void SetUpGDBEnv(); void ResetGDBEnv(); + MemPool *GetCodeMempool() { return codeMemPool; } - MapleAllocator *GetCodeMemPoolAllocator() { - return &codeMemPoolAllocator; + MapleAllocator &GetCodeMemPoolAllocator() { + return codeMemPoolAllocator; } - MapleAllocator *GetCodeMempoolAllocator() { - return &codeMemPoolAllocator; + MapleAllocator &GetCodeMempoolAllocator() { + return codeMemPoolAllocator; } void NewBody(); @@ -556,17 +382,15 @@ class MIRFunction { PUIdx GetPuidx() const { return puIdx; } - - void SetPuidx(PUIdx n) { - puIdx = n; + void SetPuidx(PUIdx idx) { + puIdx = idx; } PUIdx GetPuidxOrigin() const { return puIdxOrigin; } - - void SetPuidxOrigin(PUIdx n) { - puIdxOrigin = n; + void SetPuidxOrigin(PUIdx idx) { + puIdxOrigin = idx; } StIdx GetStIdx() const { @@ -580,7 +404,6 @@ class MIRFunction { MIRFuncType *GetMIRFuncType() { return funcType; } - void SetMIRFuncType(MIRFuncType *type) { funcType = type; } @@ -592,12 +415,10 @@ class MIRFunction { void ClearArgumentsTyIdx() { argumentsTyIdx.clear(); } - - TyIdx GetArgumentsTyIdxItem(size_t n) const { - ASSERT(n < argumentsTyIdx.size(), "array index out of range"); - return argumentsTyIdx.at(n); + TyIdx GetArgumentsTyIdxItem(size_t i) const { + ASSERT(i < argumentsTyIdx.size(), "array index out of range"); + return argumentsTyIdx.at(i); } - size_t GetArgumentsTyIdxSize() const { return argumentsTyIdx.size(); } @@ -619,21 +440,25 @@ class MIRFunction { typeNameTab->SetGStrIdxToTyIdx(gStrIdx, tyIdx); } - const std::string &GetLabelTabItem(LabelIdx labidx) const { - return labelTab->GetName(labidx); + const std::string &GetLabelTabItem(LabelIdx labelIdx) const { + return labelTab->GetName(labelIdx); } MIRPregTable *GetPregTab() { return pregTab; } - - MIRPreg *GetPregItem(PregIdx idx) const { - return pregTab->PregFromPregIdx(idx); + const MIRPregTable *GetPregTab() const { + return pregTab; } - void SetPregTab(MIRPregTable *tab) { pregTab = tab; } + MIRPreg *GetPregItem(PregIdx idx) { + return const_cast(const_cast(this)->GetPregItem(idx)); + } + const MIRPreg *GetPregItem(PregIdx idx) const { + return pregTab->PregFromPregIdx(idx); + } MemPool *GetMemPool() { return dataMemPool; @@ -642,11 +467,9 @@ class MIRFunction { BlockNode *GetBody() { return body; } - const BlockNode *GetBody() const { return body; } - void SetBody(BlockNode *node) { body = node; } @@ -654,38 +477,36 @@ class MIRFunction { SrcPosition &GetSrcPosition() { return srcPosition; } - void SetSrcPosition(const SrcPosition &sp) { - srcPosition = sp; + void SetSrcPosition(const SrcPosition &position) { + srcPosition = position; } const FuncAttrs &GetFuncAttrs() const { return funcAttrs; } - void SetFuncAttrs(const FuncAttrs &fa) { - funcAttrs = fa; + void SetFuncAttrs(const FuncAttrs &attrs) { + funcAttrs = attrs; } void SetFuncAttrs(uint64 attrFlag) { funcAttrs.SetAttrFlag(attrFlag); } - uint32 GetFlag() { + uint32 GetFlag() const { return flag; } - - void SetFlag(uint32 f) { - flag = f; + void SetFlag(uint32 newFlag) { + flag = newFlag; } - uint16 GetHashCode() { + uint16 GetHashCode() const { return hashCode; } - - void SetHashCode(uint16 h) { - hashCode = h; + void SetHashCode(uint16 newHashCode) { + hashCode = newHashCode; } - void SetFileIndex(uint32 fi) { - fileIndex = fi; + void SetFileIndex(uint32 newFileIndex) { + fileIndex = newFileIndex; } const MIRInfoVector &GetInfoVector() const { @@ -708,120 +529,104 @@ class MIRFunction { const MapleMap &GetAliasVarMap() const { return aliasVarMap; } - void SetAliasVarMap(GStrIdx g, MIRAliasVars &a) { - aliasVarMap[g] = a; + void SetAliasVarMap(GStrIdx idx, MIRAliasVars &vars) { + aliasVarMap[idx] = vars; } - bool WithLocInfo() { + bool WithLocInfo() const { return withLocInfo; } - - void SetWithLocInfo(bool s) { - withLocInfo = s; + void SetWithLocInfo(bool withInfo) { + withLocInfo = withInfo; } - uint8 GetLayoutType() { + uint8 GetLayoutType() const { return layoutType; } - - const uint8 GetLayoutType() const { - return layoutType; + void SetLayoutType(uint8 type) { + layoutType = type; } - void SetLayoutType(uint8 lt) { - layoutType = lt; - } uint16 GetFrameSize() const { return frameSize; } - - void SetFrameSize(uint16 fs) { - frameSize = fs; + void SetFrameSize(uint16 size) { + frameSize = size; } uint16 GetUpFormalSize() const { return upFormalSize; } - - void SetUpFormalSize(uint16 uf) { - upFormalSize = uf; + void SetUpFormalSize(uint16 size) { + upFormalSize = size; } uint16 GetModuleId() const { return moduleID; } - - void SetModuleID(uint16 mi) { - moduleID = mi; + void SetModuleID(uint16 id) { + moduleID = id; } uint32 GetFuncSize() const { return funcSize; } - - void SetFuncSize(uint32 fs) { - funcSize = fs; + void SetFuncSize(uint32 size) { + funcSize = size; } uint32 GetTempCount() const { return tempCount; } - void IncTempCount() { - tempCount++; + ++tempCount; } const uint8 *GetFormalWordsTypeTagged() const { return formalWordsTypeTagged; } - + void SetFormalWordsTypeTagged(uint8 *tagged) { + formalWordsTypeTagged = tagged; + } uint8 **GetFwtAddress() { return &formalWordsTypeTagged; } - void SetFormalWordsTypeTagged(uint8 *fwt) { - formalWordsTypeTagged = fwt; - } - - uint8 **GetLwtAddress() { - return &localWordsTypeTagged; - } - const uint8 *GetLocalWordsTypeTagged() const { return localWordsTypeTagged; } - - void SetLocalWordsTypeTagged(uint8 *lwt) { - localWordsTypeTagged = lwt; + void SetLocalWordsTypeTagged(uint8 *tagged) { + localWordsTypeTagged = tagged; } - - uint8 **GetFwrAddress() { - return &formalWordsRefCounted; + uint8 **GetLwtAddress() { + return &localWordsTypeTagged; } const uint8 *GetFormalWordsRefCounted() const { return formalWordsRefCounted; } - - void SetFormalWordsRefCounted(uint8 *fwr) { - formalWordsRefCounted = fwr; + void SetFormalWordsRefCounted(uint8 *counted) { + formalWordsRefCounted = counted; + } + uint8 **GetFwrAddress() { + return &formalWordsRefCounted; } const uint8 *GetLocalWordsRefCounted() const { return localWordsRefCounted; } - void SetLocalWordsRefCounted(uint8 *lwr) { - localWordsRefCounted = lwr; + void SetLocalWordsRefCounted(uint8 *counted) { + localWordsRefCounted = counted; } MeFunction *GetMeFunc() { - return mefunc; + return meFunc; } void SetMeFunc(MeFunction *func) { - mefunc = func; + meFunc = func; } EAConnectionGraph *GetEACG() { @@ -831,28 +636,26 @@ class MIRFunction { eacg = eacgVal; } - void SetFormals(MapleVector currFormals) { + void SetFormals(const MapleVector &currFormals) { formals = currFormals; } - - MIRSymbol *GetFormal(size_t i) const { - CHECK_FATAL(i < formals.size(), "array index out of range"); + MIRSymbol *GetFormal(size_t i) { + return const_cast(const_cast(this)->GetFormal(i)); + } + const MIRSymbol *GetFormal(size_t i) const { + ASSERT(i < formals.size(), "array index out of range"); return formals[i]; } - void SetFormal(size_t index, MIRSymbol *value) { - CHECK_FATAL(index < formals.size(), "array index out of range"); + ASSERT(index < formals.size(), "array index out of range"); formals[index] = value; } - size_t GetFormalCount() const { return formals.size(); } - void AddFormal(MIRSymbol *formal) { formals.push_back(formal); } - void ClearFormals() { formals.clear(); } @@ -860,8 +663,8 @@ class MIRFunction { uint32 GetSymbolTabSize() const { return symTab->GetSymbolTableSize(); } - MIRSymbol *GetSymbolTabItem(uint32 idx, bool checkfirst = false) const { - return symTab->GetSymbolFromStIdx(idx, checkfirst); + MIRSymbol *GetSymbolTabItem(uint32 idx, bool checkFirst = false) const { + return symTab->GetSymbolFromStIdx(idx, checkFirst); } const MIRSymbolTable *GetSymTab() const { return symTab; @@ -873,11 +676,9 @@ class MIRFunction { const MIRLabelTable *GetLabelTab() const { return labelTab; } - MIRLabelTable *GetLabelTab() { return labelTab; } - void SetLabelTab(MIRLabelTable *currLabelTab) { labelTab = currLabelTab; } @@ -905,44 +706,46 @@ class MIRFunction { return codeMemPoolAllocator; } + private: MIRModule *module; // the module that owns this function PUIdx puIdx = 0; // the PU index of this function - PUIdx puIdxOrigin; // the original puIdx when initial generation + PUIdx puIdxOrigin = 0; // the original puIdx when initial generation StIdx symbolTableIdx; // the symbol table index of this function MIRFuncType *funcType = nullptr; - TyIdx returnTyIdx; // the declared return type of this function + TyIdx returnTyIdx{0}; // the declared return type of this function TyIdx classTyIdx{0}; // class/interface type this function belongs to - MapleVector formals; // formal parameter symbols of this function - MapleSet retRefSym; - MapleVector argumentsTyIdx; // arguments types of this function - MapleVector argumentsAttrs; + MapleVector formals{module->GetMPAllocator().Adapter()}; // formal parameter symbols of this function + MapleSet retRefSym{module->GetMPAllocator().Adapter()}; + MapleVector argumentsTyIdx{module->GetMPAllocator().Adapter()}; // arguments types of this function + MapleVector argumentsAttrs{module->GetMPAllocator().Adapter()}; MIRSymbolTable *symTab = nullptr; MIRTypeNameTable *typeNameTab = nullptr; MIRLabelTable *labelTab = nullptr; MIRPregTable *pregTab = nullptr; - MemPool *dataMemPool; - MapleAllocator dataMPAllocator; - MemPool *codeMemPool; - MapleAllocator codeMemPoolAllocator; + MemPool *dataMemPool = memPoolCtrler.NewMemPool("func data mempool"); + MapleAllocator dataMPAllocator{dataMemPool}; + MemPool *codeMemPool = memPoolCtrler.NewMemPool("func code mempool"); + MapleAllocator codeMemPoolAllocator{codeMemPool}; BlockNode *body = nullptr; - SrcPosition srcPosition; - FuncAttrs funcAttrs; + SrcPosition srcPosition{}; + FuncAttrs funcAttrs{}; uint32 flag = 0; - uint16 hashCode; // for methodmetadata order + uint16 hashCode = 0; // for methodmetadata order uint32 fileIndex = 0; // this function belongs to which file, used by VM for plugin manager - MIRInfoVector info; - MapleVector infoIsString; // tells if an entry has string value - MapleMap aliasVarMap; // source code alias variables for debuginfo - bool withLocInfo; - - uint8_t layoutType; - uint16 frameSize; - uint16 upFormalSize; - uint16 moduleID; - uint32 funcSize; // size of code in words - uint32 tempCount; + MIRInfoVector info{module->GetMPAllocator().Adapter()}; + MapleVector infoIsString{module->GetMPAllocator().Adapter()}; // tells if an entry has string value + MapleMap aliasVarMap{module->GetMPAllocator().Adapter()}; // source code alias variables + //for debuginfo + bool withLocInfo = true; + + uint8_t layoutType = kLayoutUnused; + uint16 frameSize = 0; + uint16 upFormalSize = 0; + uint16 moduleID = 0; + uint32 funcSize = 0; // size of code in words + uint32 tempCount = 0; uint8 *formalWordsTypeTagged = nullptr; // bit vector where the Nth bit tells whether // the Nth word in the formal parameters area // addressed upward from %%FP (that means @@ -974,14 +777,14 @@ class MIRFunction { // uint16 numlabels; // removed. label table size // StmtNode **lbl2stmt; // lbl2stmt table, removed; // to hold unmangled class and function names - MeFunction *mefunc; - EAConnectionGraph *eacg; - GStrIdx baseClassStrIdx; // the string table index of base class name - GStrIdx baseFuncStrIdx; // the string table index of base function name + MeFunction *meFunc = nullptr; + EAConnectionGraph *eacg = nullptr; + GStrIdx baseClassStrIdx{0}; // the string table index of base class name + GStrIdx baseFuncStrIdx{0}; // the string table index of base function name // the string table index of base function name mangled with type info - GStrIdx baseFuncWithTypeStrIdx; + GStrIdx baseFuncWithTypeStrIdx{0}; // funcname + types of args, no type of retv - GStrIdx signatureStrIdx; + GStrIdx signatureStrIdx{0}; void DumpFlavorLoweredThanMmpl() const; }; diff --git a/src/maple_ir/include/mir_nodes.h b/src/maple_ir/include/mir_nodes.h index a7fcf0e23f3e2df56f9b831ff861a595cf9eafde..7ef9d8f86b55d9f48589330a0c30577afc433ae4 100644 --- a/src/maple_ir/include/mir_nodes.h +++ b/src/maple_ir/include/mir_nodes.h @@ -147,7 +147,7 @@ class BaseNode { ASSERT(0, "This should not happen"); } - virtual bool IsLeaf(void) const { + virtual bool IsLeaf() const { return true; } @@ -159,11 +159,11 @@ class BaseNode { return nullptr; } - virtual bool IsUnaryNode(void) const { + virtual bool IsUnaryNode() const { return false; } - virtual bool IsBinaryNode(void) const { + virtual bool IsBinaryNode() const { return false; } @@ -216,7 +216,7 @@ class UnaryNode : public BaseNode { return uOpnd; } - uint8 NumOpnds(void) const { + uint8 NumOpnds() const { return 1; } @@ -224,11 +224,11 @@ class UnaryNode : public BaseNode { uOpnd = node; } - bool IsLeaf(void) const { + bool IsLeaf() const { return false; } - bool IsUnaryNode(void) const { + bool IsUnaryNode() const { return true; } @@ -587,7 +587,7 @@ class BinaryNode : public BaseNode, public BinaryOpnds { return GetBOpnd(i); } - uint8 NumOpnds(void) const { + uint8 NumOpnds() const { return kOperandNumBinary; } @@ -595,11 +595,11 @@ class BinaryNode : public BaseNode, public BinaryOpnds { SetBOpnd(node, i); } - bool IsLeaf(void) const { + bool IsLeaf() const { return false; } - bool IsBinaryNode(void) const { + bool IsBinaryNode() const { return true; } }; @@ -763,7 +763,7 @@ class TernaryNode : public BaseNode { return topnd[i]; } - uint8 NumOpnds(void) const override { + uint8 NumOpnds() const override { return kOperandNumTernary; } @@ -772,7 +772,7 @@ class TernaryNode : public BaseNode { topnd[i] = node; } - bool IsLeaf(void) const override { + bool IsLeaf() const override { return false; } @@ -856,7 +856,7 @@ class NaryNode : public BaseNode, public NaryOpnds { return GetNopndAt(i); } - uint8 NumOpnds(void) const override { + uint8 NumOpnds() const override { ASSERT(numOpnds == GetNopndSize(), "NaryNode has wrong numOpnds field"); return GetNopndSize(); } @@ -866,7 +866,7 @@ class NaryNode : public BaseNode, public NaryOpnds { SetNOpndAt(i, node); } - bool IsLeaf(void) const override { + bool IsLeaf() const override { return false; } @@ -1482,7 +1482,7 @@ class IassignNode : public StmtNode { return rhs; } - uint8 NumOpnds(void) const { + uint8 NumOpnds() const { return kOperandNumBinary; } @@ -2431,7 +2431,7 @@ class DoloopNode : public StmtNode { return *(&doBody + i - 3); } - uint8 NumOpnds(void) const { + uint8 NumOpnds() const { return kOperandNumDoloop; } @@ -2537,7 +2537,7 @@ class BinaryStmtNode : public StmtNode, public BinaryOpnds { return GetBOpnd(i); } - uint8 NumOpnds(void) const { + uint8 NumOpnds() const { return kOperandNumBinary; } @@ -2545,7 +2545,7 @@ class BinaryStmtNode : public StmtNode, public BinaryOpnds { SetBOpnd(node, i); } - bool IsLeaf(void) const { + bool IsLeaf() const { return false; } }; @@ -2660,7 +2660,7 @@ class NaryStmtNode : public StmtNode, public NaryOpnds { SetNOpndAt(i, node); } - uint8 NumOpnds(void) const { + uint8 NumOpnds() const { ASSERT(numOpnds == GetNopndSize(), "NaryStmtNode has wrong numOpnds field"); return GetNopndSize(); } diff --git a/src/maple_ir/include/mir_parser.h b/src/maple_ir/include/mir_parser.h index df3f53a4dddfae3474d3d583f87f95500849c7c7..3d4be69a8036a6d2dc0f9b43d3d1a339ed62dc50 100644 --- a/src/maple_ir/include/mir_parser.h +++ b/src/maple_ir/include/mir_parser.h @@ -28,7 +28,10 @@ using BlockNodePtr = BlockNode*; class MIRParser { public: explicit MIRParser(MIRModule &md) - : lexer(md), + : paramOpForStmt(kOpUndef), + paramTokenKindForStmt(kTkInvalid), + paramCurrFuncForParseStmtBlock(nullptr), + lexer(md), mod(md), options(kKeepFirst), definedLabels(mod.GetMPAllocator().Adapter()), @@ -42,12 +45,9 @@ class MIRParser { paramFileIdx(0), paramIsIPA(false), paramIsComb(false), - paramTokenKind(kTkInvalid), - paramOpForStmt(kOpUndef), - paramTokenKindForStmt(kTkInvalid), - paramCurrFuncForParseStmtBlock(nullptr) {} + paramTokenKind(kTkInvalid) {} - ~MIRParser() {} + ~MIRParser() = default; MIRPreg *CreateMirPreg(uint32 pregNo) const; PregIdx LookupOrCreatePregIdx(uint32 pregNo, bool isref, MIRFunction &curfunc); @@ -201,7 +201,6 @@ class MIRParser { void Warning(const std::string&); void FixupForwardReferencedTypeByMap(); - public: const std::string &GetError(); const std::string &GetWarning() const; bool ParseFuncInfo(void); @@ -218,30 +217,6 @@ class MIRParser { } private: - MIRLexer lexer; - MIRModule &mod; - std::string message; - std::string warningMessage; - uint32 options; - MapleVector definedLabels; // true if label at labidx is defined - MIRFunction *dummyFunction; - MIRFunction *curFunc; - uint16 lastFileNum; // to remember first number after LOC - uint32 lastLineNum; // to remember second number after LOC - uint32 firstLineNum; // to track function starting line - std::map typeDefIdxMap; // map previous declared tyIdx - uint32 maxPregNo; // max pregNo seen so far in current function - - // param for ParseTypedef - bool paramParseLocalType; - - // param for ParseMIR() - uint32 paramFileIdx; - bool paramIsIPA; - bool paramIsComb; - TokenKind paramTokenKind; - std::vector paramImportFileList; - // func ptr map for ParseMIR() using FuncPtrParseMIRForElem = bool (MIRParser::*)(); static std::map funcPtrMapForParseMIR; @@ -303,6 +278,30 @@ class MIRParser { // common func void SetSrcPos(StmtNodePtr stmt, uint32 mplNum); + + MIRLexer lexer; + MIRModule &mod; + std::string message; + std::string warningMessage; + uint32 options; + MapleVector definedLabels; // true if label at labidx is defined + MIRFunction *dummyFunction; + MIRFunction *curFunc; + uint16 lastFileNum; // to remember first number after LOC + uint32 lastLineNum; // to remember second number after LOC + uint32 firstLineNum; // to track function starting line + std::map typeDefIdxMap; // map previous declared tyIdx + uint32 maxPregNo; // max pregNo seen so far in current function + + // param for ParseTypedef + bool paramParseLocalType; + + // param for ParseMIR() + uint32 paramFileIdx; + bool paramIsIPA; + bool paramIsComb; + TokenKind paramTokenKind; + std::vector paramImportFileList; }; } // namespace maple #endif // MAPLE_IR_INCLUDE_MIR_PARSER_H diff --git a/src/maple_ir/include/mir_preg.h b/src/maple_ir/include/mir_preg.h index 1555476c53656e27e7307a8257c0ab65e7026d97..d507bc7366fb3f83d23aef21964b35035e40acc0 100644 --- a/src/maple_ir/include/mir_preg.h +++ b/src/maple_ir/include/mir_preg.h @@ -146,6 +146,9 @@ class MIRPregTable { } MIRPreg *PregFromPregIdx(PregIdx pregIdx) { + return const_cast(const_cast(this)->PregFromPregIdx(pregIdx)); + } + const MIRPreg *PregFromPregIdx(PregIdx pregIdx) const { // pregIdx < 0 denotes special register return (pregIdx < 0) ? &specPregTable[-pregIdx] : pregTable.at(pregIdx); } diff --git a/src/maple_ir/include/mir_type.h b/src/maple_ir/include/mir_type.h index 3234c2ad3b31ecb4dab9e32b23bd00123d48c92c..6ff392a17376d33db3afb3d1ea229fb9efb080ae 100644 --- a/src/maple_ir/include/mir_type.h +++ b/src/maple_ir/include/mir_type.h @@ -763,6 +763,9 @@ class MIRStructType : public MIRType { MethodVector &GetMethods() { return methods; } + const MethodVector &GetMethods() const { + return methods; + } const MethodPair &GetMethodsElement(size_t n) const { ASSERT(n < methods.size(), "array index out of range"); @@ -1169,6 +1172,7 @@ class MIRClassType : public MIRStructType { FieldID GetFirstLocalFieldID() const; // return class id or superclass id accroding to input string MIRClassType *GetExceptionRootType(); + const MIRClassType *GetExceptionRootType() const; bool IsExceptionType() const; void AddImplementedInterface(TyIdx interfaceTyIdx) { if (std::find(interfacesImplemented.begin(), interfacesImplemented.end(), interfaceTyIdx) != diff --git a/src/maple_ir/include/opcode_info.h b/src/maple_ir/include/opcode_info.h index 993de3a0aa6eac4d04fe18670133f49337de6776..c558a163aefa7af1aeed134eb9f09444d5b7c125 100644 --- a/src/maple_ir/include/opcode_info.h +++ b/src/maple_ir/include/opcode_info.h @@ -56,7 +56,7 @@ struct OpcodeDesc { class OpcodeTable { public: OpcodeTable(); - ~OpcodeTable() {} + ~OpcodeTable() = default; OpcodeDesc GetTableItemAt(Opcode o) const { ASSERT(o < kOpLast, "invalid opcode"); diff --git a/src/maple_ir/include/parser_opt.h b/src/maple_ir/include/parser_opt.h index 05f49d49c69bd306279e678ec310e000204cb934..4a4ed8134a57ed71f5defc4de18ec52d2002470d 100644 --- a/src/maple_ir/include/parser_opt.h +++ b/src/maple_ir/include/parser_opt.h @@ -20,10 +20,10 @@ namespace maple { // option bits passed into ParseMIR enum ParserOptions : uint8 { kInvalidOption = 0x0, - kWithDbgInfo = 0x1, // collect dbginfo + kWithDbgInfo = 0x1, // collect dbginfo kKeepFirst = 0x2, // ignore second type def, not emit error kWithProfileInfo = 0x4, - kParseOptFunc = 0x08, // parse optimized function mpl file + kParseOptFunc = 0x08, // parse optimized function mpl file }; } // namespace maple #endif // MAPLE_IR_INCLUDE_PARSER_OPT_H diff --git a/src/maple_ir/include/types_def.h b/src/maple_ir/include/types_def.h index 6a876c1dd30fcdd4bcb9cfa0d56cb709f39f999b..90116797b2bee593ab24e7da6bfc30e829e68d4b 100644 --- a/src/maple_ir/include/types_def.h +++ b/src/maple_ir/include/types_def.h @@ -116,6 +116,9 @@ class IdxTemplate { IdxTemplate &operator=(const IdxTemplate&) = default; ~IdxTemplate() = default; + void operator=(T id) { + idx = id; + } bool operator==(const IdxTemplate &x) const { return idx == x.idx; } diff --git a/src/maple_ir/src/bin_mpl_export.cpp b/src/maple_ir/src/bin_mpl_export.cpp index 37df50b4a0f40acf652386bb8fc45a0a1722e8bb..a7249b3983d34b640f773be507ab22b3ada293f2 100644 --- a/src/maple_ir/src/bin_mpl_export.cpp +++ b/src/maple_ir/src/bin_mpl_export.cpp @@ -177,12 +177,12 @@ void OutputTypeFunction(const MIRType &ty, BinaryMplExport &mplExport) { size_t size = type.GetParamTypeList().size(); mplExport.WriteNum(size); for (size_t i = 0; i < size; ++i) { - mplExport.OutputType(type.GetParamTypeList()[i]); + mplExport.OutputType(type.GetNthParamType(i)); } size = type.GetParamAttrsList().size(); mplExport.WriteNum(size); for (size_t i = 0; i < size; ++i) { - mplExport.OutputTypeAttrs(type.GetParamAttrsList()[i]); + mplExport.OutputTypeAttrs(type.GetNthParamAttrs(i)); } } @@ -222,7 +222,7 @@ void OutputTypeStruct(MIRType &ty, BinaryMplExport &mplExport) { mplExport.OutputTypeBase(type); MIRTypeKind kind = ty.GetKind(); if (type.IsImported()) { - CHECK_FATAL(ty.GetKind() != kTypeUnion, "must be"); + CHECK_FATAL(ty.GetKind() != kTypeUnion, "Must be."); kind = kTypeStructIncomplete; } mplExport.WriteNum(kind); @@ -404,7 +404,7 @@ void BinaryMplExport::OutputStr(const GStrIdx &gstr) { size_t mark = gStrMark.size(); gStrMark[gstr] = mark; WriteNum(kBinString); - ASSERT(GlobalTables::GetStrTable().StringTableSize() != 0, "container check"); + ASSERT(GlobalTables::GetStrTable().StringTableSize() != 0, "Container check"); WriteAsciiStr(GlobalTables::GetStrTable().GetStringFromStrIdx(gstr)); } @@ -486,7 +486,7 @@ void BinaryMplExport::OutputFieldPair(const FieldPair &fp) { void BinaryMplExport::OutputMethodPair(const MethodPair &memPool) { // use GStrIdx instead, StIdx will be created by ImportMethodPair MIRSymbol *funcSt = GlobalTables::GetGsymTable().GetSymbolFromStidx(memPool.first.Idx()); - CHECK_FATAL(funcSt != nullptr, "can't get symbol! Check it!"); + CHECK_FATAL(funcSt != nullptr, "Pointer funcSt is nullptr, can't get symbol! Check it!"); WriteAsciiStr(GlobalTables::GetStrTable().GetStringFromStrIdx(funcSt->GetNameStrIdx())); OutputType(memPool.second.first); // TyIdx WriteNum(memPool.second.second.GetAttrFlag()); // FuncAttrs @@ -584,10 +584,7 @@ void BinaryMplExport::OutputSymbol(const MIRSymbol *sym) { return; } - if (sym->GetSKind() != kStFunc) { - ASSERT(false, "should not be used"); - } - + ASSERT(sym->GetSKind() == kStFunc, "Should not be used"); WriteNum(kBinSymbol); WriteNum(sym->GetScopeIdx()); OutputStr(sym->GetNameStrIdx()); @@ -615,7 +612,7 @@ void BinaryMplExport::OutputFunction(PUIdx puIdx) { WriteNum(kBinFunction); MIRSymbol *funcSt = GlobalTables::GetGsymTable().GetSymbolFromStidx(func->GetStIdx().Idx()); - CHECK_FATAL(funcSt != nullptr, "can't get symbol! Check it!"); + CHECK_FATAL(funcSt != nullptr, "Pointer funcSt is nullptr, cannot get symbol! Check it!"); OutputSymbol(funcSt); OutputType(func->GetReturnTyIdx()); WriteNum(func->GetFuncAttrs().GetAttrFlag()); @@ -656,7 +653,7 @@ void BinaryMplExport::WriteTypeField(uint64 contentIdx) { for (uint32 tyIdx : mod.GetClassList()) { TyIdx curTyidx(tyIdx); MIRType *type = GlobalTables::GetTypeTable().GetTypeFromTyIdx(curTyidx); - CHECK_FATAL(type != nullptr, "can't get type, check it!"); + CHECK_FATAL(type != nullptr, "Pointer type is nullptr, cannot get type, check it!"); if (type->GetKind() == kTypeClass || type->GetKind() == kTypeInterface) { MIRStructType *structType = static_cast(type); // skip imported class/interface and incomplete types @@ -714,7 +711,7 @@ void BinaryMplExport::AppendAt(const std::string &name, int32 offset) { FATAL(kLncFatal, "Error while creating the binary file: %s\n", name.c_str()); } int seekRet = fseek(f, (long int)offset, SEEK_SET); - CHECK_FATAL(seekRet == 0, "call fseek failed"); + CHECK_FATAL(seekRet == 0, "Call fseek failed."); size_t size = buf.size(); size_t k = fwrite(&buf[0], sizeof(uint8), size, f); fclose(f); @@ -743,7 +740,7 @@ void BinaryMplExport::OutputType(const TyIdx &tyIdx) { WriteNum(0); return; } - CHECK_FATAL(ty != nullptr, "if get's nulltype, should have been returned!"); + CHECK_FATAL(ty != nullptr, "If gets nulltype, should have been returned!"); auto it = typMark.find(ty); if (it != typMark.end()) { if (ty->GetKind() != kTypeFunction) { diff --git a/src/maple_ir/src/lexer.cpp b/src/maple_ir/src/lexer.cpp index c266b2fcb7ccddd57b1c483de11c5f27a5737c6d..a370ece79d8c9ee05adae91b20ac753b0cffb897 100644 --- a/src/maple_ir/src/lexer.cpp +++ b/src/maple_ir/src/lexer.cpp @@ -22,7 +22,6 @@ #include "utils.h" namespace maple { - int32_t HexCharToDigit(char c) { int32_t ret = utils::ToDigit<16, int32_t>(c); return (ret != INT32_MAX ? ret : 0); diff --git a/src/maple_ir/src/mir_builder.cpp b/src/maple_ir/src/mir_builder.cpp index 3f882d71a96902db17e4272073d1818f9509c46d..faa8b7610e4eb48a21820011b9d5bf7057264870 100644 --- a/src/maple_ir/src/mir_builder.cpp +++ b/src/maple_ir/src/mir_builder.cpp @@ -20,8 +20,7 @@ namespace maple { // This is for compiler-generated metadata 1-level struct void MIRBuilder::AddIntFieldConst(const MIRStructType &sType, MIRAggConst &newConst, uint32 fieldID, int64 constValue) { - MIRConst *fieldConst = - mirModule->GetMemPool()->New(constValue, *sType.GetElemType(fieldID - 1), fieldID); + MIRConst *fieldConst = mirModule->GetMemPool()->New(constValue, *sType.GetElemType(fieldID - 1), fieldID); newConst.PushBack(fieldConst); } @@ -58,10 +57,6 @@ bool MIRBuilder::TraverseToNamedField(MIRStructType &structType, GStrIdx nameIdx return TraverseToNamedFieldWithTypeAndMatchStyle(structType, nameIdx, tid, fieldID, kMatchAnyField); } -bool MIRBuilder::IsOfSameType(MIRType &type1, MIRType &type2) { - return type1.IsOfSameType(type2); -} - // traverse parent first but match self first. void MIRBuilder::TraverseToNamedFieldWithType(MIRStructType &structType, GStrIdx nameIdx, TyIdx typeIdx, uint32 &fieldID, uint32 &idx) { @@ -74,22 +69,22 @@ void MIRBuilder::TraverseToNamedFieldWithType(MIRStructType &structType, GStrIdx MIRType *type = GlobalTables::GetTypeTable().GetTypeFromTyIdx(classType.GetParentTyIdx()); MIRStructType *parentType = static_cast(type); if (parentType != nullptr) { - fieldID++; + ++fieldID; TraverseToNamedFieldWithType(*parentType, nameIdx, typeIdx, fieldID, idx); } } - for (uint32 fieldIdx = 0; fieldIdx < structType.GetFieldsSize(); fieldIdx++) { - fieldID++; + for (uint32 fieldIdx = 0; fieldIdx < structType.GetFieldsSize(); ++fieldIdx) { + ++fieldID; TyIdx fieldTyIdx = structType.GetFieldsElemt(fieldIdx).second.first; MIRType *fieldType = GlobalTables::GetTypeTable().GetTypeFromTyIdx(fieldTyIdx); if (structType.GetFieldsElemt(fieldIdx).first == nameIdx) { - if ((typeIdx == 0 || fieldTyIdx == typeIdx)) { + if (typeIdx == 0 || fieldTyIdx == typeIdx) { idx = fieldID; continue; } // for pointer type, check their pointed type MIRType *type = GlobalTables::GetTypeTable().GetTypeFromTyIdx(typeIdx); - if (IsOfSameType(*type, *fieldType)) { + if (type->IsOfSameType(*fieldType)) { idx = fieldID; } } @@ -122,7 +117,7 @@ bool MIRBuilder::TraverseToNamedFieldWithTypeAndMatchStyle(MIRStructType &struct MIRType *type = GlobalTables::GetTypeTable().GetTypeFromTyIdx(classType.GetParentTyIdx()); MIRStructType *parentType = static_cast(type); if (parentType != nullptr) { - fieldID++; + ++fieldID; if (matchStyle == (kFoundInChild | kParentFirst | kUpdateFieldID)) { matchStyle = kParentFirst; uint32 idxBackup = nameIdx.GetIdx(); @@ -138,14 +133,14 @@ bool MIRBuilder::TraverseToNamedFieldWithTypeAndMatchStyle(MIRStructType &struct return false; } } - for (uint32 fieldIdx = 0; fieldIdx < structType.GetFieldsSize(); fieldIdx++) { - fieldID++; + for (uint32 fieldIdx = 0; fieldIdx < structType.GetFieldsSize(); ++fieldIdx) { + ++fieldID; TyIdx fieldTyIdx = structType.GetFieldsElemt(fieldIdx).second.first; MIRType *fieldType = GlobalTables::GetTypeTable().GetTypeFromTyIdx(fieldTyIdx); ASSERT(fieldType != nullptr, "fieldType is null"); if (matchStyle && structType.GetFieldsElemt(fieldIdx).first == nameIdx) { if (typeIdx == 0 || fieldTyIdx == typeIdx || - IsOfSameType(*GlobalTables::GetTypeTable().GetTypeFromTyIdx(typeIdx), *fieldType)) { + fieldType->IsOfSameType(*GlobalTables::GetTypeTable().GetTypeFromTyIdx(typeIdx))) { return true; } } @@ -182,7 +177,7 @@ FieldID MIRBuilder::GetStructFieldIDFromNameAndTypeParentFirst(MIRType &type, co FieldID MIRBuilder::GetStructFieldIDFromNameAndTypeParentFirstFoundInChild(MIRType &type, const std::string &name, TyIdx idx) { // do not match but traverse to update fieldid, traverse parent first, found in child - return GetStructFieldIDFromNameAndType(type, name, idx, (kFoundInChild | kParentFirst | kUpdateFieldID)); + return GetStructFieldIDFromNameAndType(type, name, idx, kFoundInChild | kParentFirst | kUpdateFieldID); } FieldID MIRBuilder::GetStructFieldIDFromFieldName(MIRType &type, const std::string &name) { @@ -209,7 +204,7 @@ void MIRBuilder::SetStructFieldIDFromFieldName(MIRType &structtype, const std::s structType.SetElemtTyIdx(fieldID, newFieldType.GetTypeIndex()); return; } - fieldID++; + ++fieldID; } } @@ -273,7 +268,7 @@ MIRFunction *MIRBuilder::CreateFunction(const std::string &name, const MIRType & GlobalTables::GetFunctionTable().GetFuncTable().push_back(fn); std::vector funcVecType; std::vector funcVecAttrs; - for (size_t i = 0; i < arguments.size(); i++) { + for (size_t i = 0; i < arguments.size(); ++i) { MIRSymbol *argSymbol = fn->GetSymTab()->CreateSymbol(kScopeLocal); argSymbol->SetNameStrIdx(GetOrCreateStringIndex(arguments[i].first.c_str())); MIRType *ty = arguments[i].second; @@ -358,7 +353,7 @@ MIRSymbol *MIRBuilder::GetOrCreateDeclInFunc(const std::string &str, const MIRTy return st; } -MIRSymbol *MIRBuilder::GetOrCreateLocalDecl(const std::string &str, MIRType &type) { +MIRSymbol *MIRBuilder::GetOrCreateLocalDecl(const std::string &str, const MIRType &type) { MIRFunction *currentFunc = GetCurrentFunction(); CHECK_FATAL(currentFunc != nullptr, "null ptr check"); return GetOrCreateDeclInFunc(str, type, *currentFunc); @@ -512,7 +507,7 @@ ConstvalNode *MIRBuilder::CreateAddrofConst(BaseNode &e) { // determine the type of 'e' and create a pointer type, accordingly AddrofNode &aNode = static_cast(e); - MIRSymbol *var = currentFunctionInner->GetLocalOrGlobalSymbol(aNode.GetStIdx()); + const MIRSymbol *var = currentFunctionInner->GetLocalOrGlobalSymbol(aNode.GetStIdx()); TyIdx ptyIdx = var->GetTyIdx(); MIRPtrType ptrType(ptyIdx); ptyIdx = GlobalTables::GetTypeTable().GetOrCreateMIRType(&ptrType); @@ -673,8 +668,7 @@ ExtractbitsNode *MIRBuilder::CreateExprExtractbits(Opcode o, const MIRType &type } RetypeNode *MIRBuilder::CreateExprRetype(const MIRType &type, const MIRType &fromType, BaseNode *opnd) { - return GetCurrentFuncCodeMp()->New(type.GetPrimType(), fromType.GetPrimType(), - type.GetTypeIndex(), opnd); + return GetCurrentFuncCodeMp()->New(type.GetPrimType(), fromType.GetPrimType(), type.GetTypeIndex(), opnd); } BinaryNode *MIRBuilder::CreateExprBinary(Opcode opcode, const MIRType &type, BaseNode *opnd0, BaseNode *opnd1) { diff --git a/src/maple_ir/src/mir_function.cpp b/src/maple_ir/src/mir_function.cpp index 0a515f61c21e83ad9a0b10f9791b79d1cb1822a9..2e9a318f1af1f52cd43f44681c4c769014fa17a4 100644 --- a/src/maple_ir/src/mir_function.cpp +++ b/src/maple_ir/src/mir_function.cpp @@ -19,8 +19,183 @@ #include "mir_nodes.h" #include "class_hierarchy.h" #include "printing.h" +#include "string_utils.h" + +namespace { +using namespace maple; + +enum FuncProp : uint32_t { + kFuncPropHasCall = 1U, // the function has call + kFuncPropRetStruct = 1U << 1, // the function returns struct + kFuncPropUserFunc = 1U << 2, // the function is a user func + kFuncPropInfoPrinted = 1U << 3, // to avoid printing framesize/moduleid/funcSize info more + // than once per function since they + // can only be printed at the beginning of a block + kFuncPropNeverReturn = 1U << 4, // the function when called never returns +}; + +enum FuncAttrProp : uint32_t { + kDefEffect = 0x80, + kUseEffect = 0x40, + kIpaSeen = 0x20, + kPureFunc = 0x10, + kNoDefArgEffect = 0x8, + kNoDefEffect = 0x4, + kNoRetNewlyAllocObj = 0x2, + kNoThrowException = 0x1, +}; +} // namespace namespace maple { +void MIRFunction::Init() { + // Initially allocate symTab and pregTab on the module mempool for storing + // parameters. If later mirfunction turns out to be a definition, new + // tables will be allocated on the local data mempool. + symTab = module->GetMemPool()->New(module->GetMPAllocator()); + pregTab = module->GetMemPool()->New(module, &module->GetMPAllocator()); + typeNameTab = module->GetMemPool()->New(module->GetMPAllocator()); + labelTab = module->GetMemPool()->New(module->GetMPAllocator()); +} + +const MIRSymbol *MIRFunction::GetFuncSymbol() const { + return GlobalTables::GetGsymTable().GetSymbolFromStidx(symbolTableIdx.Idx()); +} +MIRSymbol *MIRFunction::GetFuncSymbol() { + return const_cast(const_cast(this)->GetFuncSymbol()); +} + +const std::string &MIRFunction::GetName() const { + return GlobalTables::GetGsymTable().GetSymbolFromStidx(symbolTableIdx.Idx())->GetName(); +} + +GStrIdx MIRFunction::GetNameStrIdx() const { + return GlobalTables::GetGsymTable().GetSymbolFromStidx(symbolTableIdx.Idx())->GetNameStrIdx(); +} + +const std::string &MIRFunction::GetBaseClassName() const { + return GlobalTables::GetStrTable().GetStringFromStrIdx(baseClassStrIdx); +} + +const std::string &MIRFunction::GetBaseFuncName() const { + return GlobalTables::GetStrTable().GetStringFromStrIdx(baseFuncStrIdx); +} + +const std::string &MIRFunction::GetBaseFuncNameWithType() const { + return GlobalTables::GetStrTable().GetStringFromStrIdx(baseFuncWithTypeStrIdx); +} + + +const std::string &MIRFunction::GetSignature() const { + return GlobalTables::GetStrTable().GetStringFromStrIdx(signatureStrIdx); +} + +const MIRType *MIRFunction::GetReturnType() const { + return GlobalTables::GetTypeTable().GetTypeFromTyIdx(funcType->GetRetTyIdx()); +} +MIRType *MIRFunction::GetReturnType() { + return const_cast(const_cast(this)->GetReturnType()); +} +const MIRType *MIRFunction::GetClassType() const { + return GlobalTables::GetTypeTable().GetTypeFromTyIdx(classTyIdx); +} +const MIRType *MIRFunction::GetNthParamType(size_t i) const { + ASSERT(i < funcType->GetParamTypeList().size(), "array index out of range"); + return GlobalTables::GetTypeTable().GetTypeFromTyIdx(funcType->GetParamTypeList()[i]); +} +MIRType *MIRFunction::GetNthParamType(size_t i) { + return const_cast(const_cast(this)->GetNthParamType(i)); +} + +LabelIdx MIRFunction::GetOrCreateLableIdxFromName(const std::string &name) { + // TODO: this function should never be used after parsing, so move to parser? + GStrIdx strIdx = GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(name); + LabelIdx labelIdx = GetLabelTab()->GetStIdxFromStrIdx(strIdx); + if (labelIdx == 0) { + labelIdx = GetLabelTab()->CreateLabel(); + GetLabelTab()->SetSymbolFromStIdx(labelIdx, strIdx); + GetLabelTab()->AddToStringLabelMap(labelIdx); + } + return labelIdx; +} + +bool MIRFunction::HasCall() const { + return flag & kFuncPropHasCall; +} +void MIRFunction::SetHasCall() { + flag |= kFuncPropHasCall; +} + +bool MIRFunction::IsReturnStruct() const { + return flag & kFuncPropRetStruct; +} +void MIRFunction::SetReturnStruct() { + flag |= kFuncPropRetStruct; +} +void MIRFunction::SetReturnStruct(MIRType &retType) { + if (retType.IsStructType()) { + flag |= kFuncPropRetStruct; + } +} + +bool MIRFunction::IsUserFunc() const { + return flag & kFuncPropUserFunc; +} +void MIRFunction::SetUserFunc() { + flag |= kFuncPropUserFunc; +} + +bool MIRFunction::IsInfoPrinted() const { + return flag & kFuncPropInfoPrinted; +} +void MIRFunction::SetInfoPrinted() { + flag |= kFuncPropInfoPrinted; +} +void MIRFunction::ResetInfoPrinted() { + flag &= ~kFuncPropInfoPrinted; +} + +void MIRFunction::SetNoReturn() { + flag |= kFuncPropNeverReturn; +} +bool MIRFunction::NeverReturns() const { + return flag & kFuncPropNeverReturn; +} + +void MIRFunction::SetAttrsFromSe(uint8 specialEffect) { + // NoPrivateDefEffect + if ((specialEffect & kDefEffect) == kDefEffect) { + funcAttrs.SetAttr(FUNCATTR_noprivate_defeffect); + } + // NoPrivateUseEffect + if ((specialEffect & kUseEffect) == kUseEffect) { + funcAttrs.SetAttr(FUNCATTR_noprivate_useeffect); + } + // IpaSeen + if ((specialEffect & kIpaSeen) == kIpaSeen) { + funcAttrs.SetAttr(FUNCATTR_ipaseen); + } + // Pure + if ((specialEffect & kPureFunc) == kPureFunc) { + funcAttrs.SetAttr(FUNCATTR_pure); + } + // NoDefArgEffect + if ((specialEffect & kNoDefArgEffect) == kNoDefArgEffect) { + funcAttrs.SetAttr(FUNCATTR_nodefargeffect); + } + // NoDefEffect + if ((specialEffect & kNoDefEffect) == kNoDefEffect) { + funcAttrs.SetAttr(FUNCATTR_nodefeffect); + } + // NoRetNewlyAllocObj + if ((specialEffect & kNoRetNewlyAllocObj) == kNoRetNewlyAllocObj) { + funcAttrs.SetAttr(FUNCATTR_noret_newly_alloc_obj); + } + // NoThrowException + if ((specialEffect & kNoThrowException) == kNoThrowException) { + funcAttrs.SetAttr(FUNCATTR_nothrow_exception); + } +} + void FuncAttrs::DumpAttributes() const { #define STRING(s) #s #define FUNC_ATTR @@ -34,10 +209,11 @@ void FuncAttrs::DumpAttributes() const { void MIRFunction::DumpFlavorLoweredThanMmpl() const { LogInfo::MapleLogger() << " ("; + // Dump arguments size_t argSize = GetParamSize(); for (size_t i = 0; i < argSize; ++i) { - MIRSymbol *symbol = formals[i]; + const MIRSymbol *symbol = formals[i]; if (symbol != nullptr) { if (symbol->GetSKind() != kStPreg) { LogInfo::MapleLogger() << "var %" << symbol->GetName() << " "; @@ -46,10 +222,10 @@ void MIRFunction::DumpFlavorLoweredThanMmpl() const { } } constexpr int kIndent = 2; - MIRType *ty = GetNthParamType(i); - ty->Dump(kIndent); - TypeAttrs tA = GetNthParamAttr(i); - tA.DumpAttributes(); + const MIRType *type = GetNthParamType(i); + type->Dump(kIndent); + const TypeAttrs &attrs = GetNthParamAttr(i); + attrs.DumpAttributes(); if (i != (argSize - 1)) { LogInfo::MapleLogger() << ", "; } @@ -61,6 +237,7 @@ void MIRFunction::DumpFlavorLoweredThanMmpl() const { LogInfo::MapleLogger() << ", ..."; } } + LogInfo::MapleLogger() << ") "; GetReturnType()->Dump(1); } @@ -73,55 +250,61 @@ void MIRFunction::Dump(bool withoutBody) { if (GetParamSize() != formals.size() || GetAttr(FUNCATTR_optimized)) { return; } + // save the module's curfunction and set it to the one currently Dump()ing MIRFunction *savedFunc = module->CurFunction(); module->SetCurFunction(this); - MIRSymbol *fnSt = GlobalTables::GetGsymTable().GetSymbolFromStidx(symbolTableIdx.Idx()); - ASSERT(fnSt != nullptr, "fnSt MIRSymbol is null"); - LogInfo::MapleLogger() << "func " << "&" << fnSt->GetName(); + + MIRSymbol *symbol = GlobalTables::GetGsymTable().GetSymbolFromStidx(symbolTableIdx.Idx()); + ASSERT(symbol != nullptr, "symbol MIRSymbol is null"); + LogInfo::MapleLogger() << "func " << "&" << symbol->GetName(); + funcAttrs.DumpAttributes(); + if (module->GetFlavor() < kMmpl) { DumpFlavorLoweredThanMmpl(); } + // codeMemPool is nullptr, means maple_ir has been released for memory's sake if (codeMemPool == nullptr) { - LogInfo::MapleLogger() << std::endl; - LogInfo::MapleLogger() << "# [WARNING] skipped dumping because codeMemPool is nullptr " << std::endl; - } else if (GetBody() && !withoutBody && fnSt->GetStorageClass() != kScExtern) { + LogInfo::MapleLogger() << '\n'; + LogInfo::MapleLogger() << "# [WARNING] skipped dumping because codeMemPool is nullptr " << '\n'; + } else if (GetBody() && !withoutBody && symbol->GetStorageClass() != kScExtern) { ResetInfoPrinted(); // this ensures funcinfo will be printed GetBody()->Dump(*module, 0, module->GetFlavor() < kMmpl ? GetSymTab() : nullptr, module->GetFlavor() < kMmpl ? GetPregTab() : nullptr, false, true); // Dump body } else { - LogInfo::MapleLogger() << std::endl; + LogInfo::MapleLogger() << '\n'; } + // restore the curfunction module->SetCurFunction(savedFunc); } void MIRFunction::DumpUpFormal(int32 indent) const { PrintIndentation(indent + 1); - LogInfo::MapleLogger() << "upformalsize " << static_cast(GetUpFormalSize()) << std::endl; + + LogInfo::MapleLogger() << "upFormalSize " << GetUpFormalSize() << '\n'; if (localWordsTypeTagged != nullptr) { PrintIndentation(indent + 1); - LogInfo::MapleLogger() << "formalwordstypetagged = [ "; - uint32 *p = const_cast(reinterpret_cast(localWordsTypeTagged)); + LogInfo::MapleLogger() << "formalWordsTypeTagged = [ "; + const uint32 *p = reinterpret_cast(localWordsTypeTagged); LogInfo::MapleLogger() << std::hex; - while (p < const_cast(reinterpret_cast( - localWordsTypeTagged + BlockSize2BitVectorSize(GetUpFormalSize())))) { + while (p < reinterpret_cast(localWordsTypeTagged + BlockSize2BitVectorSize(GetUpFormalSize()))) { LogInfo::MapleLogger() << std::hex << "0x" << *p << " "; - p++; + ++p; } LogInfo::MapleLogger() << std::dec << "]\n"; } + if (formalWordsRefCounted != nullptr) { PrintIndentation(indent + 1); - LogInfo::MapleLogger() << "formalwordsrefcounted = [ "; - uint32 *p = const_cast(reinterpret_cast(formalWordsRefCounted)); + LogInfo::MapleLogger() << "formalWordsRefCounted = [ "; + const uint32 *p = reinterpret_cast(formalWordsRefCounted); LogInfo::MapleLogger() << std::hex; - while (p < const_cast(reinterpret_cast( - formalWordsRefCounted + BlockSize2BitVectorSize(GetUpFormalSize())))) { + while (p < reinterpret_cast(formalWordsRefCounted + BlockSize2BitVectorSize(GetUpFormalSize()))) { LogInfo::MapleLogger() << std::hex << "0x" << *p << " "; - p++; + ++p; } LogInfo::MapleLogger() << std::dec << "]\n"; } @@ -129,77 +312,87 @@ void MIRFunction::DumpUpFormal(int32 indent) const { void MIRFunction::DumpFrame(int32 indent) const { PrintIndentation(indent + 1); - LogInfo::MapleLogger() << "framesize " << GetFrameSize() << std::endl; + + LogInfo::MapleLogger() << "frameSize " << static_cast(GetFrameSize()) << '\n'; if (localWordsTypeTagged != nullptr) { PrintIndentation(indent + 1); - LogInfo::MapleLogger() << "localwordstypetagged = [ "; - uint32 *p = const_cast(reinterpret_cast(localWordsTypeTagged)); + LogInfo::MapleLogger() << "localWordsTypeTagged = [ "; + const uint32 *p = reinterpret_cast(localWordsTypeTagged); LogInfo::MapleLogger() << std::hex; - while (p < const_cast(reinterpret_cast( - localWordsTypeTagged + BlockSize2BitVectorSize(GetFrameSize())))) { + while (p < reinterpret_cast(localWordsTypeTagged + BlockSize2BitVectorSize(GetFrameSize()))) { LogInfo::MapleLogger() << std::hex << "0x" << *p << " "; - p++; + ++p; } LogInfo::MapleLogger() << std::dec << "]\n"; } + if (localWordsRefCounted != nullptr) { PrintIndentation(indent + 1); - LogInfo::MapleLogger() << "localwordsrefcounted = [ "; - uint32 *p = const_cast(reinterpret_cast(localWordsRefCounted)); + LogInfo::MapleLogger() << "localWordsRefCounted = [ "; + const uint32 *p = reinterpret_cast(localWordsRefCounted); LogInfo::MapleLogger() << std::hex; - while (p < const_cast(reinterpret_cast( - localWordsRefCounted + BlockSize2BitVectorSize(GetFrameSize())))) { + while (p < reinterpret_cast(localWordsRefCounted + BlockSize2BitVectorSize(GetFrameSize()))) { LogInfo::MapleLogger() << std::hex << "0x" << *p << " "; - p++; + ++p; } LogInfo::MapleLogger() << std::dec << "]\n"; } } void MIRFunction::DumpFuncBody(int32 indent) { - LogInfo::MapleLogger() << " funcid " << GetPuidxOrigin() << std::endl; - if (!IsInfoPrinted()) { - SetInfoPrinted(); - if (GetUpFormalSize()) { - DumpUpFormal(indent); - } - if (GetFrameSize()) { - DumpFrame(indent); - } - if (GetModuleId()) { - PrintIndentation(indent + 1); - LogInfo::MapleLogger() << "moduleid " << static_cast(GetModuleId()) << std::endl; - } - if (GetModuleId()) { - PrintIndentation(indent + 1); - LogInfo::MapleLogger() << "funcsize " << GetFuncSize() << std::endl; + LogInfo::MapleLogger() << " funcid " << GetPuidxOrigin() << '\n'; + + if (IsInfoPrinted()) { + return; + } + + SetInfoPrinted(); + + if (GetUpFormalSize() > 0) { + DumpUpFormal(indent); + } + + if (GetFrameSize() > 0) { + DumpFrame(indent); + } + + if (GetModuleId() > 0) { + PrintIndentation(indent + 1); + LogInfo::MapleLogger() << "moduleID " << static_cast(GetModuleId()) << '\n'; + } + + if (GetFuncSize() > 0) { + PrintIndentation(indent + 1); + LogInfo::MapleLogger() << "funcSize " << GetFuncSize() << '\n'; + } + + if (GetInfoVector().empty()) { + return; + } + + const MIRInfoVector &funcInfo = GetInfoVector(); + const MapleVector &funcInfoIsString = InfoIsString(); + PrintIndentation(indent + 1); + LogInfo::MapleLogger() << "funcinfo {\n"; + size_t size = funcInfo.size(); + constexpr int kIndentOffset = 2; + for (size_t i = 0; i < size; ++i) { + PrintIndentation(indent + kIndentOffset); + LogInfo::MapleLogger() << "@" << GlobalTables::GetStrTable().GetStringFromStrIdx(funcInfo[i].first) << " "; + if (!funcInfoIsString[i]) { + LogInfo::MapleLogger() << funcInfo[i].second; + } else { + LogInfo::MapleLogger() << "\"" + << GlobalTables::GetStrTable().GetStringFromStrIdx(GStrIdx(funcInfo[i].second)) + << "\""; } - if (!GetInfoVector().empty()) { - const MIRInfoVector &funcInfo = GetInfoVector(); - MapleVector funcInfoIsString = InfoIsString(); - PrintIndentation(indent + 1); - LogInfo::MapleLogger() << "funcinfo {\n"; - size_t size = funcInfo.size(); - constexpr int kIndentOffset = 2; - for (size_t i = 0; i < size; i++) { - PrintIndentation(indent + kIndentOffset); - LogInfo::MapleLogger() << "@" << GlobalTables::GetStrTable().GetStringFromStrIdx(funcInfo[i].first) << " "; - if (!funcInfoIsString[i]) { - LogInfo::MapleLogger() << funcInfo[i].second; - } else { - LogInfo::MapleLogger() << "\"" - << GlobalTables::GetStrTable().GetStringFromStrIdx(GStrIdx(funcInfo[i].second)) - << "\""; - } - if (i < size - 1) { - LogInfo::MapleLogger() << ",\n"; - } else { - LogInfo::MapleLogger() << "}\n"; - } - } - LogInfo::MapleLogger() << std::endl; + if (i < size - 1) { + LogInfo::MapleLogger() << ",\n"; + } else { + LogInfo::MapleLogger() << "}\n"; } } + LogInfo::MapleLogger() << '\n'; } bool MIRFunction::IsEmpty() const { @@ -207,23 +400,20 @@ bool MIRFunction::IsEmpty() const { } bool MIRFunction::IsClinit() const { + const std::string clInitPostfix = "_7C_3Cclinit_3E_7C_28_29V"; const std::string &funcName = this->GetName(); - size_t clinitSuffixPos = funcName.rfind("_7C_3Cclinit_3E_7C_28_29V"); - bool isClinit = (clinitSuffixPos != std::string::npos) && - (clinitSuffixPos + sizeof("_7C_3Cclinit_3E_7C_28_29V") - 1 == funcName.size()); // this does not work for smali files like art/test/511-clinit-interface/smali/BogusInterface.smali, // which is decorated without "constructor". - return isClinit; + return StringUtils::EndsWith(funcName, clInitPostfix); } uint32 MIRFunction::GetInfo(GStrIdx strIdx) const { - size_t size = info.size(); - for (size_t i = 0; i < size; i++) { - if (info[i].first == strIdx) { - return info[i].second; + for (const auto &item : info) { + if (item.first == strIdx) { + return item.second; } } - ASSERT(false, "info ptr check"); + ASSERT(false, "get info error"); return 0; } @@ -244,13 +434,13 @@ void MIRFunction::SetBaseClassFuncNames(GStrIdx strIdx) { if (baseClassStrIdx != 0 || baseFuncStrIdx != 0) { return; } - std::string name = GlobalTables::GetStrTable().GetStringFromStrIdx(strIdx); + const std::string name = GlobalTables::GetStrTable().GetStringFromStrIdx(strIdx); std::string delimiter = "|"; uint32 width = 1; // delimiter width size_t pos = name.find(delimiter); if (pos == std::string::npos) { delimiter = NameMangler::kNameSplitterStr; - width = 3; + width = 3; // delimiter width pos = name.find(delimiter); // make sure it is not __7C, but ___7C ok while (pos != std::string::npos && (name[pos - 1] == '_' && name[pos - 2] != '_')) { @@ -258,7 +448,7 @@ void MIRFunction::SetBaseClassFuncNames(GStrIdx strIdx) { } } if (pos != std::string::npos && pos > 0) { - std::string className = name.substr(0, pos); + const std::string className = name.substr(0, pos); baseClassStrIdx = GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(className); std::string funcNameWithtype = name.substr(pos + width, name.length() - pos - width); baseFuncWithTypeStrIdx = GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(funcNameWithtype); @@ -266,14 +456,14 @@ void MIRFunction::SetBaseClassFuncNames(GStrIdx strIdx) { ASSERT(index != std::string::npos, "Invalid name, cannot find '_29' in name"); size_t posEnd = index + (std::string(NameMangler::kRigthBracketStr)).length(); funcNameWithtype = name.substr(pos + width, posEnd - pos - width); - size_t pos1 = name.find(delimiter, pos + width); - while (pos1 != std::string::npos && (name[pos1 - 1] == '_' && name[pos1 - 2] != '_')) { - pos1 = name.find(delimiter, pos1 + width); + size_t newPos = name.find(delimiter, pos + width); + while (newPos != std::string::npos && (name[newPos - 1] == '_' && name[newPos - 2] != '_')) { + newPos = name.find(delimiter, newPos + width); } - if (pos1) { - std::string funcName = name.substr(pos + width, pos1 - pos - width); + if (newPos != 0) { + std::string funcName = name.substr(pos + width, newPos - pos - width); baseFuncStrIdx = GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(funcName); - std::string signature = name.substr(pos1 + width, name.length() - pos1 - width); + std::string signature = name.substr(newPos + width, name.length() - newPos - width); signatureStrIdx = GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(signature); } return; @@ -281,18 +471,22 @@ void MIRFunction::SetBaseClassFuncNames(GStrIdx strIdx) { baseFuncStrIdx = strIdx; } -MIRSymbol *MIRFunction::GetLocalOrGlobalSymbol(const StIdx &idx, bool checkFirst) const { +const MIRSymbol *MIRFunction::GetLocalOrGlobalSymbol(const StIdx &idx, bool checkFirst) const { return idx.Islocal() ? GetSymbolTabItem(idx.Idx(), checkFirst) : GlobalTables::GetGsymTable().GetSymbolFromStidx(idx.Idx(), checkFirst); } +MIRSymbol *MIRFunction::GetLocalOrGlobalSymbol(const StIdx &idx, bool checkFirst) { + return const_cast(const_cast(this)->GetLocalOrGlobalSymbol(idx, checkFirst)); +} -MIRType *MIRFunction::GetNodeType(BaseNode &node) { +const MIRType *MIRFunction::GetNodeType(const BaseNode &node) const { if (node.GetOpCode() == OP_dread) { - MIRSymbol *sym = GetLocalOrGlobalSymbol(static_cast(node).GetStIdx()); + const MIRSymbol *sym = GetLocalOrGlobalSymbol(static_cast(node).GetStIdx()); return GlobalTables::GetTypeTable().GetTypeFromTyIdx(sym->GetTyIdx()); - } else if (node.GetOpCode() == OP_regread) { - RegreadNode &nodeReg = static_cast(node); - MIRPreg *pReg = GetPregTab()->PregFromPregIdx(nodeReg.GetRegIdx()); + } + if (node.GetOpCode() == OP_regread) { + const auto &nodeReg = static_cast(node); + const MIRPreg *pReg = GetPregTab()->PregFromPregIdx(nodeReg.GetRegIdx()); if (pReg->GetPrimType() == PTY_ref) { return pReg->GetMIRType(); } @@ -313,7 +507,7 @@ void MIRFunction::NewBody() { typeNameTab = dataMemPool->New(dataMPAllocator); SetLabelTab(dataMemPool->New(dataMPAllocator)); if (oldSymTable != nullptr) { - for (size_t i = 1; i < oldSymTable->GetSymbolTableSize(); i++) { + for (size_t i = 1; i < oldSymTable->GetSymbolTableSize(); ++i) { (void)GetSymTab()->AddStOutside(oldSymTable->GetSymbolFromStIdx(i)); } } @@ -344,5 +538,4 @@ void MIRFunction::ResetGDBEnv() { memPoolCtrler.DeleteMemPool(codeMemPool); codeMemPool = nullptr; } - } // namespace maple diff --git a/src/maple_ir/src/mir_lower.cpp b/src/maple_ir/src/mir_lower.cpp index f2dda546bd0fcde50348e400dcc827544063d54e..e3e0ce0192494f3e2947e8563c8380d014ee4415 100644 --- a/src/maple_ir/src/mir_lower.cpp +++ b/src/maple_ir/src/mir_lower.cpp @@ -208,7 +208,7 @@ BlockNode *MIRLower::LowerDoloopStmt(DoloopNode &doloop) { endRegassign->SetOpnd(add); blk->AddStatement(endRegassign); } else { - MIRSymbol *doVarSym = mirModule.CurFunction()->GetLocalOrGlobalSymbol(doloop.GetDoVarStIdx()); + const MIRSymbol *doVarSym = mirModule.CurFunction()->GetLocalOrGlobalSymbol(doloop.GetDoVarStIdx()); PrimType doVarPType = doVarSym->GetType()->GetPrimType(); DreadNode *readDovar = mirModule.CurFuncCodeMemPool()->New(OP_dread, doVarPType, doloop.GetDoVarStIdx(), 0); diff --git a/src/maple_ir/src/mir_module.cpp b/src/maple_ir/src/mir_module.cpp index e9d537153d3d98267eb6d30113dc69dcb37609e5..0b22d828b0bfdd834df15572e104e15fd6eb002a 100644 --- a/src/maple_ir/src/mir_module.cpp +++ b/src/maple_ir/src/mir_module.cpp @@ -67,7 +67,7 @@ MemPool *MIRModule::CurFuncCodeMemPool(void) const { } MapleAllocator *MIRModule::CurFuncCodeMemPoolAllocator(void) const { - return curFunction->GetCodeMempoolAllocator(); + return &curFunction->GetCodeMempoolAllocator(); } MapleAllocator &MIRModule::GetCurFuncCodeMPAllocator(void) const { diff --git a/src/maple_ir/src/mir_nodes.cpp b/src/maple_ir/src/mir_nodes.cpp index a1adf578075c5e671add48eaaf79cd135a25ffba..b58913b9fbe1335ca4d2485db12a01136cb40e31 100644 --- a/src/maple_ir/src/mir_nodes.cpp +++ b/src/maple_ir/src/mir_nodes.cpp @@ -65,7 +65,7 @@ bool BaseNode::MayThrowException() { } bool AddrofNode::CheckNode(const MIRModule &mod) const { - MIRSymbol *st = mod.CurFunction()->GetLocalOrGlobalSymbol(GetStIdx()); + const MIRSymbol *st = mod.CurFunction()->GetLocalOrGlobalSymbol(GetStIdx()); MIRType *ty = st->GetType(); switch (ty->GetKind()) { case kTypeScalar: { @@ -501,7 +501,7 @@ void FieldsDistNode::Dump(const MIRModule &mod, int32 indent) const { void AddrofNode::Dump(const MIRModule &mod, int32 indent) const { LogInfo::MapleLogger() << kOpcodeInfo.GetTableItemAt(GetOpCode()).name << " " << GetPrimTypeName(GetPrimType()); - MIRSymbol *st = mod.CurFunction()->GetLocalOrGlobalSymbol(GetStIdx()); + const MIRSymbol *st = mod.CurFunction()->GetLocalOrGlobalSymbol(GetStIdx()); LogInfo::MapleLogger() << (GetStIdx().Islocal() ? " %" : " $"); LogInfo::MapleLogger() << st->GetName(); if (fieldID != 0) { @@ -597,7 +597,7 @@ void StmtNode::InsertBeforeThis(StmtNode &pos) { void DassignNode::Dump(const MIRModule &mod, int32 indent) const { StmtNode::DumpBase(mod, indent); - MIRSymbol *st = mod.CurFunction()->GetLocalOrGlobalSymbol(stIdx); + const MIRSymbol *st = mod.CurFunction()->GetLocalOrGlobalSymbol(stIdx); LogInfo::MapleLogger() << (st->IsLocal() ? " %" : " $"); LogInfo::MapleLogger() << st->GetName() << " " << fieldID; LogInfo::MapleLogger() << " ("; @@ -841,7 +841,7 @@ void DoloopNode::DumpDoVar(const MIRModule &mod) const { << mod.CurFunction()->GetPregTab()->PregFromPregIdx(doVarStIdx.FullIdx())->GetPregNo() << " (" << std::endl; } else { - MIRSymbol *st = mod.CurFunction()->GetLocalOrGlobalSymbol(doVarStIdx); + const MIRSymbol *st = mod.CurFunction()->GetLocalOrGlobalSymbol(doVarStIdx); LogInfo::MapleLogger() << " %" << st->GetName().c_str() << " (" << std::endl; } } @@ -863,7 +863,7 @@ void DoloopNode::Dump(const MIRModule &mod, int32 indent) const { void ForeachelemNode::Dump(const MIRModule &mod, int32 indent) const { StmtNode::DumpBase(mod, indent); - MIRSymbol *st = mod.CurFunction()->GetLocalOrGlobalSymbol(elemStIdx); + const MIRSymbol *st = mod.CurFunction()->GetLocalOrGlobalSymbol(elemStIdx); ASSERT(st != nullptr, "null ptr check"); LogInfo::MapleLogger() << " %" << st->GetName().c_str(); st = mod.CurFunction()->GetLocalOrGlobalSymbol(arrayStIdx); @@ -898,7 +898,7 @@ void DumpCallReturns(const MIRModule &mod, CallReturnVector nrets, int32 indent) StIdx stIdx = nrets.begin()->first; RegFieldPair regFieldPair = nrets.begin()->second; if (!regFieldPair.IsReg()) { - MIRSymbol *st = mirFunc->GetLocalOrGlobalSymbol(stIdx); + const MIRSymbol *st = mirFunc->GetLocalOrGlobalSymbol(stIdx); ASSERT(st != nullptr, "st is null"); uint16 fieldID = regFieldPair.GetFieldID(); LogInfo::MapleLogger() << " { dassign "; @@ -907,7 +907,7 @@ void DumpCallReturns(const MIRModule &mod, CallReturnVector nrets, int32 indent) return; } else { PregIdx16 regIdx = regFieldPair.GetPregIdx(); - MIRPreg *mirPreg = mirFunc->GetPregItem(static_cast(regIdx)); + const MIRPreg *mirPreg = mirFunc->GetPregItem(static_cast(regIdx)); ASSERT(mirPreg != nullptr, "mirPreg is null"); LogInfo::MapleLogger() << " { regassign"; LogInfo::MapleLogger() << " " << GetPrimTypeName(mirPreg->GetPrimType()); @@ -923,13 +923,13 @@ void DumpCallReturns(const MIRModule &mod, CallReturnVector nrets, int32 indent) if (!regFieldPair.IsReg()) { uint16 fieldID = regFieldPair.GetFieldID(); LogInfo::MapleLogger() << "dassign"; - MIRSymbol *st = mirFunc->GetLocalOrGlobalSymbol(stIdx); + const MIRSymbol *st = mirFunc->GetLocalOrGlobalSymbol(stIdx); ASSERT(st != nullptr, "st is null"); LogInfo::MapleLogger() << (stIdx.Islocal() ? " %" : " $"); LogInfo::MapleLogger() << st->GetName() << " " << fieldID << std::endl; } else { PregIdx16 regidx = regFieldPair.GetPregIdx(); - MIRPreg *mirPreg = mirFunc->GetPregItem(static_cast(regidx)); + const MIRPreg *mirPreg = mirFunc->GetPregItem(static_cast(regidx)); ASSERT(mirPreg != nullptr, "mirPreg is null"); LogInfo::MapleLogger() << "regassign" << " " << GetPrimTypeName(mirPreg->GetPrimType()); @@ -1268,7 +1268,7 @@ bool FloatIntCvtTypeVerify(PrimType resPType, PrimType opndPType) { } inline MIRTypeKind GetTypeKind(StIdx stIdx) { - MIRSymbol *var = theModule->CurFunction()->GetLocalOrGlobalSymbol(stIdx); + const MIRSymbol *var = theModule->CurFunction()->GetLocalOrGlobalSymbol(stIdx); ASSERT(var != nullptr, "null ptr check"); MIRType *type = var->GetType(); ASSERT(type != nullptr, "null ptr check"); @@ -1640,7 +1640,7 @@ bool AddrofNode::Verify() const { } } if (fieldID != 0 && structVerf) { - MIRSymbol *var = theModule->CurFunction()->GetLocalOrGlobalSymbol(GetStIdx()); + const MIRSymbol *var = theModule->CurFunction()->GetLocalOrGlobalSymbol(GetStIdx()); MIRType *type = var->GetType(); MIRStructType *stty = static_cast(type); if (IsStructureTypeKind(GetFieldTypeKind(stty, fieldID))) { diff --git a/src/maple_ir/src/mir_parser.cpp b/src/maple_ir/src/mir_parser.cpp index 311bca63870bd9d45b74c2bf741c5df91cdfff17..95c59205c5acc3da0080456ad63775edede152d5 100644 --- a/src/maple_ir/src/mir_parser.cpp +++ b/src/maple_ir/src/mir_parser.cpp @@ -29,7 +29,6 @@ bool MIRParser::ParseStmtDassign(StmtNodePtr &stmt) { Error("expect dassign but get "); return false; } - DassignNode *assignstmt = mod.CurFuncCodeMemPool()->New(); // parse %i lexer.NextToken(); StIdx stidx; @@ -40,11 +39,12 @@ bool MIRParser::ParseStmtDassign(StmtNodePtr &stmt) { Error("expect a symbol parsing ParseStmtDassign"); return false; } - assignstmt->SetStIdx(stidx); + auto *assignStmt = mod.CurFuncCodeMemPool()->New(); + assignStmt->SetStIdx(stidx); TokenKind ntk = lexer.NextToken(); // parse field id if (ntk == kTkIntconst) { // may be a field id - assignstmt->SetFieldID(lexer.GetTheIntVal()); + assignStmt->SetFieldID(lexer.GetTheIntVal()); ntk = lexer.NextToken(); } // parse expression like (constval i32 0) @@ -52,31 +52,31 @@ bool MIRParser::ParseStmtDassign(StmtNodePtr &stmt) { if (!ParseExprOneOperand(expr)) { return false; } - assignstmt->SetRHS(expr); - stmt = assignstmt; + assignStmt->SetRHS(expr); + stmt = assignStmt; lexer.NextToken(); return true; } bool MIRParser::ParseStmtRegassign(StmtNodePtr &stmt) { - RegassignNode *regassign = mod.CurFuncCodeMemPool()->New(); if (!IsPrimitiveType(lexer.NextToken())) { Error("expect type parsing binary operator but get "); return false; } - regassign->SetPrimType(GetPrimitiveType(lexer.GetTokenKind())); + auto *regAssign = mod.CurFuncCodeMemPool()->New(); + regAssign->SetPrimType(GetPrimitiveType(lexer.GetTokenKind())); lexer.NextToken(); if (lexer.GetTokenKind() == kTkSpecialreg) { - PregIdx tempPregIdx = regassign->GetRegIdx(); + PregIdx tempPregIdx = regAssign->GetRegIdx(); bool isSuccess = ParseSpecialReg(tempPregIdx); - regassign->SetRegIdx(tempPregIdx); + regAssign->SetRegIdx(tempPregIdx); if (!isSuccess) { return false; } } else if (lexer.GetTokenKind() == kTkPreg) { - PregIdx tempPregIdx = regassign->GetRegIdx(); - bool isSuccess = ParsePseudoReg(regassign->GetPrimType(), tempPregIdx); - regassign->SetRegIdx(tempPregIdx); + PregIdx tempPregIdx = regAssign->GetRegIdx(); + bool isSuccess = ParsePseudoReg(regAssign->GetPrimType(), tempPregIdx); + regAssign->SetRegIdx(tempPregIdx); if (!isSuccess) { return false; } @@ -88,9 +88,9 @@ bool MIRParser::ParseStmtRegassign(StmtNodePtr &stmt) { if (!ParseExprOneOperand(expr)) { return false; } - regassign->SetOpnd(expr); - if (regassign->GetRegIdx() > 0) { // check type consistenency for the preg - MIRPreg *preg = mod.CurFunction()->GetPregTab()->PregFromPregIdx(regassign->GetRegIdx()); + regAssign->SetOpnd(expr); + if (regAssign->GetRegIdx() > 0) { // check type consistenency for the preg + MIRPreg *preg = mod.CurFunction()->GetPregTab()->PregFromPregIdx(regAssign->GetRegIdx()); if (preg->GetPrimType() == kPtyInvalid) { preg->SetPrimType(expr->GetPrimType()); } else if (preg->GetPrimType() == PTY_dynany) { @@ -106,13 +106,13 @@ bool MIRParser::ParseStmtRegassign(StmtNodePtr &stmt) { } } } - stmt = regassign; + stmt = regAssign; lexer.NextToken(); return true; } bool MIRParser::ParseStmtIassign(StmtNodePtr &stmt) { - // iassign <* [10] int> () + // iAssign <* [10] int> () if (lexer.GetTokenKind() != TK_iassign) { Error("expect iassign but get "); return false; @@ -121,13 +121,13 @@ bool MIRParser::ParseStmtIassign(StmtNodePtr &stmt) { lexer.NextToken(); TyIdx tyIdx(0); if (!ParseDerivedType(tyIdx)) { - Error("ParseStmtIassign failed when parisng derived type"); + Error("ParseStmtIassign failed when parsing derived type"); return false; } - IassignNode *iassign = mod.CurFuncCodeMemPool()->New(); - iassign->SetTyIdx(tyIdx); + auto *iAssign = mod.CurFuncCodeMemPool()->New(); + iAssign->SetTyIdx(tyIdx); if (lexer.GetTokenKind() == kTkIntconst) { - iassign->SetFieldID(lexer.theIntVal); + iAssign->SetFieldID(lexer.theIntVal); lexer.NextToken(); } BaseNode *addr = nullptr; @@ -136,73 +136,73 @@ bool MIRParser::ParseStmtIassign(StmtNodePtr &stmt) { if (!ParseExprTwoOperand(addr, rhs)) { return false; } - iassign->SetOpnd(addr, 0); - iassign->SetRHS(rhs); + iAssign->SetOpnd(addr, 0); + iAssign->SetRHS(rhs); lexer.NextToken(); - stmt = iassign; + stmt = iAssign; return true; } bool MIRParser::ParseStmtIassignoff(StmtNodePtr &stmt) { - // iassign ( , ) - IassignoffNode *iassignoff = mod.CurFuncCodeMemPool()->New(); if (!IsPrimitiveType(lexer.NextToken())) { Error("expect type parsing binary operator but get "); return false; } - iassignoff->SetPrimType(GetPrimitiveType(lexer.GetTokenKind())); + // iassign ( , ) + auto *iAssignOff = mod.CurFuncCodeMemPool()->New(); + iAssignOff->SetPrimType(GetPrimitiveType(lexer.GetTokenKind())); if (lexer.NextToken() != kTkIntconst) { Error("expect offset but get "); return false; } - iassignoff->SetOffset(lexer.GetTheIntVal()); + iAssignOff->SetOffset(lexer.GetTheIntVal()); lexer.NextToken(); BaseNode *addr = nullptr; BaseNode *rhs = nullptr; if (!ParseExprTwoOperand(addr, rhs)) { return false; } - iassignoff->SetBOpnd(addr, 0); - iassignoff->SetBOpnd(rhs, 1); + iAssignOff->SetBOpnd(addr, 0); + iAssignOff->SetBOpnd(rhs, 1); lexer.NextToken(); - stmt = iassignoff; + stmt = iAssignOff; return true; } bool MIRParser::ParseStmtIassignFPoff(StmtNodePtr &stmt) { - // iassignfpoff ( ) - IassignFPoffNode *iassignoff = mod.CurFuncCodeMemPool()->New(); if (!IsPrimitiveType(lexer.NextToken())) { Error("expect type parsing binary operator but get "); return false; } - iassignoff->SetPrimType(GetPrimitiveType(lexer.GetTokenKind())); + // iassignfpoff ( ) + auto *iAssignOff = mod.CurFuncCodeMemPool()->New(); + iAssignOff->SetPrimType(GetPrimitiveType(lexer.GetTokenKind())); if (lexer.NextToken() != kTkIntconst) { Error("expect offset but get "); return false; } - iassignoff->SetOffset(lexer.GetTheIntVal()); + iAssignOff->SetOffset(lexer.GetTheIntVal()); lexer.NextToken(); BaseNode *expr = nullptr; if (!ParseExprOneOperand(expr)) { return false; } - iassignoff->SetOpnd(expr); + iAssignOff->SetOpnd(expr); lexer.NextToken(); - stmt = iassignoff; + stmt = iAssignOff; return true; } bool MIRParser::ParseStmtDoloop(StmtNodePtr &stmt) { // syntax: doloop (, , ) { // } - DoloopNode *doloopnode = mod.CurFuncCodeMemPool()->New(); - stmt = doloopnode; + auto *doLoopNode = mod.CurFuncCodeMemPool()->New(); + stmt = doLoopNode; lexer.NextToken(); if (lexer.GetTokenKind() == kTkPreg) { - PregIdx pregidx = LookupOrCreatePregIdx(static_cast(lexer.GetTheIntVal()), false, *mod.CurFunction()); - doloopnode->SetIsPreg(true); - doloopnode->SetDoVarStFullIdx(pregidx); + PregIdx pregIdx = LookupOrCreatePregIdx(static_cast(lexer.GetTheIntVal()), false, *mod.CurFunction()); + doLoopNode->SetIsPreg(true); + doLoopNode->SetDoVarStFullIdx(pregIdx); // let other appearances handle the preg primitive type } else { StIdx stIdx; @@ -217,7 +217,7 @@ bool MIRParser::ParseStmtDoloop(StmtNodePtr &stmt) { Error("expect local variable for doloop var but get "); return false; } - doloopnode->SetDoVarStIdx(stIdx); + doLoopNode->SetDoVarStIdx(stIdx); } // parse ( if (lexer.NextToken() != kTkLparen) { @@ -231,19 +231,19 @@ bool MIRParser::ParseStmtDoloop(StmtNodePtr &stmt) { Error("ParseStmtDoloop when parsing start expression"); return false; } - if (doloopnode->IsPreg()) { - PregIdx regidx = (PregIdx)doloopnode->GetDoVarStIdx().FullIdx(); - MIRPreg *mpreg = mod.CurFunction()->GetPregTab()->PregFromPregIdx(regidx); - if (mpreg->GetPrimType() == kPtyInvalid) { + if (doLoopNode->IsPreg()) { + PregIdx regIdx = (PregIdx)doLoopNode->GetDoVarStIdx().FullIdx(); + MIRPreg *mpReg = mod.CurFunction()->GetPregTab()->PregFromPregIdx(regIdx); + if (mpReg->GetPrimType() == kPtyInvalid) { CHECK_FATAL(start != nullptr, "null ptr check"); - mpreg->SetPrimType(start->GetPrimType()); + mpReg->SetPrimType(start->GetPrimType()); } } if (lexer.GetTokenKind() != kTkComa) { Error("expect , after start expression but get "); return false; } - doloopnode->SetStartExpr(start); + doLoopNode->SetStartExpr(start); // parse end expression lexer.NextToken(); BaseNode *end = nullptr; @@ -255,7 +255,7 @@ bool MIRParser::ParseStmtDoloop(StmtNodePtr &stmt) { Error("expect , after condition expression but get "); return false; } - doloopnode->SetContExpr(end); + doLoopNode->SetContExpr(end); // parse renew induction expression lexer.NextToken(); BaseNode *induction = nullptr; @@ -268,23 +268,23 @@ bool MIRParser::ParseStmtDoloop(StmtNodePtr &stmt) { Error("expect ) parsing doloop but get "); return false; } - doloopnode->SetIncrExpr(induction); + doLoopNode->SetIncrExpr(induction); // parse body of the loop lexer.NextToken(); - BlockNode *bodystmt = nullptr; - if (!ParseStmtBlock(bodystmt)) { + BlockNode *bodyStmt = nullptr; + if (!ParseStmtBlock(bodyStmt)) { Error("ParseStmtDoloop when parsing body of the loop"); return false; } - doloopnode->SetDoBody(bodystmt); + doLoopNode->SetDoBody(bodyStmt); return true; } bool MIRParser::ParseStmtForeachelem(StmtNodePtr &stmt) { // syntax: foreachelem { // } - ForeachelemNode *fornode = mod.CurFuncCodeMemPool()->New(); - stmt = fornode; + auto *forNode = mod.CurFuncCodeMemPool()->New(); + stmt = forNode; lexer.NextToken(); // skip foreachelem token StIdx stidx; if (!ParseDeclaredSt(stidx)) { @@ -298,7 +298,7 @@ bool MIRParser::ParseStmtForeachelem(StmtNodePtr &stmt) { Error("illegal global scope for element variable for foreachelem in "); return false; } - fornode->SetElemStIdx(stidx); + forNode->SetElemStIdx(stidx); lexer.NextToken(); if (!ParseDeclaredSt(stidx)) { return false; @@ -307,15 +307,15 @@ bool MIRParser::ParseStmtForeachelem(StmtNodePtr &stmt) { Error("error parsing array/collection variable of foreachelem in "); return false; } - fornode->SetArrayStIdx(stidx); + forNode->SetArrayStIdx(stidx); lexer.NextToken(); // parse body of the loop - BlockNode *bodystmt = nullptr; - if (!ParseStmtBlock(bodystmt)) { + BlockNode *bodyStmt = nullptr; + if (!ParseStmtBlock(bodyStmt)) { Error("error when parsing body of foreachelem loop in "); return false; } - fornode->SetLoopBody(bodystmt); + forNode->SetLoopBody(bodyStmt); return true; } @@ -324,40 +324,40 @@ bool MIRParser::ParseStmtIf(StmtNodePtr &stmt) { Error("expect if but get "); return false; } - IfStmtNode *ifstmt = mod.CurFuncCodeMemPool()->New(); + auto *ifStmt = mod.CurFuncCodeMemPool()->New(); lexer.NextToken(); BaseNode *expr = nullptr; if (!ParseExprOneOperand(expr)) { return false; } - ifstmt->SetOpnd(expr); + ifStmt->SetOpnd(expr); if (lexer.NextToken() != kTkLbrace) { Error("expect { begin if body but get "); return false; } - BlockNode *thenblock = nullptr; - if (!ParseStmtBlock(thenblock)) { + BlockNode *thenBlock = nullptr; + if (!ParseStmtBlock(thenBlock)) { Error("ParseStmtIf failed when parsing then block"); return false; } - ifstmt->SetThenPart(thenblock); - BlockNode *elseblock = nullptr; + ifStmt->SetThenPart(thenBlock); + BlockNode *elseBlock = nullptr; if (lexer.GetTokenKind() == TK_else) { // has else part if (lexer.NextToken() != kTkLbrace) { Error("expect { begin if body but get "); return false; } - if (!ParseStmtBlock(elseblock)) { + if (!ParseStmtBlock(elseBlock)) { Error("ParseStmtIf failed when parsing else block"); return false; } - ifstmt->SetElsePart(elseblock); - if (elseblock != nullptr) { - ifstmt->SetNumOpnds(ifstmt->GetNumOpnds() + 1); + ifStmt->SetElsePart(elseBlock); + if (elseBlock != nullptr) { + ifStmt->SetNumOpnds(ifStmt->GetNumOpnds() + 1); } } - stmt = ifstmt; + stmt = ifStmt; return true; } @@ -366,24 +366,24 @@ bool MIRParser::ParseStmtWhile(StmtNodePtr &stmt) { Error("expect while but get "); return false; } - WhileStmtNode *whilestmt = mod.CurFuncCodeMemPool()->New(OP_while); + auto *whileStmt = mod.CurFuncCodeMemPool()->New(OP_while); lexer.NextToken(); BaseNode *expr = nullptr; if (!ParseExprOneOperand(expr)) { return false; } - whilestmt->SetOpnd(expr); + whileStmt->SetOpnd(expr); if (lexer.NextToken() != kTkLbrace) { Error("expect { begin if body but get "); return false; } - BlockNode *whilebody = nullptr; - if (!ParseStmtBlock(whilebody)) { + BlockNode *whileBody = nullptr; + if (!ParseStmtBlock(whileBody)) { Error("ParseStmtWhile failed when parse while body"); return false; } - whilestmt->SetBody(whilebody); - stmt = whilestmt; + whileStmt->SetBody(whileBody); + stmt = whileStmt; return true; } @@ -392,47 +392,47 @@ bool MIRParser::ParseStmtDowhile(StmtNodePtr &stmt) { Error("expect while but get "); return false; } - WhileStmtNode *whilestmt = mod.CurFuncCodeMemPool()->New(OP_dowhile); + auto *whileStmt = mod.CurFuncCodeMemPool()->New(OP_dowhile); if (lexer.NextToken() != kTkLbrace) { Error("expect { begin if body but get "); return false; } - BlockNode *dowhilebody = nullptr; - if (!ParseStmtBlock(dowhilebody)) { + BlockNode *doWhileBody = nullptr; + if (!ParseStmtBlock(doWhileBody)) { Error("ParseStmtDowhile failed when trying to parsing do while body"); return false; } - whilestmt->SetBody(dowhilebody); + whileStmt->SetBody(doWhileBody); BaseNode *expr = nullptr; if (!ParseExprOneOperand(expr)) { return false; } - whilestmt->SetOpnd(expr); + whileStmt->SetOpnd(expr); lexer.NextToken(); - stmt = whilestmt; + stmt = whileStmt; return true; } bool MIRParser::ParseStmtLabel(StmtNodePtr &stmt) { - GStrIdx stridx = GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(lexer.GetName()); - LabelIdx labidx = mod.CurFunction()->GetLabelTab()->GetStIdxFromStrIdx(stridx); - if (labidx == 0) { - labidx = mod.CurFunction()->GetLabelTab()->CreateLabel(); - mod.CurFunction()->GetLabelTab()->SetSymbolFromStIdx(labidx, stridx); - mod.CurFunction()->GetLabelTab()->AddToStringLabelMap(labidx); + GStrIdx strIdx = GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(lexer.GetName()); + LabelIdx labIdx = mod.CurFunction()->GetLabelTab()->GetStIdxFromStrIdx(strIdx); + if (labIdx == 0) { + labIdx = mod.CurFunction()->GetLabelTab()->CreateLabel(); + mod.CurFunction()->GetLabelTab()->SetSymbolFromStIdx(labIdx, strIdx); + mod.CurFunction()->GetLabelTab()->AddToStringLabelMap(labIdx); } else { - if (definedLabels.size() > labidx && definedLabels[labidx]) { + if (definedLabels.size() > labIdx && definedLabels[labIdx]) { Error("label multiply declared "); return false; } } - if (definedLabels.size() <= labidx) { - definedLabels.resize(labidx + 1); + if (definedLabels.size() <= labIdx) { + definedLabels.resize(labIdx + 1); } - definedLabels[labidx] = true; - LabelNode *labnode = mod.CurFuncCodeMemPool()->New(); - labnode->SetLabelIdx(labidx); - stmt = labnode; + definedLabels[labIdx] = true; + auto *labNode = mod.CurFuncCodeMemPool()->New(); + labNode->SetLabelIdx(labIdx); + stmt = labNode; lexer.NextToken(); return true; } @@ -446,16 +446,16 @@ bool MIRParser::ParseStmtGoto(StmtNodePtr &stmt) { Error("expect label in goto but get "); return false; } - GStrIdx stridx = GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(lexer.GetName()); - LabelIdx labidx = mod.CurFunction()->GetLabelTab()->GetStIdxFromStrIdx(stridx); - if (labidx == 0) { - labidx = mod.CurFunction()->GetLabelTab()->CreateLabel(); - mod.CurFunction()->GetLabelTab()->SetSymbolFromStIdx(labidx, stridx); - mod.CurFunction()->GetLabelTab()->AddToStringLabelMap(labidx); + GStrIdx strIdx = GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(lexer.GetName()); + LabelIdx labIdx = mod.CurFunction()->GetLabelTab()->GetStIdxFromStrIdx(strIdx); + if (labIdx == 0) { + labIdx = mod.CurFunction()->GetLabelTab()->CreateLabel(); + mod.CurFunction()->GetLabelTab()->SetSymbolFromStIdx(labIdx, strIdx); + mod.CurFunction()->GetLabelTab()->AddToStringLabelMap(labIdx); } - GotoNode *gotonode = mod.CurFuncCodeMemPool()->New(OP_goto); - gotonode->SetOffset(labidx); - stmt = gotonode; + auto *gotoNode = mod.CurFuncCodeMemPool()->New(OP_goto); + gotoNode->SetOffset(labIdx); + stmt = gotoNode; lexer.NextToken(); return true; } @@ -470,34 +470,34 @@ bool MIRParser::ParseStmtBr(StmtNodePtr &stmt) { Error("expect label in goto but get "); return false; } - GStrIdx stridx = GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(lexer.GetName()); - LabelIdx labidx = mod.CurFunction()->GetLabelTab()->GetStIdxFromStrIdx(stridx); - if (labidx == 0) { - labidx = mod.CurFunction()->GetLabelTab()->CreateLabel(); - mod.CurFunction()->GetLabelTab()->SetSymbolFromStIdx(labidx, stridx); - mod.CurFunction()->GetLabelTab()->AddToStringLabelMap(labidx); + GStrIdx strIdx = GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(lexer.GetName()); + LabelIdx labIdx = mod.CurFunction()->GetLabelTab()->GetStIdxFromStrIdx(strIdx); + if (labIdx == 0) { + labIdx = mod.CurFunction()->GetLabelTab()->CreateLabel(); + mod.CurFunction()->GetLabelTab()->SetSymbolFromStIdx(labIdx, strIdx); + mod.CurFunction()->GetLabelTab()->AddToStringLabelMap(labIdx); } - CondGotoNode *condgoto = mod.CurFuncCodeMemPool()->New(tk == TK_brtrue ? OP_brtrue : OP_brfalse); - condgoto->SetOffset(labidx); + auto *condGoto = mod.CurFuncCodeMemPool()->New(tk == TK_brtrue ? OP_brtrue : OP_brfalse); + condGoto->SetOffset(labIdx); lexer.NextToken(); // parse () BaseNode *expr = nullptr; if (!ParseExprOneOperand(expr)) { return false; } - condgoto->SetOpnd(expr); - stmt = condgoto; + condGoto->SetOpnd(expr); + stmt = condGoto; lexer.NextToken(); return true; } -bool MIRParser::ParseSwitchCase(int32 &constval, LabelIdx &lblIdx) { +bool MIRParser::ParseSwitchCase(int32 &constVal, LabelIdx &lblIdx) { // syntax : goto if (lexer.GetTokenKind() != kTkIntconst) { Error("expect intconst in switch but get "); return false; } - constval = lexer.GetTheIntVal(); + constVal = lexer.GetTheIntVal(); if (lexer.NextToken() != kTkColon) { Error("expect : in switch but get "); return false; @@ -516,20 +516,20 @@ bool MIRParser::ParseSwitchCase(int32 &constval, LabelIdx &lblIdx) { } bool MIRParser::ParseStmtSwitch(StmtNodePtr &stmt) { - SwitchNode *switchnode = mod.CurFuncCodeMemPool()->New(mod); - stmt = switchnode; + auto *switchNode = mod.CurFuncCodeMemPool()->New(mod); + stmt = switchNode; lexer.NextToken(); BaseNode *expr = nullptr; if (!ParseExprOneOperand(expr)) { return false; } - switchnode->SetSwitchOpnd(expr); + switchNode->SetSwitchOpnd(expr); if (!IsPrimitiveInteger(expr->GetPrimType())) { Error("expect expression return integer but get "); return false; } if (lexer.NextToken() == TK_label) { - switchnode->SetDefaultLabel(mod.CurFunction()->GetOrCreateLableIdxFromName(lexer.GetName())); + switchNode->SetDefaultLabel(mod.CurFunction()->GetOrCreateLableIdxFromName(lexer.GetName())); } else { Error("expect label in switch but get "); return false; @@ -555,7 +555,7 @@ bool MIRParser::ParseStmtSwitch(StmtNodePtr &stmt) { Error("duplicated switch case "); return false; } - switchnode->InsertCasePair(CasePair(constVal, lbl)); + switchNode->InsertCasePair(CasePair(constVal, lbl)); casesSet.insert(constVal); tk = lexer.GetTokenKind(); } @@ -564,20 +564,20 @@ bool MIRParser::ParseStmtSwitch(StmtNodePtr &stmt) { } bool MIRParser::ParseStmtRangegoto(StmtNodePtr &stmt) { - RangeGotoNode *rangegotonode = mod.CurFuncCodeMemPool()->New(mod); - stmt = rangegotonode; + auto *rangeGotoNode = mod.CurFuncCodeMemPool()->New(mod); + stmt = rangeGotoNode; lexer.NextToken(); BaseNode *expr = nullptr; if (!ParseExprOneOperand(expr)) { return false; } if (!IsPrimitiveInteger(expr->GetPrimType())) { - rangegotonode->SetOpnd(expr); + rangeGotoNode->SetOpnd(expr); Error("expect expression return integer but get "); return false; } if (lexer.NextToken() == kTkIntconst) { - rangegotonode->SetTagOffset(lexer.GetTheIntVal()); + rangeGotoNode->SetTagOffset(lexer.GetTheIntVal()); } else { Error("expect tag offset in rangegoto but get "); return false; @@ -592,8 +592,8 @@ bool MIRParser::ParseStmtRangegoto(StmtNodePtr &stmt) { // : goto TokenKind tk = lexer.NextToken(); std::set casesSet; - int32 minidx = UINT16_MAX; - int32 maxidx = 0; + int32 minIdx = UINT16_MAX; + int32 maxIdx = 0; while (tk != kTkRbrace) { int32 constVal = 0; LabelIdx lbl = 0; @@ -609,19 +609,19 @@ bool MIRParser::ParseStmtRangegoto(StmtNodePtr &stmt) { Error("duplicated switch case "); return false; } - if (constVal < minidx) { - minidx = constVal; + if (constVal < minIdx) { + minIdx = constVal; } - if (constVal > maxidx) { - maxidx = constVal; + if (constVal > maxIdx) { + maxIdx = constVal; } - rangegotonode->AddRangeGoto(static_cast(constVal), static_cast(lbl)); + rangeGotoNode->AddRangeGoto(static_cast(constVal), static_cast(lbl)); casesSet.insert(constVal); tk = lexer.GetTokenKind(); } - ASSERT(rangegotonode->GetNumOpnds() == 1, "Rangegoto is a UnaryOpnd; numOpnds must be 1"); + ASSERT(rangeGotoNode->GetNumOpnds() == 1, "Rangegoto is a UnaryOpnd; numOpnds must be 1"); // check there is no gap - if (static_cast(static_cast(maxidx - minidx) + 1) != casesSet.size()) { + if (static_cast(static_cast(maxIdx - minIdx) + 1) != casesSet.size()) { Error("gap not allowed in rangegoto case tags "); return false; } @@ -630,16 +630,16 @@ bool MIRParser::ParseStmtRangegoto(StmtNodePtr &stmt) { } bool MIRParser::ParseStmtMultiway(StmtNodePtr &stmt) { - MultiwayNode *multiwaynode = mod.CurFuncCodeMemPool()->New(mod); - stmt = multiwaynode; + auto *multiwayNode = mod.CurFuncCodeMemPool()->New(mod); + stmt = multiwayNode; lexer.NextToken(); BaseNode *expr = nullptr; if (!ParseExprOneOperand(expr)) { return false; } - multiwaynode->SetMultiWayOpnd(expr); + multiwayNode->SetMultiWayOpnd(expr); if (lexer.NextToken() == TK_label) { - multiwaynode->SetDefaultlabel(mod.CurFunction()->GetOrCreateLableIdxFromName(lexer.GetName())); + multiwayNode->SetDefaultlabel(mod.CurFunction()->GetOrCreateLableIdxFromName(lexer.GetName())); } else { Error("expect label in multiway but get "); return false; @@ -672,11 +672,11 @@ bool MIRParser::ParseStmtMultiway(StmtNodePtr &stmt) { } LabelIdx lblIdx = mod.CurFunction()->GetOrCreateLableIdxFromName(lexer.GetName()); lexer.NextToken(); - multiwaynode->AppendElemToMultiWayTable(MCasePair(static_cast(x), lblIdx)); + multiwayNode->AppendElemToMultiWayTable(MCasePair(static_cast(x), lblIdx)); tk = lexer.GetTokenKind(); } - const MapleVector &multiWayTable = multiwaynode->GetMultiWayTable(); - multiwaynode->SetNumOpnds(multiWayTable.size()); + const MapleVector &multiWayTable = multiwayNode->GetMultiWayTable(); + multiwayNode->SetNumOpnds(multiWayTable.size()); lexer.NextToken(); return true; } @@ -689,22 +689,22 @@ PUIdx MIRParser::EnterUndeclaredFunction(bool isMcount) { } else { funcName = lexer.GetName(); } - GStrIdx stridx = GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(funcName); + GStrIdx strIdx = GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(funcName); MIRSymbol *funcSt = GlobalTables::GetGsymTable().CreateSymbol(kScopeGlobal); - funcSt->SetNameStrIdx(stridx); + funcSt->SetNameStrIdx(strIdx); (void)GlobalTables::GetGsymTable().AddToStringSymbolMap(*funcSt); funcSt->SetStorageClass(kScText); funcSt->SetSKind(kStFunc); - MIRFunction *fn = mod.GetMemPool()->New(&mod, funcSt->GetStIdx()); + auto *fn = mod.GetMemPool()->New(&mod, funcSt->GetStIdx()); fn->Init(); fn->SetPuidx(GlobalTables::GetFunctionTable().GetFuncTable().size()); GlobalTables::GetFunctionTable().GetFuncTable().push_back(fn); funcSt->SetFunction(fn); - MIRFuncType *functype = mod.GetMemPool()->New(); - fn->SetMIRFuncType(functype); + auto *funcType = mod.GetMemPool()->New(); + fn->SetMIRFuncType(funcType); if (isMcount) { - MIRType *rettype = GlobalTables::GetTypeTable().GetTypeFromTyIdx(TyIdx(PTY_void)); - fn->SetReturnTyIdx(rettype->GetTypeIndex()); + MIRType *retType = GlobalTables::GetTypeTable().GetTypeFromTyIdx(TyIdx(PTY_void)); + fn->SetReturnTyIdx(retType->GetTypeIndex()); } return fn->GetPuidx(); } @@ -712,13 +712,13 @@ PUIdx MIRParser::EnterUndeclaredFunction(bool isMcount) { bool MIRParser::ParseStmtCallMcount(StmtNodePtr &stmt) { // syntax: call (, ..., ) Opcode o = OP_call; - PUIdx pidx = EnterUndeclaredFunction(true); - CallNode *callstmt = mod.CurFuncCodeMemPool()->New(mod, o); - callstmt->SetPUIdx(pidx); + PUIdx pIdx = EnterUndeclaredFunction(true); + auto *callStmt = mod.CurFuncCodeMemPool()->New(mod, o); + callStmt->SetPUIdx(pIdx); MapleVector opndsvec(mod.CurFuncCodeMemPoolAllocator()->Adapter()); - callstmt->SetNOpnd(opndsvec); - callstmt->SetNumOpnds(opndsvec.size()); - stmt = callstmt; + callStmt->SetNOpnd(opndsvec); + callStmt->SetNumOpnds(opndsvec.size()); + stmt = callStmt; return true; } @@ -727,13 +727,13 @@ bool MIRParser::ParseStmtCall(StmtNodePtr &stmt) { TokenKind tk = lexer.GetTokenKind(); Opcode o = GetOpFromToken(tk); ASSERT(kOpcodeInfo.IsCall(o), "ParseStmtCall: not a call opcode"); - bool hasassigned = kOpcodeInfo.IsCallAssigned(o); - bool hasinstant = false; - bool withtype = false; + bool hasAssigned = kOpcodeInfo.IsCallAssigned(o); + bool hasInstant = false; + bool withType = false; switch (tk) { case TK_polymorphiccall: case TK_polymorphiccallassigned: - withtype = true; + withType = true; break; case TK_callinstant: case TK_virtualcallinstant: @@ -743,19 +743,19 @@ bool MIRParser::ParseStmtCall(StmtNodePtr &stmt) { case TK_virtualcallinstantassigned: case TK_superclasscallinstantassigned: case TK_interfacecallinstantassigned: - hasinstant = true; + hasInstant = true; break; default: break; } - TyIdx polymophictyidx(0); + TyIdx polymophicTyidx(0); if (o == OP_polymorphiccallassigned || o == OP_polymorphiccall) { TokenKind nextTk = lexer.NextToken(); if (nextTk == kTkLangle) { nextTk = lexer.NextToken(); if (nextTk == TK_func) { lexer.NextToken(); - if (!ParseFuncType(polymophictyidx)) { + if (!ParseFuncType(polymophicTyidx)) { Error("error parsing functype in ParseStmtCall for polymorphiccallassigned at "); return false; } @@ -773,21 +773,21 @@ bool MIRParser::ParseStmtCall(StmtNodePtr &stmt) { Error("expect func name in call but get "); return false; } - PUIdx pidx; - if (!ParseDeclaredFunc(pidx)) { + PUIdx pIdx; + if (!ParseDeclaredFunc(pIdx)) { if (mod.GetFlavor() < kMmpl) { Error("expect .mmpl"); return false; } - pidx = EnterUndeclaredFunction(); + pIdx = EnterUndeclaredFunction(); } lexer.NextToken(); - CallNode *callstmt = nullptr; + CallNode *callStmt = nullptr; CallinstantNode *callInstantStmt = nullptr; - if (withtype) { - callstmt = mod.CurFuncCodeMemPool()->New(mod, o); - callstmt->SetTyIdx(polymophictyidx); - } else if (hasinstant) { + if (withType) { + callStmt = mod.CurFuncCodeMemPool()->New(mod, o); + callStmt->SetTyIdx(polymophicTyidx); + } else if (hasInstant) { TokenKind langleTk = lexer.GetTokenKind(); if (langleTk != kTkLangle) { Error("missing < in generic method instantiation at "); @@ -798,8 +798,8 @@ bool MIRParser::ParseStmtCall(StmtNodePtr &stmt) { Error("missing { in generic method instantiation at "); return false; } - MIRInstantVectorType instvecty; - if (!ParseGenericInstantVector(instvecty)) { + MIRInstantVectorType instVecTy; + if (!ParseGenericInstantVector(instVecTy)) { Error("error parsing generic method instantiation at "); return false; } @@ -808,35 +808,35 @@ bool MIRParser::ParseStmtCall(StmtNodePtr &stmt) { Error("missing > in generic method instantiation at "); return false; } - TyIdx tyidx = GlobalTables::GetTypeTable().GetOrCreateMIRType(&instvecty); - callInstantStmt = mod.CurFuncCodeMemPool()->New(mod, o, tyidx); - callstmt = callInstantStmt; + TyIdx tyIdx = GlobalTables::GetTypeTable().GetOrCreateMIRType(&instVecTy); + callInstantStmt = mod.CurFuncCodeMemPool()->New(mod, o, tyIdx); + callStmt = callInstantStmt; lexer.NextToken(); // skip the > } else { - callstmt = mod.CurFuncCodeMemPool()->New(mod, o); + callStmt = mod.CurFuncCodeMemPool()->New(mod, o); } - callstmt->SetPUIdx(pidx); - MapleVector opndsvec(mod.CurFuncCodeMemPoolAllocator()->Adapter()); - if (!ParseExprNaryOperand(opndsvec)) { + callStmt->SetPUIdx(pIdx); + MapleVector opndsVec(mod.CurFuncCodeMemPoolAllocator()->Adapter()); + if (!ParseExprNaryOperand(opndsVec)) { return false; } - callstmt->SetNOpnd(opndsvec); - callstmt->SetNumOpnds(opndsvec.size()); - if (hasassigned) { - CallReturnVector retsvec(mod.CurFuncCodeMemPoolAllocator()->Adapter()); - if (!ParseCallReturns(retsvec)) { + callStmt->SetNOpnd(opndsVec); + callStmt->SetNumOpnds(opndsVec.size()); + if (hasAssigned) { + CallReturnVector retsVec(mod.CurFuncCodeMemPoolAllocator()->Adapter()); + if (!ParseCallReturns(retsVec)) { return false; } - if (!hasinstant) { - ASSERT(callstmt != nullptr, "callstmt is null in MIRParser::ParseStmtCall"); - callstmt->SetReturnVec(retsvec); + if (!hasInstant) { + ASSERT(callStmt != nullptr, "callstmt is null in MIRParser::ParseStmtCall"); + callStmt->SetReturnVec(retsVec); } else { ASSERT(callInstantStmt != nullptr, "callinstantstmt is null in MIRParser::ParseStmtCall"); - callInstantStmt->SetReturnVec(retsvec); + callInstantStmt->SetReturnVec(retsVec); } } lexer.NextToken(); - stmt = callstmt; + stmt = callStmt; return true; } @@ -847,23 +847,23 @@ bool MIRParser::ParseStmtIcall(StmtNodePtr &stmt, bool isAssigned) { // dassign // . . . // dassign } - IcallNode *icallStmt = mod.CurFuncCodeMemPool()->New(mod, !isAssigned ? OP_icall : OP_icallassigned); + auto *iCallStmt = mod.CurFuncCodeMemPool()->New(mod, !isAssigned ? OP_icall : OP_icallassigned); lexer.NextToken(); - MapleVector opndsvec(mod.CurFuncCodeMemPoolAllocator()->Adapter()); - if (!ParseExprNaryOperand(opndsvec)) { + MapleVector opndsVec(mod.CurFuncCodeMemPoolAllocator()->Adapter()); + if (!ParseExprNaryOperand(opndsVec)) { return false; } - icallStmt->SetNOpnd(opndsvec); - icallStmt->SetNumOpnds(opndsvec.size()); + iCallStmt->SetNOpnd(opndsVec); + iCallStmt->SetNumOpnds(opndsVec.size()); if (isAssigned) { - CallReturnVector retsvec(mod.CurFuncCodeMemPoolAllocator()->Adapter()); - if (!ParseCallReturns(retsvec)) { + CallReturnVector retsVec(mod.CurFuncCodeMemPoolAllocator()->Adapter()); + if (!ParseCallReturns(retsVec)) { return false; } - icallStmt->SetReturnVec(retsvec); + iCallStmt->SetReturnVec(retsVec); } lexer.NextToken(); - stmt = icallStmt; + stmt = iCallStmt; return true; } @@ -879,35 +879,35 @@ bool MIRParser::ParseStmtIntrinsiccall(StmtNodePtr &stmt, bool isAssigned) { Opcode o = !isAssigned ? (lexer.GetTokenKind() == TK_intrinsiccall ? OP_intrinsiccall : OP_xintrinsiccall) : (lexer.GetTokenKind() == TK_intrinsiccallassigned ? OP_intrinsiccallassigned : OP_xintrinsiccallassigned); - IntrinsiccallNode *intrncallnode = mod.CurFuncCodeMemPool()->New(mod, o); + auto *intrnCallNode = mod.CurFuncCodeMemPool()->New(mod, o); lexer.NextToken(); if (o == !isAssigned ? OP_intrinsiccall : OP_intrinsiccallassigned) { - intrncallnode->SetIntrinsic(GetIntrinsicId(lexer.GetTokenKind())); + intrnCallNode->SetIntrinsic(GetIntrinsicId(lexer.GetTokenKind())); } else { - intrncallnode->SetIntrinsic(static_cast(lexer.GetTheIntVal())); + intrnCallNode->SetIntrinsic(static_cast(lexer.GetTheIntVal())); } lexer.NextToken(); - MapleVector opndsvec(mod.CurFuncCodeMemPoolAllocator()->Adapter()); - if (!ParseExprNaryOperand(opndsvec)) { + MapleVector opndsVec(mod.CurFuncCodeMemPoolAllocator()->Adapter()); + if (!ParseExprNaryOperand(opndsVec)) { return false; } - intrncallnode->SetNOpnd(opndsvec); - intrncallnode->SetNumOpnds(opndsvec.size()); + intrnCallNode->SetNOpnd(opndsVec); + intrnCallNode->SetNumOpnds(opndsVec.size()); if (isAssigned) { - CallReturnVector retsvec(mod.CurFuncCodeMemPoolAllocator()->Adapter()); - if (!ParseCallReturns(retsvec)) { + CallReturnVector retsVec(mod.CurFuncCodeMemPoolAllocator()->Adapter()); + if (!ParseCallReturns(retsVec)) { return false; } // store return type of IntrinsiccallNode - if (retsvec.size() == 1 && retsvec[0].first.Idx() != 0) { - MIRSymbol *retsymbol = curFunc->GetSymTab()->GetSymbolFromStIdx(retsvec[0].first.Idx()); - MIRType *rettype = GlobalTables::GetTypeTable().GetTypeFromTyIdx(retsymbol->GetTyIdx()); - CHECK_FATAL(rettype != nullptr, "rettype is null in MIRParser::ParseStmtIntrinsiccallAssigned"); - intrncallnode->SetPrimType(rettype->GetPrimType()); + if (retsVec.size() == 1 && retsVec[0].first.Idx() != 0) { + MIRSymbol *retSymbol = curFunc->GetSymTab()->GetSymbolFromStIdx(retsVec[0].first.Idx()); + MIRType *retType = GlobalTables::GetTypeTable().GetTypeFromTyIdx(retSymbol->GetTyIdx()); + CHECK_FATAL(retType != nullptr, "rettype is null in MIRParser::ParseStmtIntrinsiccallAssigned"); + intrnCallNode->SetPrimType(retType->GetPrimType()); } - intrncallnode->SetReturnVec(retsvec); + intrnCallNode->SetReturnVec(retsVec); } - stmt = intrncallnode; + stmt = intrnCallNode; lexer.NextToken(); return true; } @@ -922,42 +922,42 @@ bool MIRParser::ParseStmtIntrinsiccallassigned(StmtNodePtr &stmt) { bool MIRParser::ParseStmtIntrinsiccallwithtype(StmtNodePtr &stmt, bool isAssigned) { Opcode o = !isAssigned ? OP_intrinsiccallwithtype : OP_intrinsiccallwithtypeassigned; - IntrinsiccallNode *intrncallnode = mod.CurFuncCodeMemPool()->New(mod, o); + IntrinsiccallNode *intrnCallNode = mod.CurFuncCodeMemPool()->New(mod, o); TokenKind tk = lexer.NextToken(); - TyIdx tyidx(0); + TyIdx tyIdx(0); if (IsPrimitiveType(tk)) { - if (!ParsePrimType(tyidx)) { + if (!ParsePrimType(tyIdx)) { Error("expect primitive type in ParseStmtIntrinsiccallwithtype but get "); return false; } - } else if (!ParseDerivedType(tyidx)) { + } else if (!ParseDerivedType(tyIdx)) { Error("error parsing type in ParseStmtIntrinsiccallwithtype at "); return false; } - intrncallnode->SetTyIdx(tyidx); - intrncallnode->SetIntrinsic(GetIntrinsicId(lexer.GetTokenKind())); + intrnCallNode->SetTyIdx(tyIdx); + intrnCallNode->SetIntrinsic(GetIntrinsicId(lexer.GetTokenKind())); lexer.NextToken(); - MapleVector opndsvec(mod.CurFuncCodeMemPoolAllocator()->Adapter()); - if (!ParseExprNaryOperand(opndsvec)) { + MapleVector opndsVec(mod.CurFuncCodeMemPoolAllocator()->Adapter()); + if (!ParseExprNaryOperand(opndsVec)) { return false; } - intrncallnode->SetNOpnd(opndsvec); - intrncallnode->SetNumOpnds(opndsvec.size()); + intrnCallNode->SetNOpnd(opndsVec); + intrnCallNode->SetNumOpnds(opndsVec.size()); if (isAssigned) { - CallReturnVector retsvec(mod.CurFuncCodeMemPoolAllocator()->Adapter()); - if (!ParseCallReturns(retsvec)) { + CallReturnVector retsVec(mod.CurFuncCodeMemPoolAllocator()->Adapter()); + if (!ParseCallReturns(retsVec)) { return false; } // store return type of IntrinsiccallNode - if (retsvec.size() == 1 && retsvec[0].first.Idx() != 0) { - MIRSymbol *retsymbol = curFunc->GetSymTab()->GetSymbolFromStIdx(retsvec[0].first.Idx()); - MIRType *rettype = GlobalTables::GetTypeTable().GetTypeFromTyIdx(retsymbol->GetTyIdx()); - CHECK_FATAL(rettype != nullptr, "rettype is null in MIRParser::ParseStmtIntrinsiccallwithtypeAssigned"); - intrncallnode->SetPrimType(rettype->GetPrimType()); + if (retsVec.size() == 1 && retsVec[0].first.Idx() != 0) { + MIRSymbol *retSymbol = curFunc->GetSymTab()->GetSymbolFromStIdx(retsVec[0].first.Idx()); + MIRType *retType = GlobalTables::GetTypeTable().GetTypeFromTyIdx(retSymbol->GetTyIdx()); + CHECK_FATAL(retType != nullptr, "rettype is null in MIRParser::ParseStmtIntrinsiccallwithtypeAssigned"); + intrnCallNode->SetPrimType(retType->GetPrimType()); } - intrncallnode->SetReturnVec(retsvec); + intrnCallNode->SetReturnVec(retsVec); } - stmt = intrncallnode; + stmt = intrnCallNode; lexer.NextToken(); return true; } @@ -1002,34 +1002,34 @@ bool MIRParser::ParseCallReturns(CallReturnVector &retsvec) { return false; } if (lexer.GetTokenKind() == kTkLname) { - MIRSymbolTable *lsymtab = mod.CurFunction()->GetSymTab(); - MIRSymbol *lsym = lsymtab->GetSymbolFromStIdx(stidx.Idx(), 0); - ASSERT(lsym != nullptr, "lsym MIRSymbol is null"); - if (lsym->GetName().find("L_STR") == 0) { - MIRType *ty = GlobalTables::GetTypeTable().GetTypeFromTyIdx(lsym->GetTyIdx()); + MIRSymbolTable *lSymTab = mod.CurFunction()->GetSymTab(); + MIRSymbol *lSym = lSymTab->GetSymbolFromStIdx(stidx.Idx(), 0); + ASSERT(lSym != nullptr, "lsym MIRSymbol is null"); + if (lSym->GetName().find("L_STR") == 0) { + MIRType *ty = GlobalTables::GetTypeTable().GetTypeFromTyIdx(lSym->GetTyIdx()); MIRPtrType *ptrTy = static_cast(ty->CopyMIRTypeNode()); ASSERT(ptrTy != nullptr, "null ptr check"); ptrTy->SetPrimType(PTY_ptr); TyIdx newTyidx = GlobalTables::GetTypeTable().GetOrCreateMIRType(ptrTy); delete ptrTy; - lsym->SetTyIdx(newTyidx); + lSym->SetTyIdx(newTyidx); } } if (stidx.FullIdx() == 0) { Error("expect a symbol parsing ParseCallAssignedStmts. "); return false; } - uint16 fieldid = 0; + uint16 fieldId = 0; TokenKind ntk = lexer.NextToken(); // parse field id if (ntk == kTkIntconst) { - fieldid = lexer.GetTheIntVal(); + fieldId = lexer.GetTheIntVal(); } else { Error("expect a fieldID parsing ParseCallAssignedStmts. "); } - RegFieldPair regfieldpair; - regfieldpair.SetFieldID(fieldid); - retsvec.push_back(CallReturnPair(stidx, regfieldpair)); + RegFieldPair regFieldPair; + regFieldPair.SetFieldID(fieldId); + retsvec.push_back(CallReturnPair(stidx, regFieldPair)); tk = lexer.NextToken(); } else { // parse type @@ -1046,14 +1046,14 @@ bool MIRParser::ParseCallReturns(CallReturnVector &retsvec) { return false; } PrimType ptype = GlobalTables::GetTypeTable().GetPrimTypeFromTyIdx(tyidx); - PregIdx pregidx; + PregIdx pregIdx; if (lexer.GetTokenKind() == kTkSpecialreg) { - if (!ParseSpecialReg(pregidx)) { + if (!ParseSpecialReg(pregIdx)) { Error("expect specialreg parsing callassign CallReturnVector"); return false; } } else if (lexer.GetTokenKind() == kTkPreg) { - if (!ParsePseudoReg(ptype, pregidx)) { + if (!ParsePseudoReg(ptype, pregIdx)) { Error("expect pseudoreg parsing callassign CallReturnVector"); return false; } @@ -1061,11 +1061,11 @@ bool MIRParser::ParseCallReturns(CallReturnVector &retsvec) { Error("expect special or pseudo register but get "); return false; } - ASSERT(pregidx > 0, "register number is zero"); - ASSERT(pregidx <= 0xffff, "register number is over 16 bits"); - RegFieldPair regfieldpair; - regfieldpair.SetPregIdx(pregidx); - retsvec.push_back(CallReturnPair(StIdx(), regfieldpair)); + ASSERT(pregIdx > 0, "register number is zero"); + ASSERT(pregIdx <= 0xffff, "register number is over 16 bits"); + RegFieldPair regFieldPair; + regFieldPair.SetPregIdx(pregIdx); + retsvec.push_back(CallReturnPair(StIdx(), regFieldPair)); tk = lexer.GetTokenKind(); } } @@ -1073,11 +1073,11 @@ bool MIRParser::ParseCallReturns(CallReturnVector &retsvec) { } bool MIRParser::ParseStmtJsTry(StmtNodePtr &stmt) { - JsTryNode *trynode = mod.CurFuncCodeMemPool()->New(); + auto *tryNode = mod.CurFuncCodeMemPool()->New(); lexer.NextToken(); // parse handler label if (lexer.GetTokenKind() == kTkIntconst && lexer.GetTheIntVal() == 0) { - trynode->SetCatchOffset(0); + tryNode->SetCatchOffset(0); } else { if (lexer.GetTokenKind() != TK_label) { Error("expect handler label in try but get "); @@ -1090,12 +1090,12 @@ bool MIRParser::ParseStmtJsTry(StmtNodePtr &stmt) { mod.CurFunction()->GetLabelTab()->SetSymbolFromStIdx(labidx, stridx); mod.CurFunction()->GetLabelTab()->AddToStringLabelMap(labidx); } - trynode->SetCatchOffset(labidx); + tryNode->SetCatchOffset(labidx); } lexer.NextToken(); // parse finally label if (lexer.GetTokenKind() == kTkIntconst && lexer.GetTheIntVal() == 0) { - trynode->SetFinallyOffset(0); + tryNode->SetFinallyOffset(0); } else { if (lexer.GetTokenKind() != TK_label) { Error("expect finally label in try but get "); @@ -1108,15 +1108,15 @@ bool MIRParser::ParseStmtJsTry(StmtNodePtr &stmt) { mod.CurFunction()->GetLabelTab()->SetSymbolFromStIdx(labidx, stridx); mod.CurFunction()->GetLabelTab()->AddToStringLabelMap(labidx); } - trynode->SetFinallyOffset(labidx); + tryNode->SetFinallyOffset(labidx); } - stmt = trynode; + stmt = tryNode; lexer.NextToken(); return true; } bool MIRParser::ParseStmtTry(StmtNodePtr &stmt) { - TryNode *trynode = mod.CurFuncCodeMemPool()->New(mod); + auto *tryNode = mod.CurFuncCodeMemPool()->New(mod); lexer.NextToken(); ASSERT(lexer.GetTokenKind() == kTkLbrace, "expect left brace in try but get "); lexer.NextToken(); @@ -1133,16 +1133,16 @@ bool MIRParser::ParseStmtTry(StmtNodePtr &stmt) { mod.CurFunction()->GetLabelTab()->SetSymbolFromStIdx(labidx, stridx); mod.CurFunction()->GetLabelTab()->AddToStringLabelMap(labidx); } - trynode->AddOffset(labidx); + tryNode->AddOffset(labidx); lexer.NextToken(); } - stmt = trynode; + stmt = tryNode; lexer.NextToken(); return true; } bool MIRParser::ParseStmtCatch(StmtNodePtr &stmt) { - CatchNode *catchnode = mod.CurFuncCodeMemPool()->New(mod); + auto *catchNode = mod.CurFuncCodeMemPool()->New(mod); lexer.NextToken(); ASSERT(lexer.GetTokenKind() == kTkLbrace, "expect left brace in catch but get "); lexer.NextToken(); @@ -1152,23 +1152,23 @@ bool MIRParser::ParseStmtCatch(StmtNodePtr &stmt) { Error("expect type parsing java catch statement"); return false; } - catchnode->PushBack(tyidx); + catchNode->PushBack(tyidx); } - catchnode->SetNumOpnds(0); - stmt = catchnode; + catchNode->SetNumOpnds(0); + stmt = catchNode; lexer.NextToken(); return true; } bool MIRParser::ParseUnaryStmt(Opcode op, StmtNodePtr &stmt) { lexer.NextToken(); - UnaryStmtNode *throwstmt = mod.CurFuncCodeMemPool()->New(op); - stmt = throwstmt; + auto *throwStmt = mod.CurFuncCodeMemPool()->New(op); + stmt = throwStmt; BaseNode *expr = nullptr; if (!ParseExprOneOperand(expr)) { return false; } - throwstmt->SetOpnd(expr); + throwStmt->SetOpnd(expr); lexer.NextToken(); return true; } @@ -1234,8 +1234,8 @@ bool MIRParser::ParseStmtMarker(StmtNodePtr &stmt) { default: return false; } - StmtNode *stmtnode = mod.CurFuncCodeMemPool()->New(op); - stmt = stmtnode; + auto *stmtNode = mod.CurFuncCodeMemPool()->New(op); + stmt = stmtNode; lexer.NextToken(); return true; } @@ -1252,24 +1252,24 @@ bool MIRParser::ParseStmtGosub(StmtNodePtr &stmt) { mod.CurFunction()->GetLabelTab()->SetSymbolFromStIdx(labidx, stridx); mod.CurFunction()->GetLabelTab()->AddToStringLabelMap(labidx); } - GotoNode *gosubnode = mod.CurFuncCodeMemPool()->New(OP_gosub); - gosubnode->SetOffset(labidx); - stmt = gosubnode; + auto *goSubNode = mod.CurFuncCodeMemPool()->New(OP_gosub); + goSubNode->SetOffset(labidx); + stmt = goSubNode; lexer.NextToken(); return true; } bool MIRParser::ParseBinaryStmt(StmtNodePtr &stmt, Opcode op) { - BinaryStmtNode *assstmt = mod.CurFuncCodeMemPool()->New(op); + auto *assStmt = mod.CurFuncCodeMemPool()->New(op); lexer.NextToken(); BaseNode *opnd0 = nullptr; BaseNode *opnd1 = nullptr; if (!ParseExprTwoOperand(opnd0, opnd1)) { return false; } - assstmt->SetBOpnd(opnd0, 0); - assstmt->SetBOpnd(opnd1, 1); - stmt = assstmt; + assStmt->SetBOpnd(opnd0, 0); + assStmt->SetBOpnd(opnd1, 1); + stmt = assStmt; lexer.NextToken(); return true; } @@ -1283,7 +1283,7 @@ bool MIRParser::ParseBinaryStmtAssertLT(StmtNodePtr &stmt) { } bool MIRParser::ParseNaryStmt(StmtNodePtr &stmt, Opcode op) { - NaryStmtNode *stmtReturn = mod.CurFuncCodeMemPool()->New(mod, op); + auto *stmtReturn = mod.CurFuncCodeMemPool()->New(mod, op); if (lexer.NextToken() != kTkLparen) { Error("expect return with ( but get "); return false; @@ -1310,13 +1310,13 @@ bool MIRParser::ParseNaryStmt(StmtNodePtr &stmt, Opcode op) { } stmtReturn->GetNopnd().push_back(exprSync); } else { - MIRType *inttype = GlobalTables::GetTypeTable().GetTypeFromTyIdx((TyIdx)PTY_i32); + MIRType *intType = GlobalTables::GetTypeTable().GetTypeFromTyIdx((TyIdx)PTY_i32); // default 2 for __sync_enter_fast() - MIRIntConst *intconst = mod.GetMemPool()->New(2, *inttype); - ConstvalNode *exprconst = mod.GetMemPool()->New(); - exprconst->SetPrimType(PTY_i32); - exprconst->SetConstVal(intconst); - stmtReturn->GetNopnd().push_back(exprconst); + MIRIntConst *intConst = mod.GetMemPool()->New(2, *intType); + ConstvalNode *exprConst = mod.GetMemPool()->New(); + exprConst->SetPrimType(PTY_i32); + exprConst->SetConstVal(intConst); + stmtReturn->GetNopnd().push_back(exprConst); stmtReturn->SetNumOpnds(stmtReturn->GetNopndSize()); } } @@ -1439,7 +1439,7 @@ void MIRParser::ParseStmtBlockForSeenComment(BlockNodePtr blk, uint32 mplNum) { // collect accumulated comments into comment statement nodes if (!lexer.seenComments.empty()) { for (size_t i = 0; i < lexer.seenComments.size(); i++) { - CommentNode *cmnt = mod.CurFuncCodeMemPool()->New(mod); + auto *cmnt = mod.CurFuncCodeMemPool()->New(mod); cmnt->SetComment(lexer.seenComments[i]); SetSrcPos(cmnt, mplNum); blk->AddStatement(cmnt); @@ -1480,26 +1480,26 @@ bool MIRParser::ParseStmtBlockForReg() { Error("expect %%preg after reg"); return false; } - PregIdx pregidx; - if (!ParseRefPseudoReg(pregidx)) { + PregIdx pregIdx; + if (!ParseRefPseudoReg(pregIdx)) { return false; } - MIRPreg *preg = mod.CurFunction()->GetPregTab()->PregFromPregIdx(pregidx); + MIRPreg *preg = mod.CurFunction()->GetPregTab()->PregFromPregIdx(pregIdx); TyIdx tyidx(0); if (!ParseType(tyidx)) { Error("ParseDeclareVar failed when parsing the type"); return false; } ASSERT(tyidx.GetIdx() > 0, "parse declare var failed "); - MIRType *mirtype = GlobalTables::GetTypeTable().GetTypeFromTyIdx(tyidx); - preg->SetMIRType(mirtype); + MIRType *mirType = GlobalTables::GetTypeTable().GetTypeFromTyIdx(tyidx); + preg->SetMIRType(mirType); if (lexer.GetTokenKind() == kTkIntconst) { - int64 theintval = lexer.GetTheIntVal(); - if (theintval != 0 && theintval != 1) { + int64 theIntVal = lexer.GetTheIntVal(); + if (theIntVal != 0 && theIntVal != 1) { Error("parseDeclareReg failed"); return false; } - preg->SetNeedRC(theintval == 0 ? false : true); + preg->SetNeedRC(theIntVal == 0 ? false : true); } else { Error("parseDeclareReg failed"); return false; @@ -1824,8 +1824,8 @@ bool MIRParser::ParseExprDread(BaseNodePtr &expr) { } bool MIRParser::ParseExprRegread(BaseNodePtr &expr) { - RegreadNode *regread = mod.CurFuncCodeMemPool()->New(); - expr = regread; + auto *regRead = mod.CurFuncCodeMemPool()->New(); + expr = regRead; lexer.NextToken(); TyIdx tyidx(0); if (!ParsePrimType(tyidx)) { @@ -1837,21 +1837,21 @@ bool MIRParser::ParseExprRegread(BaseNodePtr &expr) { } expr->SetPrimType(GlobalTables::GetTypeTable().GetPrimTypeFromTyIdx(tyidx)); if (lexer.GetTokenKind() == kTkSpecialreg) { - PregIdx tempPregIdx = regread->GetRegIdx(); + PregIdx tempPregIdx = regRead->GetRegIdx(); bool isSuccess = ParseSpecialReg(tempPregIdx); - regread->SetRegIdx(tempPregIdx); + regRead->SetRegIdx(tempPregIdx); return isSuccess; } if (lexer.GetTokenKind() == kTkPreg) { if (expr->GetPrimType() == PTY_ptr || expr->GetPrimType() == PTY_ref) { - PregIdx tempPregIdx = regread->GetRegIdx(); + PregIdx tempPregIdx = regRead->GetRegIdx(); bool isSuccess = ParseRefPseudoReg(tempPregIdx); - regread->SetRegIdx(tempPregIdx); + regRead->SetRegIdx(tempPregIdx); return isSuccess; } else { - PregIdx tempPregIdx = regread->GetRegIdx(); + PregIdx tempPregIdx = regRead->GetRegIdx(); bool isSuccess = ParsePseudoReg(expr->GetPrimType(), tempPregIdx); - regread->SetRegIdx(tempPregIdx); + regRead->SetRegIdx(tempPregIdx); return isSuccess; } } @@ -1860,34 +1860,34 @@ bool MIRParser::ParseExprRegread(BaseNodePtr &expr) { } bool MIRParser::ParseExprConstval(BaseNodePtr &expr) { - ConstvalNode *exprconst = mod.CurFuncCodeMemPool()->New(); + auto *exprConst = mod.CurFuncCodeMemPool()->New(); TokenKind typeTk = lexer.NextToken(); if (!IsPrimitiveType(typeTk)) { Error("expect type for GetConstVal but get "); return false; } - exprconst->SetPrimType(GetPrimitiveType(typeTk)); + exprConst->SetPrimType(GetPrimitiveType(typeTk)); lexer.NextToken(); - MIRConst *constval = nullptr; - if (!ParseScalarValue(constval, *GlobalTables::GetTypeTable().GetPrimType(exprconst->GetPrimType()))) { + MIRConst *constVal = nullptr; + if (!ParseScalarValue(constVal, *GlobalTables::GetTypeTable().GetPrimType(exprConst->GetPrimType()))) { Error("expect scalar type but get "); return false; } - exprconst->SetConstVal(constval); - expr = exprconst; + exprConst->SetConstVal(constVal); + expr = exprConst; lexer.NextToken(); return true; } bool MIRParser::ParseExprConststr(BaseNodePtr &expr) { - ConststrNode *strconst = mod.CurFuncCodeMemPool()->New(); + auto *strConst = mod.CurFuncCodeMemPool()->New(); TokenKind tk = lexer.NextToken(); if (!IsPrimitiveType(tk)) { Error("expect primitive type for conststr but get "); return false; } - strconst->SetPrimType(GetPrimitiveType(tk)); - if (!IsAddress(strconst->GetPrimType())) { + strConst->SetPrimType(GetPrimitiveType(tk)); + if (!IsAddress(strConst->GetPrimType())) { Error("expect primitive type for conststr but get "); return false; } @@ -1896,14 +1896,14 @@ bool MIRParser::ParseExprConststr(BaseNodePtr &expr) { Error("expect string literal for conststr but get "); return false; } - strconst->SetStrIdx(GlobalTables::GetUStrTable().GetOrCreateStrIdxFromName(lexer.GetName())); - expr = strconst; + strConst->SetStrIdx(GlobalTables::GetUStrTable().GetOrCreateStrIdxFromName(lexer.GetName())); + expr = strConst; lexer.NextToken(); return true; } bool MIRParser::ParseExprConststr16(BaseNodePtr &expr) { - Conststr16Node *str16Const = mod.CurFuncCodeMemPool()->New(); + auto *str16Const = mod.CurFuncCodeMemPool()->New(); TokenKind tk = lexer.NextToken(); if (!IsPrimitiveType(tk)) { Error("expect primitive type for conststr16 but get "); @@ -1932,21 +1932,21 @@ bool MIRParser::ParseExprConststr16(BaseNodePtr &expr) { } bool MIRParser::ParseExprSizeoftype(BaseNodePtr &expr) { - SizeoftypeNode *exprSizeoftype = mod.CurFuncCodeMemPool()->New(); + auto *exprSizeOfType = mod.CurFuncCodeMemPool()->New(); TokenKind typeTk = lexer.NextToken(); if (!IsPrimitiveType(typeTk)) { Error("expect type for GetConstVal but get "); return false; } - exprSizeoftype->SetPrimType(GetPrimitiveType(typeTk)); + exprSizeOfType->SetPrimType(GetPrimitiveType(typeTk)); lexer.NextToken(); TyIdx tyidx(0); if (!ParseType(tyidx)) { Error("expect type parsing array but get "); return false; } - exprSizeoftype->SetTyIdx(tyidx); - expr = exprSizeoftype; + exprSizeOfType->SetTyIdx(tyidx); + expr = exprSizeOfType; return true; } @@ -1956,7 +1956,7 @@ bool MIRParser::ParseExprFieldsDist(BaseNodePtr &expr) { Error("expect type for GetConstVal but get "); return false; } - FieldsDistNode *node = mod.CurFuncCodeMemPool()->New(); + auto *node = mod.CurFuncCodeMemPool()->New(); node->SetPrimType(GetPrimitiveType(typeTk)); lexer.NextToken(); TyIdx tyIdx(0); @@ -1988,47 +1988,47 @@ bool MIRParser::ParseExprBinary(BaseNodePtr &expr) { Error("expect add operator but get "); return false; } - BinaryNode *addexpr = mod.CurFuncCodeMemPool()->New(opcode); + auto *addExpr = mod.CurFuncCodeMemPool()->New(opcode); if (!IsPrimitiveType(lexer.NextToken())) { Error("expect type parsing binary operator but get "); return false; } - addexpr->SetPrimType(GetPrimitiveType(lexer.GetTokenKind())); + addExpr->SetPrimType(GetPrimitiveType(lexer.GetTokenKind())); lexer.NextToken(); BaseNode *opnd0 = nullptr; BaseNode *opnd1 = nullptr; if (!ParseExprTwoOperand(opnd0, opnd1)) { return false; } - addexpr->SetBOpnd(opnd0, 0); - addexpr->SetBOpnd(opnd1, 1); - expr = addexpr; + addExpr->SetBOpnd(opnd0, 0); + addExpr->SetBOpnd(opnd1, 1); + expr = addExpr; lexer.NextToken(); return true; } bool MIRParser::ParseExprCompare(BaseNodePtr &expr) { Opcode opcode = GetBinaryOp(lexer.GetTokenKind()); - CompareNode *addexpr = mod.CurFuncCodeMemPool()->New(opcode); + auto *addExpr = mod.CurFuncCodeMemPool()->New(opcode); if (!IsPrimitiveType(lexer.NextToken())) { Error("expect type parsing compare operator but get "); return false; } - addexpr->SetPrimType(GetPrimitiveType(lexer.GetTokenKind())); + addExpr->SetPrimType(GetPrimitiveType(lexer.GetTokenKind())); if (!IsPrimitiveType(lexer.NextToken())) { Error("expect operand type parsing compare operator but get "); return false; } - addexpr->SetOpndType(GetPrimitiveType(lexer.GetTokenKind())); + addExpr->SetOpndType(GetPrimitiveType(lexer.GetTokenKind())); lexer.NextToken(); BaseNode *opnd0 = nullptr; BaseNode *opnd1 = nullptr; if (!ParseExprTwoOperand(opnd0, opnd1)) { return false; } - addexpr->SetBOpnd(opnd0, 0); - addexpr->SetBOpnd(opnd1, 1); - expr = addexpr; + addExpr->SetBOpnd(opnd0, 0); + addExpr->SetBOpnd(opnd1, 1); + expr = addExpr; lexer.NextToken(); return true; } @@ -2039,7 +2039,7 @@ bool MIRParser::ParseExprDepositbits(BaseNodePtr &expr) { Error("expect depositbits but get "); return false; } - DepositbitsNode *dpsbNode = mod.CurFuncCodeMemPool()->New(); + auto *dpsbNode = mod.CurFuncCodeMemPool()->New(); expr = dpsbNode; PrimType ptyp = GetPrimitiveType(lexer.NextToken()); if (!IsPrimitiveInteger(ptyp)) { @@ -2102,30 +2102,30 @@ bool MIRParser::ParseExprIreadIaddrof(IreadNode &expr) { bool MIRParser::ParseExprIread(BaseNodePtr &expr) { // syntax : iread () - IreadNode *iexpr = mod.CurFuncCodeMemPool()->New(OP_iread); - if (!ParseExprIreadIaddrof(*iexpr)) { + auto *iExpr = mod.CurFuncCodeMemPool()->New(OP_iread); + if (!ParseExprIreadIaddrof(*iExpr)) { Error("ParseExprIread failed when trying to parse addof"); return false; } - expr = iexpr; + expr = iExpr; return true; } bool MIRParser::ParseExprIaddrof(BaseNodePtr &expr) { // syntax : iaddrof () - IreadNode *iexpr = mod.CurFuncCodeMemPool()->New(OP_iaddrof); - if (!ParseExprIreadIaddrof(*iexpr)) { + auto *iExpr = mod.CurFuncCodeMemPool()->New(OP_iaddrof); + if (!ParseExprIreadIaddrof(*iExpr)) { Error("ParseExprIaddrof failed when trying to parse addof"); return false; } - expr = iexpr; + expr = iExpr; return true; } bool MIRParser::ParseExprIreadoff(BaseNodePtr &expr) { // syntax : iread () - IreadoffNode *ireadoff = mod.CurFuncCodeMemPool()->New(); - expr = ireadoff; + auto *iReadOff = mod.CurFuncCodeMemPool()->New(); + expr = iReadOff; if (!IsPrimitiveType(lexer.NextToken())) { Error("expect primitive type but get "); return false; @@ -2134,8 +2134,8 @@ bool MIRParser::ParseExprIreadoff(BaseNodePtr &expr) { if (!ParsePrimType(tyidx)) { return false; } - ireadoff->SetPrimType(GlobalTables::GetTypeTable().GetPrimTypeFromTyIdx(tyidx)); - if (!IsPrimitiveScalar(ireadoff->GetPrimType())) { + iReadOff->SetPrimType(GlobalTables::GetTypeTable().GetPrimTypeFromTyIdx(tyidx)); + if (!IsPrimitiveScalar(iReadOff->GetPrimType())) { Error("only scalar types allowed for ireadoff"); return false; } @@ -2143,22 +2143,22 @@ bool MIRParser::ParseExprIreadoff(BaseNodePtr &expr) { Error("expect offset but get "); return false; } - ireadoff->SetOffset(lexer.GetTheIntVal()); + iReadOff->SetOffset(lexer.GetTheIntVal()); lexer.NextToken(); BaseNode *opnd = nullptr; if (!ParseExprOneOperand(opnd)) { Error("ParseExprIreadoff when paring one operand"); return false; } - ireadoff->SetOpnd(opnd); + iReadOff->SetOpnd(opnd); lexer.NextToken(); return true; } bool MIRParser::ParseExprIreadFPoff(BaseNodePtr &expr) { // syntax : iread - IreadFPoffNode *ireadoff = mod.CurFuncCodeMemPool()->New(); - expr = ireadoff; + auto *iReadOff = mod.CurFuncCodeMemPool()->New(); + expr = iReadOff; if (!IsPrimitiveType(lexer.NextToken())) { Error("expect primitive type but get "); return false; @@ -2167,8 +2167,8 @@ bool MIRParser::ParseExprIreadFPoff(BaseNodePtr &expr) { if (!ParsePrimType(tyidx)) { return false; } - ireadoff->SetPrimType(GlobalTables::GetTypeTable().GetPrimTypeFromTyIdx(tyidx)); - if (!IsPrimitiveScalar(ireadoff->GetPrimType())) { + iReadOff->SetPrimType(GlobalTables::GetTypeTable().GetPrimTypeFromTyIdx(tyidx)); + if (!IsPrimitiveScalar(iReadOff->GetPrimType())) { Error("only scalar types allowed for ireadoff"); return false; } @@ -2176,14 +2176,14 @@ bool MIRParser::ParseExprIreadFPoff(BaseNodePtr &expr) { Error("expect offset but get "); return false; } - ireadoff->SetOffset(lexer.GetTheIntVal()); + iReadOff->SetOffset(lexer.GetTheIntVal()); lexer.NextToken(); return true; } bool MIRParser::ParseExprAddrof(BaseNodePtr &expr) { // syntax: addrof - AddrofNode *addrofNode = mod.CurFuncCodeMemPool()->New(OP_addrof); + auto *addrofNode = mod.CurFuncCodeMemPool()->New(OP_addrof); expr = addrofNode; if (lexer.GetTokenKind() != TK_addrof) { Error("expect addrof but get "); @@ -2218,8 +2218,8 @@ bool MIRParser::ParseExprAddrof(BaseNodePtr &expr) { } bool MIRParser::ParseExprAddroffunc(BaseNodePtr &expr) { - AddroffuncNode *addroffuncNode = mod.CurFuncCodeMemPool()->New(); - expr = addroffuncNode; + auto *addrOfFuncNode = mod.CurFuncCodeMemPool()->New(); + expr = addrOfFuncNode; TokenKind tk = lexer.NextToken(); if (tk != TK_a32 && tk != TK_a64 && tk != TK_ptr) { Error("expect address primitive type but get "); @@ -2230,7 +2230,7 @@ bool MIRParser::ParseExprAddroffunc(BaseNodePtr &expr) { Error("ParseExprAddroffunc failed when parsing primitive type"); return false; } - addroffuncNode->SetPrimType(GlobalTables::GetTypeTable().GetPrimTypeFromTyIdx(tyidx)); + addrOfFuncNode->SetPrimType(GlobalTables::GetTypeTable().GetPrimTypeFromTyIdx(tyidx)); if (lexer.GetTokenKind() != kTkFname) { Error("expect function name but get "); return false; @@ -2243,15 +2243,15 @@ bool MIRParser::ParseExprAddroffunc(BaseNodePtr &expr) { } pidx = EnterUndeclaredFunction(); } - addroffuncNode->SetPUIdx(pidx); + addrOfFuncNode->SetPUIdx(pidx); lexer.NextToken(); return true; } bool MIRParser::ParseExprAddroflabel(BaseNodePtr &expr) { // syntax: addroflabel