diff --git a/src/bin/jbc2mpl b/src/bin/jbc2mpl index 5b1fa08c7a2df0178e65946b9662091aa5f72c7b..477ac365d678ee81f9720466d573aeed4a1492ef 100755 Binary files a/src/bin/jbc2mpl and b/src/bin/jbc2mpl differ diff --git a/src/bin/maple b/src/bin/maple index cba45b7576a3e395e6d52d351220308af11eba9a..5b67753cf66d8a5c78c780d7e60edde8c0c3feda 100755 Binary files a/src/bin/maple and b/src/bin/maple differ diff --git a/src/bin/mplcg b/src/bin/mplcg index a13aa431a59f5c35cb6a906174dbc23f04c987a6..7d24e86ae8d41cd243ad18dc7a3e56269b4c7fab 100755 Binary files a/src/bin/mplcg and b/src/bin/mplcg differ diff --git a/src/deplibs/libmempool.a b/src/deplibs/libmempool.a index 509e3b7701651d0836ba77e48e2de8a36c4461cd..65f58630fd2a222971410c793cb1db51fa5b09be 100644 Binary files a/src/deplibs/libmempool.a and b/src/deplibs/libmempool.a differ diff --git a/src/maple_driver/include/compiler.h b/src/maple_driver/include/compiler.h index e5907770b33e673ae7e2edf1a4198e105e6fd63c..fc6122033eef2060675e8f46d3ca72b8c6d40209 100644 --- a/src/maple_driver/include/compiler.h +++ b/src/maple_driver/include/compiler.h @@ -37,13 +37,6 @@ class Compiler { virtual ~Compiler() = default; virtual ErrorCode Compile(const MplOptions &options, MIRModulePtr &theModule); - const std::string &GetName() const { - return name; - } - - virtual const std::vector GetBinNames() const { - return std::vector(); - } virtual void GetTmpFilesToDelete(const MplOptions &mplOptions, std::vector &tempFiles) const {} @@ -61,7 +54,7 @@ class Compiler { virtual const std::string GetInputFileName(const MplOptions &options) const { std::ostringstream ss; - for (auto const &inputFile : options.splitsInputFiles) { + for (auto const &inputFile : options.GetSplitsInputFiles()) { ss << " " << inputFile; } return ss.str(); @@ -71,75 +64,79 @@ class Compiler { return DefaultOption(); } - virtual void AppendExtraOptions(std::map &finalOptions, - const std::map> &extraOptions) const; virtual const std::string AppendSpecialOption(const MplOptions &options, const std::string &optionStr) const { return optionStr; } virtual const std::string AppendOptimization(const MplOptions &options, const std::string &optionStr) const; + + virtual const std::vector GetBinNames() const { + return std::vector(); + } + const bool CanAppendOptimization(const std::string &optionStr) const; - void AppendOptions(std::map &finalOptions, const std::string &key, const std::string &value, - const std::string &connectSymbol) const; private: + const std::string name; const std::string MakeOption(const MplOptions &options); void AppendDefaultOptions(std::map &finalOptions, const std::map &defaultOptions) const; void AppendUserOptions(std::map &finalOptions, const std::vector &userOption) const; + void AppendOptions(std::map &finalOptions, const std::string &key, const std::string &value, + const std::string &connectSymbol) const; + void AppendExtraOptions(std::map &finalOptions, + const std::map> &extraOptions) const; const std::map MakeDefaultOptions(const MplOptions &options); const int Exe(const MplOptions &mplOptions, const std::string &options) const; - const std::string name; + const std::string &GetName() const { + return name; + } }; class Jbc2MplCompiler : public Compiler { public: explicit Jbc2MplCompiler(const std::string &name) : Compiler(name) {} - ~Jbc2MplCompiler() {} - - const std::vector GetBinNames() const; + ~Jbc2MplCompiler() = default; - protected: - const std::string GetBinName() const; - const DefaultOption GetDefaultOptions(const MplOptions &options); - void GetTmpFilesToDelete(const MplOptions &mplOptions, std::vector &tempFiles) const; - const std::unordered_set GetFinalOutputs(const MplOptions &mplOptions) const; + private: + const std::string GetBinName() const override; + const DefaultOption GetDefaultOptions(const MplOptions &options) override; + void GetTmpFilesToDelete(const MplOptions &mplOptions, std::vector &tempFiles) const override; + const std::unordered_set GetFinalOutputs(const MplOptions &mplOptions) const override; + const std::vector GetBinNames() const override; }; class MapleCombCompiler : public Compiler { public: explicit MapleCombCompiler(const std::string &name) : Compiler(name), realRunningExe("") {} - ~MapleCombCompiler() {} + ~MapleCombCompiler() = default; - ErrorCode Compile(const MplOptions &options, MIRModulePtr &theModule); - void PrintCommand(const MplOptions &options) const; - const std::string GetInputFileName(const MplOptions &options) const; - - protected: - const std::unordered_set GetFinalOutputs(const MplOptions &mplOptions) const; + ErrorCode Compile(const MplOptions &options, MIRModulePtr &theModule) override; + void PrintCommand(const MplOptions &options) const override; + const std::string GetInputFileName(const MplOptions &options) const override; private: + std::string realRunningExe; + const std::unordered_set GetFinalOutputs(const MplOptions &mplOptions) const override; MeOption *MakeMeOptions(const MplOptions &options, MemPool &optmp); Options *MakeMpl2MplOptions(const MplOptions &options, MemPool &optmp); - std::string realRunningExe; }; class MplcgCompiler : public Compiler { public: explicit MplcgCompiler(const std::string &name) : Compiler(name) {} - ~MplcgCompiler() {} + ~MplcgCompiler() = default; - const std::string GetBinName() const; - const std::vector GetBinNames() const; - - protected: - const std::string GetInputFileName(const MplOptions &options) const; - const DefaultOption GetDefaultOptions(const MplOptions &options); + private: + const std::string GetInputFileName(const MplOptions &options) const override; + const DefaultOption GetDefaultOptions(const MplOptions &options) override; + const std::string GetBinName() const override; + const std::vector GetBinNames() const override; }; } // namespace maple diff --git a/src/maple_driver/include/compiler_selector.h b/src/maple_driver/include/compiler_selector.h index c9bf437544652dc5c038bd3c4b7e79afdac1a0ee..1655a749395e2024fe89bfac63ff85079f7d6da8 100644 --- a/src/maple_driver/include/compiler_selector.h +++ b/src/maple_driver/include/compiler_selector.h @@ -45,7 +45,7 @@ class CompilerSelectorImpl : public CompilerSelector { private: Compiler *FindCompiler(const SupportedCompilers &compilers, const std::string &name) const; const ErrorCode InsertCompilerIfNeeded(std::vector &selected, const SupportedCompilers &compilers, - const std::string name) const; + const std::string &name) const; }; } // namespace maple #endif // MAPLE_DRIVER_INCLUDE_COMPILER_SELECTOR_H diff --git a/src/maple_driver/include/mpl_options.h b/src/maple_driver/include/mpl_options.h index 679797e064ddef11c34fc5e68ddfcaa9550fed08..c1963c4f9b230f01413343d959be925803711ea4 100644 --- a/src/maple_driver/include/mpl_options.h +++ b/src/maple_driver/include/mpl_options.h @@ -42,6 +42,46 @@ enum RunMode { kAutoRun, kCustomRun, kUnkownRun }; class MplOption { public: + MplOption(const std::string &key, const std::string &value, const std::string &connectSymbol, bool isAppend, + const std::string &appendSplit, bool needRootPath = false) + : key(key), + value(value), + connectSymbol(connectSymbol), + isAppend(isAppend), + appendSplit(appendSplit), + needRootPath(needRootPath) { + CHECK_FATAL(!key.empty(), "MplOption got an empty key."); + } + + const std::string &GetKey() const { + return key; + } + + const std::string &GetValue() const { + return value; + } + + void SetValue(std::string val) { + value = val; + } + + const std::string &GetconnectSymbol() const { + return connectSymbol; + } + + bool GetIsAppend() const { + return isAppend; + } + + const std::string &GetAppendSplit() const { + return appendSplit; + } + + bool GetNeedRootPath() const { + return needRootPath; + } + + private: // option key std::string key; // option value @@ -52,20 +92,6 @@ class MplOption { bool isAppend; std::string appendSplit; bool needRootPath; - - public: - void init(const std::string &key, const std::string &value, const std::string &connectSymbol, bool isAppend, - const std::string &appendSplit, - bool needRootPath = false) { - CHECK_FATAL(!key.empty(), "MplOption got an empty key."); - - this->key = key; - this->value = value; - this->connectSymbol = connectSymbol; - this->isAppend = isAppend; - this->appendSplit = appendSplit; - this->needRootPath = needRootPath; - } }; struct DefaultOption { @@ -75,30 +101,6 @@ struct DefaultOption { class MplOptions { public: - 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; - bool isWithIpa; - std::string printCommandStr; - bool debugFlag; - bool timePhases; - bool genMemPl; - bool genVtableImpl; - bool verify; MplOptions() : optionParser(nullptr), options({}), @@ -117,7 +119,6 @@ class MplOptions { splitsInputFiles({}), extras({}), runningExes({}), - isWithIpa(false), printCommandStr(""), debugFlag(false), timePhases(false), @@ -129,7 +130,110 @@ class MplOptions { int Parse(int argc, char **argv); const std::string OptimizationLevelStr() const; + const std::map> &GetOptions() const { + return options; + } + + const std::map> &GetExeOptions() const { + return exeOptions; + } + + const std::string &GetInputFiles() const { + return inputFiles; + } + + const std::string &GetOutputFolder() const { + return outputFolder; + } + + const std::string &GetOutputName() const { + return outputName; + } + + const std::string &GetExeFolder() const { + return exeFolder; + } + + const InputFileType &GetInputFileType() const { + return inputFileType; + } + + const OptimizationLevel &GetOptimizationLevel() const { + return optimizationLevel; + } + + const bool GetSetDefaultLevel() const { + return setDefaultLevel; + } + + const bool GetIsSaveTmps() const { + return isSaveTmps; + } + + const std::vector &GetSaveFiles() const { + return saveFiles; + } + + const std::vector &GetSplitsInputFiles() const { + return splitsInputFiles; + } + + const std::map> &GetExtras() const { + return extras; + } + + const std::vector &GetRunningExes() const { + return runningExes; + } + + const std::string &GetPrintCommandStr() const { + return printCommandStr; + } + + const bool GetDebugFlag() const { + return debugFlag; + } + + const bool GetTimePhases() const { + return timePhases; + } + + const bool GetGenMemPl() const { + return genMemPl; + } + + const bool GetGenVtableImpl() const { + return genVtableImpl; + } + + const bool GetVerify() const { + return verify; + } + 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; bool Init(const std::string &inputFile); ErrorCode HandleGeneralOptions(); ErrorCode DecideRunType(); @@ -138,7 +242,6 @@ class MplOptions { ErrorCode CheckRunMode(RunMode mode); ErrorCode CheckFileExits(); void AddOption(const mapleOption::Option &option); - void UpdateOptLevel(OptimizationLevel level); ErrorCode UpdatePhaseOption(const std::string &args, const std::string &exeName); ErrorCode UpdateExtraOptionOpt(const std::string &args); ErrorCode AppendDefaultCombOptions(); diff --git a/src/maple_driver/include/safe_exe.h b/src/maple_driver/include/safe_exe.h index a48f5331a10c514909b239a99c10248de7087b9a..e53745c280517e1b2534928183c93a74231e125d 100644 --- a/src/maple_driver/include/safe_exe.h +++ b/src/maple_driver/include/safe_exe.h @@ -36,36 +36,26 @@ class SafeExe { */ #if __linux__ or __linux static ErrorCode HandleCommand(const std::string &cmd, const std::string &args) { - std::vector tmpArgs; - StringUtils::Split(args, tmpArgs, ' '); - // remove ' ' in vector - for (auto iter = tmpArgs.begin(); iter != tmpArgs.end();) { - if (*iter == " " || *iter == "") { - iter = tmpArgs.erase(iter); - } else { - iter++; - } - } - tmpArgs.insert(tmpArgs.begin(), cmd); + std::vector vectorArgs = ParseArgsVector(cmd, args); // extra space for exe name and args - char **argv = new char* [tmpArgs.size() + 1]; + char **argv = new char*[vectorArgs.size() + 1]; // argv[0] is program name // copy args - for (int j = 0; j < tmpArgs.size(); ++j) { - int strLength = tmpArgs[j].size(); + for (int j = 0; j < vectorArgs.size(); ++j) { + int strLength = vectorArgs[j].size(); argv[j] = new char[strLength + 1]; - strncpy_s(argv[j], strLength + 1, tmpArgs[j].c_str(), strLength); + strncpy_s(argv[j], strLength + 1, vectorArgs[j].c_str(), strLength); argv[j][strLength] = '\0'; } - // end of arguments sentinel is NULL - argv[tmpArgs.size()] = NULL; + // end of arguments sentinel is nullptr + argv[vectorArgs.size()] = nullptr; pid_t pid = fork(); ErrorCode ret = ErrorCode::kErrorNoError; if (pid == 0) { // child process - fflush(NULL); + fflush(nullptr); if (execv(cmd.c_str(), argv) < 0) { - for (int j = 0; j < tmpArgs.size(); ++j) { + for (int j = 0; j < vectorArgs.size(); ++j) { delete [] argv[j]; } delete [] argv; @@ -83,7 +73,7 @@ class SafeExe { ret = ErrorCode::kErrorCompileFail; } } - for (int j = 0; j < tmpArgs.size(); ++j) { + for (int j = 0; j < vectorArgs.size(); ++j) { delete [] argv[j]; } delete [] argv; @@ -105,6 +95,21 @@ class SafeExe { return ErrorCode::kErrorNotImplement; #endif } + private: + static std::vector ParseArgsVector(const std::string &cmd, const std::string &args) { + std::vector tmpArgs; + StringUtils::Split(args, tmpArgs, ' '); + // remove ' ' in vector + for (auto iter = tmpArgs.begin(); iter != tmpArgs.end();) { + if (*iter == " " || *iter =="") { + iter = tmpArgs.erase(iter); + } else { + iter++; + } + } + tmpArgs.insert(tmpArgs.begin(), cmd); + return tmpArgs; + } }; } // namespace maple #endif // MAPLE_DRIVER_INCLUDE_SAFE_EXE_H diff --git a/src/maple_driver/src/compiler.cpp b/src/maple_driver/src/compiler.cpp index a7082b81ca7114a59b5d3841a7f44206bbd66040..a84f2aff57800829cba3317846ba382f6729d78b 100644 --- a/src/maple_driver/src/compiler.cpp +++ b/src/maple_driver/src/compiler.cpp @@ -36,14 +36,14 @@ const std::string Compiler::GetBinPath(const MplOptions &mplOptions) const { binPath = binPath + FileSeperator::kFileSeperatorChar; } #else - std::string binPath = mplOptions.exeFolder; + std::string binPath = mplOptions.GetExeFolder(); #endif return binPath; } ErrorCode Compiler::Compile(const MplOptions &options, MIRModulePtr &theModule) { MPLTimer timer = MPLTimer(); - LogInfo::MapleLogger() << "Starting " << GetName() << std::endl; + LogInfo::MapleLogger() << "Starting " << GetName() << '\n'; timer.Start(); std::string strOption = MakeOption(options); if (strOption.empty()) { @@ -53,7 +53,7 @@ ErrorCode Compiler::Compile(const MplOptions &options, MIRModulePtr &theModule) return ErrorCode::kErrorCompileFail; } timer.Stop(); - LogInfo::MapleLogger() << (GetName() + " consumed ") << timer.Elapsed() << "s" << std::endl; + LogInfo::MapleLogger() << (GetName() + " consumed ") << timer.Elapsed() << "s" << '\n'; return ErrorCode::kErrorNoError; } @@ -62,23 +62,23 @@ const std::string Compiler::MakeOption(const MplOptions &options) { auto defaultOptions = MakeDefaultOptions(options); AppendDefaultOptions(finalOptions, defaultOptions); for (auto binName : GetBinNames()) { - auto userOption = options.options.find(binName); - if (userOption != options.options.end()) { + auto userOption = options.GetOptions().find(binName); + if (userOption != options.GetOptions().end()) { AppendUserOptions(finalOptions, userOption->second); } } - AppendExtraOptions(finalOptions, options.extras); + AppendExtraOptions(finalOptions, options.GetExtras()); std::ostringstream strOption; for (auto finalOption : finalOptions) { - strOption << " " << finalOption.first << finalOption.second.connectSymbol << finalOption.second.value; - if (options.debugFlag) { + strOption << " " << finalOption.first << finalOption.second.GetconnectSymbol() << finalOption.second.GetValue(); + if (options.GetDebugFlag()) { LogInfo::MapleLogger() << Compiler::GetName() << " options: " << finalOption.first << " " - << finalOption.second.value << std::endl; + << finalOption.second.GetValue() << '\n'; } } strOption << " " << this->GetInputFileName(options); - if (options.debugFlag) { - LogInfo::MapleLogger() << Compiler::GetName() << " input files: " << GetInputFileName(options) << std::endl; + if (options.GetDebugFlag()) { + LogInfo::MapleLogger() << Compiler::GetName() << " input files: " << GetInputFileName(options) << '\n'; } return FileUtils::ConvertPathIfNeeded(strOption.str()); } @@ -111,7 +111,7 @@ void Compiler::AppendExtraOptions(std::map &finalOptions continue; } for (auto &secondExtras : extras->second) { - AppendOptions(finalOptions, secondExtras.key, secondExtras.value, secondExtras.connectSymbol); + AppendOptions(finalOptions, secondExtras.GetKey(), secondExtras.GetValue(), secondExtras.GetconnectSymbol()); } } } @@ -121,7 +121,7 @@ const std::map Compiler::MakeDefaultOptions(const MplOpt std::map defaultOptions; if (rawDefaultOptions.mplOptions != nullptr) { for (unsigned int i = 0; i < rawDefaultOptions.length; i++) { - defaultOptions.insert(std::make_pair(rawDefaultOptions.mplOptions[i].key, rawDefaultOptions.mplOptions[i])); + defaultOptions.insert(std::make_pair(rawDefaultOptions.mplOptions[i].GetKey(), rawDefaultOptions.mplOptions[i])); } } return defaultOptions; @@ -131,14 +131,14 @@ void Compiler::AppendOptions(std::map &finalOptions, con const std::string &value, const std::string &connectSymbol) const { auto finalOpt = finalOptions.find(key); if (finalOpt != finalOptions.end()) { - if (finalOpt->second.isAppend) { - finalOpt->second.value += finalOpt->second.appendSplit + value; + if (finalOpt->second.GetIsAppend()) { + std::string temp = finalOpt->second.GetValue() + finalOpt->second.GetAppendSplit() + value; + finalOpt->second.SetValue(temp); } else { - finalOpt->second.value = value; + finalOpt->second.SetValue(value); } } else { - MplOption option; - option.init(key, value, connectSymbol, false, ""); + MplOption option(key, value, connectSymbol, false, ""); finalOptions.insert(make_pair(key, option)); } } diff --git a/src/maple_driver/src/compiler_factory.cpp b/src/maple_driver/src/compiler_factory.cpp index b320661d4c93933ce3969c9008d338c696b6a03b..74bdbac58e025f864d0074c159acee2d79df7303 100644 --- a/src/maple_driver/src/compiler_factory.cpp +++ b/src/maple_driver/src/compiler_factory.cpp @@ -68,13 +68,13 @@ ErrorCode CompilerFactory::DeleteTmpFiles(const MplOptions &mplOptions, const st int ret = 0; for (auto tmpFile : tempFiles) { bool isSave = false; - for (auto saveFile : mplOptions.saveFiles) { + for (auto saveFile : mplOptions.GetSaveFiles()) { if (!saveFile.empty() && std::regex_match(tmpFile, std::regex(StringUtils::Replace(saveFile, "*", ".*?")))) { isSave = true; break; } } - if (!isSave && mplOptions.inputFiles.find(tmpFile) == std::string::npos && // not input + if (!isSave && mplOptions.GetInputFiles().find(tmpFile) == std::string::npos && // not input (finalOutputs.find(tmpFile) == finalOutputs.end())) { // not output ret = FileUtils::Remove(tmpFile); } @@ -100,7 +100,7 @@ ErrorCode CompilerFactory::Compile(const MplOptions &mplOptions) { } } - if (!mplOptions.isSaveTmps || !mplOptions.saveFiles.empty()) { + if (!mplOptions.GetIsSaveTmps() || !mplOptions.GetSaveFiles().empty()) { auto tmpFiles = std::vector(); for (auto compiler : compilers) { compiler->GetTmpFilesToDelete(mplOptions, tmpFiles); diff --git a/src/maple_driver/src/compiler_selector.cpp b/src/maple_driver/src/compiler_selector.cpp index 1f14f8a987e771c8ab81c701035818d63cdccfe7..79fdb58a728be5fd8cb61bb4920de00f676e3866 100644 --- a/src/maple_driver/src/compiler_selector.cpp +++ b/src/maple_driver/src/compiler_selector.cpp @@ -27,7 +27,7 @@ Compiler *CompilerSelectorImpl::FindCompiler(const SupportedCompilers &compilers const ErrorCode CompilerSelectorImpl::InsertCompilerIfNeeded(std::vector &selected, const SupportedCompilers &compilers, - const std::string name) const { + const std::string &name) const { Compiler *compiler = FindCompiler(compilers, name); if (compiler != nullptr) { if (std::find(selected.cbegin(), selected.cend(), compiler) == selected.cend()) { @@ -35,7 +35,7 @@ const ErrorCode CompilerSelectorImpl::InsertCompilerIfNeeded(std::vector &selected) const { bool combPhases = false; - int ret = ErrorCode::kErrorNoError; - if (!mplOptions.runningExes.empty()) { - for (auto runningExe : mplOptions.runningExes) { + if (!mplOptions.GetRunningExes().empty()) { + for (auto runningExe : mplOptions.GetRunningExes()) { if (runningExe == kBinNameMe) { combPhases = true; } else if (runningExe == kBinNameMpl2mpl && combPhases) { continue; } - ret = InsertCompilerIfNeeded(selected, supportedCompilers, runningExe); + ErrorCode ret = InsertCompilerIfNeeded(selected, supportedCompilers, runningExe); if (ret != ErrorCode::kErrorNoError) { return ErrorCode::kErrorToolNotFound; } diff --git a/src/maple_driver/src/jbc2mpl_compiler.cpp b/src/maple_driver/src/jbc2mpl_compiler.cpp index 6cd6d04f05853be81d20ba5c57efa9183d69aecf..db0d0c942cdfe752400f5e5dde9d0b77c8c4e613 100644 --- a/src/maple_driver/src/jbc2mpl_compiler.cpp +++ b/src/maple_driver/src/jbc2mpl_compiler.cpp @@ -33,12 +33,12 @@ const DefaultOption Jbc2MplCompiler::GetDefaultOptions(const MplOptions &options } void Jbc2MplCompiler::GetTmpFilesToDelete(const MplOptions &mplOptions, std::vector &tempFiles) const { - tempFiles.push_back(mplOptions.outputFolder + mplOptions.outputName + ".mpl"); + tempFiles.push_back(mplOptions.GetOutputFolder() + mplOptions.GetOutputName() + ".mpl"); } const std::unordered_set Jbc2MplCompiler::GetFinalOutputs(const MplOptions &mplOptions) const { auto finalOutputs = std::unordered_set(); - finalOutputs.insert(mplOptions.outputFolder + mplOptions.outputName + ".mpl"); + finalOutputs.insert(mplOptions.GetOutputFolder() + mplOptions.GetOutputName() + ".mpl"); return finalOutputs; } } // namespace maple diff --git a/src/maple_driver/src/maple_comb_compiler.cpp b/src/maple_driver/src/maple_comb_compiler.cpp index a63b82e35766e3c21500fee4cd0ed99bd5ed14d3..7f9120b6d5aea6fd241e97451ae814a0b72c4c4f 100644 --- a/src/maple_driver/src/maple_comb_compiler.cpp +++ b/src/maple_driver/src/maple_comb_compiler.cpp @@ -24,17 +24,17 @@ namespace maple { using namespace mapleOption; const std::string MapleCombCompiler::GetInputFileName(const MplOptions &options) const { - if (options.inputFileType == InputFileType::kVtableImplMpl) { - return options.outputFolder + options.outputName + ".VtableImpl.mpl"; + if (options.GetInputFileType() == InputFileType::kVtableImplMpl) { + return options.GetOutputFolder() + options.GetOutputName() + ".VtableImpl.mpl"; } else { - return options.outputFolder + options.outputName + ".mpl"; + return options.GetOutputFolder() + options.GetOutputName() + ".mpl"; } } const std::unordered_set MapleCombCompiler::GetFinalOutputs(const MplOptions &mplOptions) const { auto finalOutputs = std::unordered_set(); - finalOutputs.insert(mplOptions.outputFolder + mplOptions.outputName + ".VtableImpl.mpl"); + finalOutputs.insert(mplOptions.GetOutputFolder() + mplOptions.GetOutputName() + ".VtableImpl.mpl"); return finalOutputs; } @@ -43,44 +43,44 @@ void MapleCombCompiler::PrintCommand(const MplOptions &options) const { std::string optionStr = "--option=\""; std::string connectSym = ""; bool firstComb = false; - if (options.exeOptions.find(kBinNameMe) != options.exeOptions.end()) { + if (options.GetExeOptions().find(kBinNameMe) != options.GetExeOptions().end()) { runStr += "me"; - auto inputMeOptions = options.exeOptions.find(kBinNameMe); + auto inputMeOptions = options.GetExeOptions().find(kBinNameMe); for (auto &opt : inputMeOptions->second) { connectSym = opt.Args() != "" ? "=" : ""; optionStr += " --" + opt.OptionKey() + connectSym + opt.Args(); } firstComb = true; } - if (options.exeOptions.find(kBinNameMpl2mpl) != options.exeOptions.end()) { + if (options.GetExeOptions().find(kBinNameMpl2mpl) != options.GetExeOptions().end()) { if (firstComb) { runStr += ":mpl2mpl"; optionStr += ":"; } else { runStr += "mpl2mpl"; } - auto inputMpl2mplOptions = options.exeOptions.find(kBinNameMpl2mpl); + auto inputMpl2mplOptions = options.GetExeOptions().find(kBinNameMpl2mpl); for (auto &opt : inputMpl2mplOptions->second) { connectSym = opt.Args() != "" ? "=" : ""; optionStr += " --" + opt.OptionKey() + connectSym + opt.Args(); } } optionStr += "\""; - LogInfo::MapleLogger() << "Starting:" << options.exeFolder << "maple " << runStr << " " << optionStr << " " - << GetInputFileName(options) << options.printCommandStr << std::endl; + LogInfo::MapleLogger() << "Starting:" << options.GetExeFolder() << "maple " << runStr << " " << optionStr << " " + << GetInputFileName(options) << options.GetPrintCommandStr() << '\n'; } MeOption *MapleCombCompiler::MakeMeOptions(const MplOptions &options, maple::MemPool &optMp) { MeOption *meOption = new MeOption(optMp); - auto inputMeOptions = options.exeOptions.find(kBinNameMe); - if (inputMeOptions == options.exeOptions.end()) { - LogInfo::MapleLogger() << "no me input options" << std::endl; + auto inputMeOptions = options.GetExeOptions().find(kBinNameMe); + if (inputMeOptions == options.GetExeOptions().end()) { + LogInfo::MapleLogger() << "no me input options" << '\n'; return meOption; } for (auto &opt : inputMeOptions->second) { - if (options.debugFlag) { + if (options.GetDebugFlag()) { LogInfo::MapleLogger() << "Me options: " << opt.Index() << " " << opt.OptionKey() << " " << opt.Args() - << std::endl; + << '\n'; } switch (opt.Index()) { case kMeSkipPhases: @@ -166,15 +166,15 @@ MeOption *MapleCombCompiler::MakeMeOptions(const MplOptions &options, maple::Mem Options *MapleCombCompiler::MakeMpl2MplOptions(const MplOptions &options, maple::MemPool &optMp) { Options *mpl2mplOption = new Options(optMp); - auto inputOptions = options.exeOptions.find(kBinNameMpl2mpl); - if (inputOptions == options.exeOptions.end()) { - LogInfo::MapleLogger() << "no mpl2mpl input options" << std::endl; + auto inputOptions = options.GetExeOptions().find(kBinNameMpl2mpl); + if (inputOptions == options.GetExeOptions().end()) { + LogInfo::MapleLogger() << "no mpl2mpl input options" << '\n'; return mpl2mplOption; } for (auto &opt : inputOptions->second) { - if (options.debugFlag) { + if (options.GetDebugFlag()) { LogInfo::MapleLogger() << "mpl2mpl options: " << opt.Index() << " " << opt.OptionKey() << " " << opt.Args() - << std::endl; + << '\n'; } switch (opt.Index()) { case kMpl2MplDumpBefore: @@ -237,28 +237,28 @@ Options *MapleCombCompiler::MakeMpl2MplOptions(const MplOptions &options, maple: } ErrorCode MapleCombCompiler::Compile(const MplOptions &options, MIRModulePtr &theModule) { - MemPool *optMp = mempoolctrler.NewMemPool("maplecomb mempool"); + MemPool *optMp = memPoolCtrler.NewMemPool("maplecomb mempool"); std::string fileName = GetInputFileName(options); theModule = new MIRModule(fileName); std::unique_ptr meOptions; std::unique_ptr mpl2mplOptions; - auto iterMe = std::find(options.runningExes.begin(), options.runningExes.end(), kBinNameMe); - if (iterMe != options.runningExes.end()) { + auto iterMe = std::find(options.GetRunningExes().begin(), options.GetRunningExes().end(), kBinNameMe); + if (iterMe != options.GetRunningExes().end()) { meOptions.reset(MakeMeOptions(options, *optMp)); } - auto iterMpl2Mpl = std::find(options.runningExes.begin(), options.runningExes.end(), kBinNameMpl2mpl); - if (iterMpl2Mpl != options.runningExes.end()) { + auto iterMpl2Mpl = std::find(options.GetRunningExes().begin(), options.GetRunningExes().end(), kBinNameMpl2mpl); + if (iterMpl2Mpl != options.GetRunningExes().end()) { mpl2mplOptions.reset(MakeMpl2MplOptions(options, *optMp)); } - LogInfo::MapleLogger() << "Starting mpl2mpl&mplme" << std::endl; + LogInfo::MapleLogger() << "Starting mpl2mpl&mplme" << '\n'; PrintCommand(options); - DriverRunner runner(theModule, options.runningExes, mpl2mplOptions.get(), fileName, meOptions.get(), + DriverRunner runner(theModule, options.GetRunningExes(), mpl2mplOptions.get(), fileName, meOptions.get(), fileName, fileName, optMp, - options.timePhases, options.genMemPl); + options.GetTimePhases(), options.GetGenMemPl()); ErrorCode nErr = runner.Run(); - mempoolctrler.DeleteMemPool(optMp); + memPoolCtrler.DeleteMemPool(optMp); return nErr; } } // namespace maple \ No newline at end of file diff --git a/src/maple_driver/src/mpl_options.cpp b/src/maple_driver/src/mpl_options.cpp index d7ac623110dce28c897ca80ff55f418617cfba8f..9b5a6257a8b9e692b2d437e62b89cd60eff542e5 100644 --- a/src/maple_driver/src/mpl_options.cpp +++ b/src/maple_driver/src/mpl_options.cpp @@ -250,7 +250,7 @@ ErrorCode MplOptions::CheckFileExits() { std::ifstream infile; infile.open(fileName); if (infile.fail()) { - LogInfo::MapleLogger(kLlErr) << "Cannot open input file " << fileName << std::endl; + LogInfo::MapleLogger(kLlErr) << "Cannot open input file " << fileName << '\n'; ret = ErrorCode::kErrorFileNotFound; return ret; } @@ -314,10 +314,6 @@ const std::string MplOptions::OptimizationLevelStr() const { } } -void MplOptions::UpdateOptLevel(OptimizationLevel level) { - this->optimizationLevel = level; -} - ErrorCode MplOptions::AppendDefaultCombOptions() { ErrorCode ret = ErrorCode::kErrorNoError; if (optimizationLevel == kO0) { @@ -343,10 +339,9 @@ ErrorCode MplOptions::AppendDefaultCgOptions() { } ErrorCode MplOptions::AppendDefaultOptions(const std::string &exeName, MplOption mplOptions[], unsigned int length) { - bool ret = true; auto &exeOption = exeOptions[exeName]; for (unsigned int i = 0; i < length; i++) { - ret = optionParser->SetOption(mplOptions[i].key, mplOptions[i].value, exeName, exeOption); + bool ret = optionParser->SetOption(mplOptions[i].GetKey(), mplOptions[i].GetValue(), exeName, exeOption); if (!ret) { return ErrorCode::kErrorInvalidParameter; } @@ -376,13 +371,13 @@ ErrorCode MplOptions::UpdatePhaseOption(const std::string &args, const std::stri // For compiler bins called by system() auto &extraOption = extras[exeName]; for (size_t i = 0; i < exeOption.size(); i++) { - MplOption mplOption; if (exeOption[i].Args() != "") { - mplOption.init("-" + exeOption[i].OptionKey(), exeOption[i].Args(), "=", false, ""); + MplOption mplOption("-" + exeOption[i].OptionKey(), exeOption[i].Args(), "=", false, ""); + extraOption.push_back(mplOption); } else { - mplOption.init("-" + exeOption[i].OptionKey(), "", " ", false, ""); + MplOption mplOption("-" + exeOption[i].OptionKey(), "", " ", false, ""); + extraOption.push_back(mplOption); } - extraOption.push_back(mplOption); } return ret; } @@ -393,7 +388,7 @@ ErrorCode MplOptions::UpdateExtraOptionOpt(const std::string &args) { if (temp.size() != extras.size() && temp.size() != runningExes.size()) { // parameter not match ignore LogInfo::MapleLogger(kLlErr) << "The --run and --option are not matched, please check them.(Too many ':'?)" - << std::endl; + << '\n'; return ErrorCode::kErrorInvalidParameter; } auto settingExe = runningExes.begin(); diff --git a/src/maple_driver/src/mplcg_compiler.cpp b/src/maple_driver/src/mplcg_compiler.cpp index 6d463adc92d322d26a50fe89a94503e2302e5768..591e1845d60cf74cb5d413883f06dc84892df6d9 100644 --- a/src/maple_driver/src/mplcg_compiler.cpp +++ b/src/maple_driver/src/mplcg_compiler.cpp @@ -21,7 +21,7 @@ using namespace maple; const DefaultOption MplcgCompiler::GetDefaultOptions(const MplOptions &options) { DefaultOption defaultOptions = { nullptr, 0 }; - if (options.optimizationLevel == kO0 && options.setDefaultLevel) { + if (options.GetOptimizationLevel() == kO0 && options.GetSetDefaultLevel()) { defaultOptions.mplOptions = kMplcgDefaultOptionsO0; defaultOptions.length = sizeof(kMplcgDefaultOptionsO0) / sizeof(MplOption); } @@ -39,11 +39,11 @@ const std::vector MplcgCompiler::GetBinNames() const { } const std::string MplcgCompiler::GetInputFileName(const MplOptions &options) const { - std::string::size_type idx = options.outputName.find(".VtableImpl"); - std::string outputName = options.outputName; + std::string::size_type idx = options.GetOutputName().find(".VtableImpl"); + std::string outputName = options.GetOutputName(); if (idx != std::string::npos) { - outputName = options.outputName.substr(0, idx); + outputName = options.GetOutputName().substr(0, idx); } - return options.outputFolder + outputName + ".VtableImpl.mpl"; + return options.GetOutputFolder() + outputName + ".VtableImpl.mpl"; } diff --git a/src/maple_ipa/include/module_phase_manager.h b/src/maple_ipa/include/module_phase_manager.h index e0c977dfed7a6715c3d99da4b837a1fba61974fd..477f004498c50c1ed3ad917aae31fb2fc4572dc7 100644 --- a/src/maple_ipa/include/module_phase_manager.h +++ b/src/maple_ipa/include/module_phase_manager.h @@ -36,7 +36,7 @@ class DoKlassHierarchy : public ModulePhase { class ModulePhaseManager : public PhaseManager { public: ModulePhaseManager(MemPool *memPool, MIRModule &mod, ModuleResultMgr *mrm = nullptr) - : PhaseManager(memPool, "modulephase"), mirModule(mod) { + : PhaseManager(*memPool, "modulephase"), mirModule(mod) { if (mrm != nullptr) { arModuleMgr = mrm; } else { diff --git a/src/maple_ipa/src/interleaved_manager.cpp b/src/maple_ipa/src/interleaved_manager.cpp index 408938c31fc547b8e8ec4b6405a461a51f3f61f0..cff0314566bb3e7b3592dce6dd2378433add8103 100644 --- a/src/maple_ipa/src/interleaved_manager.cpp +++ b/src/maple_ipa/src/interleaved_manager.cpp @@ -49,7 +49,7 @@ void InterleavedManager::AddPhases(const std::vector &phases, bool MeFuncPhaseManager *fpm = GetMempool()->New(GetMempool(), mirModule, mrm); fpm->RegisterFuncPhases(); if (genMpl) { - fpm->SetGenMempool(true); + fpm->SetGenMeMpl(true); } if (timePhases) { fpm->SetTimePhases(true); @@ -61,7 +61,7 @@ void InterleavedManager::AddPhases(const std::vector &phases, bool void InterleavedManager::Run() { - for (PhaseManager * const &pm : phaseManagers) { + for (auto *pm : phaseManagers) { if (pm == nullptr) { continue; } @@ -96,7 +96,7 @@ void InterleavedManager::Run() { fpm->Run(func, rangeNum, meInput); rangeNum++; } - if (fpm->GetGenMempool()) { + if (fpm->GetGenMeMpl()) { mirModule.Emit("comb.me.mpl"); } } else { diff --git a/src/maple_ipa/src/module_phase_manager.cpp b/src/maple_ipa/src/module_phase_manager.cpp index ac2f772b990e88334c9220aa1cabd6b883253a1a..f9e0fc07250f7d892d256154e7f4700560a7ef52 100644 --- a/src/maple_ipa/src/module_phase_manager.cpp +++ b/src/maple_ipa/src/module_phase_manager.cpp @@ -34,7 +34,7 @@ namespace maple { // Manage the phases of middle and implement some maplecomb-options such as // skipAfter, skipFrom, quiet. AnalysisResult *DoKlassHierarchy::Run(MIRModule *module, ModuleResultMgr *m) { - MemPool *memPool = mempoolctrler.NewMemPool("classhierarchy mempool"); + MemPool *memPool = memPoolCtrler.NewMemPool("classhierarchy mempool"); KlassHierarchy *kh = memPool->New(module, memPool); KlassHierarchy::traceFlag = TRACE_PHASE; kh->BuildHierarchy(); @@ -72,7 +72,7 @@ void ModulePhaseManager::RegisterModulePhases() { void ModulePhaseManager::AddModulePhases(const std::vector &phases) { for (std::string const &phase : phases) { - AddPhase(phase.c_str()); + AddPhase(phase); } } diff --git a/src/maple_ir/include/bin_mpl_export.h b/src/maple_ir/include/bin_mpl_export.h index 66ee4a56671bfdbe6824ded04ddcbd47276147f8..2a189c9c64d4a3cce8db5cb8b10b169e684bd708 100644 --- a/src/maple_ir/include/bin_mpl_export.h +++ b/src/maple_ir/include/bin_mpl_export.h @@ -84,7 +84,7 @@ class BinaryMplExport { void OutputConstBase(const MIRConst &c); void OutputStr(const GStrIdx &gstr); void OutputUsrStr(UStrIdx ustr); - void OutputTypePairs(MIRInstantVectorType &typ); + void OutputTypePairs(const MIRInstantVectorType &typ); void OutputTypeBase(const MIRType &type); void OutputType(const TyIdx &tyIdx); void OutputTypeAttrs(const TypeAttrs &ta); diff --git a/src/maple_ir/include/bin_mpl_import.h b/src/maple_ir/include/bin_mpl_import.h index 3cf261a446890eb394eeba7faf76a49f2a29ba5e..39a032106afe98c8c0f103865fd76f05ce19e3d0 100644 --- a/src/maple_ir/include/bin_mpl_import.h +++ b/src/maple_ir/include/bin_mpl_import.h @@ -90,7 +90,7 @@ class BinaryMplImport { TyIdx ImportType(bool forPointedType = false); void ImportTypeBase(PrimType &primType, GStrIdx &strIdx, bool &nameIsLocal); void InSymTypeTable(); - void ImportTypePairs(std::vector &tpairs); + void ImportTypePairs(MIRInstantVectorType &insVecType); TypeAttrs ImportTypeAttrs(); MIRPragmaElement *ImportPragmaElement(); MIRPragma *ImportPragma(); diff --git a/src/maple_ir/include/global_tables.h b/src/maple_ir/include/global_tables.h index 523d7ebae90095686d77e6bf7879f23f3f4d57e1..deaae238f2c6572f26d2d621d667706fed96cd68 100644 --- a/src/maple_ir/include/global_tables.h +++ b/src/maple_ir/include/global_tables.h @@ -404,8 +404,14 @@ class FPConstTable { void PostInit(); std::unordered_map floatConstTable; // map float const value to the table; std::unordered_map doubleConstTable; // map double const value to the table; - MIRFloatConst *nanFloatConst, *infFloatConst, *minusInfFloatConst, *minusZeroFloatConst; - MIRDoubleConst *nanDoubleConst, *infDoubleConst, *minusInfDoubleConst, *minusZeroDoubleConst; + MIRFloatConst *nanFloatConst = nullptr; + MIRFloatConst *infFloatConst = nullptr; + MIRFloatConst *minusInfFloatConst = nullptr; + MIRFloatConst *minusZeroFloatConst = nullptr; + MIRDoubleConst *nanDoubleConst = nullptr; + MIRDoubleConst *infDoubleConst = nullptr; + MIRDoubleConst *minusInfDoubleConst = nullptr; + MIRDoubleConst *minusZeroDoubleConst = nullptr; }; // STypeNameTable is only used to store class and interface types. diff --git a/src/maple_ir/include/lexer.h b/src/maple_ir/include/lexer.h index 9a2e5bff46e5b9dc9230b4bf97cc4814cb2c82fa..dc13bc19888979edd4ffca27ac7a9dd5af2a0c59 100644 --- a/src/maple_ir/include/lexer.h +++ b/src/maple_ir/include/lexer.h @@ -37,7 +37,7 @@ class MIRLexer { void PrepareForFile(const std::string &filename); void PrepareForString(const std::string &src); - TokenKind NextToken(void); + TokenKind NextToken(); TokenKind LexToken(); TokenKind GetTokenKind() const { return kind; diff --git a/src/maple_ir/include/metadata_layout.h b/src/maple_ir/include/metadata_layout.h index fde800e54389ccd2370c0871223d2e062a283965..19f739d682eefc4fee8bedbae727cefef1dd28a4 100644 --- a/src/maple_ir/include/metadata_layout.h +++ b/src/maple_ir/include/metadata_layout.h @@ -60,34 +60,17 @@ static inline void EncodeValueAsRelOffset64(const void *value, int64_t *addr) { } } -template -struct BaseDataRefOffset { - INT refOffset; - - void* DecodeDataRef() const { - intptr_t ref = static_cast(refOffset); - ref += reinterpret_cast(this); - return reinterpret_cast(ref); - } -}; - -// specialized for int32_t, check for out-of-boundary -struct DataRefOffset32 : public BaseDataRefOffset { - void EncodeDataRef(void* ref) { - intptr_t offset = reinterpret_cast(ref) - reinterpret_cast(this); - if (INT32_MIN <= offset && offset <= INT32_MAX) { - refOffset = static_cast(offset); - } else { - std::abort(); - } - } +struct DataRefOffset32 { + int32_t refOffset; + inline void SetDataRef(void *ref); + inline void *GetDataRef() const; }; // DataRefOffset is meant to have pointer size. -struct DataRefOffset : public BaseDataRefOffset { - void EncodeDataRef(void* ref) { - refOffset = reinterpret_cast(ref) - reinterpret_cast(this); - } +struct DataRefOffset { + intptr_t refOffset; + inline void SetDataRef(void *ref); + inline void *GetDataRef() const; }; /* DataRef aims for reference to data generated by maple compiler. @@ -109,19 +92,18 @@ enum DataRefFormat { kDataRefBitMask = 3, }; -// specialized for int32_t, check for out-of-boundary struct DataRef32 { // be careful when *refVal* is treated as an offset which is a signed integer actually. uint32_t refVal; - void *DecodeDataRef() const; - void EncodeDataRef(void* ref, DataRefFormat format = kDataRefIsDirect); + inline void *GetDataRef() const; + inline void SetDataRef(void *ref, DataRefFormat format = kDataRefIsDirect); }; // DataRef is meant to have pointer size. struct DataRef { void *refVal; - void *DecodeDataRef() const; - void EncodeDataRef(void *ref, DataRefFormat format = kDataRefIsDirect); + inline void *GetDataRef() const; + inline void SetDataRef(void *ref, DataRefFormat format = kDataRefIsDirect); }; // MethodMeta defined in MethodMeta.h @@ -146,9 +128,9 @@ struct ClassMetadataRO { int64_t fields; // point to info of fields int64_t methods; // point to info of methods union { // Element classinfo of array, others parent classinfo - struct ClassMetadata **superclass; + DataRef superclass; struct ClassMetadata *componentClass; - } familyClass; + }; uint16_t numOfFields; uint16_t numOfMethods; diff --git a/src/maple_ir/include/mir_const.h b/src/maple_ir/include/mir_const.h index f594de91448cd42dca03576a1693e6c24cbec9b7..86596d8fa75e9a1686cccf1536bde03070529ead 100644 --- a/src/maple_ir/include/mir_const.h +++ b/src/maple_ir/include/mir_const.h @@ -53,15 +53,15 @@ class MIRConst { fieldID = fieldIdx; } - virtual bool IsZero() { + virtual bool IsZero() const { return false; } - virtual bool IsOne() { + virtual bool IsOne() const { return false; } - virtual bool IsMagicNum() { + virtual bool IsMagicNum() const { return false; } @@ -151,18 +151,18 @@ class MIRIntConst : public MIRConst { } void Dump() const; - bool IsZero() { + bool IsZero() const { return value == 0 && IsPrimitiveInteger(GetType().GetPrimType()); } - bool IsOne() { + bool IsOne() const { return value == 1 && IsPrimitiveInteger(GetType().GetPrimType()); }; - bool IsMagicNum() { + bool IsMagicNum() const { constexpr int64 kMagicNum = 51; return value == kMagicNum && IsPrimitiveInteger(GetType().GetPrimType()); }; - bool IsAllBitsOne() { + bool IsAllBitsOne() const { return value == -1 && IsPrimitiveInteger(GetType().GetPrimType()); }; void Neg() { @@ -329,14 +329,14 @@ class MIRFloatConst : public MIRConst { } void Dump() const; - bool IsZero() { + bool IsZero() const { return fabs(value.floatValue) <= 1e-6; } - bool IsOne() { + bool IsOne() const { return value.floatValue == 1; }; - bool IsAllBitsOne() { + bool IsAllBitsOne() const { return value.floatValue == -1; }; void Neg() { @@ -386,14 +386,14 @@ class MIRDoubleConst : public MIRConst { } void Dump() const; - bool IsZero() { + bool IsZero() const { return fabs(value.dValue) <= 1e-15; } - bool IsOne() { + bool IsOne() const { return value.dValue == 1; }; - bool IsAllBitsOne() { + bool IsAllBitsOne() const { return value.dValue == -1; }; void Neg() { @@ -427,16 +427,16 @@ class MIRFloat128Const : public MIRConst { return kPrimType; } - bool IsZero() { + bool IsZero() const { MIR_ASSERT(value && "value must not be nullptr!"); return value[0] == 0 && value[1] == 0; } - bool IsOne() { + bool IsOne() const { MIR_ASSERT(value && "value must not be nullptr!"); return value[0] == 0 && value[1] == 0x3FFF000000000000; }; - bool IsAllBitsOne() { + bool IsAllBitsOne() const { MIR_ASSERT(value && "value must not be nullptr!"); return (value[0] == 0xffffffffffffffff && value[1] == 0xffffffffffffffff); }; @@ -515,7 +515,7 @@ class MIRStConst : public MIRConst { const MapleVector &GetStVec() const { return stVec; } - void PushbackSt(MIRSymbol *sym) { + void PushbackSymbolToSt(MIRSymbol *sym) { stVec.push_back(sym); } @@ -527,7 +527,7 @@ class MIRStConst : public MIRConst { const MapleVector &GetStOffsetVec() const { return stOffsetVec; } - void PushbackStOffset(uint32 offset) { + void PushbackOffsetToSt(uint32 offset) { stOffsetVec.push_back(offset); } diff --git a/src/maple_ir/include/mir_function.h b/src/maple_ir/include/mir_function.h index 30c366b62063fe62f3eb6223a80b1a31aa92008c..aa6f59a9911ecacbc366c77b13a04fc676fd9d49 100644 --- a/src/maple_ir/include/mir_function.h +++ b/src/maple_ir/include/mir_function.h @@ -69,9 +69,9 @@ class MIRFunction { retRefSym(mod->GetMPAllocator().Adapter()), argumentsTyIdx(mod->GetMPAllocator().Adapter()), argumentsAttrs(mod->GetMPAllocator().Adapter()), - dataMemPool(mempoolctrler.NewMemPool("func data mempool")), + dataMemPool(memPoolCtrler.NewMemPool("func data mempool")), dataMPAllocator(dataMemPool), - codeMemPool(mempoolctrler.NewMemPool("func code mempool")), + codeMemPool(memPoolCtrler.NewMemPool("func code mempool")), codeMemPoolAllocator(codeMemPool), info(mod->GetMPAllocator().Adapter()), infoIsString(mod->GetMPAllocator().Adapter()), @@ -100,10 +100,10 @@ class MIRFunction { // 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()); + 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()); + labelTab = module->GetMemPool()->New(module->GetMPAllocator()); } void Dump(bool withoutBody = false); diff --git a/src/maple_ir/include/mir_nodes.h b/src/maple_ir/include/mir_nodes.h index a04244c2f3c8028204707be7df9ef34e8eaa2800..a7fcf0e23f3e2df56f9b831ff861a595cf9eafde 100644 --- a/src/maple_ir/include/mir_nodes.h +++ b/src/maple_ir/include/mir_nodes.h @@ -167,6 +167,14 @@ class BaseNode { return false; } + virtual bool IsTernaryNode() const { + return false; + } + + virtual bool IsNaryNode() const { + return false; + } + bool IsCondBr() const { return kOpcodeInfo.IsCondBr(GetOpCode()); } @@ -739,10 +747,10 @@ class TernaryNode : public BaseNode { ~TernaryNode() = default; - void Dump(const MIRModule &mod, int32 indent) const; - bool Verify() const; + void Dump(const MIRModule &mod, int32 indent) const override; + bool Verify() const override; - TernaryNode *CloneTree(MapleAllocator &allocator) const { + TernaryNode *CloneTree(MapleAllocator &allocator) const override { TernaryNode *nd = allocator.GetMemPool()->New(*this); nd->topnd[0] = topnd[0]->CloneTree(allocator); nd->topnd[1] = topnd[1]->CloneTree(allocator); @@ -750,24 +758,28 @@ class TernaryNode : public BaseNode { return nd; } - BaseNode *Opnd(size_t i) const { + BaseNode *Opnd(size_t i) const override { CHECK_FATAL(i < kOperandNumTernary, "array index out of range"); return topnd[i]; } - uint8 NumOpnds(void) const { + uint8 NumOpnds(void) const override { return kOperandNumTernary; } - void SetOpnd(BaseNode *node, size_t i = 0) { + void SetOpnd(BaseNode *node, size_t i = 0) override { CHECK_FATAL(i < kOperandNumTernary, "array index out of range"); topnd[i] = node; } - bool IsLeaf(void) const { + bool IsLeaf(void) const override { return false; } + bool IsTernaryNode() const override { + return true; + } + private: BaseNode *topnd[kOperandNumTernary]; }; @@ -830,9 +842,9 @@ class NaryNode : public BaseNode, public NaryOpnds { NaryNode &operator=(const NaryNode &node) = delete; ~NaryNode() = default; - virtual void Dump(const MIRModule &mod, int32 indent) const; + virtual void Dump(const MIRModule &mod, int32 indent) const override; - NaryNode *CloneTree(MapleAllocator &allocator) const { + NaryNode *CloneTree(MapleAllocator &allocator) const override { NaryNode *nd = allocator.GetMemPool()->New(allocator, *this); for (size_t i = 0; i < GetNopndSize(); i++) { nd->GetNopnd().push_back(GetNopndAt(i)->CloneTree(allocator)); @@ -840,25 +852,29 @@ class NaryNode : public BaseNode, public NaryOpnds { return nd; } - BaseNode *Opnd(size_t i) const { + BaseNode *Opnd(size_t i) const override { return GetNopndAt(i); } - uint8 NumOpnds(void) const { + uint8 NumOpnds(void) const override { ASSERT(numOpnds == GetNopndSize(), "NaryNode has wrong numOpnds field"); return GetNopndSize(); } - void SetOpnd(BaseNode *node, size_t i = 0) { + void SetOpnd(BaseNode *node, size_t i = 0) override { ASSERT(i < GetNopnd().size(), "array index out of range"); SetNOpndAt(i, node); } - bool IsLeaf(void) const { + bool IsLeaf(void) const override { return false; } - bool Verify() const { + bool Verify() const override { + return true; + } + + bool IsNaryNode() const override { return true; } }; @@ -1129,13 +1145,13 @@ class ArrayNode : public NaryNode { return nd; } - MIRType *GetArrayType(TypeTable &tt) const; + MIRType *GetArrayType(const TypeTable &tt) const; BaseNode *GetIndex(size_t i) { return Opnd(i + 1); } - BaseNode *GetDim(const MIRModule &mod, TypeTable &tt, int i); + BaseNode *GetDim(const MIRModule &mod, const TypeTable &tt, int i) const; BaseNode *GetBase() { return Opnd(0); } @@ -1179,7 +1195,7 @@ class AddrofNode : public BaseNode { return allocator.GetMemPool()->New(*this); } - const StIdx &GetStIdx() const { + StIdx GetStIdx() const { return stIdx; } @@ -1226,14 +1242,9 @@ class RegreadNode : public BaseNode { return allocator.GetMemPool()->New(*this); } - const PregIdx &GetRegIdx() const { + PregIdx GetRegIdx() const { return regIdx; } - - PregIdx &GetRegIdx() { - return regIdx; - } - void SetRegIdx(PregIdx reg) { regIdx = reg; } @@ -1680,7 +1691,7 @@ class CatchNode : public StmtNode { return exceptionTyIdxVec[i]; } - MapleVector &GetExceptionTyIdxVec() { + const MapleVector &GetExceptionTyIdxVec() const { return exceptionTyIdxVec; } @@ -1981,11 +1992,9 @@ class DassignNode : public UnaryStmtNode { UnaryStmtNode::SetOpnd(rhs, 0); } - - const StIdx &GetStIdx() const { + StIdx GetStIdx() const { return stIdx; } - void SetStIdx(StIdx s) { stIdx = s; } @@ -2032,14 +2041,9 @@ class RegassignNode : public UnaryStmtNode { UnaryStmtNode::SetOpnd(rhs, 0); } - PregIdx &GetRegIdx() { + PregIdx GetRegIdx() const { return regIdx; } - - const PregIdx &GetRegIdx() const { - return regIdx; - } - void SetRegIdx(PregIdx idx) { regIdx = idx; } @@ -2083,29 +2087,29 @@ class CondGotoNode : public UnaryStmtNode { using SmallCasePair = std::pair; using SmallCaseVector = MapleVector; -class RangegotoNode : public UnaryStmtNode { +class RangeGotoNode : public UnaryStmtNode { public: - explicit RangegotoNode(MapleAllocator &allocator) + explicit RangeGotoNode(MapleAllocator &allocator) : UnaryStmtNode(OP_rangegoto), tagOffset(0), rangegotoTable(allocator.Adapter()) {} - explicit RangegotoNode(const MIRModule &mod) : RangegotoNode(mod.GetCurFuncCodeMPAllocator()) {} + explicit RangeGotoNode(const MIRModule &mod) : RangeGotoNode(mod.GetCurFuncCodeMPAllocator()) {} - RangegotoNode(MapleAllocator &allocator, const RangegotoNode &node) + RangeGotoNode(MapleAllocator &allocator, const RangeGotoNode &node) : UnaryStmtNode(node.GetOpCode(), node.GetPrimType()), tagOffset(node.tagOffset), rangegotoTable(allocator.Adapter()) {} - RangegotoNode(const MIRModule &mod, const RangegotoNode &node) - : RangegotoNode(mod.GetCurFuncCodeMPAllocator(), node) {} + RangeGotoNode(const MIRModule &mod, const RangeGotoNode &node) + : RangeGotoNode(mod.GetCurFuncCodeMPAllocator(), node) {} - RangegotoNode(RangegotoNode &node) = delete; - RangegotoNode &operator=(const RangegotoNode &node) = delete; - ~RangegotoNode() = default; + RangeGotoNode(RangeGotoNode &node) = delete; + RangeGotoNode &operator=(const RangeGotoNode &node) = delete; + ~RangeGotoNode() = default; void Dump(const MIRModule &mod, int32 indent) const; bool Verify() const; - RangegotoNode *CloneTree(MapleAllocator &allocator) const { - RangegotoNode *nd = allocator.GetMemPool()->New(allocator, *this); + RangeGotoNode *CloneTree(MapleAllocator &allocator) const { + RangeGotoNode *nd = allocator.GetMemPool()->New(allocator, *this); nd->SetOpnd(Opnd()->CloneTree(allocator)); for (size_t i = 0; i < rangegotoTable.size(); i++) { nd->rangegotoTable.push_back(rangegotoTable[i]); diff --git a/src/maple_ir/include/mir_parser.h b/src/maple_ir/include/mir_parser.h index ac416d6ebd8a016bdfcb39db53447001bbcd1024..df3f53a4dddfae3474d3d583f87f95500849c7c7 100644 --- a/src/maple_ir/include/mir_parser.h +++ b/src/maple_ir/include/mir_parser.h @@ -97,7 +97,7 @@ class MIRParser { bool ParseTypeParam(TyIdx &tyIdx); bool ParsePointType(TyIdx &tyIdx); bool ParseFuncType(TyIdx &tyIdx); - bool ParseGenericInstantVector(GenericInstantVector&); + bool ParseGenericInstantVector(MIRInstantVectorType &insVecType); bool ParseDerivedType(TyIdx &tyIdx, MIRTypeKind kind = kTypeUnknown); bool ParseType(TyIdx &tyIdx); bool ParseStatement(StmtNodePtr &stmt); diff --git a/src/maple_ir/include/mir_pragma.h b/src/maple_ir/include/mir_pragma.h index 96f7953c82b4cf5132e22af10b39b25dab438c1d..93a5fbaa048303ae6c93f06d6d88434bb8ebb262 100644 --- a/src/maple_ir/include/mir_pragma.h +++ b/src/maple_ir/include/mir_pragma.h @@ -78,8 +78,8 @@ class MIRPragmaElement { ~MIRPragmaElement() = default; void Dump(int indent) const; - void PushSubElemVec(MIRPragmaElement &elem) { - subElemVec.push_back(&elem); + void SubElemVecPushBack(MIRPragmaElement *elem) { + subElemVec.push_back(elem); } const MapleVector &GetSubElemVec() const { @@ -232,6 +232,10 @@ class MIRPragma { return elementVec; } + void ElementVecPushBack(MIRPragmaElement *elem) { + elementVec.push_back(elem); + } + void SetKind(PragmaKind kind) { pragmaKind = kind; } diff --git a/src/maple_ir/include/mir_symbol.h b/src/maple_ir/include/mir_symbol.h index 14e1820594feaf0b7306d335151c4e1af259b0c7..2defc694069d4afd7c106402cd3f6337276989cb 100644 --- a/src/maple_ir/include/mir_symbol.h +++ b/src/maple_ir/include/mir_symbol.h @@ -116,7 +116,7 @@ class MIRSymbol { isImported = imported; } - bool GetIsImported() { + bool GetIsImported() const { return isImported; } @@ -185,16 +185,16 @@ class MIRSymbol { typeAttrs.SetAttrFlag(typeAttrs.GetAttrFlag() | attr.GetAttrFlag()); } - bool GetAttr(AttrKind x) const { - return typeAttrs.GetAttr(x); + bool GetAttr(AttrKind attrKind) const { + return typeAttrs.GetAttr(attrKind); } - void SetAttr(AttrKind x) { - typeAttrs.SetAttr(x); + void SetAttr(AttrKind attrKind) { + typeAttrs.SetAttr(attrKind); } - void ResetAttr(AttrKind x) { - typeAttrs.ResetAttr(x); + void ResetAttr(AttrKind attrKind) { + typeAttrs.ResetAttr(attrKind); } bool IsVolatile() const { @@ -352,7 +352,7 @@ class MIRSymbol { bool IsRegJNIFuncTab() const; bool IsMuidTab() const; bool IsCodeLayoutInfo() const; - std::string GetMuidTabName(); + std::string GetMuidTabName() const; bool IsMuidFuncDefTab() const; bool IsMuidFuncDefOrigTab() const; bool IsMuidFuncInfTab() const; @@ -403,8 +403,8 @@ class MIRSymbol { class MIRSymbolTable { public: - explicit MIRSymbolTable(MapleAllocator *allocator) - : mAllocator(allocator), strIdxToStIdxMap(mAllocator->Adapter()), symbolTable(mAllocator->Adapter()) { + explicit MIRSymbolTable(MapleAllocator &allocator) + : mAllocator(allocator), strIdxToStIdxMap(mAllocator.Adapter()), symbolTable(mAllocator.Adapter()) { symbolTable.push_back(nullptr); } @@ -423,7 +423,7 @@ class MIRSymbolTable { } MIRSymbol *CreateSymbol(uint8 scopeID) { - MIRSymbol *st = mAllocator->GetMemPool()->New(symbolTable.size(), scopeID); + MIRSymbol *st = mAllocator.GetMemPool()->New(symbolTable.size(), scopeID); symbolTable.push_back(st); return st; } @@ -469,7 +469,7 @@ class MIRSymbolTable { } private: - MapleAllocator *mAllocator; + MapleAllocator mAllocator; // hash table mapping string index to st index MapleMap strIdxToStIdxMap; // map symbol idx to symbol node @@ -478,10 +478,10 @@ class MIRSymbolTable { class MIRLabelTable { public: - explicit MIRLabelTable(MapleAllocator *allocator) + explicit MIRLabelTable(MapleAllocator &allocator) : mAllocator(allocator), - strIdxToLabIdxMap(std::less(), mAllocator->Adapter()), - labelTable(mAllocator->Adapter()) { + strIdxToLabIdxMap(std::less(), mAllocator.Adapter()), + labelTable(mAllocator.Adapter()) { labelTable.push_back(GStrIdx(kDummyLabel)); // push dummy label index 0 } @@ -545,7 +545,7 @@ class MIRLabelTable { private: static constexpr uint32 kDummyLabel = 0; - MapleAllocator *mAllocator; + MapleAllocator mAllocator; MapleMap strIdxToLabIdxMap; MapleVector labelTable; // map label idx to label name }; diff --git a/src/maple_ir/include/mir_type.h b/src/maple_ir/include/mir_type.h index bf6b972ba2d1d4af2f1fb079e28aa0d2a9f2b95e..3234c2ad3b31ecb4dab9e32b23bd00123d48c92c 100644 --- a/src/maple_ir/include/mir_type.h +++ b/src/maple_ir/include/mir_type.h @@ -1514,13 +1514,14 @@ class MIRInstantVectorType : public MIRType { return 0; } // size unknown - GenericInstantVector &GetInstantVec() { - return instantVec; - } const GenericInstantVector &GetInstantVec() const { return instantVec; } + void AddInstant(TypePair typePair) { + instantVec.push_back(typePair); + } + size_t GetHashIndex() const override { uint32 hidx = typeKind << kShiftNumOfTypeKind; for (TypePair typePair : instantVec) { diff --git a/src/maple_ir/include/opcodes.def b/src/maple_ir/include/opcodes.def index 8559c1f45478e7c4d4843c9385c9e54d134b5f45..07a79fcb8899f1a834bf855103a80ad0b3dc0ef4 100644 --- a/src/maple_ir/include/opcodes.def +++ b/src/maple_ir/include/opcodes.def @@ -54,7 +54,7 @@ OPCODE(brfalse, CondGotoNode, OPCODEISSTMT, 8) OPCODE(brtrue, CondGotoNode, OPCODEISSTMT, 8) OPCODE(return, NaryStmtNode, (OPCODEISSTMT | OPCODEISVARSIZE | OPCODEHASSSAUSE), 0) - OPCODE(rangegoto, RangegotoNode, OPCODEISSTMT, 8) + OPCODE(rangegoto, RangeGotoNode, OPCODEISSTMT, 8) // call opcodes OPCODE(call, CallNode, (OPCODEISSTMT | OPCODEISVARSIZE | OPCODEHASSSAUSE | OPCODEHASSSADEF | OPCODEISCALL), 8) OPCODE(virtualcall, CallNode, (OPCODEISSTMT | OPCODEISVARSIZE | OPCODEHASSSAUSE | OPCODEHASSSADEF | OPCODEISCALL), 8) diff --git a/src/maple_ir/include/option.h b/src/maple_ir/include/option.h index 73afa1d39e063bb485a78c5f49803ae8905845e6..693c793db66ebc4da5847d472d2073012bf51c4f 100644 --- a/src/maple_ir/include/option.h +++ b/src/maple_ir/include/option.h @@ -33,7 +33,7 @@ class Options { explicit Options(maple::MemPool &memPool) : optionAlloc(&memPool) {} bool ParseOptions(int argc, char **argv, std::string &fileName); - ~Options() {} + ~Options() = default; void DumpOptions(); std::vector &GetSequence() { diff --git a/src/maple_ir/src/bin_mpl_export.cpp b/src/maple_ir/src/bin_mpl_export.cpp index 1a8a8cdb1e12c2c91b5c02686c096cce4c9b54c8..25ac37b410b12f0824b71d055136381f99fa2c50 100644 --- a/src/maple_ir/src/bin_mpl_export.cpp +++ b/src/maple_ir/src/bin_mpl_export.cpp @@ -724,12 +724,12 @@ void BinaryMplExport::AppendAt(const std::string &name, int32 offset) { } } -void BinaryMplExport::OutputTypePairs(MIRInstantVectorType &type) { +void BinaryMplExport::OutputTypePairs(const MIRInstantVectorType &type) { size_t size = type.GetInstantVec().size(); WriteNum(size); - for (TypePair &tpair : type.GetInstantVec()) { - OutputType(tpair.first); - OutputType(tpair.second); + for (const TypePair &typePair : type.GetInstantVec()) { + OutputType(typePair.first); + OutputType(typePair.second); } } diff --git a/src/maple_ir/src/bin_mpl_import.cpp b/src/maple_ir/src/bin_mpl_import.cpp index 2d34eea7c158660cca387ae6b716661b2fd5394d..83694fe8b6c035add0efe29dff944059de3ca16f 100644 --- a/src/maple_ir/src/bin_mpl_import.cpp +++ b/src/maple_ir/src/bin_mpl_import.cpp @@ -115,7 +115,7 @@ MIRConst *BinaryMplImport::ImportConst(MIRFunction *func) { } else if (tag == kBinKindConstAddrof) { ImportConstBase(kind, type, fieldID); MIRSymbol *sym = InSymbol(func); - ASSERT(sym != nullptr, "null ptr check"); + CHECK_FATAL(sym != nullptr, "null ptr check"); FieldID fi = ReadNum(); return memPool->New(sym->GetStIdx(), fi, *type); } else if (tag == kBinKindConstAddrofFunc) { @@ -169,15 +169,15 @@ MIRConst *BinaryMplImport::ImportConst(MIRFunction *func) { MIRStConst *stConst = mod.GetMemPool()->New(mod, *type); int64 size = ReadNum(); for (int64 i = 0; i < size; i++) { - stConst->PushbackSt(InSymbol(func)); + stConst->PushbackSymbolToSt(InSymbol(func)); } size = ReadNum(); for (int64 i = 0; i < size; i++) { - stConst->PushbackStOffset(ReadNum()); + stConst->PushbackOffsetToSt(ReadNum()); } return stConst; } else { - ASSERT(false, "Unhandled const type"); + CHECK_FATAL(false, "Unhandled const type"); } return nullptr; } @@ -190,7 +190,7 @@ GStrIdx BinaryMplImport::ImportStr() { CHECK_FATAL(-tag < static_cast(gStrTab.size()), "index out of range in BinaryMplt::ImportStr"); return gStrTab[-tag]; } else { - ASSERT(tag == kBinString, "expecting kBinString"); + CHECK_FATAL(tag == kBinString, "expecting kBinString"); std::string str; ReadAsciiStr(str); GStrIdx strIdx = GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(str); @@ -207,7 +207,7 @@ UStrIdx BinaryMplImport::ImportUsrStr() { CHECK_FATAL(-tag < static_cast(uStrTab.size()), "index out of range in BinaryMplt::InUsrStr"); return uStrTab[-tag]; } else { - ASSERT(tag == kBinUsrString, "expecting kBinUsrString"); + CHECK_FATAL(tag == kBinUsrString, "expecting kBinUsrString"); std::string str; ReadAsciiStr(str); UStrIdx strIdx = GlobalTables::GetUStrTable().GetOrCreateStrIdxFromName(str); @@ -229,7 +229,7 @@ MIRPragmaElement *BinaryMplImport::ImportPragmaElement() { } int64 size = ReadNum(); for (int64 i = 0; i < size; i++) { - element->PushSubElemVec(*ImportPragmaElement()); + element->SubElemVecPushBack(ImportPragmaElement()); } return element; } @@ -269,7 +269,7 @@ void BinaryMplImport::ImportMethodPair(MethodPair &memPool) { ReadAsciiStr(funcName); TyIdx funcTyidx = ImportType(); int64 x = ReadNum(); - ASSERT(x >= 0, "ReadNum error, x: %d", x); + CHECK_FATAL(x >= 0, "ReadNum error, x: %d", x); uint64 attrFlag = static_cast(x); GStrIdx stridx = GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(funcName); @@ -309,7 +309,7 @@ void BinaryMplImport::ImportMethodPair(MethodPair &memPool) { void BinaryMplImport::UpdateMethodSymbols() { for (auto sym : methodSymbols) { MIRFunction *fn = sym->GetFunction(); - ASSERT(fn != nullptr, "fn is null"); + CHECK_FATAL(fn != nullptr, "fn is null"); MIRFuncType *funcType = static_cast(GlobalTables::GetTypeTable().GetTypeFromTyIdx(sym->GetTyIdx())); fn->SetMIRFuncType(funcType); fn->SetReturnStruct(*GlobalTables::GetTypeTable().GetTypeFromTyIdx(funcType->GetRetTyIdx())); @@ -379,8 +379,8 @@ void BinaryMplImport::ImportInfoOfStructType(MIRStructType &type) { for (int64 i = 0; i < size; i++) { GStrIdx idx = ImportStr(); int64 x = (type.GetInfoIsString()[i]) ? ImportStr().GetIdx() : ReadNum(); - ASSERT(x >= 0, "ReadNum nagative, x: %d", x); - ASSERT(x <= std::numeric_limits::max(), "ReadNum too large, x: %d", x); + CHECK_FATAL(x >= 0, "ReadNum nagative, x: %d", x); + CHECK_FATAL(x <= std::numeric_limits::max(), "ReadNum too large, x: %d", x); if (isEmpty) { type.PushbackMIRInfo(MIRInfoPair(idx, static_cast(x))); } @@ -459,13 +459,13 @@ TypeAttrs BinaryMplImport::ImportTypeAttrs() { return ta; } -void BinaryMplImport::ImportTypePairs(std::vector &tpairs) { +void BinaryMplImport::ImportTypePairs(MIRInstantVectorType &insVecType) { int64 size = ReadNum(); for (int64 i = 0; i < size; i++) { TyIdx t0 = ImportType(); TyIdx t1 = ImportType(); TypePair tp(t0, t1); - tpairs.push_back(tp); + insVecType.AddInstant(tp); } } @@ -497,7 +497,7 @@ TyIdx BinaryMplImport::ImportType(bool forPointedType) { if (tag == 0) { return TyIdx(0); } else if (tag < 0) { - ASSERT(static_cast(-tag) < typTab.size(), "index out of bounds"); + CHECK_FATAL(static_cast(-tag) < typTab.size(), "index out of bounds"); return typTab.at(-tag)->GetTypeIndex(); } bool nameIsLocal = false; @@ -588,14 +588,14 @@ TyIdx BinaryMplImport::ImportType(bool forPointedType) { type.SetNameIsLocal(nameIsLocal); MIRInstantVectorType *origType = static_cast(&InsertInTypeTables(type)); typTab.push_back(origType); - ImportTypePairs(origType->GetInstantVec()); + ImportTypePairs(*origType); return origType->GetTypeIndex(); } else if (tag == kBinKindTypeGenericInstant) { MIRGenericInstantType type(strIdx); type.SetNameIsLocal(nameIsLocal); MIRGenericInstantType *origType = static_cast(&InsertInTypeTables(type)); typTab.push_back(origType); - ImportTypePairs(origType->GetInstantVec()); + ImportTypePairs(*origType); origType->SetGenericTyIdx(ImportType()); return origType->GetTypeIndex(); } else if (tag == kBinKindTypeBitField) { @@ -650,7 +650,7 @@ TyIdx BinaryMplImport::ImportType(bool forPointedType) { } return origType.GetTypeIndex(); } else { - ASSERT(false, "Unexpected binary kind"); + CHECK_FATAL(false, "Unexpected binary kind"); } return TyIdx(0); } @@ -689,7 +689,7 @@ MIRType &BinaryMplImport::InsertInTypeTables(MIRType &type) { } else { // New definition wins type.SetTypeIndex(prevTyIdx); - ASSERT(GlobalTables::GetTypeTable().GetTypeTable().empty() == false, "container check"); + CHECK_FATAL(GlobalTables::GetTypeTable().GetTypeTable().empty() == false, "container check"); GlobalTables::GetTypeTable().SetTypeWithTyIdx(prevTyIdx, type.CopyMIRTypeNode()); resultTypePtr = GlobalTables::GetTypeTable().GetTypeFromTyIdx(prevTyIdx); if (!IsIncomplete(*resultTypePtr)) { @@ -745,10 +745,10 @@ MIRSymbol *BinaryMplImport::InSymbol(MIRFunction *func) { if (tag == 0) { return nullptr; } else if (tag < 0) { - ASSERT(static_cast(-tag) < symTab.size(), "index out of bounds"); + CHECK_FATAL(static_cast(-tag) < symTab.size(), "index out of bounds"); return symTab.at(-tag); } else { - ASSERT(tag == kBinSymbol, "expecting kBinSymbol"); + CHECK_FATAL(tag == kBinSymbol, "expecting kBinSymbol"); int64 scope = ReadNum(); GStrIdx stridx = ImportStr(); MIRSymKind skind = static_cast(ReadNum()); @@ -760,9 +760,9 @@ MIRSymbol *BinaryMplImport::InSymbol(MIRFunction *func) { sym->SetIsTmp(ReadNum() != 0); sym->SetIsImported(imported); if (skind == kStPreg) { - ASSERT(false, "outing kStPreg"); + CHECK_FATAL(false, "outing kStPreg"); } else if (skind == kStConst || skind == kStVar) { - ASSERT(false, "outing kStConst or kStVar"); + CHECK_FATAL(false, "outing kStConst or kStVar"); } else if (skind == kStFunc) { PUIdx puidx = ImportFunction(); TyIdx tyidx = ImportType(); @@ -778,12 +778,12 @@ PUIdx BinaryMplImport::ImportFunction() { if (tag == 0) { return 0; } else if (tag < 0) { - ASSERT(static_cast(-tag) < funcTab.size(), "index out of bounds"); + CHECK_FATAL(static_cast(-tag) < funcTab.size(), "index out of bounds"); return funcTab.at(-tag)->GetPuidx(); } - ASSERT(tag == kBinFunction, "expecting kBinFunction"); + CHECK_FATAL(tag == kBinFunction, "expecting kBinFunction"); MIRSymbol *funcSt = InSymbol(nullptr); - ASSERT(funcSt != nullptr, "null ptr check"); + CHECK_FATAL(funcSt != nullptr, "null ptr check"); MIRFunction *func = nullptr; if (funcSt->GetFunction() == nullptr) { maple::MIRBuilder builder(&mod); @@ -814,26 +814,26 @@ inline void BinaryMplImport::SkipTotalSize() { void BinaryMplImport::ReadStrField() { SkipTotalSize(); - int64 tag = 0; int32 size = ReadInt(); for (int64 i = 0; i < size; i++) { GStrIdx stridx = ImportStr(); GlobalTables::GetConstPool().PutLiteralNameAsImported(stridx); } + int64 tag = 0; tag = ReadNum(); - ASSERT(tag == ~kBinStrStart, "pattern mismatch in Read STR"); + CHECK_FATAL(tag == ~kBinStrStart, "pattern mismatch in Read STR"); } void BinaryMplImport::ReadTypeField() { SkipTotalSize(); - int64 tag = 0; int32 size = ReadInt(); for (int64 i = 0; i < size; i++) { ImportType(); } + int64 tag = 0; tag = ReadNum(); - ASSERT(tag == ~kBinTypeStart, "pattern mismatch in Read TYPE"); + CHECK_FATAL(tag == ~kBinTypeStart, "pattern mismatch in Read TYPE"); } void BinaryMplImport::ReadContentField() { @@ -847,7 +847,7 @@ void BinaryMplImport::ReadContentField() { offset = ReadInt(); content[item] = offset; } - ASSERT(ReadNum() == ~kBinContentStart, "pattern mismatch in Read CONTENT"); + CHECK_FATAL(ReadNum() == ~kBinContentStart, "pattern mismatch in Read CONTENT"); } void BinaryMplImport::Jump2NextField() { @@ -884,7 +884,7 @@ bool BinaryMplImport::Import(const std::string &fname, bool readSymbols, bool re break; } default: - ASSERT(false, "should not run here"); + CHECK_FATAL(false, "should not run here"); } fieldID = ReadNum(); } diff --git a/src/maple_ir/src/lexer.cpp b/src/maple_ir/src/lexer.cpp index ed63db21cbb5778253c955cbea7254babc359de9..730df3534f5fe302848a1b5ffafd074c008946a4 100644 --- a/src/maple_ir/src/lexer.cpp +++ b/src/maple_ir/src/lexer.cpp @@ -533,7 +533,7 @@ TokenKind MIRLexer::GetTokenSpecial() { return kTkEof; } -TokenKind MIRLexer::LexToken(void) { +TokenKind MIRLexer::LexToken() { // skip spaces char c = GetCurrentCharWithUpperCheck(); while (c == ' ' || c == '\t') { @@ -554,9 +554,9 @@ TokenKind MIRLexer::LexToken(void) { c = GetNextCurrentCharWithUpperCheck(); } } - char curchar = c; + char curChar = c; curIdx++; - switch (curchar) { + switch (curChar) { case '\n': return kTkNewline; case '(': @@ -611,7 +611,7 @@ TokenKind MIRLexer::LexToken(void) { return GetTokenWithPrefixAmpersand(); case '@': case '^': - return GetTokenWithPrefixAtOrCircumflex(curchar); + return GetTokenWithPrefixAtOrCircumflex(curChar); case '!': return GetTokenWithPrefixExclamation(); case '\'': diff --git a/src/maple_ir/src/mir_function.cpp b/src/maple_ir/src/mir_function.cpp index bbf2a24954099b4bbb60f910ee632a0b73c0e5c6..0a515f61c21e83ad9a0b10f9791b79d1cb1822a9 100644 --- a/src/maple_ir/src/mir_function.cpp +++ b/src/maple_ir/src/mir_function.cpp @@ -308,10 +308,10 @@ void MIRFunction::NewBody() { MIRPregTable *oldPregTable = GetPregTab(); MIRTypeNameTable *oldTypenameTable = typeNameTab; MIRLabelTable *oldLabelTable = GetLabelTab(); - symTab = dataMemPool->New(&dataMPAllocator); + symTab = dataMemPool->New(dataMPAllocator); SetPregTab(dataMemPool->New(module, &dataMPAllocator)); typeNameTab = dataMemPool->New(dataMPAllocator); - SetLabelTab(dataMemPool->New(&dataMPAllocator)); + SetLabelTab(dataMemPool->New(dataMPAllocator)); if (oldSymTable != nullptr) { for (size_t i = 1; i < oldSymTable->GetSymbolTableSize(); i++) { (void)GetSymTab()->AddStOutside(oldSymTable->GetSymbolFromStIdx(i)); @@ -334,14 +334,14 @@ void MIRFunction::NewBody() { void MIRFunction::SetUpGDBEnv() { if (codeMemPool != nullptr) { - mempoolctrler.DeleteMemPool(codeMemPool); + memPoolCtrler.DeleteMemPool(codeMemPool); } - codeMemPool = mempoolctrler.NewMemPool("tmp debug"); + codeMemPool = memPoolCtrler.NewMemPool("tmp debug"); codeMemPoolAllocator.SetMemPool(codeMemPool); } void MIRFunction::ResetGDBEnv() { - mempoolctrler.DeleteMemPool(codeMemPool); + memPoolCtrler.DeleteMemPool(codeMemPool); codeMemPool = nullptr; } diff --git a/src/maple_ir/src/mir_module.cpp b/src/maple_ir/src/mir_module.cpp index 85e03294281b54d35e14df8b1bc701e3d9c45eaf..e9d537153d3d98267eb6d30113dc69dcb37609e5 100644 --- a/src/maple_ir/src/mir_module.cpp +++ b/src/maple_ir/src/mir_module.cpp @@ -29,7 +29,7 @@ namespace maple { #if MIR_FEATURE_FULL // to avoid compilation error when MIR_FEATURE_FULL=0 MIRModule::MIRModule(const std::string &fn) - : memPool(mempoolctrler.NewMemPool("maple_ir mempool")), + : memPool(memPoolCtrler.NewMemPool("maple_ir mempool")), memPoolAllocator(memPool), functionList(memPoolAllocator.Adapter()), compilationList(memPoolAllocator.Adapter()), @@ -56,7 +56,7 @@ MIRModule::MIRModule(const std::string &fn) } MIRModule::~MIRModule() { - mempoolctrler.DeleteMemPool(memPool); + memPoolCtrler.DeleteMemPool(memPool); if (binMplt) { delete binMplt; } diff --git a/src/maple_ir/src/mir_nodes.cpp b/src/maple_ir/src/mir_nodes.cpp index 0b700924225fe1dda37fb82f57c7dbdad6858194..a1adf578075c5e671add48eaaf79cd135a25ffba 100644 --- a/src/maple_ir/src/mir_nodes.cpp +++ b/src/maple_ir/src/mir_nodes.cpp @@ -414,13 +414,14 @@ void NaryNode::Dump(const MIRModule &mod, int32 indent) const { NaryOpnds::Dump(mod, indent); } -MIRType *ArrayNode::GetArrayType(TypeTable &tt) const { - MIRPtrType *pointType = MIR_DYN_CAST(tt.GetTypeFromTyIdx(tyIdx), MIRPtrType*); - ASSERT(pointType != nullptr, "expect array type pointer"); +MIRType *ArrayNode::GetArrayType(const TypeTable &tt) const { + MIRType *type = tt.GetTypeFromTyIdx(tyIdx); + CHECK_FATAL(type->GetKind() == kTypePointer, "expect array type pointer"); + auto *pointType = static_cast(type); return tt.GetTypeFromTyIdx(pointType->GetPointedTyIdx()); } -BaseNode *ArrayNode::GetDim(const MIRModule &mod, TypeTable &tt, int i) { +BaseNode *ArrayNode::GetDim(const MIRModule &mod, const TypeTable &tt, int i) const { MIRArrayType *arrayType = static_cast(GetArrayType(tt)); MIRConst *mirConst = mod.CurFuncCodeMemPool()->New(*tt.GetTypeFromTyIdx(arrayType->GetElemTyIdx())); return mod.CurFuncCodeMemPool()->New(mirConst); @@ -733,7 +734,7 @@ void SwitchNode::Dump(const MIRModule &mod, int32 indent) const { LogInfo::MapleLogger() << " }" << std::endl; } -void RangegotoNode::Dump(const MIRModule &mod, int32 indent) const { +void RangeGotoNode::Dump(const MIRModule &mod, int32 indent) const { StmtNode::DumpBase(mod, indent); LogInfo::MapleLogger() << " ("; Opnd()->Dump(mod, indent); @@ -1737,7 +1738,7 @@ bool BinaryStmtNode::Verify() const { BinaryStrictSignVerify0(GetBOpnd(0), GetBOpnd(1)); } -bool RangegotoNode::Verify() const { +bool RangeGotoNode::Verify() const { bool opndExprVerf = Opnd()->Verify(); bool opndTypeVerf = IntTypeVerify(Opnd()->GetPrimType()); if (!opndTypeVerf) { diff --git a/src/maple_ir/src/mir_parser.cpp b/src/maple_ir/src/mir_parser.cpp index c52195e2efcc1cb83cf8ef771ca958fdb08b39a5..311bca63870bd9d45b74c2bf741c5df91cdfff17 100644 --- a/src/maple_ir/src/mir_parser.cpp +++ b/src/maple_ir/src/mir_parser.cpp @@ -67,11 +67,17 @@ bool MIRParser::ParseStmtRegassign(StmtNodePtr &stmt) { regassign->SetPrimType(GetPrimitiveType(lexer.GetTokenKind())); lexer.NextToken(); if (lexer.GetTokenKind() == kTkSpecialreg) { - if (!ParseSpecialReg(regassign->GetRegIdx())) { + PregIdx tempPregIdx = regassign->GetRegIdx(); + bool isSuccess = ParseSpecialReg(tempPregIdx); + regassign->SetRegIdx(tempPregIdx); + if (!isSuccess) { return false; } } else if (lexer.GetTokenKind() == kTkPreg) { - if (!ParsePseudoReg(regassign->GetPrimType(), regassign->GetRegIdx())) { + PregIdx tempPregIdx = regassign->GetRegIdx(); + bool isSuccess = ParsePseudoReg(regassign->GetPrimType(), tempPregIdx); + regassign->SetRegIdx(tempPregIdx); + if (!isSuccess) { return false; } } else { @@ -558,7 +564,7 @@ bool MIRParser::ParseStmtSwitch(StmtNodePtr &stmt) { } bool MIRParser::ParseStmtRangegoto(StmtNodePtr &stmt) { - RangegotoNode *rangegotonode = mod.CurFuncCodeMemPool()->New(mod); + RangeGotoNode *rangegotonode = mod.CurFuncCodeMemPool()->New(mod); stmt = rangegotonode; lexer.NextToken(); BaseNode *expr = nullptr; @@ -793,7 +799,7 @@ bool MIRParser::ParseStmtCall(StmtNodePtr &stmt) { return false; } MIRInstantVectorType instvecty; - if (!ParseGenericInstantVector(instvecty.GetInstantVec())) { + if (!ParseGenericInstantVector(instvecty)) { Error("error parsing generic method instantiation at "); return false; } @@ -1831,13 +1837,22 @@ bool MIRParser::ParseExprRegread(BaseNodePtr &expr) { } expr->SetPrimType(GlobalTables::GetTypeTable().GetPrimTypeFromTyIdx(tyidx)); if (lexer.GetTokenKind() == kTkSpecialreg) { - return ParseSpecialReg(regread->GetRegIdx()); + PregIdx tempPregIdx = regread->GetRegIdx(); + bool isSuccess = ParseSpecialReg(tempPregIdx); + regread->SetRegIdx(tempPregIdx); + return isSuccess; } if (lexer.GetTokenKind() == kTkPreg) { if (expr->GetPrimType() == PTY_ptr || expr->GetPrimType() == PTY_ref) { - return ParseRefPseudoReg(regread->GetRegIdx()); + PregIdx tempPregIdx = regread->GetRegIdx(); + bool isSuccess = ParseRefPseudoReg(tempPregIdx); + regread->SetRegIdx(tempPregIdx); + return isSuccess; } else { - return ParsePseudoReg(expr->GetPrimType(), regread->GetRegIdx()); + PregIdx tempPregIdx = regread->GetRegIdx(); + bool isSuccess = ParsePseudoReg(expr->GetPrimType(), tempPregIdx); + regread->SetRegIdx(tempPregIdx); + return isSuccess; } } Error("expect special or pseudo register but get "); diff --git a/src/maple_ir/src/mir_pragma.cpp b/src/maple_ir/src/mir_pragma.cpp index 39c1271088a1f3f66d23b4163e7a02df73a0ab8f..f12ec6a3b2f0c2f0a23dba0d62f1a748474f4ece 100644 --- a/src/maple_ir/src/mir_pragma.cpp +++ b/src/maple_ir/src/mir_pragma.cpp @@ -165,7 +165,7 @@ MIRPragmaElement *MIRPragma::GetPragmaElemFromSignature(const std::string &signa case kStartWithSubvec: { MIRPragmaElement *etmp = mod->GetMemPool()->New(*mod); etmp->SetType(kValueArray); - elemStack.top()->PushSubElemVec(*etmp); + elemStack.top()->SubElemVecPushBack(etmp); elemStack.push(etmp); break; } @@ -174,7 +174,7 @@ MIRPragmaElement *MIRPragma::GetPragmaElemFromSignature(const std::string &signa etmp->SetType(kValueType); std::string typeStr = signature.substr(start, end - start); etmp->SetU64Val(static_cast(GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(typeStr).GetIdx())); - elemStack.top()->PushSubElemVec(*etmp); + elemStack.top()->SubElemVecPushBack(etmp); break; } case kNormalTypeStrEndWithSubvecNeedSemicolon: { @@ -182,7 +182,7 @@ MIRPragmaElement *MIRPragma::GetPragmaElemFromSignature(const std::string &signa etmp->SetType(kValueType); std::string typeStr = signature.substr(start, end - start) + ";"; etmp->SetU64Val(static_cast(GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(typeStr).GetIdx())); - elemStack.top()->PushSubElemVec(*etmp); + elemStack.top()->SubElemVecPushBack(etmp); break; } case kEndWithSubvec: diff --git a/src/maple_ir/src/mir_symbol.cpp b/src/maple_ir/src/mir_symbol.cpp index a720be1841520916ad22ca6822b240a4e6711c42..40a69516a345d8672812397611174cc2b07476ee 100644 --- a/src/maple_ir/src/mir_symbol.cpp +++ b/src/maple_ir/src/mir_symbol.cpp @@ -89,7 +89,7 @@ bool MIRSymbol::IsCodeLayoutInfo() const { return (GetName().find(kFunctionLayoutStr) == 0); } -std::string MIRSymbol::GetMuidTabName() { +std::string MIRSymbol::GetMuidTabName() const { if (!IsMuidTab()) { return ""; } @@ -248,8 +248,8 @@ bool MIRSymbol::IgnoreRC() const { } // ignore ptr to types Ljava_2Flang_2FClass_3B, // Ljava_2Flang_2Freflect_2FMethod_3B - MIRPtrType *ptype = static_cast(type); - GStrIdx strIdx = GlobalTables::GetTypeTable().GetTypeFromTyIdx(ptype->GetPointedTyIdx())->GetNameStrIdx(); + const auto *pType = static_cast(type); + GStrIdx strIdx = GlobalTables::GetTypeTable().GetTypeFromTyIdx(pType->GetPointedTyIdx())->GetNameStrIdx(); if (reflectClassNameIdx == 0) { reflectClassNameIdx = GlobalTables::GetStrTable().GetOrCreateStrIdxFromName( NameMangler::GetInternalNameLiteral("Ljava_2Flang_2FClass_3B")); diff --git a/src/maple_ir/src/mir_type.cpp b/src/maple_ir/src/mir_type.cpp index eedf814c8a822fb0512345eb5d90017fc240fc17..8eea18cd4af682eeb2d70c2c6a9b4fd1ccefa584 100644 --- a/src/maple_ir/src/mir_type.cpp +++ b/src/maple_ir/src/mir_type.cpp @@ -631,7 +631,7 @@ FieldID MIRClassType::GetFirstLocalFieldID() const { } else if (parentTyIdx != 0) { MIRClassType *parentClassType = MIR_DYN_CAST(GlobalTables::GetTypeTable().GetTypeFromTyIdx(parentTyIdx), MIRClassType*); - ASSERT(parentClassType != nullptr, "null pointer check"); + CHECK_FATAL(parentClassType != nullptr, "null pointer check"); return (!parentClassType->IsLocal()) ? parentClassType->GetLastFieldID() + lastFieldIDOffset : parentClassType->GetFirstLocalFieldID() + firstLocalFieldIDOffset; } @@ -1367,7 +1367,6 @@ bool MIRInterfaceType::HasTypeParam() const { FieldPair MIRClassType::TraverseToFieldRef(FieldID &fieldID) const { if (parentTyIdx != 0) { - // parent can be a struct? MIRClassType *parentClassType = MIR_DYN_CAST(GlobalTables::GetTypeTable().GetTypeFromTyIdx(parentTyIdx), MIRClassType*); if (parentClassType != nullptr) { diff --git a/src/maple_ir/src/parser.cpp b/src/maple_ir/src/parser.cpp index 50c96cfea7fef5f0932fadd5012aa616470ceca7..bbde07639806ec1ed9f07e6cc5f3917bacc32958 100644 --- a/src/maple_ir/src/parser.cpp +++ b/src/maple_ir/src/parser.cpp @@ -56,10 +56,10 @@ void MIRParser::ResetMaxPregNo(MIRFunction &func) { for (uint32 i = 0; i < func.GetFormalCount(); i++) { MIRSymbol *formalSt = func.GetFormal(i); if (formalSt->IsPreg()) { - uint32 pRegNo = + uint32 pRegNO = static_cast(formalSt->GetPreg()->GetPregNo()); // no special register appears in the formals - if (pRegNo > maxPregNo) { - maxPregNo = pRegNo; + if (pRegNO > maxPregNo) { + maxPregNo = pRegNO; } } } @@ -220,9 +220,9 @@ bool MIRParser::ParseSpecialReg(PregIdx &pRegIdx) { } bool MIRParser::ParseRefPseudoReg(PregIdx &pRegIdx) { - uint32 pRegNo = static_cast(lexer.GetTheIntVal()); - ASSERT(pRegNo <= 0xffff, "preg number must be 16 bits"); - pRegIdx = LookupOrCreatePregIdx(pRegNo, true, *mod.CurFunction()); + uint32 pRegNO = static_cast(lexer.GetTheIntVal()); + ASSERT(pRegNO <= 0xffff, "preg number must be 16 bits"); + pRegIdx = LookupOrCreatePregIdx(pRegNO, true, *mod.CurFunction()); lexer.NextToken(); return true; } @@ -458,7 +458,7 @@ bool MIRParser::ParsePragmaElementForArray(MIRPragmaElement &elem) { Error("parsing pragma error type "); return false; } - elem.PushSubElemVec(*e0); + elem.SubElemVecPushBack(e0); tk = lexer.NextToken(); if (tk != kTkComa && tk != kTkRbrack) { Error("parsing pragma error: expecting , or ] but get "); @@ -511,7 +511,7 @@ bool MIRParser::ParsePragmaElementForAnnotation(MIRPragmaElement &elem) { Error("parsing pragma error type "); return false; } - elem.PushSubElemVec(*e0); + elem.SubElemVecPushBack(e0); tk = lexer.NextToken(); if (tk != kTkComa && tk != kTkRbrack) { Error("parsing pragma error: expecting , or ] but get "); @@ -1254,7 +1254,7 @@ bool MIRParser::ParseFuncType(TyIdx &tyIdx) { // parse the generic type instantiation vector enclosed inside braces; syntax // is: { = [, = ] } // where the contents enclosed in [ and ] can occur 0 or more times -bool MIRParser::ParseGenericInstantVector(GenericInstantVector &instantVec) { +bool MIRParser::ParseGenericInstantVector(MIRInstantVectorType &insVecType) { TokenKind tokenKind; TyIdx typeParmIdx; do { @@ -1274,7 +1274,7 @@ bool MIRParser::ParseGenericInstantVector(GenericInstantVector &instantVec) { Error("error parsing type in generic type/function instantiation at "); return false; } - instantVec.push_back(TypePair(typeParmIdx, realTyIdx)); + insVecType.AddInstant(TypePair(typeParmIdx, realTyIdx)); tokenKind = lexer.GetTokenKind(); if (tokenKind == kTkRbrace) { lexer.NextToken(); // skip the rbrace @@ -1341,7 +1341,7 @@ bool MIRParser::ParseDerivedType(TyIdx &tyIdx, MIRTypeKind kind) { } if (lexer.GetTokenKind() == kTkLbrace) { MIRGenericInstantType genericinstty(tyIdx); - if (!ParseGenericInstantVector(genericinstty.GetInstantVec())) { + if (!ParseGenericInstantVector(genericinstty)) { Error("error parsing generic type instantiation at "); return false; } @@ -1606,7 +1606,7 @@ bool MIRParser::ParseDeclareReg(MIRSymbol &symbol, MIRFunction &func) { Error("expect preg but get"); return false; } - uint32 thePRegNo = static_cast(lexer.GetTheIntVal()); + uint32 thePRegNO = static_cast(lexer.GetTheIntVal()); lexer.NextToken(); // parse ty TyIdx tyIdx(0); @@ -1621,7 +1621,7 @@ bool MIRParser::ParseDeclareReg(MIRSymbol &symbol, MIRFunction &func) { } symbol.SetTyIdx(tyIdx); MIRType *mirType = GlobalTables::GetTypeTable().GetTypeFromTyIdx(tyIdx); - PregIdx pRegIdx = LookupOrCreatePregIdx(thePRegNo, mirType->GetPrimType() == PTY_ref, func); + PregIdx pRegIdx = LookupOrCreatePregIdx(thePRegNO, mirType->GetPrimType() == PTY_ref, func); MIRPregTable *pRegTab = func.GetPregTab(); MIRPreg *preg = pRegTab->PregFromPregIdx(pRegIdx); preg->SetIsRef(mirType->GetPrimType() == PTY_ref); diff --git a/src/maple_me/BUILD.gn b/src/maple_me/BUILD.gn index 41557d832c82426744f3caae717b89d24c1d9150..2bf0766959d9f9aadacda3046cc1f38ecdec57d1 100644 --- a/src/maple_me/BUILD.gn +++ b/src/maple_me/BUILD.gn @@ -33,6 +33,7 @@ src_libmplmewpo = [ "src/func_emit.cpp", "src/irmap.cpp", "src/irmap_emit.cpp", + "src/me_builder.cpp", "src/me_ir.cpp", "src/orig_symbol.cpp", "src/ssa.cpp", diff --git a/src/maple_me/include/bb.h b/src/maple_me/include/bb.h index f7ca07282e31df7b0b33384e2bae64e44362ee18..e16acd5f8109e8d53b193b016bfea95ebe17050c 100644 --- a/src/maple_me/include/bb.h +++ b/src/maple_me/include/bb.h @@ -409,6 +409,7 @@ class BB { StmtNodes stmtNodeList; MeStmts meStmtList; }; + class SCCOfBBs { public: SCCOfBBs(uint32 index, BB *bb, MapleAllocator *alloc) @@ -417,6 +418,7 @@ class SCCOfBBs { bbs(alloc->Adapter()), predSCC(std::less(), alloc->Adapter()), succSCC(std::less(), alloc->Adapter()) {} + ~SCCOfBBs() = default; void Dump(); void Verify(MapleVector &sccOfBB); void SetUp(MapleVector &sccOfBB); diff --git a/src/maple_me/include/irmap.h b/src/maple_me/include/irmap.h index 949e39a75b29a8998d2959b79ef0998854e1c253..0fd0c71af90d38768f1680979d301812bebe391f 100644 --- a/src/maple_me/include/irmap.h +++ b/src/maple_me/include/irmap.h @@ -19,6 +19,7 @@ #include "ssa_tab.h" #include "me_ir.h" #include "dominance.h" +#include "me_builder.h" namespace maple { class IRMap : public AnalysisResult { @@ -34,7 +35,10 @@ class IRMap : public AnalysisResult { hashTable(mapHashLength, nullptr, irMapAlloc.Adapter()), verst2MeExprTable(ssaTab.GetVersionStTableSize(), nullptr, irMapAlloc.Adapter()), regMeExprTable(irMapAlloc.Adapter()), - curBB(nullptr) {} + curBB(nullptr), + meBuilder(irMapAlloc) { + InitMeStmtFactory(); + } virtual ~IRMap() = default; @@ -174,6 +178,7 @@ class IRMap : public AnalysisResult { bool needAnotherPass = false; // set to true if CFG has changed bool dumpStmtNum = false; BB *curBB; // current maple_me::BB being visited + MeBuilder meBuilder; bool ReplaceMeExprStmtOpnd(uint32, MeStmt&, MeExpr&, MeExpr&); MeExpr *BuildLHSVar(const VersionSt &verSt, DassignMeStmt &defMeStmt); @@ -192,6 +197,20 @@ class IRMap : public AnalysisResult { void BuildMuList(MapleMap &, MapleMap &); void BuildPhiMeNode(BB&); BB *GetFalseBrBB(CondGotoMeStmt&); + void SetMeExprOpnds(MeExpr &meExpr, BaseNode &mirNode); + void InitMeStmtFactory() const; + MeStmt *BuildDassignMeStmt(StmtNode &stmt, AccessSSANodes &ssaPart); + MeStmt *BuildRegassignMeStmt(StmtNode &stmt, AccessSSANodes &ssaPart); + MeStmt *BuildIassignMeStmt(StmtNode &stmt, AccessSSANodes &ssaPart); + MeStmt *BuildMaydassignMeStmt(StmtNode &stmt, AccessSSANodes &ssaPart); + MeStmt *BuildCallMeStmt(StmtNode &stmt, AccessSSANodes &ssaPart); + MeStmt *BuildNaryMeStmt(StmtNode &stmt, AccessSSANodes &ssaPart); + MeStmt *BuildRetMeStmt(StmtNode &stmt, AccessSSANodes &ssaPart); + MeStmt *BuildWithMuMeStmt(StmtNode &stmt, AccessSSANodes &ssaPart); + MeStmt *BuildGosubMeStmt(StmtNode &stmt, AccessSSANodes &ssaPart); + MeStmt *BuildThrowMeStmt(StmtNode &stmt, AccessSSANodes &ssaPart); + MeStmt *BuildSyncMeStmt(StmtNode &stmt, AccessSSANodes &ssaPart); + MeExpr *ReplaceMeExprExpr(MeExpr &origExpr, MeExpr &newExpr, size_t opndsSize, MeExpr &meExpr, MeExpr &repExpr); }; } // namespace maple #endif // MAPLE_ME_INCLUDE_IRMAP_H diff --git a/src/maple_me/include/me_builder.h b/src/maple_me/include/me_builder.h new file mode 100644 index 0000000000000000000000000000000000000000..1ccbd5c52db74690142e1219e25164ac3c7791ee --- /dev/null +++ b/src/maple_me/include/me_builder.h @@ -0,0 +1,72 @@ +/* + * Copyright (c) [2019] Huawei Technologies Co.,Ltd.All rights reserved. + * + * OpenArkCompiler is licensed under the Mulan PSL v1. + * You can use this software according to the terms and conditions of the Mulan PSL v1. + * You may obtain a copy of Mulan PSL v1 at: + * + * http://license.coscl.org.cn/MulanPSL + * + * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER + * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR + * FIT FOR A PARTICULAR PURPOSE. + * See the Mulan PSL v1 for more details. + */ +#ifndef MAPLE_ME_INCLUDE_ME_BUILDER_H +#define MAPLE_ME_INCLUDE_ME_BUILDER_H +#include "me_ir.h" + +namespace maple { +class MeBuilder { + public: + explicit MeBuilder(MapleAllocator &allocator) : allocator(allocator) { + InitMeExprBuildFactory(); + } + + virtual ~MeBuilder() = default; + + MeExpr *CreateMeExpr(int32 exprId, MeExpr &meExpr) const; + MeExpr *BuildMeExpr(BaseNode &mirNode) const; + + private: + template + T *NewInPool(Arguments&&... args) const { + return allocator.GetMemPool()->New(&allocator, std::forward(args)...); + } + + template + T *New(Arguments&&... args) const { + return allocator.GetMemPool()->New(std::forward(args)...); + } + + OpMeExpr *BuildOpMeExpr(BaseNode &mirNode) const { + OpMeExpr *meExpr = New(kInvalidExprID); + meExpr->InitBase(mirNode.GetOpCode(), mirNode.GetPrimType(), mirNode.GetNumOpnds()); + return meExpr; + } + + void InitMeExprBuildFactory() const; + MeExpr *BuildAddrofMeExpr(BaseNode &mirNode) const; + MeExpr *BuildAddroffuncMeExpr(BaseNode &mirNode) const; + MeExpr *BuildGCMallocMeExpr(BaseNode &mirNode) const; + MeExpr *BuildSizeoftypeMeExpr(BaseNode &mirNode) const; + MeExpr *BuildFieldsDistMeExpr(BaseNode &mirNode) const; + MeExpr *BuildIvarMeExpr(BaseNode &mirNode) const; + MeExpr *BuildConstMeExpr(BaseNode &mirNode) const; + MeExpr *BuildConststrMeExpr(BaseNode &mirNode) const; + MeExpr *BuildConststr16MeExpr(BaseNode &mirNode) const; + MeExpr *BuildOpMeExprForCompare(BaseNode &mirNode) const; + MeExpr *BuildOpMeExprForTypeCvt(BaseNode &mirNode) const; + MeExpr *BuildOpMeExprForRetype(BaseNode &mirNode) const; + MeExpr *BuildOpMeExprForIread(BaseNode &mirNode) const; + MeExpr *BuildOpMeExprForExtractbits(BaseNode &mirNode) const; + MeExpr *BuildOpMeExprForJarrayMalloc(BaseNode &mirNode) const; + MeExpr *BuildOpMeExprForResolveFunc(BaseNode &mirNode) const; + MeExpr *BuildNaryMeExprForArray(BaseNode &mirNode) const; + MeExpr *BuildNaryMeExprForIntrinsicop(BaseNode &mirNode) const; + MeExpr *BuildNaryMeExprForIntrinsicWithType(BaseNode &mirNode) const; + + MapleAllocator &allocator; +}; +} // namespace maple +#endif // MAPLE_ME_INCLUDE_MEBUILDER_H diff --git a/src/maple_me/include/me_ir.h b/src/maple_me/include/me_ir.h index be464bb9364cfb983931d72e0eeb8b4be70fca67..9b37cfdedc637d66fb77f93ca57d27e9411172c9 100644 --- a/src/maple_me/include/me_ir.h +++ b/src/maple_me/include/me_ir.h @@ -141,6 +141,15 @@ class MeExpr { return nullptr; } + virtual void SetOpnd(size_t idx, MeExpr *opndsVal) { + ASSERT(false, "Should not reach here"); + } + + virtual MeExpr *GetIdenticalExpr(MeExpr &expr) const { + ASSERT(false, "Should not reach here"); + return nullptr; + } + void UpdateDepth(); // update the depth, suppose all sub nodes have already depth done. MeExpr &GetAddrExprBase(); // get the base of the address expression MeExpr *FindSymAppearance(OStIdx oidx); // find the appearance of the symbol @@ -572,11 +581,11 @@ class ConstMeExpr : public MeExpr { ConstMeExpr(int32 exprID, MIRConst *constValParam) : MeExpr(exprID, kMeOpConst), constVal(constValParam) {} ~ConstMeExpr() = default; - void Dump(IRMap*, int32 indent = 0) const; - BaseNode &EmitExpr(SSATab &); + void Dump(IRMap*, int32 indent = 0) const override; + BaseNode &EmitExpr(SSATab &) override; bool GeZero() const; bool GtZero() const; - bool IsZero() const; + bool IsZero() const override; bool IsOne() const; int64 GetIntValue() const; @@ -584,7 +593,9 @@ class ConstMeExpr : public MeExpr { return constVal; } - uint32 GetHashIndex() const { + MeExpr *GetIdenticalExpr(MeExpr &expr) const override; + + uint32 GetHashIndex() const override { if (constVal->GetKind() == kConstInt) { MIRIntConst *intConst = static_cast(constVal); return intConst->GetValue(); @@ -615,14 +626,15 @@ class ConststrMeExpr : public MeExpr { ~ConststrMeExpr() = default; - void Dump(IRMap*, int32 indent = 0) const; - BaseNode &EmitExpr(SSATab &); + void Dump(IRMap*, int32 indent = 0) const override; + BaseNode &EmitExpr(SSATab &) override; + MeExpr *GetIdenticalExpr(MeExpr &expr) const override; UStrIdx GetStrIdx() const { return strIdx; } - uint32 GetHashIndex() const { + uint32 GetHashIndex() const override { constexpr uint32 kConststrHashShift = 6; return strIdx.GetIdx() << kConststrHashShift; } @@ -636,14 +648,15 @@ class Conststr16MeExpr : public MeExpr { Conststr16MeExpr(int32 exprID, U16StrIdx idx) : MeExpr(exprID, kMeOpConststr16), strIdx(idx) {} ~Conststr16MeExpr() = default; - void Dump(IRMap*, int32 indent = 0) const; - BaseNode &EmitExpr(SSATab &); + void Dump(IRMap*, int32 indent = 0) const override; + BaseNode &EmitExpr(SSATab &) override; + MeExpr *GetIdenticalExpr(MeExpr &expr) const override; U16StrIdx GetStrIdx() { return strIdx; } - uint32 GetHashIndex() const { + uint32 GetHashIndex() const override { constexpr uint32 kConststr16HashShift = 6; return strIdx.GetIdx() << kConststr16HashShift; } @@ -657,14 +670,15 @@ class SizeoftypeMeExpr : public MeExpr { SizeoftypeMeExpr(int32 exprid, TyIdx idx) : MeExpr(exprid, kMeOpSizeoftype), tyIdx(idx) {} ~SizeoftypeMeExpr() = default; - void Dump(IRMap*, int32 indent = 0) const; - BaseNode &EmitExpr(SSATab &); + void Dump(IRMap*, int32 indent = 0) const override; + BaseNode &EmitExpr(SSATab &) override; + MeExpr *GetIdenticalExpr(MeExpr &expr) const override; TyIdx GetTyIdx() const { return tyIdx; } - uint32 GetHashIndex() const { + uint32 GetHashIndex() const override { constexpr uint32 kSizeoftypeHashShift = 5; return tyIdx.GetIdx() << kSizeoftypeHashShift; } @@ -679,8 +693,9 @@ class FieldsDistMeExpr : public MeExpr { : MeExpr(exprid, kMeOpFieldsDist), tyIdx(idx), fieldID1(f1), fieldID2(f2) {} ~FieldsDistMeExpr() = default; - void Dump(IRMap*, int32 indent = 0) const; - BaseNode &EmitExpr(SSATab &); + void Dump(IRMap*, int32 indent = 0) const override; + BaseNode &EmitExpr(SSATab &) override; + MeExpr *GetIdenticalExpr(MeExpr &expr) const override; TyIdx GetTyIdx() const { return tyIdx; @@ -694,7 +709,7 @@ class FieldsDistMeExpr : public MeExpr { return fieldID2; } - uint32 GetHashIndex() const { + uint32 GetHashIndex() const override { constexpr uint32 kFieldsDistHashShift = 5; constexpr uint32 kTyIdxShiftFactor = 10; return (tyIdx.GetIdx() << kTyIdxShiftFactor) + (static_cast(fieldID1) << kFieldsDistHashShift) + fieldID2; @@ -715,6 +730,7 @@ class AddrofMeExpr : public MeExpr { void Dump(IRMap*, int32 indent = 0) const override; bool IsUseSameSymbol(const MeExpr &) const override; BaseNode &EmitExpr(SSATab &) override; + MeExpr *GetIdenticalExpr(MeExpr &expr) const override; OStIdx GetOstIdx() const { return ostIdx; @@ -744,14 +760,15 @@ class AddroffuncMeExpr : public MeExpr { ~AddroffuncMeExpr() = default; - void Dump(IRMap*, int32 indent = 0) const; - BaseNode &EmitExpr(SSATab &); + void Dump(IRMap*, int32 indent = 0) const override; + BaseNode &EmitExpr(SSATab &) override; + MeExpr *GetIdenticalExpr(MeExpr &expr) const override; PUIdx GetPuIdx() { return puIdx; } - uint32 GetHashIndex() const { + uint32 GetHashIndex() const override { constexpr uint32 kAddroffuncHashShift = 5; return puIdx << kAddroffuncHashShift; } @@ -805,13 +822,14 @@ class OpMeExpr : public MeExpr { bool IsIdentical(const OpMeExpr &meexpr) const; void Dump(IRMap*, int32 indent = 0) const override; bool IsUseSameSymbol(const MeExpr &) const override; + MeExpr *GetIdenticalExpr(MeExpr &expr) const override; BaseNode &EmitExpr(SSATab &) override; MeExpr *GetOpnd(size_t i) const override { CHECK_FATAL(i < kOperandNumTernary, "OpMeExpr cannot have more than 3 operands"); return opnds[i]; } - void SetOpnd(uint32 idx, MeExpr *opndsVal) { + void SetOpnd(size_t idx, MeExpr *opndsVal) override { CHECK_FATAL(idx < kOperandNumTernary, "out of range in OpMeExpr::SetOpnd"); opnds[idx] = opndsVal; } @@ -915,6 +933,8 @@ class IvarMeExpr : public MeExpr { bool IsFinal(); bool IsRCWeak(); bool IsUseSameSymbol(const MeExpr &) const override; + bool IsIdentical(IvarMeExpr &expr) const; + MeExpr *GetIdenticalExpr(MeExpr &expr) const override; MeExpr *GetOpnd(size_t idx) const override { ASSERT(idx == 0, "IvarMeExpr can only have 1 operand"); return base; @@ -1019,6 +1039,7 @@ class NaryMeExpr : public MeExpr { bool IsIdentical(NaryMeExpr &) const; bool IsUseSameSymbol(const MeExpr &) const override; BaseNode &EmitExpr(SSATab &) override; + MeExpr *GetIdenticalExpr(MeExpr &expr) const override; MeExpr *GetOpnd(size_t idx) const override { ASSERT(idx < opnds.size(), "NaryMeExpr operand out of bounds"); return opnds[idx]; @@ -1040,7 +1061,7 @@ class NaryMeExpr : public MeExpr { return opnds; } - void SetOpnd(size_t idx, MeExpr *val) { + void SetOpnd(size_t idx, MeExpr *val) override { opnds[idx] = val; } @@ -2517,6 +2538,10 @@ class AssertMeStmt : public MeStmt { CHECK(op == OP_assertge || op == OP_assertlt, "runtime check error"); } + size_t NumMeStmtOpnds() const override { + return kOperandNumBinary; + } + AssertMeStmt(const AssertMeStmt &assmestmt) : MeStmt(assmestmt.GetOp()) { SetOp(assmestmt.GetOp()); opnds[0] = assmestmt.opnds[0]; @@ -2538,18 +2563,18 @@ class AssertMeStmt : public MeStmt { return opnds[0]; } - void SetOpnd(uint32 i, MeExpr *opnd) { + void SetOpnd(uint32 i, MeExpr *opnd) override { CHECK_FATAL(i < kOperandNumBinary, "AssertMeStmt has two opnds"); opnds[i] = opnd; } - MeExpr *GetOpnd(size_t i) const { + MeExpr *GetOpnd(size_t i) const override { CHECK_FATAL(i < kOperandNumBinary, "AssertMeStmt has two opnds"); return opnds[i]; } - void Dump(IRMap*) const; - StmtNode &EmitStmt(SSATab &ssatab); + void Dump(IRMap*) const override; + StmtNode &EmitStmt(SSATab &ssatab) override; private: MeExpr *opnds[kOperandNumBinary]; diff --git a/src/maple_me/include/me_phase_manager.h b/src/maple_me/include/me_phase_manager.h index 5154bbe41c1de4f8b71eb5b0ec6eb643730178ba..38c7f5041d9f0b4d8b77f0533fb51f76cf5d3dfc 100644 --- a/src/maple_me/include/me_phase_manager.h +++ b/src/maple_me/include/me_phase_manager.h @@ -29,12 +29,12 @@ enum MePhaseType { kMePhaseInvalid, kMePhaseMainopt, kMePhaseLno }; class MeFuncPhaseManager : public PhaseManager { public: MeFuncPhaseManager(MemPool *memPool, MIRModule &mod, ModuleResultMgr *mrm = nullptr) - : PhaseManager(memPool, "mephase"), + : PhaseManager(*memPool, "mephase"), arFuncManager(GetMemAllocator()), mirModule(mod), modResMgr(mrm), mePhaseType(kMePhaseInvalid), - genMempool(false), + genMeMpl(false), timePhases(false), ipa(false) {} @@ -68,12 +68,12 @@ class MeFuncPhaseManager : public PhaseManager { bool FuncFilter(const std::string &filter, const std::string &name); - bool GetGenMempool() { - return genMempool; + bool GetGenMeMpl() { + return genMeMpl; } - void SetGenMempool(bool pl) { - genMempool = pl; + void SetGenMeMpl(bool pl) { + genMeMpl = pl; } void SetTimePhases(bool phs) { @@ -94,7 +94,7 @@ class MeFuncPhaseManager : public PhaseManager { MIRModule &mirModule; ModuleResultMgr *modResMgr; MePhaseType mePhaseType; - bool genMempool; + bool genMeMpl; bool timePhases; bool ipa; }; diff --git a/src/maple_me/include/me_ssa_update.h b/src/maple_me/include/me_ssa_update.h index 65d0670b444ab739fa062a295b4b43816c9541c6..a6f1c54ecb480b8bf11e9930da19449d938a3afa 100644 --- a/src/maple_me/include/me_ssa_update.h +++ b/src/maple_me/include/me_ssa_update.h @@ -32,7 +32,7 @@ class MeSSAUpdate { renameStacks(std::less(), ssaUpdateAlloc.Adapter()) {} ~MeSSAUpdate() { - mempoolctrler.DeleteMemPool(&ssaUpdateMp); + memPoolCtrler.DeleteMemPool(&ssaUpdateMp); } void Run(); diff --git a/src/maple_me/include/orig_symbol.h b/src/maple_me/include/orig_symbol.h index a2b7eeba8c81a1b534c101673c20a47b26086b09..a65414882c333c63384921d9c515be8740f764da 100644 --- a/src/maple_me/include/orig_symbol.h +++ b/src/maple_me/include/orig_symbol.h @@ -80,10 +80,10 @@ class OriginalSt { return symOrPreg.mirSt; } - bool HasAttr(AttrKind x) const { + bool HasAttr(AttrKind attrKind) const { if (ostType == kSymbolOst) { TypeAttrs typeAttr = symOrPreg.mirSt->GetAttrs(); - if (typeAttr.GetAttr(x)) { + if (typeAttr.GetAttr(attrKind)) { return true; } } diff --git a/src/maple_me/include/ssa_tab.h b/src/maple_me/include/ssa_tab.h index c21a42361792615f04459fc7b5ad9e1cfcc514d2..d2584dc5c6ffc227e1b5f532ff655b90121129f0 100644 --- a/src/maple_me/include/ssa_tab.h +++ b/src/maple_me/include/ssa_tab.h @@ -24,12 +24,12 @@ namespace maple { class SSATab : public AnalysisResult { // represent the SSA table public: - SSATab(MemPool *memPool, MemPool *versmp, MIRModule *mod) + SSATab(MemPool *memPool, MemPool *versMp, MIRModule *mod) : AnalysisResult(memPool), mirModule(*mod), - versionStTable(versmp), + versionStTable(*versMp), originalStTable(*memPool, *mod), - stmtsSSAPart(versmp) {} + stmtsSSAPart(versMp) {} ~SSATab() = default; @@ -130,9 +130,9 @@ class SSATab : public AnalysisResult { private: MIRModule &mirModule; - VersionStTable versionStTable; // this uses special versmp because it will be freed earlier + VersionStTable versionStTable; // this uses special versMp because it will be freed earlier OriginalStTable originalStTable; - StmtsSSAPart stmtsSSAPart; // this uses special versmp because it will be freed earlier + StmtsSSAPart stmtsSSAPart; // this uses special versMp because it will be freed earlier bool wholeProgramScope = false; }; } // namespace maple diff --git a/src/maple_me/include/ver_symbol.h b/src/maple_me/include/ver_symbol.h index f0129390e24b476183e08f64ec4e3d56e02f9faf..ab5c84ef421bad64daf74a5b5e58a3b49d924ca2 100644 --- a/src/maple_me/include/ver_symbol.h +++ b/src/maple_me/include/ver_symbol.h @@ -193,7 +193,7 @@ class VersionSt { class VersionStTable { public: - explicit VersionStTable(MemPool *vstMp) : vstAlloc(vstMp), versionStVector(vstAlloc.Adapter()) { + explicit VersionStTable(MemPool &vstMp) : vstAlloc(&vstMp), versionStVector(vstAlloc.Adapter()) { versionStVector.push_back(&dummyVST); } diff --git a/src/maple_me/src/irmap.cpp b/src/maple_me/src/irmap.cpp index 7dc542780304bf489e93009e09900e87aec52d3a..7fea26371fe42e5e6e8022be70f3cde2601cff94 100644 --- a/src/maple_me/src/irmap.cpp +++ b/src/maple_me/src/irmap.cpp @@ -17,8 +17,11 @@ #include "ssa_mir_nodes.h" #include "ssa.h" #include "mir_builder.h" +#include "factory.h" namespace maple { +using MeStmtFactory = FunctionFactory; + // recursively invoke itself in a pre-order traversal of the dominator tree of // the CFG to build the HSSA representation for the code in each BB void IRMap::BuildBB(BB &bb, std::vector &bbIRMapProcessed) { @@ -389,140 +392,128 @@ MeStmt *IRMap::BuildMeStmtWithNoSSAPart(StmtNode &stmt) { } } +MeStmt *IRMap::BuildDassignMeStmt(StmtNode &stmt, AccessSSANodes &ssaPart) { + DassignMeStmt *meStmt = NewInPool(&stmt); + DassignNode &dassiNode = static_cast(stmt); + meStmt->SetRHS(BuildExpr(*dassiNode.GetRHS())); + VarMeExpr *varlhs = static_cast(BuildLHSVar(*ssaPart.GetSSAVar(), *meStmt)); + meStmt->SetLHS(varlhs); + BuildChiList(*meStmt, ssaPart.GetMayDefNodes(), *meStmt->GetChiList()); + return meStmt; +} + +MeStmt *IRMap::BuildRegassignMeStmt(StmtNode &stmt, AccessSSANodes &ssaPart) { + RegassignMeStmt *meStmt = New(&stmt); + RegassignNode ®Node = static_cast(stmt); + meStmt->SetRHS(BuildExpr(*regNode.Opnd(0))); + RegMeExpr *regLHS = static_cast(BuildLHSReg(*ssaPart.GetSSAVar(), *meStmt, regNode)); + meStmt->SetLHS(regLHS); + return meStmt; +} + +MeStmt *IRMap::BuildIassignMeStmt(StmtNode &stmt, AccessSSANodes &ssaPart) { + IassignNode &iasNode = static_cast(stmt); + IassignMeStmt *meStmt = NewInPool(&stmt); + meStmt->SetTyIdx(iasNode.GetTyIdx()); + meStmt->SetRHS(BuildExpr(*iasNode.GetRHS())); + meStmt->SetLHSVal(BuildLHSIvar(*BuildExpr(*iasNode.Opnd(0)), *meStmt, iasNode.GetFieldID())); + BuildChiList(*meStmt, ssaPart.GetMayDefNodes(), *(meStmt->GetChiList())); + return meStmt; +} + +MeStmt *IRMap::BuildMaydassignMeStmt(StmtNode &stmt, AccessSSANodes &ssaPart) { + MaydassignMeStmt *meStmt = NewInPool(&stmt); + DassignNode &dassiNode = static_cast(stmt); + meStmt->SetRHS(BuildExpr(*dassiNode.GetRHS())); + meStmt->SetMayDassignSym(ssaPart.GetSSAVar()->GetOrigSt()); + meStmt->SetFieldID(dassiNode.GetFieldID()); + BuildChiList(*meStmt, ssaPart.GetMayDefNodes(), *(meStmt->GetChiList())); + return meStmt; +} + +MeStmt *IRMap::BuildCallMeStmt(StmtNode &stmt, AccessSSANodes &ssaPart) { + CallMeStmt *callMeStmt = NewInPool(&stmt); + CallNode &intrinNode = static_cast(stmt); + callMeStmt->SetPUIdx(intrinNode.GetPUIdx()); + for (size_t i = 0; i < intrinNode.NumOpnds(); i++) { + callMeStmt->GetOpnds().push_back(BuildExpr(*intrinNode.Opnd(i))); + } + BuildMuList(ssaPart.GetMayUseNodes(), *(callMeStmt->GetMuList())); + if (kOpcodeInfo.IsCallAssigned(stmt.GetOpCode())) { + BuildMustDefList(*callMeStmt, ssaPart.GetMustDefNodes(), *(callMeStmt->GetMustDefList())); + } + BuildChiList(*callMeStmt, ssaPart.GetMayDefNodes(), *(callMeStmt->GetChiList())); + return callMeStmt; +} + + +MeStmt *IRMap::BuildNaryMeStmt(StmtNode &stmt, AccessSSANodes &ssaPart) { + Opcode op = stmt.GetOpCode(); + NaryMeStmt *naryMeStmt = (op == OP_icall || op == OP_icallassigned) + ? static_cast(NewInPool(&stmt)) + : static_cast(NewInPool(&stmt)); + NaryStmtNode &naryStmtNode = static_cast(stmt); + for (size_t i = 0; i < naryStmtNode.NumOpnds(); i++) { + naryMeStmt->GetOpnds().push_back(BuildExpr(*naryStmtNode.Opnd(i))); + } + BuildMuList(ssaPart.GetMayUseNodes(), *(naryMeStmt->GetMuList())); + if (kOpcodeInfo.IsCallAssigned(op)) { + BuildMustDefList(*naryMeStmt, ssaPart.GetMustDefNodes(), *(naryMeStmt->GetMustDefList())); + } + BuildChiList(*naryMeStmt, ssaPart.GetMayDefNodes(), *(naryMeStmt->GetChiList())); + return naryMeStmt; +} + +MeStmt *IRMap::BuildRetMeStmt(StmtNode &stmt, AccessSSANodes &ssaPart) { + NaryStmtNode &retStmt = static_cast(stmt); + RetMeStmt *meStmt = NewInPool(&stmt); + for (size_t i = 0; i < retStmt.NumOpnds(); i++) { + meStmt->GetOpnds().push_back(BuildExpr(*retStmt.Opnd(i))); + } + BuildMuList(ssaPart.GetMayUseNodes(), *(meStmt->GetMuList())); + return meStmt; +} + +MeStmt *IRMap::BuildWithMuMeStmt(StmtNode &stmt, AccessSSANodes &ssaPart) { + WithMuMeStmt *retSub = NewInPool(&stmt); + BuildMuList(ssaPart.GetMayUseNodes(), *(retSub->GetMuList())); + return retSub; +} + +MeStmt *IRMap::BuildGosubMeStmt(StmtNode &stmt, AccessSSANodes &ssaPart) { + GosubMeStmt *goSub = NewInPool(&stmt); + BuildMuList(ssaPart.GetMayUseNodes(), *(goSub->GetMuList())); + return goSub; +} + +MeStmt *IRMap::BuildThrowMeStmt(StmtNode &stmt, AccessSSANodes &ssaPart) { + UnaryStmtNode &unaryNode = static_cast(stmt); + ThrowMeStmt *tmeStmt = NewInPool(&stmt); + tmeStmt->SetMeStmtOpndValue(BuildExpr(*unaryNode.Opnd(0))); + BuildMuList(ssaPart.GetMayUseNodes(), *(tmeStmt->GetMuList())); + return tmeStmt; +} + +MeStmt *IRMap::BuildSyncMeStmt(StmtNode &stmt, AccessSSANodes &ssaPart) { + NaryStmtNode &naryNode = static_cast(stmt); + SyncMeStmt *naryStmt = NewInPool(&stmt); + for (size_t i = 0; i < naryNode.NumOpnds(); i++) { + naryStmt->GetOpnds().push_back(BuildExpr(*naryNode.Opnd(i))); + } + BuildMuList(ssaPart.GetMayUseNodes(), *(naryStmt->GetMuList())); + BuildChiList(*naryStmt, ssaPart.GetMayDefNodes(), *(naryStmt->GetChiList())); + return naryStmt; +} + MeStmt *IRMap::BuildMeStmt(StmtNode &stmt) { AccessSSANodes *ssaPart = ssaTab.GetStmtsSSAPart().SSAPartOf(stmt); if (ssaPart == nullptr) { return BuildMeStmtWithNoSSAPart(stmt); } - Opcode op = stmt.GetOpCode(); - switch (op) { - case OP_dassign: { - DassignMeStmt *meStmt = NewInPool(&stmt); - DassignNode &dassiNode = static_cast(stmt); - meStmt->SetRHS(BuildExpr(*dassiNode.GetRHS())); - VarMeExpr *varlhs = static_cast(BuildLHSVar(*ssaPart->GetSSAVar(), *meStmt)); - meStmt->SetLHS(varlhs); - BuildChiList(*meStmt, ssaPart->GetMayDefNodes(), *meStmt->GetChiList()); - return meStmt; - } - case OP_regassign: { - RegassignMeStmt *meStmt = New(&stmt); - RegassignNode ®Node = static_cast(stmt); - meStmt->SetRHS(BuildExpr(*regNode.Opnd(0))); - RegMeExpr *regLHS = static_cast(BuildLHSReg(*ssaPart->GetSSAVar(), *meStmt, regNode)); - meStmt->SetLHS(regLHS); - return meStmt; - } - case OP_iassign: { - IassignNode &iasNode = static_cast(stmt); - IassignMeStmt *meStmt = NewInPool(&stmt); - meStmt->SetTyIdx(iasNode.GetTyIdx()); - meStmt->SetRHS(BuildExpr(*iasNode.GetRHS())); - meStmt->SetLHSVal(BuildLHSIvar(*BuildExpr(*iasNode.Opnd(0)), *meStmt, iasNode.GetFieldID())); - BuildChiList(*meStmt, ssaPart->GetMayDefNodes(), *(meStmt->GetChiList())); - return meStmt; - } - case OP_maydassign: { - MaydassignMeStmt *meStmt = NewInPool(&stmt); - DassignNode &dassiNode = static_cast(stmt); - meStmt->SetRHS(BuildExpr(*dassiNode.GetRHS())); - meStmt->SetMayDassignSym(ssaPart->GetSSAVar()->GetOrigSt()); - meStmt->SetFieldID(dassiNode.GetFieldID()); - BuildChiList(*meStmt, ssaPart->GetMayDefNodes(), *(meStmt->GetChiList())); - return meStmt; - } - case OP_call: - case OP_virtualcall: - case OP_virtualicall: - case OP_superclasscall: - case OP_interfacecall: - case OP_interfaceicall: - case OP_customcall: - case OP_polymorphiccall: - case OP_callassigned: - case OP_virtualcallassigned: - case OP_virtualicallassigned: - case OP_superclasscallassigned: - case OP_interfacecallassigned: - case OP_interfaceicallassigned: - case OP_customcallassigned: - case OP_polymorphiccallassigned: { - CallMeStmt *callMeStmt = NewInPool(&stmt); - CallNode &intrinNode = static_cast(stmt); - callMeStmt->SetPUIdx(intrinNode.GetPUIdx()); - for (size_t i = 0; i < intrinNode.NumOpnds(); i++) { - callMeStmt->GetOpnds().push_back(BuildExpr(*intrinNode.Opnd(i))); - } - BuildMuList(ssaPart->GetMayUseNodes(), *(callMeStmt->GetMuList())); - if (kOpcodeInfo.IsCallAssigned(op)) { - BuildMustDefList(*callMeStmt, ssaPart->GetMustDefNodes(), *(callMeStmt->GetMustDefList())); - } - BuildChiList(*callMeStmt, ssaPart->GetMayDefNodes(), *(callMeStmt->GetChiList())); - return callMeStmt; - } - case OP_icall: - case OP_icallassigned: - case OP_intrinsiccall: - case OP_xintrinsiccall: - case OP_intrinsiccallwithtype: - case OP_intrinsiccallassigned: - case OP_intrinsiccallwithtypeassigned: { - NaryMeStmt *naryMeStmt = (op == OP_icall || op == OP_icallassigned) - ? static_cast(NewInPool(&stmt)) - : static_cast(NewInPool(&stmt)); - NaryStmtNode &naryStmtNode = static_cast(stmt); - for (size_t i = 0; i < naryStmtNode.NumOpnds(); i++) { - naryMeStmt->GetOpnds().push_back(BuildExpr(*naryStmtNode.Opnd(i))); - } - BuildMuList(ssaPart->GetMayUseNodes(), *(naryMeStmt->GetMuList())); - if (kOpcodeInfo.IsCallAssigned(op)) { - BuildMustDefList(*naryMeStmt, ssaPart->GetMustDefNodes(), *(naryMeStmt->GetMustDefList())); - } - BuildChiList(*naryMeStmt, ssaPart->GetMayDefNodes(), *(naryMeStmt->GetChiList())); - return naryMeStmt; - } - case OP_return: { - NaryStmtNode &retStmt = static_cast(stmt); - RetMeStmt *meStmt = NewInPool(&stmt); - for (size_t i = 0; i < retStmt.NumOpnds(); i++) { - meStmt->GetOpnds().push_back(BuildExpr(*retStmt.Opnd(i))); - } - BuildMuList(ssaPart->GetMayUseNodes(), *(meStmt->GetMuList())); - return meStmt; - } - case OP_retsub: { - WithMuMeStmt *retSub = NewInPool(&stmt); - BuildMuList(ssaPart->GetMayUseNodes(), *(retSub->GetMuList())); - return retSub; - } - case OP_gosub: { - GosubMeStmt *goSub = NewInPool(&stmt); - BuildMuList(ssaPart->GetMayUseNodes(), *(goSub->GetMuList())); - return goSub; - } - case OP_throw: { - UnaryStmtNode &unaryNode = static_cast(stmt); - ThrowMeStmt *tmeStmt = NewInPool(&stmt); - tmeStmt->SetMeStmtOpndValue(BuildExpr(*unaryNode.Opnd(0))); - BuildMuList(ssaPart->GetMayUseNodes(), *(tmeStmt->GetMuList())); - return tmeStmt; - } - case OP_syncenter: - case OP_syncexit: { - NaryStmtNode &naryNode = static_cast(stmt); - SyncMeStmt *naryStmt = NewInPool(&stmt); - for (size_t i = 0; i < naryNode.NumOpnds(); i++) { - naryStmt->GetOpnds().push_back(BuildExpr(*naryNode.Opnd(i))); - } - BuildMuList(ssaPart->GetMayUseNodes(), *(naryStmt->GetMuList())); - BuildChiList(*naryStmt, ssaPart->GetMayDefNodes(), *(naryStmt->GetChiList())); - return naryStmt; - } - default: { - ASSERT(false, "NYI"); - return nullptr; - } - } + + auto func = CreateProductFunction(stmt.GetOpCode()); + ASSERT(func != nullptr, "NYI"); + return func != nullptr ? func(this, stmt, *ssaPart) : nullptr; } void IRMap::BuildMuList(MapleMap &mayuseList, MapleMap &mulist) { @@ -535,279 +526,78 @@ void IRMap::BuildMuList(MapleMap &mayuseList, MapleMap(mirNode); - VersionSt *verSt = addrofnode.GetSSAVar(); - OriginalSt *oSt = verSt->GetOrigSt(); - AddrofMeExpr addrofme(kInvalidExprID, oSt->GetIndex()); - addrofme.InitBase(mirNode.GetOpCode(), mirNode.GetPrimType(), mirNode.GetNumOpnds()); - addrofme.SetFieldID(addrofnode.GetFieldID()); - retMeExpr = HashMeExpr(addrofme); - break; - } - case OP_dread: { - AddrofSSANode &addrofnode = static_cast(mirNode); - VersionSt *verSt = addrofnode.GetSSAVar(); - VarMeExpr *varmeexpr = GetOrCreateVarFromVerSt(*verSt); - varmeexpr->InitBase(mirNode.GetOpCode(), mirNode.GetPrimType(), mirNode.GetNumOpnds()); - if (verSt->GetOrigSt()->IsRealSymbol()) { - ASSERT(!verSt->GetOrigSt()->IsPregOst(), "not expect preg symbol here"); - varmeexpr->SetPtyp( - GlobalTables::GetTypeTable().GetTypeFromTyIdx(verSt->GetOrigSt()->GetTyIdx())->GetPrimType()); - varmeexpr->SetFieldID(addrofnode.GetFieldID()); - } - retMeExpr = varmeexpr; - break; - } - case OP_regread: { - RegreadSSANode ®node = static_cast(mirNode); - VersionSt *verSt = regnode.GetSSAVar(); - RegMeExpr *regmeexpr = GetOrCreateRegFromVerSt(*verSt); - regmeexpr->InitBase(mirNode.GetOpCode(), mirNode.GetPrimType(), mirNode.GetNumOpnds()); - retMeExpr = regmeexpr; - break; - } - case OP_addroffunc: { - AddroffuncNode &addfuncnode = static_cast(mirNode); - PUIdx puidx = addfuncnode.GetPUIdx(); - AddroffuncMeExpr addrfuncme(kInvalidExprID, puidx); - addrfuncme.InitBase(mirNode.GetOpCode(), mirNode.GetPrimType(), mirNode.GetNumOpnds()); - retMeExpr = HashMeExpr(addrfuncme); - break; - } - case OP_gcmalloc: - case OP_gcpermalloc: { - GCMallocNode &gcmallocnode = static_cast(mirNode); - TyIdx tyidx = gcmallocnode.GetTyIdx(); - GcmallocMeExpr gcmallocme(kInvalidExprID, tyidx); - gcmallocme.InitBase(mirNode.GetOpCode(), mirNode.GetPrimType(), mirNode.GetNumOpnds()); - retMeExpr = HashMeExpr(gcmallocme); - break; - } - case OP_sizeoftype: { - SizeoftypeNode &sizeoftypenode = static_cast(mirNode); - SizeoftypeMeExpr sizemeexpr(kInvalidExprID, sizeoftypenode.GetTyIdx()); - sizemeexpr.InitBase(mirNode.GetOpCode(), mirNode.GetPrimType(), mirNode.GetNumOpnds()); - retMeExpr = HashMeExpr(sizemeexpr); - break; - } - case OP_fieldsdist: { - FieldsDistNode &fieldsDistNode = static_cast(mirNode); - FieldsDistMeExpr fieldsDistExpr(kInvalidExprID, fieldsDistNode.GetTyIdx(), fieldsDistNode.GetFiledID1(), - fieldsDistNode.GetFiledID2()); - fieldsDistExpr.InitBase(mirNode.GetOpCode(), mirNode.GetPrimType(), mirNode.GetNumOpnds()); - retMeExpr = HashMeExpr(fieldsDistExpr); - break; - } - case OP_iread: { - IreadSSANode &ireadnode = static_cast(mirNode); - IvarMeExpr ivarmeexpr(kInvalidExprID); - ivarmeexpr.SetFieldID(ireadnode.GetFieldID()); - ivarmeexpr.SetTyIdx(ireadnode.GetTyIdx()); - ivarmeexpr.SetBase(BuildExpr(*ireadnode.Opnd(0))); - ivarmeexpr.InitBase(mirNode.GetOpCode(), mirNode.GetPrimType(), mirNode.GetNumOpnds()); - VersionSt *verSt = ireadnode.GetSSAVar(); - if (verSt != nullptr) { - VarMeExpr *varmeexpr = GetOrCreateVarFromVerSt(*verSt); - ivarmeexpr.SetMuVal(varmeexpr); - } - retMeExpr = HashMeExpr(ivarmeexpr); - ASSERT(static_cast(retMeExpr)->GetMu() != nullptr, - "BuildExpr: ivar node cannot have mu == nullptr"); - break; - } - case OP_constval: { - ConstvalNode &constnode = static_cast(mirNode); - retMeExpr = CreateConstMeExpr(constnode.GetPrimType(), *constnode.GetConstVal()); - break; - } - case OP_conststr: { - ConststrNode &constnode = static_cast(mirNode); - ConststrMeExpr conststrmeexpr(kInvalidExprID, constnode.GetStrIdx()); - conststrmeexpr.InitBase(mirNode.GetOpCode(), mirNode.GetPrimType(), mirNode.GetNumOpnds()); - retMeExpr = HashMeExpr(conststrmeexpr); - break; - } - case OP_conststr16: { - Conststr16Node &constnode = static_cast(mirNode); - Conststr16MeExpr conststrmeexpr(kInvalidExprID, constnode.GetStrIdx()); - conststrmeexpr.InitBase(mirNode.GetOpCode(), mirNode.GetPrimType(), mirNode.GetNumOpnds()); - retMeExpr = HashMeExpr(conststrmeexpr); - break; - } - case OP_eq: - case OP_ne: - case OP_lt: - case OP_gt: - case OP_le: - case OP_ge: - case OP_cmpg: - case OP_cmpl: - case OP_cmp: { - OpMeExpr opmeexpr(kInvalidExprID); - CompareNode &cmpnode = static_cast(mirNode); - opmeexpr.SetOpnd(0, BuildExpr(*cmpnode.Opnd(0))); - opmeexpr.SetOpnd(1, BuildExpr(*cmpnode.Opnd(1))); - opmeexpr.InitBase(mirNode.GetOpCode(), mirNode.GetPrimType(), mirNode.GetNumOpnds()); - opmeexpr.SetOpndType(cmpnode.GetOpndType()); - retMeExpr = HashMeExpr(opmeexpr); - static_cast(retMeExpr)->SetOpndType(cmpnode.GetOpndType()); - break; - } - case OP_ceil: - case OP_cvt: - case OP_floor: - case OP_trunc: { - OpMeExpr opmeexpr(kInvalidExprID); - TypeCvtNode &tycvtnode = static_cast(mirNode); - opmeexpr.SetOpnd(0, BuildExpr(*tycvtnode.Opnd(0))); - opmeexpr.InitBase(mirNode.GetOpCode(), mirNode.GetPrimType(), mirNode.GetNumOpnds()); - opmeexpr.SetOpndType(tycvtnode.FromType()); - retMeExpr = HashMeExpr(opmeexpr); - break; - } - case OP_retype: { - OpMeExpr opmeexpr(kInvalidExprID); - RetypeNode &tycvtnode = static_cast(mirNode); - opmeexpr.SetOpnd(0, BuildExpr(*tycvtnode.Opnd(0))); - opmeexpr.InitBase(mirNode.GetOpCode(), mirNode.GetPrimType(), mirNode.GetNumOpnds()); - opmeexpr.SetOpndType(tycvtnode.FromType()); - opmeexpr.SetTyIdx(tycvtnode.GetTyIdx()); - retMeExpr = HashMeExpr(opmeexpr); - break; - } - case OP_abs: - case OP_bnot: - case OP_lnot: - case OP_neg: - case OP_recip: - case OP_sqrt: - case OP_alloca: - case OP_malloc: { - OpMeExpr opmeexpr(kInvalidExprID); - UnaryNode &unnode = static_cast(mirNode); - opmeexpr.SetOpnd(0, BuildExpr(*unnode.Opnd(0))); - opmeexpr.InitBase(mirNode.GetOpCode(), mirNode.GetPrimType(), mirNode.GetNumOpnds()); - retMeExpr = HashMeExpr(opmeexpr); - break; - } - case OP_iaddrof: { - OpMeExpr opmeexpr(kInvalidExprID); - IreadNode &unnode = static_cast(mirNode); - opmeexpr.SetTyIdx(unnode.GetTyIdx()); - opmeexpr.SetFieldID(unnode.GetFieldID()); - opmeexpr.SetOpnd(0, BuildExpr(*unnode.Opnd(0))); - opmeexpr.InitBase(mirNode.GetOpCode(), mirNode.GetPrimType(), mirNode.GetNumOpnds()); - retMeExpr = HashMeExpr(opmeexpr); - break; - } - case OP_sext: - case OP_zext: - case OP_extractbits: { - OpMeExpr opmeexpr(kInvalidExprID); - ExtractbitsNode &extnode = static_cast(mirNode); - opmeexpr.SetOpnd(0, BuildExpr(*extnode.Opnd(0))); - opmeexpr.SetBitsOffSet(extnode.GetBitsOffset()); - opmeexpr.SetBitsSize(extnode.GetBitsSize()); - opmeexpr.InitBase(mirNode.GetOpCode(), mirNode.GetPrimType(), mirNode.GetNumOpnds()); - retMeExpr = HashMeExpr(opmeexpr); - break; - } - case OP_gcmallocjarray: - case OP_gcpermallocjarray: { - OpMeExpr opmeexpr(kInvalidExprID); - JarrayMallocNode &gcnode = static_cast(mirNode); - opmeexpr.SetOpnd(0, BuildExpr(*gcnode.Opnd(0))); - opmeexpr.SetTyIdx(gcnode.GetTyIdx()); - opmeexpr.InitBase(mirNode.GetOpCode(), mirNode.GetPrimType(), mirNode.GetNumOpnds()); - retMeExpr = HashMeExpr(opmeexpr); - break; - } - case OP_resolveinterfacefunc: - case OP_resolvevirtualfunc: { - OpMeExpr opmeexpr(kInvalidExprID); - ResolveFuncNode &rsnode = static_cast(mirNode); - opmeexpr.SetOpnd(0, BuildExpr(*rsnode.Opnd(0))); - opmeexpr.SetOpnd(1, BuildExpr(*rsnode.Opnd(1))); - opmeexpr.SetFieldID(rsnode.GetPuIdx()); - opmeexpr.InitBase(mirNode.GetOpCode(), mirNode.GetPrimType(), mirNode.GetNumOpnds()); - retMeExpr = HashMeExpr(opmeexpr); - break; - } - case OP_sub: - case OP_mul: - case OP_div: - case OP_rem: - case OP_ashr: - case OP_lshr: - case OP_shl: - case OP_max: - case OP_min: - case OP_band: - case OP_bior: - case OP_bxor: - case OP_land: - case OP_lior: - case OP_add: { - OpMeExpr opmeexpr(kInvalidExprID); - BinaryNode &bnode = static_cast(mirNode); - opmeexpr.SetOpnd(0, BuildExpr(*bnode.Opnd(0))); - opmeexpr.SetOpnd(1, BuildExpr(*bnode.Opnd(1))); - opmeexpr.InitBase(mirNode.GetOpCode(), mirNode.GetPrimType(), mirNode.GetNumOpnds()); - retMeExpr = HashMeExpr(opmeexpr); - break; - } - case OP_select: { - OpMeExpr opmeexpr(kInvalidExprID); - TernaryNode &bnode = static_cast(mirNode); - opmeexpr.SetOpnd(0, BuildExpr(*bnode.Opnd(0))); - opmeexpr.SetOpnd(1, BuildExpr(*bnode.Opnd(1))); - opmeexpr.SetOpnd(2, BuildExpr(*bnode.Opnd(2))); - opmeexpr.InitBase(mirNode.GetOpCode(), mirNode.GetPrimType(), mirNode.GetNumOpnds()); - retMeExpr = HashMeExpr(opmeexpr); - break; - } - case OP_array: { - ArrayNode &arrnode = static_cast(mirNode); - NaryMeExpr arrmeexpr(&tempAlloc, kInvalidExprID, arrnode.GetTyIdx(), INTRN_UNDEFINED, arrnode.GetBoundsCheck()); - for (size_t i = 0; i < arrnode.NumOpnds(); i++) { - arrmeexpr.GetOpnds().push_back(BuildExpr(*arrnode.Opnd(i))); - } - arrmeexpr.InitBase(mirNode.GetOpCode(), mirNode.GetPrimType(), mirNode.GetNumOpnds()); - retMeExpr = HashMeExpr(arrmeexpr); - break; - } - case OP_intrinsicop: { - IntrinsicopNode &intrinnode = static_cast(mirNode); - size_t numOpnds = intrinnode.NumOpnds(); - NaryMeExpr narymeexpr(&tempAlloc, kInvalidExprID, TyIdx(0), intrinnode.GetIntrinsic(), false); - for (size_t i = 0; i < numOpnds; i++) { - narymeexpr.GetOpnds().push_back(BuildExpr(*intrinnode.Opnd(i))); - } - narymeexpr.InitBase(mirNode.GetOpCode(), mirNode.GetPrimType(), mirNode.GetNumOpnds()); - retMeExpr = HashMeExpr(narymeexpr); - break; + + if (op == OP_dread) { + AddrofSSANode &addrofnode = static_cast(mirNode); + VersionSt *verSt = addrofnode.GetSSAVar(); + VarMeExpr *varmeexpr = GetOrCreateVarFromVerSt(*verSt); + varmeexpr->InitBase(mirNode.GetOpCode(), mirNode.GetPrimType(), mirNode.GetNumOpnds()); + if (verSt->GetOrigSt()->IsRealSymbol()) { + ASSERT(!verSt->GetOrigSt()->IsPregOst(), "not expect preg symbol here"); + varmeexpr->SetPtyp(GlobalTables::GetTypeTable().GetTypeFromTyIdx(verSt->GetOrigSt()->GetTyIdx())->GetPrimType()); + varmeexpr->SetFieldID(addrofnode.GetFieldID()); } - case OP_intrinsicopwithtype: { - IntrinsicopNode &intrinnode = static_cast(mirNode); - size_t numOpnds = intrinnode.NumOpnds(); - NaryMeExpr narymeexpr(&irMapAlloc, kInvalidExprID, intrinnode.GetTyIdx(), intrinnode.GetIntrinsic(), false); - for (size_t i = 0; i < numOpnds; i++) { - narymeexpr.GetOpnds().push_back(BuildExpr(*intrinnode.Opnd(i))); - } - narymeexpr.InitBase(mirNode.GetOpCode(), mirNode.GetPrimType(), mirNode.GetNumOpnds()); - retMeExpr = HashMeExpr(narymeexpr); - break; + return varmeexpr; + } + + if (op == OP_regread) { + RegreadSSANode ®node = static_cast(mirNode); + VersionSt *verSt = regnode.GetSSAVar(); + RegMeExpr *regmeexpr = GetOrCreateRegFromVerSt(*verSt); + regmeexpr->InitBase(mirNode.GetOpCode(), mirNode.GetPrimType(), mirNode.GetNumOpnds()); + return regmeexpr; + } + + MeExpr *meExpr = meBuilder.BuildMeExpr(mirNode); + SetMeExprOpnds(*meExpr, mirNode); + + if (op == OP_iread) { + IvarMeExpr *ivarMeExpr = static_cast(meExpr); + IreadSSANode &ireadSSANode = static_cast(mirNode); + ivarMeExpr->SetBase(BuildExpr(*ireadSSANode.Opnd(0))); + VersionSt *verSt = ireadSSANode.GetSSAVar(); + if (verSt != nullptr) { + VarMeExpr *varMeExpr = GetOrCreateVarFromVerSt(*verSt); + ivarMeExpr->SetMuVal(varMeExpr); } - default: - ASSERT(false, "NIY BuildExpe"); } + + MeExpr *retMeExpr = HashMeExpr(*meExpr); + + if (op == OP_iread) { + ASSERT(static_cast(retMeExpr)->GetMu() != nullptr, "BuildExpr: ivar node cannot have mu == nullptr"); + } + return retMeExpr; } +void IRMap::SetMeExprOpnds(MeExpr &meExpr, BaseNode &mirNode) { + OpMeExpr &opMeExpr = static_cast(meExpr); + if (mirNode.IsUnaryNode()) { + if (mirNode.GetOpCode() != OP_iread) { + opMeExpr.SetOpnd(0, BuildExpr(*static_cast(mirNode).Opnd(0))); + } + } else if (mirNode.IsBinaryNode()) { + BinaryNode &binaryNode = static_cast(mirNode); + opMeExpr.SetOpnd(0, BuildExpr(*binaryNode.Opnd(0))); + opMeExpr.SetOpnd(1, BuildExpr(*binaryNode.Opnd(1))); + } else if (mirNode.IsTernaryNode()) { + TernaryNode &ternaryNode = static_cast(mirNode); + opMeExpr.SetOpnd(0, BuildExpr(*ternaryNode.Opnd(0))); + opMeExpr.SetOpnd(1, BuildExpr(*ternaryNode.Opnd(1))); + opMeExpr.SetOpnd(2, BuildExpr(*ternaryNode.Opnd(2))); + } else if (mirNode.IsNaryNode()) { + NaryMeExpr &naryMeExpr = static_cast(meExpr); + NaryNode &naryNode = static_cast(mirNode); + for (size_t i = 0; i < naryNode.NumOpnds(); i++) { + naryMeExpr.GetOpnds().push_back(BuildExpr(*naryNode.Opnd(i))); + } + } else { + // No need to do anything + } +} + void IRMap::PutToBucket(uint32 hashidx, MeExpr &meExpr) { MeExpr *headexpr = hashTable[hashidx]; if (headexpr != nullptr) { @@ -816,244 +606,46 @@ void IRMap::PutToBucket(uint32 hashidx, MeExpr &meExpr) { hashTable[hashidx] = &meExpr; } - // Check if two IvarMeExpr are identical. - // If ivar_use is the first use of the same ivar coming from an iassign - // (ivar_def), then update its mu: ivar_def->mu = ivar_use->mu. -static bool AreIvarIdentical(IvarMeExpr &ivarUse, IvarMeExpr &ivarDef) { - if (ivarDef.GetBase()->GetExprID() != ivarUse.GetBase()->GetExprID()) { - return false; - } - if (ivarDef.GetFieldID() != ivarUse.GetFieldID()) { - return false; - } - if (ivarUse.GetTyIdx() != ivarDef.GetTyIdx()) { - return false; +MeExpr *IRMap::HashMeExpr(MeExpr &meExpr) { + MeExpr *resultExpr = nullptr; + uint32 hidx = meExpr.GetHashIndex() % mapHashLength; + MeExpr *hashedExpr = hashTable[hidx]; + + if (hashedExpr != nullptr && meExpr.GetMeOp() != kMeOpGcmalloc) { + resultExpr = meExpr.GetIdenticalExpr(*hashedExpr); } - // check the two mu being identical - if (ivarUse.GetMu() != ivarDef.GetMu()) { - if (ivarDef.GetMu() != nullptr && ivarUse.GetMu() != nullptr && ivarDef.GetMu()->GetDefBy() == kDefByChi && - ivarUse.GetMu()->GetDefBy() == kDefByChi) { - ChiMeNode &ivarDefChi = ivarDef.GetMu()->GetDefChi(); - ChiMeNode &ivarUseChi = ivarUse.GetMu()->GetDefChi(); - if (ivarDefChi.GetBase() != nullptr && ivarDefChi.GetBase() == ivarUseChi.GetBase()) { - return true; - } - } - if (ivarDef.GetMu() == nullptr && ivarDef.GetDefStmt() != nullptr && ivarUse.GetMu()) { - IassignMeStmt *iass = ivarDef.GetDefStmt(); - if (iass->GetOp() != OP_iassign) { - // this can happen due to use of placement new - return false; - } - for (auto xit = iass->GetChiList()->begin(); xit != iass->GetChiList()->end(); xit++) { - ChiMeNode *chi = xit->second; - if (chi->GetLHS()->GetExprID() == ivarUse.GetMu()->GetExprID()) { - ivarDef.SetMuVal(ivarUse.GetMu()); - return true; - } - } + + if (resultExpr == nullptr) { + resultExpr = meBuilder.CreateMeExpr(exprID++, meExpr); + if (resultExpr != nullptr) { + PutToBucket(hidx, *resultExpr); } - return false; } - return true; + + return resultExpr; } -MeExpr *IRMap::HashMeExpr(MeExpr &meExpr) { - uint32 hidx = meExpr.GetHashIndex() % mapHashLength; - switch (meExpr.GetMeOp()) { - case kMeOpIvar: { - IvarMeExpr &ivarmeexpr = static_cast(meExpr); - IvarMeExpr *itexpr = static_cast(hashTable[hidx]); - while (itexpr != nullptr) { - if (itexpr->GetMeOp() == kMeOpIvar && AreIvarIdentical(ivarmeexpr, *itexpr)) { - return itexpr; - } - itexpr = static_cast(itexpr->GetNext()); - } - IvarMeExpr *newivarexpr = New(exprID++, ivarmeexpr); - PutToBucket(hidx, *newivarexpr); - return newivarexpr; - } - case kMeOpOp: { - OpMeExpr &opmeexpr = static_cast(meExpr); - if (!kOpcodeInfo.NotPure(opmeexpr.GetOp())) { - MeExpr *itexpr = hashTable[hidx]; - while (itexpr != nullptr) { - if (opmeexpr.IsIdentical(*static_cast(itexpr))) { - return itexpr; - } - itexpr = itexpr->GetNext(); - } - } - OpMeExpr *newopmeexpr = New(opmeexpr, exprID++); - newopmeexpr->UpdateDepth(); - PutToBucket(hidx, *newopmeexpr); - return newopmeexpr; - } - case kMeOpConst: { - ConstMeExpr &constmeexpr = static_cast(meExpr); - ConstMeExpr *itexpr = static_cast(hashTable[hidx]); - MIRConst *mirconst = constmeexpr.GetConstVal(); - while (itexpr != nullptr) { - if (itexpr->GetMeOp() != kMeOpConst) { - itexpr = static_cast(itexpr->GetNext()); - continue; - } - MIRConst *itmirconst = itexpr->GetConstVal(); - if (*mirconst == *itmirconst && meExpr.GetPrimType() == itexpr->GetPrimType()) { - return itexpr; - } - itexpr = static_cast(itexpr->GetNext()); - } - ConstMeExpr *newconstmeexpr = New(exprID++, mirconst); - newconstmeexpr->InitBase(meExpr.GetOp(), meExpr.GetPrimType(), meExpr.GetNumOpnds()); - PutToBucket(hidx, *newconstmeexpr); - return newconstmeexpr; - } - case kMeOpConststr: { - ConststrMeExpr &constMeExpr = static_cast(meExpr); - ConststrMeExpr *itExpr = static_cast(hashTable[hidx]); - UStrIdx strIdx = constMeExpr.GetStrIdx(); - while (itExpr != nullptr) { - if (itExpr->GetMeOp() != kMeOpConststr) { - itExpr = static_cast(itExpr->GetNext()); - continue; - } - UStrIdx itStrIdx = itExpr->GetStrIdx(); - if (itStrIdx == strIdx) { - return itExpr; - } - itExpr = static_cast(itExpr->GetNext()); - } - ConststrMeExpr *newConstMeExpr = New(exprID++, strIdx); - newConstMeExpr->InitBase(meExpr.GetOp(), meExpr.GetPrimType(), meExpr.GetNumOpnds()); - PutToBucket(hidx, *newConstMeExpr); - return newConstMeExpr; - } - case kMeOpConststr16: { - Conststr16MeExpr &constMeExpr = static_cast(meExpr); - Conststr16MeExpr *itExpr = static_cast(hashTable[hidx]); - U16StrIdx strIdx = constMeExpr.GetStrIdx(); - while (itExpr != nullptr) { - if (itExpr->GetMeOp() != kMeOpConststr16) { - itExpr = static_cast(itExpr->GetNext()); - continue; - } - U16StrIdx itstridx = itExpr->GetStrIdx(); - if (itstridx == strIdx) { - return itExpr; - } - itExpr = static_cast(itExpr->GetNext()); - } - Conststr16MeExpr *newconstmeexpr = New(exprID++, strIdx); - newconstmeexpr->InitBase(meExpr.GetOp(), meExpr.GetPrimType(), meExpr.GetNumOpnds()); - PutToBucket(hidx, *newconstmeexpr); - return newconstmeexpr; - } - case kMeOpSizeoftype: { - SizeoftypeMeExpr &sizeoftypeexpr = static_cast(meExpr); - SizeoftypeMeExpr *itexpr = static_cast(hashTable[hidx]); - while (itexpr != nullptr) { - if (itexpr->GetMeOp() != kMeOpSizeoftype) { - itexpr = static_cast(itexpr->GetNext()); - continue; - } - if (itexpr->GetTyIdx() == sizeoftypeexpr.GetTyIdx()) { - return itexpr; - } - itexpr = static_cast(itexpr->GetNext()); - } - SizeoftypeMeExpr *newmeexpr = New(exprID++, sizeoftypeexpr.GetTyIdx()); - newmeexpr->InitBase(meExpr.GetOp(), meExpr.GetPrimType(), meExpr.GetNumOpnds()); - PutToBucket(hidx, *newmeexpr); - return newmeexpr; - } - case kMeOpFieldsDist: { - FieldsDistMeExpr &fieldsDistExpr = static_cast(meExpr); - FieldsDistMeExpr *itexpr = static_cast(hashTable[hidx]); - while (itexpr != nullptr) { - if (itexpr->GetMeOp() != kMeOpFieldsDist) { - itexpr = static_cast(itexpr->GetNext()); - continue; - } - if (itexpr->GetTyIdx() == fieldsDistExpr.GetTyIdx() && - itexpr->GetFieldID1() == fieldsDistExpr.GetFieldID1() && - itexpr->GetFieldID2() == fieldsDistExpr.GetFieldID2()) { - return itexpr; - } - itexpr = static_cast(itexpr->GetNext()); - } - FieldsDistMeExpr *newmeexpr = New(exprID++, fieldsDistExpr.GetTyIdx(), - fieldsDistExpr.GetFieldID1(), fieldsDistExpr.GetFieldID2()); - newmeexpr->InitBase(meExpr.GetOp(), meExpr.GetPrimType(), meExpr.GetNumOpnds()); - PutToBucket(hidx, *newmeexpr); - return newmeexpr; - } - case kMeOpAddrof: { - AddrofMeExpr &addrofmeexpr = static_cast(meExpr); - AddrofMeExpr *itexpr = static_cast(hashTable[hidx]); - while (itexpr != nullptr) { - if (itexpr->GetMeOp() != kMeOpAddrof) { - itexpr = static_cast(itexpr->GetNext()); - continue; - } - if (itexpr->GetOstIdx() == addrofmeexpr.GetOstIdx() && itexpr->GetFieldID() == addrofmeexpr.GetFieldID()) { - return itexpr; - } - itexpr = static_cast(itexpr->GetNext()); - } - AddrofMeExpr *newaddrofmeexpr = New(exprID++, addrofmeexpr.GetOstIdx()); - newaddrofmeexpr->InitBase(meExpr.GetOp(), meExpr.GetPrimType(), meExpr.GetNumOpnds()); - newaddrofmeexpr->SetFieldID(addrofmeexpr.GetFieldID()); - PutToBucket(hidx, *newaddrofmeexpr); - return newaddrofmeexpr; - } - case kMeOpNary: { - NaryMeExpr &narymeexpr = static_cast(meExpr); - NaryMeExpr *itexpr = static_cast(hashTable[hidx]); - while (itexpr != nullptr) { - if ((itexpr->GetOp() == OP_array || - (itexpr->GetOp() == OP_intrinsicop && IntrinDesc::intrinTable[itexpr->GetIntrinsic()].IsPure())) && - itexpr->IsIdentical(narymeexpr)) { - return itexpr; - } - itexpr = static_cast(itexpr->GetNext()); - } - NaryMeExpr *newnarymeexpr = NewInPool(exprID++, narymeexpr); - newnarymeexpr->InitBase(meExpr.GetOp(), meExpr.GetPrimType(), meExpr.GetNumOpnds()); - newnarymeexpr->UpdateDepth(); - PutToBucket(hidx, *newnarymeexpr); - return newnarymeexpr; +MeExpr *IRMap::ReplaceMeExprExpr(MeExpr &origExpr, MeExpr &newExpr, size_t opndsSize, MeExpr &meExpr, MeExpr &repExpr) { + bool needRehash = false; + + for (size_t i = 0; i < opndsSize; i++) { + MeExpr *origOpnd = origExpr.GetOpnd(i); + if (origOpnd == nullptr) { + continue; } - case kMeOpAddroffunc: { - AddroffuncMeExpr &funcmeexpr = static_cast(meExpr); - AddroffuncMeExpr *itexpr = static_cast(hashTable[hidx]); - while (itexpr != nullptr) { - if (itexpr->GetMeOp() != kMeOpAddroffunc) { - itexpr = static_cast(itexpr->GetNext()); - continue; - } - if (itexpr->GetPuIdx() == funcmeexpr.GetPuIdx()) { - return itexpr; - } - itexpr = static_cast(itexpr->GetNext()); + + if (origOpnd == &meExpr) { + needRehash = true; + newExpr.SetOpnd(i, &repExpr); + } else if (!origOpnd->IsLeaf()) { + newExpr.SetOpnd(i, ReplaceMeExprExpr(*newExpr.GetOpnd(i), meExpr, repExpr)); + if (newExpr.GetOpnd(i) != origOpnd) { + needRehash = true; } - AddroffuncMeExpr *newexpr = New(exprID++, funcmeexpr.GetPuIdx()); - newexpr->InitBase(meExpr.GetOp(), meExpr.GetPrimType(), meExpr.GetNumOpnds()); - PutToBucket(hidx, *newexpr); - return newexpr; } - case kMeOpGcmalloc: { - GcmallocMeExpr &gcmeexpr = static_cast(meExpr); - GcmallocMeExpr *newexpr = New(exprID++, gcmeexpr.GetTyIdx()); - newexpr->InitBase(meExpr.GetOp(), meExpr.GetPrimType(), meExpr.GetNumOpnds()); - PutToBucket(hidx, *newexpr); - return newexpr; - } - default: - ASSERT(false, "not yet implement"); - return nullptr; } + + return needRehash ? HashMeExpr(newExpr) : &origExpr; } // replace meExpr with repexpr. meExpr must be a kid of origexpr @@ -1062,45 +654,17 @@ MeExpr *IRMap::ReplaceMeExprExpr(MeExpr &origExpr, MeExpr &meExpr, MeExpr &repEx if (origExpr.IsLeaf()) { return &origExpr; } + switch (origExpr.GetMeOp()) { case kMeOpOp: { OpMeExpr &opMeExpr = static_cast(origExpr); OpMeExpr newMeExpr(opMeExpr, kInvalidExprID); - bool needRehash = false; - for (uint32 i = 0; i < kOperandNumTernary; i++) { - if (!opMeExpr.GetOpnd(i)) { - continue; - } - if (opMeExpr.GetOpnd(i) == &meExpr) { - needRehash = true; - newMeExpr.SetOpnd(i, &repExpr); - } else if (!opMeExpr.GetOpnd(i)->IsLeaf()) { - newMeExpr.SetOpnd(i, ReplaceMeExprExpr(*newMeExpr.GetOpnd(i), meExpr, repExpr)); - if (newMeExpr.GetOpnd(i) != opMeExpr.GetOpnd(i)) { - needRehash = true; - } - } - } - return needRehash ? HashMeExpr(newMeExpr) : &origExpr; + return ReplaceMeExprExpr(opMeExpr, newMeExpr, kOperandNumTernary, meExpr, repExpr); } case kMeOpNary: { NaryMeExpr &narymeexpr = static_cast(origExpr); NaryMeExpr newmeexpr(&irMapAlloc, kInvalidExprID, narymeexpr); - const MapleVector &opnds = narymeexpr.GetOpnds(); - bool needRehash = false; - for (size_t i = 0; i < opnds.size(); i++) { - MeExpr *opnd = opnds[i]; - if (opnd == &meExpr) { - newmeexpr.SetOpnd(i, &repExpr); - needRehash = true; - } else if (!opnd->IsLeaf()) { - newmeexpr.SetOpnd(i, ReplaceMeExprExpr(*newmeexpr.GetOpnd(i), meExpr, repExpr)); - if (newmeexpr.GetOpnd(i) != opnd) { - needRehash = true; - } - } - } - return needRehash ? HashMeExpr(newmeexpr) : &origExpr; + return ReplaceMeExprExpr(narymeexpr, newmeexpr, narymeexpr.GetOpnds().size(), meExpr, repExpr); } case kMeOpIvar: { IvarMeExpr &ivarexpr = static_cast(origExpr); @@ -1138,91 +702,32 @@ bool IRMap::ReplaceMeExprStmtOpnd(uint32 opndID, MeStmt &meStmt, MeExpr &meExpr, // replace meExpr in meStmt with repexpr bool IRMap::ReplaceMeExprStmt(MeStmt &meStmt, MeExpr &meExpr, MeExpr &repexpr) { bool isReplaced = false; - switch (meStmt.GetOp()) { - case OP_dassign: - case OP_regassign: - case OP_maydassign: - case OP_decref: - case OP_decrefreset: - case OP_incref: - case OP_assertnonnull: - case OP_eval: - case OP_free: - case OP_switch: - case OP_brtrue: - case OP_brfalse: - case OP_throw: { - isReplaced = ReplaceMeExprStmtOpnd(0, meStmt, meExpr, repexpr); - break; - } - case OP_syncenter: - case OP_syncexit: - case OP_call: - case OP_virtualcall: - case OP_virtualicall: - case OP_superclasscall: - case OP_interfacecall: - case OP_interfaceicall: - case OP_customcall: - case OP_polymorphiccall: - case OP_icall: - case OP_callassigned: - case OP_virtualcallassigned: - case OP_virtualicallassigned: - case OP_superclasscallassigned: - case OP_interfacecallassigned: - case OP_interfaceicallassigned: - case OP_customcallassigned: - case OP_polymorphiccallassigned: - case OP_icallassigned: - case OP_return: { - for (size_t i = 0; i < meStmt.NumMeStmtOpnds(); i++) { - bool curOpndReplaced = ReplaceMeExprStmtOpnd(i, meStmt, meExpr, repexpr); - isReplaced = isReplaced || curOpndReplaced; - } - break; - } - case OP_intrinsiccall: - case OP_xintrinsiccall: - case OP_intrinsiccallwithtype: - case OP_intrinsiccallassigned: - case OP_xintrinsiccallassigned: - case OP_intrinsiccallwithtypeassigned: { - for (size_t i = 0; i < meStmt.NumMeStmtOpnds(); i++) { - MeExpr *opnd = meStmt.GetOpnd(i); - if (opnd->IsLeaf() && opnd->GetMeOp() == kMeOpVar) { - VarMeExpr *varmeexpr = static_cast(opnd); - const OriginalSt *orgsym = ssaTab.GetOriginalStFromID(varmeexpr->GetOStIdx()); - if (orgsym->IsSymbolOst() && orgsym->GetMIRSymbol()->GetAttr(ATTR_static)) { - // its address may be taken - continue; - } + Opcode op = meStmt.GetOp(); + + for (size_t i = 0; i < meStmt.NumMeStmtOpnds(); i++) { + if (op == OP_intrinsiccall || op == OP_xintrinsiccall || op == OP_intrinsiccallwithtype || + op == OP_intrinsiccallassigned || op == OP_xintrinsiccallassigned || + op == OP_intrinsiccallwithtypeassigned) { + MeExpr *opnd = meStmt.GetOpnd(i); + if (opnd->IsLeaf() && opnd->GetMeOp() == kMeOpVar) { + VarMeExpr *varmeexpr = static_cast(opnd); + const OriginalSt *orgsym = ssaTab.GetOriginalStFromID(varmeexpr->GetOStIdx()); + if (orgsym->IsSymbolOst() && orgsym->GetMIRSymbol()->GetAttr(ATTR_static)) { + // its address may be taken + continue; } - bool curOpndReplaced = ReplaceMeExprStmtOpnd(i, meStmt, meExpr, repexpr); - isReplaced = isReplaced || curOpndReplaced; } - break; } - case OP_iassign: { + + bool curOpndReplaced = ReplaceMeExprStmtOpnd(i, meStmt, meExpr, repexpr); + isReplaced = isReplaced || curOpndReplaced; + + if (i == 0 && curOpndReplaced && op == OP_iassign) { IassignMeStmt &ivarstmt = static_cast(meStmt); - bool baseIsReplaced = ReplaceMeExprStmtOpnd(0, meStmt, meExpr, repexpr); - if (baseIsReplaced) { - ivarstmt.SetLHSVal(BuildLHSIvar(*ivarstmt.GetOpnd(0), ivarstmt, ivarstmt.GetLHSVal()->GetFieldID())); - } - bool rhsReplaced = ReplaceMeExprStmtOpnd(1, meStmt, meExpr, repexpr); - isReplaced = baseIsReplaced || rhsReplaced; - break; + ivarstmt.SetLHSVal(BuildLHSIvar(*ivarstmt.GetOpnd(0), ivarstmt, ivarstmt.GetLHSVal()->GetFieldID())); } - case OP_assertlt: - case OP_assertge: { - bool opnd0Replaced = ReplaceMeExprStmtOpnd(0, meStmt, meExpr, repexpr); - bool opnd1Replaced = ReplaceMeExprStmtOpnd(1, meStmt, meExpr, repexpr); - isReplaced = opnd0Replaced || opnd1Replaced; - break; - } - default: - ASSERT(false, "NYI"); } + return isReplaced; } @@ -1355,4 +860,40 @@ MeExpr *IRMap::CreateAddrofMeExprFromNewSymbol(MIRSymbol &st, PUIdx puidx) { addrofme.SetPtyp(PTY_ptr); return HashMeExpr(addrofme); } + +void IRMap::InitMeStmtFactory() const { + RegisterFactoryFunction(OP_dassign, &IRMap::BuildDassignMeStmt); + RegisterFactoryFunction(OP_regassign, &IRMap::BuildRegassignMeStmt); + RegisterFactoryFunction(OP_iassign, &IRMap::BuildIassignMeStmt); + RegisterFactoryFunction(OP_maydassign, &IRMap::BuildMaydassignMeStmt); + RegisterFactoryFunction(OP_call, &IRMap::BuildCallMeStmt); + RegisterFactoryFunction(OP_virtualcall, &IRMap::BuildCallMeStmt); + RegisterFactoryFunction(OP_virtualicall, &IRMap::BuildCallMeStmt); + RegisterFactoryFunction(OP_superclasscall, &IRMap::BuildCallMeStmt); + RegisterFactoryFunction(OP_interfacecall, &IRMap::BuildCallMeStmt); + RegisterFactoryFunction(OP_interfaceicall, &IRMap::BuildCallMeStmt); + RegisterFactoryFunction(OP_customcall, &IRMap::BuildCallMeStmt); + RegisterFactoryFunction(OP_polymorphiccall, &IRMap::BuildCallMeStmt); + RegisterFactoryFunction(OP_callassigned, &IRMap::BuildCallMeStmt); + RegisterFactoryFunction(OP_virtualcallassigned, &IRMap::BuildCallMeStmt); + RegisterFactoryFunction(OP_virtualicallassigned, &IRMap::BuildCallMeStmt); + RegisterFactoryFunction(OP_superclasscallassigned, &IRMap::BuildCallMeStmt); + RegisterFactoryFunction(OP_interfacecallassigned, &IRMap::BuildCallMeStmt); + RegisterFactoryFunction(OP_interfaceicallassigned, &IRMap::BuildCallMeStmt); + RegisterFactoryFunction(OP_customcallassigned, &IRMap::BuildCallMeStmt); + RegisterFactoryFunction(OP_polymorphiccallassigned, &IRMap::BuildCallMeStmt); + RegisterFactoryFunction(OP_icall, &IRMap::BuildNaryMeStmt); + RegisterFactoryFunction(OP_icallassigned, &IRMap::BuildNaryMeStmt); + RegisterFactoryFunction(OP_intrinsiccall, &IRMap::BuildNaryMeStmt); + RegisterFactoryFunction(OP_xintrinsiccall, &IRMap::BuildNaryMeStmt); + RegisterFactoryFunction(OP_intrinsiccallwithtype, &IRMap::BuildNaryMeStmt); + RegisterFactoryFunction(OP_intrinsiccallassigned, &IRMap::BuildNaryMeStmt); + RegisterFactoryFunction(OP_intrinsiccallwithtypeassigned, &IRMap::BuildNaryMeStmt); + RegisterFactoryFunction(OP_return, &IRMap::BuildRetMeStmt); + RegisterFactoryFunction(OP_retsub, &IRMap::BuildWithMuMeStmt); + RegisterFactoryFunction(OP_gosub, &IRMap::BuildGosubMeStmt); + RegisterFactoryFunction(OP_throw, &IRMap::BuildThrowMeStmt); + RegisterFactoryFunction(OP_syncenter, &IRMap::BuildSyncMeStmt); + RegisterFactoryFunction(OP_syncexit, &IRMap::BuildSyncMeStmt); +} } // namespace maple diff --git a/src/maple_me/src/me_builder.cpp b/src/maple_me/src/me_builder.cpp new file mode 100644 index 0000000000000000000000000000000000000000..07dec18a80c377df4a4e76e93d5ac02ca321e411 --- /dev/null +++ b/src/maple_me/src/me_builder.cpp @@ -0,0 +1,274 @@ +/* + * Copyright (c) [2019] Huawei Technologies Co.,Ltd.All rights reserved. + * + * OpenArkCompiler is licensed under the Mulan PSL v1. + * You can use this software according to the terms and conditions of the Mulan PSL v1. + * You may obtain a copy of Mulan PSL v1 at: + * + * http://license.coscl.org.cn/MulanPSL + * + * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER + * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR + * FIT FOR A PARTICULAR PURPOSE. + * See the Mulan PSL v1 for more details. + */ +#include "me_builder.h" +#include "ssa_mir_nodes.h" +#include "factory.h" + +namespace maple { +using MeExprBuildFactory = FunctionFactory; + +MeExpr *MeBuilder::CreateMeExpr(int32 exprId, MeExpr &meExpr) const { + MeExpr *resultExpr = nullptr; + switch (meExpr.GetMeOp()) { + case kMeOpIvar: + resultExpr = New(exprId, static_cast(meExpr)); + break; + case kMeOpOp: + resultExpr = New(static_cast(meExpr), exprId); + break; + case kMeOpConst: + resultExpr = New(exprId, static_cast(meExpr).GetConstVal()); + break; + case kMeOpConststr: + resultExpr = New(exprId, static_cast(meExpr).GetStrIdx()); + break; + case kMeOpConststr16: + resultExpr = New(exprId, static_cast(meExpr).GetStrIdx()); + break; + case kMeOpSizeoftype: + resultExpr = New(exprId, static_cast(meExpr).GetTyIdx()); + break; + case kMeOpFieldsDist: { + FieldsDistMeExpr &expr = static_cast(meExpr); + resultExpr = New(exprId, expr.GetTyIdx(), expr.GetFieldID1(), expr.GetFieldID2()); + break; + } + case kMeOpAddrof: + resultExpr = New(exprId, static_cast(meExpr).GetOstIdx()); + static_cast(resultExpr)->SetFieldID(static_cast(meExpr).GetFieldID()); + break; + case kMeOpNary: + resultExpr = NewInPool(exprId, static_cast(meExpr)); + break; + case kMeOpAddroffunc: + resultExpr = New(exprId, static_cast(meExpr).GetPuIdx()); + break; + case kMeOpGcmalloc: + resultExpr = New(exprId, static_cast(meExpr).GetTyIdx()); + break; + default: + ASSERT(false, "not yet implement"); + return nullptr; + } + if (resultExpr != nullptr) { + resultExpr->InitBase(meExpr.GetOp(), meExpr.GetPrimType(), meExpr.GetNumOpnds()); + if (meExpr.GetMeOp() == kMeOpOp || meExpr.GetMeOp() == kMeOpNary) { + resultExpr->UpdateDepth(); + } + } + return resultExpr; +} + +MeExpr *MeBuilder::BuildMeExpr(BaseNode &mirNode) const { + auto func = CreateProductFunction(mirNode.GetOpCode()); + ASSERT(func != nullptr, "NIY BuildExpe"); + return func(this, mirNode); +} + +MeExpr *MeBuilder::BuildAddrofMeExpr(BaseNode &mirNode) const { + AddrofSSANode &addrofNode = static_cast(mirNode); + AddrofMeExpr &meExpr = *New(kInvalidExprID, addrofNode.GetSSAVar()->GetOrigSt()->GetIndex()); + meExpr.InitBase(mirNode.GetOpCode(), mirNode.GetPrimType(), mirNode.GetNumOpnds()); + meExpr.SetFieldID(addrofNode.GetFieldID()); + return &meExpr; +} + +MeExpr *MeBuilder::BuildAddroffuncMeExpr(BaseNode &mirNode) const { + AddroffuncMeExpr &meExpr = *New(kInvalidExprID, static_cast(mirNode).GetPUIdx()); + meExpr.InitBase(mirNode.GetOpCode(), mirNode.GetPrimType(), mirNode.GetNumOpnds()); + return &meExpr; +} + +MeExpr *MeBuilder::BuildGCMallocMeExpr(BaseNode &mirNode) const { + GcmallocMeExpr &meExpr = *New(kInvalidExprID, static_cast(mirNode).GetTyIdx()); + meExpr.InitBase(mirNode.GetOpCode(), mirNode.GetPrimType(), mirNode.GetNumOpnds()); + return &meExpr; +} + +MeExpr *MeBuilder::BuildSizeoftypeMeExpr(BaseNode &mirNode) const { + SizeoftypeMeExpr &meExpr = *New(kInvalidExprID, static_cast(mirNode).GetTyIdx()); + meExpr.InitBase(mirNode.GetOpCode(), mirNode.GetPrimType(), mirNode.GetNumOpnds()); + return &meExpr; +} + +MeExpr *MeBuilder::BuildFieldsDistMeExpr(BaseNode &mirNode) const { + FieldsDistNode &fieldsDistNode = static_cast(mirNode); + FieldsDistMeExpr &meExpr = *New(kInvalidExprID, fieldsDistNode.GetTyIdx(), + fieldsDistNode.GetFiledID1(), fieldsDistNode.GetFiledID2()); + meExpr.InitBase(mirNode.GetOpCode(), mirNode.GetPrimType(), mirNode.GetNumOpnds()); + return &meExpr; +} + +MeExpr *MeBuilder::BuildIvarMeExpr(BaseNode &mirNode) const { + IreadSSANode &ireadSSANode = static_cast(mirNode); + IvarMeExpr &meExpr = *New(kInvalidExprID); + meExpr.SetFieldID(ireadSSANode.GetFieldID()); + meExpr.SetTyIdx(ireadSSANode.GetTyIdx()); + meExpr.InitBase(mirNode.GetOpCode(), mirNode.GetPrimType(), mirNode.GetNumOpnds()); + return &meExpr; +} + +MeExpr *MeBuilder::BuildConstMeExpr(BaseNode &mirNode) const { + ConstvalNode &constvalNode = static_cast(mirNode); + ConstMeExpr &meExpr = *New(kInvalidExprID, constvalNode.GetConstVal()); + meExpr.SetOp(OP_constval); + meExpr.SetPtyp(constvalNode.GetPrimType()); + return &meExpr; +} + +MeExpr *MeBuilder::BuildConststrMeExpr(BaseNode &mirNode) const { + ConststrMeExpr &meExpr = *New(kInvalidExprID, static_cast(mirNode).GetStrIdx()); + meExpr.InitBase(mirNode.GetOpCode(), mirNode.GetPrimType(), mirNode.GetNumOpnds()); + return &meExpr; +} + +MeExpr *MeBuilder::BuildConststr16MeExpr(BaseNode &mirNode) const { + Conststr16MeExpr &meExpr = *New(kInvalidExprID, static_cast(mirNode).GetStrIdx()); + meExpr.InitBase(mirNode.GetOpCode(), mirNode.GetPrimType(), mirNode.GetNumOpnds()); + return &meExpr; +} + +MeExpr *MeBuilder::BuildOpMeExprForCompare(BaseNode &mirNode) const { + OpMeExpr *meExpr = BuildOpMeExpr(mirNode); + meExpr->SetOpndType(static_cast(mirNode).GetOpndType()); + return meExpr; +} + +MeExpr *MeBuilder::BuildOpMeExprForTypeCvt(BaseNode &mirNode) const { + OpMeExpr *meExpr = BuildOpMeExpr(mirNode); + meExpr->SetOpndType(static_cast(mirNode).FromType()); + return meExpr; +} + +MeExpr *MeBuilder::BuildOpMeExprForRetype(BaseNode &mirNode) const { + RetypeNode &retypeNode = static_cast(mirNode); + OpMeExpr *meExpr = BuildOpMeExpr(mirNode); + meExpr->SetOpndType(retypeNode.FromType()); + meExpr->SetTyIdx(retypeNode.GetTyIdx()); + return meExpr; +} + +MeExpr *MeBuilder::BuildOpMeExprForIread(BaseNode &mirNode) const { + IreadNode &ireadNode = static_cast(mirNode); + OpMeExpr *meExpr = BuildOpMeExpr(mirNode); + meExpr->SetTyIdx(ireadNode.GetTyIdx()); + meExpr->SetFieldID(ireadNode.GetFieldID()); + return meExpr; +} + +MeExpr *MeBuilder::BuildOpMeExprForExtractbits(BaseNode &mirNode) const { + ExtractbitsNode &extractbitsNode = static_cast(mirNode); + OpMeExpr *meExpr = BuildOpMeExpr(mirNode); + meExpr->SetBitsOffSet(extractbitsNode.GetBitsOffset()); + meExpr->SetBitsSize(extractbitsNode.GetBitsSize()); + return meExpr; +} + +MeExpr *MeBuilder::BuildOpMeExprForJarrayMalloc(BaseNode &mirNode) const { + OpMeExpr *meExpr = BuildOpMeExpr(mirNode); + meExpr->SetTyIdx(static_cast(mirNode).GetTyIdx()); + return meExpr; +} + +MeExpr *MeBuilder::BuildOpMeExprForResolveFunc(BaseNode &mirNode) const { + OpMeExpr *meExpr = BuildOpMeExpr(mirNode); + meExpr->SetFieldID(static_cast(mirNode).GetPuIdx()); + return meExpr; +} + +MeExpr *MeBuilder::BuildNaryMeExprForArray(BaseNode &mirNode) const { + ArrayNode &arrayNode = static_cast(mirNode); + NaryMeExpr &meExpr = + *NewInPool(kInvalidExprID, arrayNode.GetTyIdx(), INTRN_UNDEFINED, arrayNode.GetBoundsCheck()); + meExpr.InitBase(mirNode.GetOpCode(), mirNode.GetPrimType(), mirNode.GetNumOpnds()); + return &meExpr; +} + +MeExpr *MeBuilder::BuildNaryMeExprForIntrinsicop(BaseNode &mirNode) const { + NaryMeExpr &meExpr = + *NewInPool(kInvalidExprID, TyIdx(0), static_cast(mirNode).GetIntrinsic(), false); + meExpr.InitBase(mirNode.GetOpCode(), mirNode.GetPrimType(), mirNode.GetNumOpnds()); + return &meExpr; +} + +MeExpr *MeBuilder::BuildNaryMeExprForIntrinsicWithType(BaseNode &mirNode) const { + IntrinsicopNode &intrinNode = static_cast(mirNode); + NaryMeExpr &meExpr = *NewInPool(kInvalidExprID, intrinNode.GetTyIdx(), intrinNode.GetIntrinsic(), false); + meExpr.InitBase(mirNode.GetOpCode(), mirNode.GetPrimType(), mirNode.GetNumOpnds()); + return &meExpr; +} + +void MeBuilder::InitMeExprBuildFactory() const { + RegisterFactoryFunction(OP_addrof, &MeBuilder::BuildAddrofMeExpr); + RegisterFactoryFunction(OP_addroffunc, &MeBuilder::BuildAddroffuncMeExpr); + RegisterFactoryFunction(OP_gcmalloc, &MeBuilder::BuildGCMallocMeExpr); + RegisterFactoryFunction(OP_gcpermalloc, &MeBuilder::BuildGCMallocMeExpr); + RegisterFactoryFunction(OP_sizeoftype, &MeBuilder::BuildSizeoftypeMeExpr); + RegisterFactoryFunction(OP_fieldsdist, &MeBuilder::BuildFieldsDistMeExpr); + RegisterFactoryFunction(OP_iread, &MeBuilder::BuildIvarMeExpr); + RegisterFactoryFunction(OP_constval, &MeBuilder::BuildConstMeExpr); + RegisterFactoryFunction(OP_conststr, &MeBuilder::BuildConststrMeExpr); + RegisterFactoryFunction(OP_conststr16, &MeBuilder::BuildConststr16MeExpr); + RegisterFactoryFunction(OP_eq, &MeBuilder::BuildOpMeExprForCompare); + RegisterFactoryFunction(OP_ne, &MeBuilder::BuildOpMeExprForCompare); + RegisterFactoryFunction(OP_lt, &MeBuilder::BuildOpMeExprForCompare); + RegisterFactoryFunction(OP_gt, &MeBuilder::BuildOpMeExprForCompare); + RegisterFactoryFunction(OP_le, &MeBuilder::BuildOpMeExprForCompare); + RegisterFactoryFunction(OP_ge, &MeBuilder::BuildOpMeExprForCompare); + RegisterFactoryFunction(OP_cmpg, &MeBuilder::BuildOpMeExprForCompare); + RegisterFactoryFunction(OP_cmpl, &MeBuilder::BuildOpMeExprForCompare); + RegisterFactoryFunction(OP_cmp, &MeBuilder::BuildOpMeExprForCompare); + RegisterFactoryFunction(OP_ceil, &MeBuilder::BuildOpMeExprForTypeCvt); + RegisterFactoryFunction(OP_cvt, &MeBuilder::BuildOpMeExprForTypeCvt); + RegisterFactoryFunction(OP_floor, &MeBuilder::BuildOpMeExprForTypeCvt); + RegisterFactoryFunction(OP_trunc, &MeBuilder::BuildOpMeExprForTypeCvt); + RegisterFactoryFunction(OP_retype, &MeBuilder::BuildOpMeExprForRetype); + RegisterFactoryFunction(OP_abs, &MeBuilder::BuildOpMeExpr); + RegisterFactoryFunction(OP_bnot, &MeBuilder::BuildOpMeExpr); + RegisterFactoryFunction(OP_lnot, &MeBuilder::BuildOpMeExpr); + RegisterFactoryFunction(OP_neg, &MeBuilder::BuildOpMeExpr); + RegisterFactoryFunction(OP_recip, &MeBuilder::BuildOpMeExpr); + RegisterFactoryFunction(OP_sqrt, &MeBuilder::BuildOpMeExpr); + RegisterFactoryFunction(OP_alloca, &MeBuilder::BuildOpMeExpr); + RegisterFactoryFunction(OP_malloc, &MeBuilder::BuildOpMeExpr); + RegisterFactoryFunction(OP_iaddrof, &MeBuilder::BuildOpMeExprForIread); + RegisterFactoryFunction(OP_sext, &MeBuilder::BuildOpMeExprForExtractbits); + RegisterFactoryFunction(OP_zext, &MeBuilder::BuildOpMeExprForExtractbits); + RegisterFactoryFunction(OP_extractbits, &MeBuilder::BuildOpMeExprForExtractbits); + RegisterFactoryFunction(OP_gcmallocjarray, &MeBuilder::BuildOpMeExprForJarrayMalloc); + RegisterFactoryFunction(OP_gcpermallocjarray, &MeBuilder::BuildOpMeExprForJarrayMalloc); + RegisterFactoryFunction(OP_resolveinterfacefunc, &MeBuilder::BuildOpMeExprForResolveFunc); + RegisterFactoryFunction(OP_resolvevirtualfunc, &MeBuilder::BuildOpMeExprForResolveFunc); + RegisterFactoryFunction(OP_sub, &MeBuilder::BuildOpMeExpr); + RegisterFactoryFunction(OP_mul, &MeBuilder::BuildOpMeExpr); + RegisterFactoryFunction(OP_div, &MeBuilder::BuildOpMeExpr); + RegisterFactoryFunction(OP_rem, &MeBuilder::BuildOpMeExpr); + RegisterFactoryFunction(OP_ashr, &MeBuilder::BuildOpMeExpr); + RegisterFactoryFunction(OP_lshr, &MeBuilder::BuildOpMeExpr); + RegisterFactoryFunction(OP_shl, &MeBuilder::BuildOpMeExpr); + RegisterFactoryFunction(OP_max, &MeBuilder::BuildOpMeExpr); + RegisterFactoryFunction(OP_min, &MeBuilder::BuildOpMeExpr); + RegisterFactoryFunction(OP_band, &MeBuilder::BuildOpMeExpr); + RegisterFactoryFunction(OP_bior, &MeBuilder::BuildOpMeExpr); + RegisterFactoryFunction(OP_bxor, &MeBuilder::BuildOpMeExpr); + RegisterFactoryFunction(OP_land, &MeBuilder::BuildOpMeExpr); + RegisterFactoryFunction(OP_lior, &MeBuilder::BuildOpMeExpr); + RegisterFactoryFunction(OP_add, &MeBuilder::BuildOpMeExpr); + RegisterFactoryFunction(OP_select, &MeBuilder::BuildOpMeExpr); + RegisterFactoryFunction(OP_array, &MeBuilder::BuildNaryMeExprForArray); + RegisterFactoryFunction(OP_intrinsicop, &MeBuilder::BuildNaryMeExprForIntrinsicop); + RegisterFactoryFunction(OP_intrinsicopwithtype, &MeBuilder::BuildNaryMeExprForIntrinsicWithType); +} +} // namespace maple diff --git a/src/maple_me/src/me_cfg.cpp b/src/maple_me/src/me_cfg.cpp index 1e5a2c451ee20500d3a20c9738c9457e90b13aa8..dd3667fcc167d4be5a31f45639a6f2b299d36837 100644 --- a/src/maple_me/src/me_cfg.cpp +++ b/src/maple_me/src/me_cfg.cpp @@ -119,7 +119,7 @@ void MeCFG::BuildMirCFG() { LabelIdx labelIdx = tryNode->GetOffset(j); ASSERT(func.GetLabelBBIdMap().find(labelIdx) != func.GetLabelBBIdMap().end(), "runtime check error"); BB *meBB = func.GetLabelBBAt(labelIdx); - ASSERT(meBB != nullptr, "null ptr check"); + CHECK_FATAL(meBB != nullptr, "null ptr check"); ASSERT(meBB->GetAttributes(kBBAttrIsCatch), "runtime check error"); size_t si = 0; if (meBB->GetAttributes(kBBAttrIsJSFinally) || meBB->GetAttributes(kBBAttrIsCatch)) { diff --git a/src/maple_me/src/me_emit.cpp b/src/maple_me/src/me_emit.cpp index de95266b245ff4dcc4cb3bba28b5423a67b82eda..ca6d4ec9f6133752cdaf35a39204733760fbfa63 100644 --- a/src/maple_me/src/me_emit.cpp +++ b/src/maple_me/src/me_emit.cpp @@ -37,9 +37,9 @@ AnalysisResult *MeDoEmit::Run(MeFunction *func, MeFuncResultMgr *funcResMgr, Mod ASSERT(func->GetIRMap() != nullptr, "null ptr check"); MIRFunction *mirFunction = func->GetMirFunc(); if (mirFunction->GetCodeMempool() != nullptr) { - mempoolctrler.DeleteMemPool(mirFunction->GetCodeMempool()); + memPoolCtrler.DeleteMemPool(mirFunction->GetCodeMempool()); } - mirFunction->SetCodeMemPool(mempoolctrler.NewMemPool("IR from IRMap::Emit()")); + mirFunction->SetCodeMemPool(memPoolCtrler.NewMemPool("IR from IRMap::Emit()")); mirFunction->GetCodeMPAllocator().SetMemPool(mirFunction->GetCodeMempool()); mirFunction->SetBody(mirFunction->GetCodeMempool()->New()); // initialize is_deleted field to true; will reset when emitting Maple IR diff --git a/src/maple_me/src/me_ir.cpp b/src/maple_me/src/me_ir.cpp index e37cb78f5bc753b8d54ee018288378cdc5b93e09..cc2191ecfd1e6d236109109d36858eefeb033104 100644 --- a/src/maple_me/src/me_ir.cpp +++ b/src/maple_me/src/me_ir.cpp @@ -344,6 +344,54 @@ bool IvarMeExpr::IsRCWeak() { return false; } +// If self is the first use of the same ivar coming from an iassign +// (argument expr), then update its mu: expr->mu = this->mu. +bool IvarMeExpr::IsIdentical(IvarMeExpr &expr) const { + if (base->GetExprID() != expr.base->GetExprID() || fieldID != expr.fieldID || tyIdx != expr.tyIdx) { + return false; + } + + // check the two mu being identical + if (mu != expr.mu) { + if (mu != nullptr && expr.mu != nullptr && mu->GetDefBy() == kDefByChi && expr.mu->GetDefBy() == kDefByChi) { + if (mu->GetDefChi().GetBase() != nullptr && mu->GetDefChi().GetBase() == expr.mu->GetDefChi().GetBase()) { + return true; + } + } + + if (mu != nullptr && expr.mu == nullptr && expr.GetDefStmt() != nullptr) { + IassignMeStmt *iass = expr.GetDefStmt(); + if (iass->GetOp() != OP_iassign) { + // this can happen due to use of placement new + return false; + } + for (auto xit = iass->GetChiList()->begin(); xit != iass->GetChiList()->end(); ++xit) { + ChiMeNode *chi = xit->second; + if (chi->GetLHS()->GetExprID() == mu->GetExprID()) { + expr.SetMuVal(mu); + return true; + } + } + } + return false; + } + + return true; +} + +MeExpr *IvarMeExpr::GetIdenticalExpr(MeExpr &expr) const { + IvarMeExpr *ivarExpr = static_cast(&expr); + + while (ivarExpr != nullptr) { + if (ivarExpr->GetMeOp() == kMeOpIvar && IsIdentical(*ivarExpr)) { + return ivarExpr; + } + ivarExpr = static_cast(ivarExpr->GetNext()); + } + + return nullptr; +} + BB *VarMeExpr::GetDefByBBMeStmt(Dominance &dominance, MeStmtPtr &defMeStmt) { switch (defBy) { case kDefByNo: @@ -444,6 +492,21 @@ bool OpMeExpr::IsUseSameSymbol(const MeExpr &expr) const { return true; } +MeExpr *OpMeExpr::GetIdenticalExpr(MeExpr &expr) const { + if (!kOpcodeInfo.NotPure(GetOp())) { + OpMeExpr *opExpr = static_cast(&expr); + + while (opExpr != nullptr) { + if (IsIdentical(*opExpr)) { + return opExpr; + } + opExpr = static_cast(opExpr->GetNext()); + } + } + + return nullptr; +} + // first, make sure it's int const and return true if the int const great or eq 0 bool ConstMeExpr::GeZero() const { return (GetIntValue() >= 0); @@ -472,6 +535,115 @@ int64 ConstMeExpr::GetIntValue() const { return static_cast(constVal)->GetValue(); } +MeExpr *ConstMeExpr::GetIdenticalExpr(MeExpr &expr) const { + ConstMeExpr *constExpr = static_cast(&expr); + + while (constExpr != nullptr) { + if (constExpr->GetMeOp() == kMeOpConst && constExpr->GetPrimType() == GetPrimType() && + *constExpr->GetConstVal() == *constVal) { + return constExpr; + } + constExpr = static_cast(constExpr->GetNext()); + } + + return nullptr; +} + +MeExpr *ConststrMeExpr::GetIdenticalExpr(MeExpr &expr) const { + ConststrMeExpr *constStrExpr = static_cast(&expr); + + while (constStrExpr != nullptr) { + if (constStrExpr->GetMeOp() == kMeOpConststr && constStrExpr->GetStrIdx() == strIdx) { + return constStrExpr; + } + constStrExpr = static_cast(constStrExpr->GetNext()); + } + + return nullptr; +} + +MeExpr *Conststr16MeExpr::GetIdenticalExpr(MeExpr &expr) const { + Conststr16MeExpr *constStr16Expr = static_cast(&expr); + + while (constStr16Expr != nullptr) { + if (constStr16Expr->GetMeOp() == kMeOpConststr16 && constStr16Expr->GetStrIdx() == strIdx) { + return constStr16Expr; + } + constStr16Expr = static_cast(constStr16Expr->GetNext()); + } + + return nullptr; +} + +MeExpr *SizeoftypeMeExpr::GetIdenticalExpr(MeExpr &expr) const { + SizeoftypeMeExpr *sizeoftypeExpr = static_cast(&expr); + + while (sizeoftypeExpr != nullptr) { + if (sizeoftypeExpr->GetMeOp() == kMeOpSizeoftype && sizeoftypeExpr->GetTyIdx() == tyIdx) { + return sizeoftypeExpr; + } + sizeoftypeExpr = static_cast(sizeoftypeExpr->GetNext()); + } + + return nullptr; +} + +MeExpr *FieldsDistMeExpr::GetIdenticalExpr(MeExpr &expr) const { + FieldsDistMeExpr *fieldsDistExpr = static_cast(&expr); + + while (fieldsDistExpr != nullptr) { + if (fieldsDistExpr->GetMeOp() == kMeOpFieldsDist && fieldsDistExpr->GetTyIdx() == GetTyIdx() && + fieldsDistExpr->GetFieldID1() == fieldID1 && fieldsDistExpr->GetFieldID2() == fieldID2) { + return fieldsDistExpr; + } + fieldsDistExpr = static_cast(fieldsDistExpr->GetNext()); + } + + return nullptr; +} + +MeExpr *AddrofMeExpr::GetIdenticalExpr(MeExpr &expr) const { + AddrofMeExpr *addrofExpr = static_cast(&expr); + + while (addrofExpr != nullptr) { + if (addrofExpr->GetMeOp() == kMeOpAddrof && addrofExpr->GetOstIdx() == GetOstIdx() && + addrofExpr->GetFieldID() == fieldID) { + return addrofExpr; + } + addrofExpr = static_cast(addrofExpr->GetNext()); + } + + return nullptr; +} + +MeExpr *NaryMeExpr::GetIdenticalExpr(MeExpr &expr) const { + NaryMeExpr *naryExpr = static_cast(&expr); + + while (naryExpr != nullptr) { + bool isPureIntrinsic = + naryExpr->GetOp() == OP_intrinsicop && IntrinDesc::intrinTable[naryExpr->GetIntrinsic()].IsPure(); + if ((naryExpr->GetOp() == OP_array || isPureIntrinsic) && IsIdentical(*naryExpr)) { + return naryExpr; + } + naryExpr = static_cast(naryExpr->GetNext()); + } + + return nullptr; +} + +MeExpr *AddroffuncMeExpr::GetIdenticalExpr(MeExpr &expr) const { + AddroffuncMeExpr *addroffuncExpr = static_cast(&expr); + + while (addroffuncExpr != nullptr) { + if (addroffuncExpr->GetMeOp() == kMeOpAddroffunc && addroffuncExpr->GetPuIdx() == puIdx) { + return addroffuncExpr; + } + addroffuncExpr = static_cast(addroffuncExpr->GetNext()); + } + + return nullptr; +} + void MeVarPhiNode::Dump(IRMap *irMap) const { LogInfo::MapleLogger() << "VAR:"; irMap->GetSSATab().GetOriginalStFromID(lhs->GetOStIdx())->Dump(); diff --git a/src/maple_me/src/me_irmap.cpp b/src/maple_me/src/me_irmap.cpp index b45415f1dd523765bf74b4879bc283af490e410e..ec03a0ed1e718652fd72d8a0b45ee945e195a811 100644 --- a/src/maple_me/src/me_irmap.cpp +++ b/src/maple_me/src/me_irmap.cpp @@ -32,7 +32,7 @@ void MeIRMap::Dump() { // we dump IRMap, restore the mempool afterwards MIRFunction *mirFunction = func.GetMirFunc(); MemPool *backup = mirFunction->GetCodeMempool(); - mirFunction->SetMemPool(mempoolctrler.NewMemPool("IR Dump")); + mirFunction->SetMemPool(memPoolCtrler.NewMemPool("IR Dump")); LogInfo::MapleLogger() << "===================Me IR dump==================\n"; auto eIt = func.valid_end(); for (auto bIt = func.valid_begin(); bIt != eIt; ++bIt) { @@ -50,7 +50,7 @@ void MeIRMap::Dump() { meStmt.Dump(this); } } - mempoolctrler.DeleteMemPool(mirFunction->GetCodeMempool()); + memPoolCtrler.DeleteMemPool(mirFunction->GetCodeMempool()); mirFunction->SetMemPool(backup); } @@ -104,7 +104,7 @@ AnalysisResult *MeDoIRMap::Run(MeFunction *func, MeFuncResultMgr *funcResMgr, Mo irMap->GetTempAlloc().SetMemPool(nullptr); // delete input IR code for current function MIRFunction *mirFunc = func->GetMirFunc(); - mempoolctrler.DeleteMemPool(mirFunc->GetCodeMempool()); + memPoolCtrler.DeleteMemPool(mirFunc->GetCodeMempool()); mirFunc->SetCodeMemPool(nullptr); // delete versionst_table #if MIR_FEATURE_FULL @@ -121,7 +121,7 @@ AnalysisResult *MeDoIRMap::Run(MeFunction *func, MeFuncResultMgr *funcResMgr, Mo bb->SetLast(nullptr); } #endif - mempoolctrler.DeleteMemPool(func->GetMeSSATab()->GetVersionStTable().GetVSTAlloc().GetMemPool()); + memPoolCtrler.DeleteMemPool(func->GetMeSSATab()->GetVersionStTable().GetVSTAlloc().GetMemPool()); return irMap; } } // namespace maple diff --git a/src/maple_me/src/me_phase_manager.cpp b/src/maple_me/src/me_phase_manager.cpp index 636f1b7125602183eab3ad291a15adfd0a5a4a1b..62abe63c52934df61cbf9e037af0b5565abec298 100644 --- a/src/maple_me/src/me_phase_manager.cpp +++ b/src/maple_me/src/me_phase_manager.cpp @@ -74,7 +74,7 @@ void MeFuncPhaseManager::RegisterFuncPhases() { void MeFuncPhaseManager::AddPhasesNoDefault(const std::vector &phases) { for (size_t i = 0; i < phases.size(); i++) { - PhaseManager::AddPhase(phases[i].c_str()); + PhaseManager::AddPhase(phases[i]); } ASSERT(phases.size() == GetPhaseSequence()->size(), "invalid phase name"); } @@ -83,7 +83,7 @@ void MeFuncPhaseManager::AddPhases(const std::unordered_set &skipPh auto addPhase = [&](const std::string &phase) { std::unordered_set::const_iterator it = skipPhases.find(phase); if (it == skipPhases.end()) { - PhaseManager::AddPhase(phase.c_str()); + PhaseManager::AddPhase(phase); } }; if (mePhaseType == kMePhaseMainopt) { @@ -106,15 +106,15 @@ bool MeFuncPhaseManager::FuncFilter(const std::string &filter, const std::string void MeFuncPhaseManager::IPACleanUp(MeFunction *func) { GetAnalysisResultManager()->InvalidAllResults(); - mempoolctrler.DeleteMemPool(func->GetMemPool()); + memPoolCtrler.DeleteMemPool(func->GetMemPool()); } void MeFuncPhaseManager::Run(MIRFunction *mirFunc, uint64 rangeNum, const std::string &meInput) { if (!MeOption::quiet) LogInfo::MapleLogger() << ">>>>>>>>>>>>>>>>>>>>>>>>>>>>> Optimizing Function < " << mirFunc->GetName() << " id=" << mirFunc->GetPuidxOrigin() << " >---\n"; - MemPool *funcMP = mempoolctrler.NewMemPool("maple_me per-function mempool"); - MemPool *versMP = mempoolctrler.NewMemPool("first verst mempool"); + MemPool *funcMP = memPoolCtrler.NewMemPool("maple_me per-function mempool"); + MemPool *versMP = memPoolCtrler.NewMemPool("first verst mempool"); MeFunction func(&mirModule, mirFunc, funcMP, versMP, meInput); func.PartialInit(false); #if DEBUG @@ -164,7 +164,7 @@ void MeFuncPhaseManager::Run(MIRFunction *mirFunc, uint64 rangeNum, const std::s CHECK_FATAL(false, "phases in ipa will not chang cfg."); } // do all the phases start over - MemPool *versMemPool = mempoolctrler.NewMemPool("second verst mempool"); + MemPool *versMemPool = memPoolCtrler.NewMemPool("second verst mempool"); MeFunction function(&mirModule, mirFunc, funcMP, versMemPool, meInput); function.PartialInit(true); function.Prepare(rangeNum); @@ -189,7 +189,7 @@ void MeFuncPhaseManager::Run(MIRFunction *mirFunc, uint64 rangeNum, const std::s GetAnalysisResultManager()->InvalidAllResults(); } if (!ipa) { - mempoolctrler.DeleteMemPool(funcMP); + memPoolCtrler.DeleteMemPool(funcMP); } } } // namespace maple diff --git a/src/maple_me/src/orig_symbol.cpp b/src/maple_me/src/orig_symbol.cpp index cc89e752fee0acb4237a23dec8af51f85ad44d47..91678aa6567edaa9a9f67c22f479d5723c85c2d6 100644 --- a/src/maple_me/src/orig_symbol.cpp +++ b/src/maple_me/src/orig_symbol.cpp @@ -54,7 +54,7 @@ OriginalStTable::OriginalStTable(MemPool &memPool, MIRModule &mod) thisField2Ost(std::less(), alloc.Adapter()), virtuaLostUnkownMem(0), virtuaLostConstMem(0) { - originalStVector.push_back(static_cast(nullptr)); + originalStVector.push_back(nullptr); } void OriginalStTable::Dump() { @@ -89,8 +89,7 @@ OriginalSt *OriginalStTable::CreateSymbolOriginalSt(MIRSymbol &mirst, PUIdx pidx ost->SetIsFinal(mirst.IsFinal()); ost->SetIsPrivate(mirst.IsPrivate()); } else { - MIRStructType *structType = - static_cast(GlobalTables::GetTypeTable().GetTypeFromTyIdx(mirst.GetTyIdx())); + auto *structType = static_cast(GlobalTables::GetTypeTable().GetTypeFromTyIdx(mirst.GetTyIdx())); ASSERT(structType, "CreateSymbolOriginalSt: non-zero fieldID for non-structure"); ost->SetTyIdx(structType->GetFieldTyIdx(fld)); FieldAttrs fattrs = structType->GetFieldAttrs(fld); diff --git a/src/maple_phase/include/phase.h b/src/maple_phase/include/phase.h index 37c0647e5730a8eead2ec5d2ec13bfcae3c2e213..1963ed629479b0287052bea25245d4c437019cee 100644 --- a/src/maple_phase/include/phase.h +++ b/src/maple_phase/include/phase.h @@ -38,7 +38,7 @@ class AnalysisResult { } void EraseMemPool() { - mempoolctrler.DeleteMemPool(memPool); + memPoolCtrler.DeleteMemPool(memPool); } virtual ~AnalysisResult() {} @@ -62,7 +62,7 @@ class Phase { ASSERT(!phaseName.empty(), "PhaseName should not be empty"); memPoolCount++; std::string memPoolName = phaseName + " MemPool " + std::to_string(memPoolCount); - MemPool *memPool = mempoolctrler.NewMemPool(memPoolName.c_str()); + MemPool *memPool = memPoolCtrler.NewMemPool(memPoolName.c_str()); memPools.push_back(memPool); return memPool; } @@ -73,7 +73,7 @@ class Phase { if (memPool == exclusion) { continue; } - mempoolctrler.DeleteMemPool(memPool); + memPoolCtrler.DeleteMemPool(memPool); memPool = nullptr; } memPools.clear(); diff --git a/src/maple_phase/include/phase_manager.h b/src/maple_phase/include/phase_manager.h index bfa2a9f1343803a01c4e6984504e6679279c99ad..39bf9360889575f01771eecb27375f6eb9e3bae6 100644 --- a/src/maple_phase/include/phase_manager.h +++ b/src/maple_phase/include/phase_manager.h @@ -21,9 +21,9 @@ namespace maple { class PhaseManager { public: - PhaseManager(MemPool *memPool, const std::string &name) + PhaseManager(MemPool &memPool, const std::string &name) : managerName(name), - allocator(memPool), + allocator(&memPool), registeredPhases(std::less(), allocator.Adapter()), phaseSequences(allocator.Adapter()), phaseTimers(allocator.Adapter()) {} diff --git a/src/mempool/include/maple_string.h b/src/mempool/include/maple_string.h index 3b91c61771640e31ebc5b2643452f8d29437e523..1aafadc467cf3f8f0d6ed2a1117731e35ff5bc6f 100644 --- a/src/mempool/include/maple_string.h +++ b/src/mempool/include/maple_string.h @@ -43,10 +43,6 @@ class MapleString { return dataLength; } - operator char *() { - return data; - } - operator const char *() const { return data; } diff --git a/src/mempool/include/mempool.h b/src/mempool/include/mempool.h index dac5ace2277590a8fe53db957813b17e74beede3..d2b9a7622b5b3f608146a4225995fcab559dcf5f 100644 --- a/src/mempool/include/mempool.h +++ b/src/mempool/include/mempool.h @@ -65,9 +65,8 @@ class MemPoolCtrler { bool operator()(const MemBlock *l, const MemBlock *r) const { if (l->available != r->available) { return l->available > r->available; - } else { - return (std::uint64_t)(l->ptr) > (std::uint64_t)(r->ptr); } + return (std::uintptr_t)(l->ptr) > (std::uintptr_t)(r->ptr); } }; @@ -81,7 +80,7 @@ class MemPool { friend MemPoolCtrler; public: // Methods - MemPool(MemPoolCtrler *ctl, const std::string &name) : ctrler(ctl), name(name) { + MemPool(MemPoolCtrler &ctl, const std::string &name) : ctrler(&ctl), name(name) { } ~MemPool(); @@ -90,7 +89,7 @@ class MemPool { void *Realloc(const void *ptr, size_t oldSize, size_t newSize); void Push(); bool Pop(); - const std::string &GetName(void) const { + const std::string &GetName() const { return name; } @@ -134,6 +133,6 @@ class MemPool { std::stack> markerStack; }; -extern MemPoolCtrler mempoolctrler; +extern MemPoolCtrler memPoolCtrler; } // namespace maple #endif // MEMPOOL_INCLUDE_MEMPOOL_H diff --git a/src/mempool/include/mempool_allocator.h b/src/mempool/include/mempool_allocator.h index cabf7e15e7b404d00679c12f7d561da7eda185d5..e34c9c0521d7c7df5ae70a112182bda94efdb10a 100644 --- a/src/mempool/include/mempool_allocator.h +++ b/src/mempool/include/mempool_allocator.h @@ -140,7 +140,7 @@ class MapleAllocatorAdapter { using other = MapleAllocatorAdapter; }; - explicit MapleAllocatorAdapter(MapleAllocator *currMapleAllocator) : mapleAllocator(currMapleAllocator) {} + explicit MapleAllocatorAdapter(MapleAllocator &currMapleAllocator) : mapleAllocator(&currMapleAllocator) {} template MapleAllocatorAdapter(const MapleAllocatorAdapter &other) : mapleAllocator(other.mapleAllocator) {} @@ -170,7 +170,7 @@ class MapleAllocatorAdapter { using other = MapleAllocatorAdapter; }; - explicit MapleAllocatorAdapter(MapleAllocator *currMapleAllocator) : mapleAllocator(currMapleAllocator) {} + explicit MapleAllocatorAdapter(MapleAllocator &currMapleAllocator) : mapleAllocator(&currMapleAllocator) {} template MapleAllocatorAdapter(const MapleAllocatorAdapter &other) : mapleAllocator(other.mapleAllocator) {} @@ -223,8 +223,7 @@ inline bool operator!=(const MapleAllocatorAdapter &lhs, const MapleAllocator } inline MapleAllocatorAdapter MapleAllocator::Adapter() { - return MapleAllocatorAdapter(this); + return MapleAllocatorAdapter(*this); } - } // namespace maple #endif // MEMPOOL_INCLUDE_MEMPOOL_ALLOCATOR_H diff --git a/src/mpl2mpl/src/reflection_analysis.cpp b/src/mpl2mpl/src/reflection_analysis.cpp index f3eaede166c5e948f8ecaf9a22d5b638146618cf..3fe8690214a20077c854d3f810816118da2824ac 100644 --- a/src/mpl2mpl/src/reflection_analysis.cpp +++ b/src/mpl2mpl/src/reflection_analysis.cpp @@ -1685,7 +1685,7 @@ void ReflectionAnalysis::Run() { } AnalysisResult *DoReflectionAnalysis::Run(MIRModule *module, ModuleResultMgr *mrm) { - MemPool *memPool = mempoolctrler.NewMemPool("ReflectionAnalysis mempool"); + MemPool *memPool = memPoolCtrler.NewMemPool("ReflectionAnalysis mempool"); auto *kh = static_cast(mrm->GetAnalysisResult(MoPhase_CHA, module)); maple::MIRBuilder mirBuilder(module); ReflectionAnalysis *rv = memPool->New(module, memPool, kh, mirBuilder); @@ -1694,7 +1694,7 @@ AnalysisResult *DoReflectionAnalysis::Run(MIRModule *module, ModuleResultMgr *mr } rv->Run(); // This is a transform phase, delete mempool. - mempoolctrler.DeleteMemPool(memPool); + memPoolCtrler.DeleteMemPool(memPool); return nullptr; } } // namespace maple