diff --git a/src/bin/jbc2mpl b/src/bin/jbc2mpl index 2e4626e18824218f6fb191d093c0249dc3127457..e026dfd2272b47c669148544111f3ae8147a553f 100755 Binary files a/src/bin/jbc2mpl and b/src/bin/jbc2mpl differ diff --git a/src/bin/maple b/src/bin/maple index 7fc07943c556cd3533ee659cbb630304dc57c2a1..d462859ba38f1c72467751a0e48911047004a595 100755 Binary files a/src/bin/maple and b/src/bin/maple differ diff --git a/src/bin/mplcg b/src/bin/mplcg index 4b9e5f72824e922f8b1bb4bef58a2ba4a962de41..d67a9f95f01cc494a9a82f827b50b638e3257e9c 100755 Binary files a/src/bin/mplcg and b/src/bin/mplcg differ diff --git a/src/deplibs/libmaple_driverutil.a b/src/deplibs/libmaple_driverutil.a index 8e684356366a2b0813203fe9c3d9f71bd9949b99..cf80ffef7184fcf172e558e3e73a5cdd3905263b 100644 Binary files a/src/deplibs/libmaple_driverutil.a and b/src/deplibs/libmaple_driverutil.a differ diff --git a/src/deplibs/libmempool.a b/src/deplibs/libmempool.a index 13285b2155ba67f1dddf8898f84ea59f4ac864d6..3556ed066881d0c678af4cb3dd735b05f581182b 100644 Binary files a/src/deplibs/libmempool.a and b/src/deplibs/libmempool.a differ diff --git a/src/deplibs/libmplphase.a b/src/deplibs/libmplphase.a index 52645dccffcfa2730210044bb977969ddedd81d7..3c5f6bf730f7c3ac8235bcd8d385a558bbb177d1 100644 Binary files a/src/deplibs/libmplphase.a and b/src/deplibs/libmplphase.a differ diff --git a/src/deplibs/libmplutil.a b/src/deplibs/libmplutil.a index 11427a42529fc3bd04c2df8766f6bbe50750a3aa..4e0e223778ecc49b518701b0268d16df32ffa9db 100644 Binary files a/src/deplibs/libmplutil.a and b/src/deplibs/libmplutil.a differ diff --git a/src/maple_driver/include/compiler_selector.h b/src/maple_driver/include/compiler_selector.h index abbc4745002a5bbbbc407b28b001c611288384fe..60ade7ccd7bed278c84ffbe1f970817e613b9c39 100644 --- a/src/maple_driver/include/compiler_selector.h +++ b/src/maple_driver/include/compiler_selector.h @@ -29,7 +29,7 @@ class CompilerSelector { virtual ErrorCode Select(const SupportedCompilers &supportedCompilers, const MplOptions &mplOptions, std::vector &selected) const { - return ErrorCode::kErrorToolNotFound; + return kErrorToolNotFound; } }; diff --git a/src/maple_driver/include/safe_exe.h b/src/maple_driver/include/safe_exe.h index ccb2fccdfbf31527de3be15e9128b7d0c1893e9e..cda8a4fb88828b8c17cd542931fd1f8601d2970b 100644 --- a/src/maple_driver/include/safe_exe.h +++ b/src/maple_driver/include/safe_exe.h @@ -52,7 +52,7 @@ class SafeExe { // end of arguments sentinel is nullptr argv[vectorArgs.size()] = nullptr; pid_t pid = fork(); - ErrorCode ret = ErrorCode::kErrorNoError; + ErrorCode ret = kErrorNoError; if (pid == 0) { // child process fflush(nullptr); @@ -69,10 +69,10 @@ class SafeExe { waitpid(pid, &status, 0); if (!WIFEXITED(status)) { LogInfo::MapleLogger() << "Error while Exe, cmd: " << cmd << " args: " << args << '\n'; - ret = ErrorCode::kErrorCompileFail; + ret = kErrorCompileFail; } else if (WEXITSTATUS(status) != 0) { LogInfo::MapleLogger() << "Error while Exe, cmd: " << cmd << " args: " << args << '\n'; - ret = ErrorCode::kErrorCompileFail; + ret = kErrorCompileFail; } } @@ -125,7 +125,7 @@ class SafeExe { LogInfo::MapleLogger() << "Starting:" << cmd << args << '\n'; if (StringUtils::HasCommandInjectionChar(cmd) || StringUtils::HasCommandInjectionChar(args)) { LogInfo::MapleLogger() << "Error while Exe, cmd: " << cmd << " args: " << args << '\n'; - return ErrorCode::kErrorCompileFail; + return kErrorCompileFail; } ErrorCode ret = HandleCommand(cmd, args); return ret; diff --git a/src/maple_driver/src/compiler.cpp b/src/maple_driver/src/compiler.cpp index 67a0fdd00924550c77e692b930b450692d867ec5..5b26d21deb782e8681b753266ef46d671e6e7ae2 100644 --- a/src/maple_driver/src/compiler.cpp +++ b/src/maple_driver/src/compiler.cpp @@ -38,7 +38,7 @@ std::string Compiler::GetBinPath(const MplOptions &mplOptions) const { #ifdef MAPLE_PRODUCT_EXECUTABLE // build flag -DMAPLE_PRODUCT_EXECUTABLE std::string binPath = std::string(MAPLE_PRODUCT_EXECUTABLE); if (binPath.empty()) { - binPath = mplOptions.exeFolder; + binPath = mplOptions.GetExeFolder(); } else { binPath = binPath + kFileSeperatorChar; } @@ -54,14 +54,14 @@ ErrorCode Compiler::Compile(const MplOptions &options, MIRModulePtr &theModule) timer.Start(); std::string strOption = MakeOption(options); if (strOption.empty()) { - return ErrorCode::kErrorInvalidParameter; + return kErrorInvalidParameter; } if (Exe(options, strOption) != 0) { - return ErrorCode::kErrorCompileFail; + return kErrorCompileFail; } timer.Stop(); LogInfo::MapleLogger() << (GetName() + " consumed ") << timer.Elapsed() << "s\n"; - return ErrorCode::kErrorNoError; + return kErrorNoError; } std::string Compiler::MakeOption(const MplOptions &options) const { diff --git a/src/maple_driver/src/compiler_factory.cpp b/src/maple_driver/src/compiler_factory.cpp index fef18712492addc3a209701021cec22ce01dc8dd..42d4eb81266aa026b669f30e0d0bb65be04e969c 100644 --- a/src/maple_driver/src/compiler_factory.cpp +++ b/src/maple_driver/src/compiler_factory.cpp @@ -79,23 +79,23 @@ ErrorCode CompilerFactory::DeleteTmpFiles(const MplOptions &mplOptions, const st ret = FileUtils::Remove(tmpFile); } } - return ret == 0 ? ErrorCode::kErrorNoError : ErrorCode::kErrorFileNotFound; + return ret == 0 ? kErrorNoError : kErrorFileNotFound; } ErrorCode CompilerFactory::Compile(const MplOptions &mplOptions) { std::vector compilers; ErrorCode ret = compilerSelector->Select(supportedCompilers, mplOptions, compilers); - if (ret != ErrorCode::kErrorNoError) { + if (ret != kErrorNoError) { return ret; } for (auto *compiler : compilers) { if (compiler == nullptr) { LogInfo::MapleLogger() << "Failed! Compiler is null." << "\n"; - return ErrorCode::kErrorCompileFail; + return kErrorCompileFail; } ret = compiler->Compile(mplOptions, this->theModule); - if (ret != ErrorCode::kErrorNoError) { + if (ret != kErrorNoError) { return ret; } } @@ -105,7 +105,7 @@ ErrorCode CompilerFactory::Compile(const MplOptions &mplOptions) { for (auto *compiler : compilers) { compiler->GetTmpFilesToDelete(mplOptions, tmpFiles); } - ret = DeleteTmpFiles(mplOptions, tmpFiles, compilers.at(compilers.size() - 1)->GetFinalOutputs(mplOptions)); + ret = DeleteTmpFiles(mplOptions, tmpFiles, compilers.back()->GetFinalOutputs(mplOptions)); } return ret; } diff --git a/src/maple_driver/src/compiler_selector.cpp b/src/maple_driver/src/compiler_selector.cpp index d8645e9695068af107c1649e4eb0d40feea60a99..b34ffe2e8a101770e604e3cb0f372220f628aeaf 100644 --- a/src/maple_driver/src/compiler_selector.cpp +++ b/src/maple_driver/src/compiler_selector.cpp @@ -33,11 +33,11 @@ ErrorCode CompilerSelectorImpl::InsertCompilerIfNeeded(std::vector &s if (std::find(selected.cbegin(), selected.cend(), compiler) == selected.cend()) { selected.push_back(compiler); } - return ErrorCode::kErrorNoError; + return kErrorNoError; } LogInfo::MapleLogger(kLlErr) << name << " not found!!!" << '\n'; - return ErrorCode::kErrorToolNotFound; + return kErrorToolNotFound; } ErrorCode CompilerSelectorImpl::Select(const SupportedCompilers &supportedCompilers, const MplOptions &mplOptions, @@ -51,11 +51,11 @@ ErrorCode CompilerSelectorImpl::Select(const SupportedCompilers &supportedCompil continue; } ErrorCode ret = InsertCompilerIfNeeded(selected, supportedCompilers, runningExe); - if (ret != ErrorCode::kErrorNoError) { - return ErrorCode::kErrorToolNotFound; + if (ret != kErrorNoError) { + return kErrorToolNotFound; } } } - return selected.empty() ? ErrorCode::kErrorToolNotFound : ErrorCode::kErrorNoError; + return selected.empty() ? kErrorToolNotFound : kErrorNoError; } } // namespace maple diff --git a/src/maple_driver/src/driver_runner.cpp b/src/maple_driver/src/driver_runner.cpp index b7d1c03e028c2fdbc933115c558e12771ca2298f..77db5ec8debd44dcb6cd61d0ef54e220c0a298c8 100644 --- a/src/maple_driver/src/driver_runner.cpp +++ b/src/maple_driver/src/driver_runner.cpp @@ -62,11 +62,11 @@ enum OptLevel { }; ErrorCode DriverRunner::Run() { - CHECK_MODULE(ErrorCode::kErrorExit); + CHECK_MODULE(kErrorExit); if (exeNames.empty()) { LogInfo::MapleLogger() << "Fatal error: no exe specified" << '\n'; - return ErrorCode::kErrorExit; + return kErrorExit; } printOutExe = exeNames[exeNames.size() - 1]; @@ -79,8 +79,8 @@ ErrorCode DriverRunner::Run() { ErrorCode ret = ParseInput(outputFile, originBaseName); - if (ret != ErrorCode::kErrorNoError) { - return ErrorCode::kErrorExit; + if (ret != kErrorNoError) { + return kErrorExit; } if (mpl2mplOptions || meOptions) { std::string vtableImplFile = originBaseName; @@ -88,7 +88,7 @@ ErrorCode DriverRunner::Run() { originBaseName.append(".VtableImpl"); ProcessMpl2mplAndMePhases(outputFile, vtableImplFile); } - return ErrorCode::kErrorNoError; + return kErrorNoError; } bool DriverRunner::FuncOrderLessThan(const MIRFunction *left, const MIRFunction *right) { @@ -110,17 +110,17 @@ std::string DriverRunner::GetPostfix() const { } ErrorCode DriverRunner::ParseInput(const std::string &outputFile, const std::string &originBaseName) const { - CHECK_MODULE(ErrorCode::kErrorExit); + CHECK_MODULE(kErrorExit); LogInfo::MapleLogger() << "Starting parse input" << '\n'; MPLTimer timer; timer.Start(); MIRParser parser(*theModule); - ErrorCode ret = ErrorCode::kErrorNoError; + ErrorCode ret = kErrorNoError; bool parsed = parser.ParseMIR(0, 0, false, true); if (!parsed) { - ret = ErrorCode::kErrorExit; + ret = kErrorExit; parser.EmitError(outputFile); } timer.Stop(); diff --git a/src/maple_driver/src/maple.cpp b/src/maple_driver/src/maple.cpp index a3af8e92eec74e6e7302b6200484211f40ce9aa4..80821562ad6d444892ab0c42096a2f32b1a3333c 100644 --- a/src/maple_driver/src/maple.cpp +++ b/src/maple_driver/src/maple.cpp @@ -52,7 +52,7 @@ void PrintErrorMessage(int ret) { int main(int argc, char **argv) { MplOptions mplOptions; int ret = mplOptions.Parse(argc, argv); - if (ret == ErrorCode::kErrorNoError) { + if (ret == kErrorNoError) { ret = CompilerFactory::GetInstance().Compile(mplOptions); } PrintErrorMessage(ret); diff --git a/src/maple_driver/src/maple_comb_compiler.cpp b/src/maple_driver/src/maple_comb_compiler.cpp index 0fc59a1a8f7c1db4fc2a20d54d26eb5d61469dc3..bb82b3f0fde37a755827a63ea79fe7985c4b8873 100644 --- a/src/maple_driver/src/maple_comb_compiler.cpp +++ b/src/maple_driver/src/maple_comb_compiler.cpp @@ -24,6 +24,9 @@ namespace maple { using namespace mapleOption; std::string MapleCombCompiler::GetInputFileName(const MplOptions &options) const { + if (options.GetRunningExes()[0] == kBinNameMe || options.GetRunningExes()[0] == kBinNameMpl2mpl) { + return options.GetInputFiles(); + } if (options.GetInputFileType() == InputFileType::kVtableImplMpl) { return options.GetOutputFolder() + options.GetOutputName() + ".VtableImpl.mpl"; } diff --git a/src/maple_driver/src/mpl_options.cpp b/src/maple_driver/src/mpl_options.cpp index f73927423ebe673b03777cb4466f74f9b855a56e..122131782d5176bc833fabe717a5c3ca18271383 100644 --- a/src/maple_driver/src/mpl_options.cpp +++ b/src/maple_driver/src/mpl_options.cpp @@ -812,12 +812,12 @@ int MplOptions::Parse(int argc, char **argv) { optionParser.reset(new OptionParser(USAGES)); exeFolder = FileUtils::GetFileFolder(*argv); int ret = optionParser->Parse(argc, argv); - if (ret != ErrorCode::kErrorNoError) { - return ErrorCode::kErrorInvalidParameter; + if (ret != kErrorNoError) { + return kErrorInvalidParameter; } // We should recognize O0, O2 and run options firstly to decide the real options ret = DecideRunType(); - if (ret != ErrorCode::kErrorNoError) { + if (ret != kErrorNoError) { return ret; } @@ -828,21 +828,21 @@ int MplOptions::Parse(int argc, char **argv) { // Check whether the input files were valid ret = CheckInputFileValidity(); - if (ret != ErrorCode::kErrorNoError) { + if (ret != kErrorNoError) { return ret; } // Decide runningExes for default options(O0, O2) by input files if (runMode != RunMode::kCustomRun) { ret = DecideRunningPhases(); - if (ret != ErrorCode::kErrorNoError) { + if (ret != kErrorNoError) { return ret; } } // Handle other options ret = HandleGeneralOptions(); - if (ret != ErrorCode::kErrorNoError) { + if (ret != kErrorNoError) { return ret; } // Check whether the file was readable @@ -851,35 +851,35 @@ int MplOptions::Parse(int argc, char **argv) { } ErrorCode MplOptions::HandleGeneralOptions() { - ErrorCode ret = ErrorCode::kErrorNoError; + ErrorCode ret = kErrorNoError; for (auto opt : optionParser->GetOptions()) { switch (opt.Index()) { case kHelp: { optionParser->PrintUsage("all"); - return ErrorCode::kErrorExitHelp; + return kErrorExitHelp; } case kVersion: { LogInfo::MapleLogger() << kMapleDriverVersion << "\n"; - return ErrorCode::kErrorExitHelp; + return kErrorExitHelp; } case kMeOpt: ret = UpdatePhaseOption(opt.Args(), kBinNameMe); - if (ret != ErrorCode::kErrorNoError) { + if (ret != kErrorNoError) { return ret; } break; case kMpl2MplOpt: ret = UpdatePhaseOption(opt.Args(), kBinNameMpl2mpl); - if (ret != ErrorCode::kErrorNoError) { + if (ret != kErrorNoError) { return ret; } break; case kMeHelp: optionParser->PrintUsage(kBinNameMe); - return ErrorCode::kErrorExitHelp; + return kErrorExitHelp; case kMpl2MplHelp: optionParser->PrintUsage(kBinNameMpl2mpl); - return ErrorCode::kErrorExitHelp; + return kErrorExitHelp; case kCombTimePhases: timePhases = true; printCommandStr += " -time-phases"; @@ -904,8 +904,8 @@ ErrorCode MplOptions::HandleGeneralOptions() { printCommandStr += " --save-temps"; break; case kOption: - if (UpdateExtraOptionOpt(opt.Args()) != ErrorCode::kErrorNoError) { - return ErrorCode::kErrorInvalidParameter; + if (UpdateExtraOptionOpt(opt.Args()) != kErrorNoError) { + return kErrorInvalidParameter; } break; case kInMplt: @@ -923,7 +923,7 @@ ErrorCode MplOptions::HandleGeneralOptions() { } ErrorCode MplOptions::DecideRunType() { - ErrorCode ret = ErrorCode::kErrorNoError; + ErrorCode ret = kErrorNoError; bool runModeConflict = false; for (auto opt : optionParser->GetOptions()) { switch (opt.Index()) { @@ -945,7 +945,7 @@ ErrorCode MplOptions::DecideRunType() { break; case kInFile: { if (!Init(opt.Args())) { - return ErrorCode::kErrorInitFail; + return kErrorInitFail; } break; } @@ -955,13 +955,13 @@ ErrorCode MplOptions::DecideRunType() { } if (runModeConflict) { LogInfo::MapleLogger(kLlErr) << "Cannot set auto mode and run mode at the same time!\n"; - ret = ErrorCode::kErrorInvalidParameter; + ret = kErrorInvalidParameter; } return ret; } ErrorCode MplOptions::DecideRunningPhases() { - ErrorCode ret = ErrorCode::kErrorNoError; + ErrorCode ret = kErrorNoError; bool isNeedMapleComb = true; bool isNeedMplcg = true; switch (inputFileType) { @@ -985,13 +985,13 @@ ErrorCode MplOptions::DecideRunningPhases() { } if (isNeedMapleComb) { ret = AppendDefaultCombOptions(); - if (ret != ErrorCode::kErrorNoError) { + if (ret != kErrorNoError) { return ret; } } if (isNeedMplcg) { ret = AppendDefaultCgOptions(); - if (ret != ErrorCode::kErrorNoError) { + if (ret != kErrorNoError) { return ret; } } @@ -1001,7 +1001,7 @@ ErrorCode MplOptions::DecideRunningPhases() { ErrorCode MplOptions::CheckInputFileValidity() { // Get input fileName if (optionParser->GetNonOptionsCount() <= 0) { - return ErrorCode::kErrorNoError; + return kErrorNoError; } std::ostringstream optionString; const std::vector &inputs = optionParser->GetNonOptions(); @@ -1013,23 +1013,23 @@ ErrorCode MplOptions::CheckInputFileValidity() { } } if (!Init(optionString.str())) { - return ErrorCode::kErrorInitFail; + return kErrorInitFail; } - return ErrorCode::kErrorNoError; + return kErrorNoError; } ErrorCode MplOptions::CheckFileExits() { - ErrorCode ret = ErrorCode::kErrorNoError; + ErrorCode ret = kErrorNoError; if (inputFiles == "") { LogInfo::MapleLogger(kLlErr) << "Forgot to input files?\n"; - return ErrorCode::kErrorFileNotFound; + return ErrorCode::kErrorInitFail; } for (auto fileName : splitsInputFiles) { std::ifstream infile; infile.open(fileName); if (infile.fail()) { LogInfo::MapleLogger(kLlErr) << "Cannot open input file " << fileName << '\n'; - ret = ErrorCode::kErrorFileNotFound; + ret = kErrorFileNotFound; return ret; } } @@ -1094,15 +1094,15 @@ std::string MplOptions::OptimizationLevelStr() const { } ErrorCode MplOptions::AppendDefaultCombOptions() { - ErrorCode ret = ErrorCode::kErrorNoError; + ErrorCode ret = kErrorNoError; if (optimizationLevel == kO0) { ret = AppendDefaultOptions(kBinNameMe, kMeDefaultOptionsO0, sizeof(kMeDefaultOptionsO0) / sizeof(MplOption)); - if (ret != ErrorCode::kErrorNoError) { + if (ret != kErrorNoError) { return ret; } ret = AppendDefaultOptions(kBinNameMpl2mpl, kMpl2MplDefaultOptionsO0, sizeof(kMpl2MplDefaultOptionsO0) / sizeof(MplOption)); - if (ret != ErrorCode::kErrorNoError) { + if (ret != kErrorNoError) { return ret; } } @@ -1110,7 +1110,7 @@ ErrorCode MplOptions::AppendDefaultCombOptions() { } ErrorCode MplOptions::AppendDefaultCgOptions() { - ErrorCode ret = ErrorCode::kErrorNoError; + ErrorCode ret = kErrorNoError; if (optimizationLevel == kO0) { UpdateRunningExe(kBinNameMplcg); } @@ -1122,28 +1122,28 @@ ErrorCode MplOptions::AppendDefaultOptions(const std::string &exeName, MplOption for (size_t i = 0; i < length; ++i) { bool ret = optionParser->SetOption(mplOptions[i].GetKey(), mplOptions[i].GetValue(), exeName, exeOption); if (!ret) { - return ErrorCode::kErrorInvalidParameter; + return kErrorInvalidParameter; } } - auto iter = std::find(runningExes.begin(), runningExes.end(), exeName.c_str()); + auto iter = std::find(runningExes.begin(), runningExes.end(), exeName); if (iter == runningExes.end()) { runningExes.push_back(exeName); } - return ErrorCode::kErrorNoError; + return kErrorNoError; } ErrorCode MplOptions::UpdatePhaseOption(const std::string &args, const std::string &exeName) { auto iter = std::find(runningExes.begin(), runningExes.end(), exeName); if (iter == runningExes.end()) { LogInfo::MapleLogger(kLlErr) << "Cannot find phase " << exeName << '\n'; - return ErrorCode::kErrorExit; + return kErrorExit; } std::vector tmpArgs; // Split options with ' ' StringUtils::Split(args, tmpArgs, ' '); auto &exeOption = exeOptions[exeName]; ErrorCode ret = optionParser->HandleInputArgs(tmpArgs, exeName, exeOption); - if (ret != ErrorCode::kErrorNoError) { + if (ret != kErrorNoError) { return ret; } // Fill extraOption @@ -1164,21 +1164,22 @@ ErrorCode MplOptions::UpdatePhaseOption(const std::string &args, const std::stri ErrorCode MplOptions::UpdateExtraOptionOpt(const std::string &args) { std::vector temp; StringUtils::Split(args, temp, ':'); - if (temp.size() != extras.size() && temp.size() != runningExes.size()) { + if (temp.size() != runningExes.size()) { // parameter not match ignore - LogInfo::MapleLogger(kLlErr) << "The --run and --option are not matched, please check them.(Too many ':'?)" + LogInfo::MapleLogger(kLlErr) << "The --run and --option are not matched, please check them." + << "(Too many or too few ':'?)" << '\n'; - return ErrorCode::kErrorInvalidParameter; + return kErrorInvalidParameter; } auto settingExe = runningExes.begin(); for (const auto &tempIt : temp) { ErrorCode ret = UpdatePhaseOption(tempIt, *settingExe); - if (ret != ErrorCode::kErrorNoError) { + if (ret != kErrorNoError) { return ret; } ++settingExe; } - return ErrorCode::kErrorNoError; + return kErrorNoError; } void MplOptions::UpdateRunningExe(const std::string &args) { diff --git a/src/maple_driver/src/mplcg_compiler.cpp b/src/maple_driver/src/mplcg_compiler.cpp index 4b19e31bad1b0db2721b213575c70e8e11ec8c7e..35e3cab38b042a846a7bf60000bde66fe0e09869 100644 --- a/src/maple_driver/src/mplcg_compiler.cpp +++ b/src/maple_driver/src/mplcg_compiler.cpp @@ -37,6 +37,9 @@ std::vector MplcgCompiler::GetBinNames() const { } std::string MplcgCompiler::GetInputFileName(const MplOptions &options) const { + if (options.GetRunningExes()[0] == kBinNameMplcg) { + return options.GetInputFiles(); + } auto idx = options.GetOutputName().find(".VtableImpl"); std::string outputName = options.GetOutputName(); if (idx != std::string::npos) { diff --git a/src/maple_ipa/src/interleaved_manager.cpp b/src/maple_ipa/src/interleaved_manager.cpp index 6f428e0325647f6561640554f0d7fe1e5927beb0..997d380680ce87277e1d138b1798d2f48a7f575f 100644 --- a/src/maple_ipa/src/interleaved_manager.cpp +++ b/src/maple_ipa/src/interleaved_manager.cpp @@ -67,7 +67,6 @@ void InterleavedManager::Run() { pm->Run(); continue; } - uint64 rangeNum = 0; MapleVector *compList; if (!mirModule.GetCompilationList().empty()) { if ((mirModule.GetCompilationList().size() != mirModule.GetFunctionList().size()) && @@ -79,6 +78,8 @@ void InterleavedManager::Run() { } else { compList = &mirModule.GetFunctionList(); } + // If rangeNum < MeOption::range[0], Move to the next function with rangeNum++ + uint64 rangeNum = 0; for (auto *func : *compList) { if (MeOption::useRange && (rangeNum < MeOption::range[0] || rangeNum > MeOption::range[1])) { ++rangeNum; diff --git a/src/maple_ir/include/bin_mir_file.h b/src/maple_ir/include/bin_mir_file.h index bf8513d8d9946d58d55c0762385472c236f0bd44..1bc8986ecd1472acbacc2c38f007c9ca6b44b45a 100644 --- a/src/maple_ir/include/bin_mir_file.h +++ b/src/maple_ir/include/bin_mir_file.h @@ -19,8 +19,8 @@ namespace maple { const std::string kBinMirFileID = "HWCMPL"; // for magic in file header -constexpr int kVersionMajor = 0; // experimental version -constexpr int kVersionMinor = 1; +constexpr uint8 kVersionMajor = 0; // experimental version +constexpr uint8 kVersionMinor = 1; constexpr int kMagicSize = 7; enum BinMirFileType { @@ -29,7 +29,12 @@ enum BinMirFileType { kMjsvmFileTypeUnknown }; -#define MAKE_VERSION_NUM(major, minor) ((uint8)(((major & 0xF) << 4) | (minor & 0xF))) +inline uint8 MakeVersionNum(uint8 major, uint8 minor) { + uint8 mj = major & 0x0Fu; + uint8 mn = minor & 0x0Fu; + return (mj << 4) | mn; +} + // file header for binary format kMmpl, 8B in total // Note the header is different with the specification struct BinMIRFileHeader { diff --git a/src/maple_ir/include/global_tables.h b/src/maple_ir/include/global_tables.h index c61c2481999e49374686405d814556b1babb2751..097cbdacf281a2951af24f0eab9edcc4782ada8a 100644 --- a/src/maple_ir/include/global_tables.h +++ b/src/maple_ir/include/global_tables.h @@ -630,5 +630,9 @@ class GlobalTables { StringTable uStrTable; StringTable u16StringTable; }; + +inline MIRType &GetTypeFromTyIdx(TyIdx idx) { + return *(GlobalTables::GetTypeTable().GetTypeFromTyIdx(idx)); +} } // namespace maple #endif // MAPLE_IR_INCLUDE_GLOBAL_TABLES_H diff --git a/src/maple_ir/include/intrinsics.def b/src/maple_ir/include/intrinsics.def index 9ea6e762baff687c7026fa51d25fa024973b3d08..5bb44c353218a73019335e5bdd3aab30aafe7d8c 100644 --- a/src/maple_ir/include/intrinsics.def +++ b/src/maple_ir/include/intrinsics.def @@ -23,6 +23,8 @@ DEF_MIR_INTRINSIC(MPL_CLEAR_STACK,\ "__mpl_clear_stack", kIntrnUndef, kArgTyVoid, kArgTyDynany, kArgTyDynany, kArgTyUndef, kArgTyUndef, kArgTyUndef, kArgTyUndef) DEF_MIR_INTRINSIC(MPL_GET_VTAB_FUNC,\ "MCC_getFuncPtrFromVtab", kIntrnUndef, kArgTyA64, kArgTyDynany, kArgTyDynany, kArgTyUndef, kArgTyUndef, kArgTyUndef, kArgTyUndef) +DEF_MIR_INTRINSIC(MPL_READ_STATIC_OFFSET_TAB,\ + "__mpl_read_static_offset", INTRNISJAVA | INTRNNOSIDEEFFECT, kArgTyDynany, kArgTyDynany, kArgTyU32, kArgTyUndef, kArgTyUndef, kArgTyUndef, kArgTyUndef) DEF_MIR_INTRINSIC(MPL_READ_OVTABLE_ENTRY,\ "__mpl_const_offset", INTRNISPURE, kArgTyA32, kArgTyDynany, kArgTyUndef, kArgTyUndef, kArgTyUndef, kArgTyUndef, kArgTyUndef) DEF_MIR_INTRINSIC(MPL_READ_OVTABLE_ENTRY2,\ diff --git a/src/maple_ir/include/mir_nodes.h b/src/maple_ir/include/mir_nodes.h index a21839c907159d8bd21a6a5f343f3d7dfebf34d5..02d7a07f090246e9020b8fe1dccf06dfd1e9be1c 100644 --- a/src/maple_ir/include/mir_nodes.h +++ b/src/maple_ir/include/mir_nodes.h @@ -23,6 +23,7 @@ #include "mir_const.h" #include "maple_string.h" #include "ptr_list_ref.h" +#include "global_tables.h" namespace maple { extern MIRModule *theMIRModule; @@ -184,6 +185,9 @@ class BaseNode { return true; } + virtual bool IsSSANode() const { + return false; + } protected: Opcode op; PrimType ptyp; @@ -924,6 +928,11 @@ class IntrinsicopNode : public NaryNode { tyIdx = idx; } + // IntrinDesc query + const IntrinDesc &GetIntrinDesc() const { + return IntrinDesc::intrinTable[intrinsic]; + } + private: MIRIntrinsicID intrinsic; TyIdx tyIdx; diff --git a/src/maple_ir/include/mir_symbol.h b/src/maple_ir/include/mir_symbol.h index f93cbaca218aae162d74f62b0631dfe9aee4759d..84fbe5e8c592c2d5cd823178096c347862f5f3ea 100644 --- a/src/maple_ir/include/mir_symbol.h +++ b/src/maple_ir/include/mir_symbol.h @@ -174,6 +174,8 @@ class MIRSymbol { return typeAttrs.GetAttr(ATTR_volatile); } + bool IsTypeVolatile(int fieldID) const; + bool IsStatic() const { return typeAttrs.GetAttr(ATTR_static); } diff --git a/src/maple_ir/include/mir_type.h b/src/maple_ir/include/mir_type.h index eeceb57f1c563267c01e3a2775ed030db8bb55aa..0c550d80029e77a3993fd1125a346573a422d42c 100644 --- a/src/maple_ir/include/mir_type.h +++ b/src/maple_ir/include/mir_type.h @@ -447,7 +447,7 @@ class MIRType { return GetPrimTypeSize(primType); } - virtual bool HasVolatileField() { + virtual bool HasVolatileField() const { return false; } @@ -460,6 +460,8 @@ class MIRType { typeKind == kTypeInterfaceIncomplete; } + bool IsVolatile(int fieldID) const; + bool IsMIRPtrType() const { return typeKind == kTypePointer; } @@ -537,6 +539,7 @@ class MIRPtrType : public MIRType { bool EqualTo(const MIRType &type) const override; bool HasTypeParam() const override; + bool IsPointedTypeVolatile(int fieldID) const; void Dump(int indent, bool dontUseName = false) const override; TyIdxFieldAttrPair GetPointedTyIdxFldAttrPairWithFieldID(FieldID fieldID) const; @@ -849,7 +852,7 @@ class MIRStructType : public MIRType { return std::find(fields.begin(), fields.end(), fieldPair) != fields.end(); } - bool HasVolatileField() override; + bool HasVolatileField() const override; bool HasTypeParam() const override; bool EqualTo(const MIRType &type) const override; MIRType *CopyMIRTypeNode() const override { @@ -992,13 +995,13 @@ class MIRStructType : public MIRType { // Weak indicates the actual definition is in another module. bool isImported = false; bool isUsed = false; - bool hasVolatileField = false; // for caching computed value - bool hasVolatileFieldSet = false; // if true, just read hasVolatileField; - // otherwise compute to initialize hasVolatileField + mutable bool hasVolatileField = false; // for caching computed value + mutable bool hasVolatileFieldSet = false; // if true, just read hasVolatileField; + // otherwise compute to initialize hasVolatileField private: FieldPair TraverseToField(FieldID fieldID) const ; FieldPair TraverseToField(GStrIdx fieldStrIdx) const ; - bool HasVolatileFieldInFields(const FieldVector &fieldsOfStruct); + bool HasVolatileFieldInFields(const FieldVector &fieldsOfStruct) const; bool HasTypeParamInFields(const FieldVector &fieldsOfStruct) const; }; @@ -1148,7 +1151,7 @@ class MIRClassType : public MIRStructType { bool IsFinal() const; bool IsInner() const; - bool HasVolatileField() override; + bool HasVolatileField() const override; bool HasTypeParam() const override; FieldPair TraverseToFieldRef(FieldID &fieldID) const override; size_t GetSize() const override; @@ -1275,7 +1278,7 @@ class MIRInterfaceType : public MIRStructType { } void Dump(int indent, bool dontUseName = false) const override; - bool HasVolatileField() override; + bool HasVolatileField() const override; bool HasTypeParam() const override; FieldPair TraverseToFieldRef(FieldID &fieldID) const override; void SetComplete() override { diff --git a/src/maple_ir/include/opcodes.h b/src/maple_ir/include/opcodes.h index 32ba25a20fc4380d1c690d46db248faf7ad004d0..fea500ac604b8ba3c1f2b8121250d3e992a825e1 100644 --- a/src/maple_ir/include/opcodes.h +++ b/src/maple_ir/include/opcodes.h @@ -36,6 +36,71 @@ inline constexpr bool IsCallAssigned(Opcode code) { code == OP_customcallassigned || code == OP_polymorphiccallassigned || code == OP_icallassigned || code == OP_intrinsiccallassigned || code == OP_xintrinsiccallassigned || code == OP_intrinsiccallwithtypeassigned); +} + +inline constexpr bool IsBranch(Opcode opcode) { + switch (opcode) { + case OP_goto: + case OP_brtrue: + case OP_brfalse: + case OP_switch: + return true; + default: + return false; + } +} + +constexpr bool IsStmtMustRequire(Opcode opcode) { + switch (opcode) { + case OP_jstry: + case OP_throw: + case OP_try: + case OP_catch: + case OP_jscatch: + case OP_finally: + case OP_endtry: + case OP_cleanuptry: + case OP_gosub: + case OP_retsub: + case OP_return: + 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: + case OP_icall: + case OP_icallassigned: + case OP_intrinsiccall: + case OP_xintrinsiccall: + case OP_intrinsiccallassigned: + case OP_xintrinsiccallassigned: + case OP_intrinsiccallwithtype: + case OP_intrinsiccallwithtypeassigned: + case OP_syncenter: + case OP_syncexit: + case OP_membaracquire: + case OP_membarrelease: + case OP_membarstoreload: + case OP_membarstorestore: + case OP_assertnonnull: + case OP_eval: + case OP_free: { + return true; + } + default: + return false; } +} } // namespace maple #endif // MAPLE_IR_INCLUDE_OPCODES_H diff --git a/src/maple_ir/src/bin_mpl_export.cpp b/src/maple_ir/src/bin_mpl_export.cpp index 0df30c257bfdbda5c8fdf4b207953ae288ca1d65..7231c3fa2f391738232d44cdc21ed1ed911b376c 100644 --- a/src/maple_ir/src/bin_mpl_export.cpp +++ b/src/maple_ir/src/bin_mpl_export.cpp @@ -471,7 +471,7 @@ void BinaryMplExport::OutputFieldPair(const FieldPair &fp) { WriteNum(fa.GetAlignValue()); if (fa.GetAttr(FLDATTR_static) && fa.GetAttr(FLDATTR_final) && (fa.GetAttr(FLDATTR_public) || fa.GetAttr(FLDATTR_protected))) { - const char *fieldName = (GlobalTables::GetStrTable().GetStringFromStrIdx(fp.first)).c_str(); + const std::string &fieldName = GlobalTables::GetStrTable().GetStringFromStrIdx(fp.first); MIRSymbol *fieldVar = mod.GetMIRBuilder()->GetGlobalDecl(fieldName); if ((fieldVar != nullptr) && (fieldVar->GetKonst() != nullptr) && (fieldVar->GetKonst()->GetKind() == kConstStr16Const)) { diff --git a/src/maple_ir/src/global_tables.cpp b/src/maple_ir/src/global_tables.cpp index 45e89d13d02467945877a33b500511a703d6a6d3..9e5ba8b75544849369f2a799c3e451cae976cca8 100644 --- a/src/maple_ir/src/global_tables.cpp +++ b/src/maple_ir/src/global_tables.cpp @@ -264,6 +264,7 @@ GSymbolTable::~GSymbolTable() { MIRSymbol *GSymbolTable::CreateSymbol(uint8 scopeID) { auto *st = new MIRSymbol(symbolTable.size(), scopeID); + CHECK_FATAL(st != nullptr, "CreateSymbol failure"); symbolTable.push_back(st); module->AddSymbol(st); return st; diff --git a/src/maple_ir/src/mir_builder.cpp b/src/maple_ir/src/mir_builder.cpp index 8a836a3cd91b814b40a346bff3831af10ea4df11..e47cc3155daeaf06745cf90dbdd31b017f4851e5 100644 --- a/src/maple_ir/src/mir_builder.cpp +++ b/src/maple_ir/src/mir_builder.cpp @@ -252,7 +252,7 @@ MIRFunction *MIRBuilder::GetFunctionFromStidx(StIdx stIdx) { MIRFunction *MIRBuilder::CreateFunction(const std::string &name, const MIRType &returnType, const ArgVector &arguments, bool isVarg, bool createBody) const { MIRSymbol *funcSymbol = GlobalTables::GetGsymTable().CreateSymbol(kScopeGlobal); - GStrIdx strIdx = GetOrCreateStringIndex(name.c_str()); + GStrIdx strIdx = GetOrCreateStringIndex(name); funcSymbol->SetNameStrIdx(strIdx); if (!GlobalTables::GetGsymTable().AddToStringSymbolMap(*funcSymbol)) { return nullptr; diff --git a/src/maple_ir/src/mir_module.cpp b/src/maple_ir/src/mir_module.cpp index adbb307cc0b75bd67f36644876c209f7e2b1ac5c..a7755163e6589094c273170a9ad7f93e624159af 100644 --- a/src/maple_ir/src/mir_module.cpp +++ b/src/maple_ir/src/mir_module.cpp @@ -288,7 +288,7 @@ void MIRModule::Emit(const std::string &outFileName) const { // Change cout's buffer to file. std::streambuf *backup = LogInfo::MapleLogger().rdbuf(); LogInfo::MapleLogger().rdbuf(file.rdbuf()); - file.open(outFileName.c_str(), std::ios::trunc); + file.open(outFileName, std::ios::trunc); DumpGlobals(); for (MIRFunction *mirFunc : functionList) { mirFunc->Dump(); @@ -328,7 +328,7 @@ void MIRModule::OutputFunctionListAsciiMpl(const std::string &phaseName) { void MIRModule::DumpToFile(const std::string &fileNameStr, bool emitStructureType) const { std::ofstream file; - file.open(fileNameStr.c_str(), std::ios::trunc); + file.open(fileNameStr, std::ios::trunc); if (!file.is_open()) { ERR(kLncErr, "Cannot open %s", fileNameStr.c_str()); return; @@ -349,7 +349,7 @@ void MIRModule::DumpInlineCandidateToFile(const std::string &fileNameStr) const // Change cout's buffer to file. std::streambuf *backup = LogInfo::MapleLogger().rdbuf(); LogInfo::MapleLogger().rdbuf(file.rdbuf()); - file.open(fileNameStr.c_str(), std::ios::trunc); + file.open(fileNameStr, std::ios::trunc); for (auto *func : optimizedFuncs) { func->SetWithLocInfo(false); func->Dump(); @@ -382,7 +382,7 @@ void MIRModule::DumpClassToFile(const std::string &path) const { outClassFile.insert(0, strPath); outClassFile.append(".mpl"); std::ofstream mplFile; - mplFile.open(outClassFile.c_str(), std::ios::trunc); + mplFile.open(outClassFile, std::ios::trunc); std::streambuf *backup = LogInfo::MapleLogger().rdbuf(); LogInfo::MapleLogger().rdbuf(mplFile.rdbuf()); /* dump class type */ diff --git a/src/maple_ir/src/mir_nodes.cpp b/src/maple_ir/src/mir_nodes.cpp index 84908695cf7aff922dedc636055ab4e6eee9035f..fd058a2eba591bd3be079888e77624d14539ffb4 100644 --- a/src/maple_ir/src/mir_nodes.cpp +++ b/src/maple_ir/src/mir_nodes.cpp @@ -861,7 +861,7 @@ void DoloopNode::DumpDoVar(const MIRModule &mod) const { << " (\n"; } else { const MIRSymbol *st = mod.CurFunction()->GetLocalOrGlobalSymbol(doVarStIdx); - LogInfo::MapleLogger() << " %" << st->GetName().c_str() << " (\n"; + LogInfo::MapleLogger() << " %" << st->GetName() << " (\n"; } } @@ -884,11 +884,11 @@ void ForeachelemNode::Dump(const MIRModule &mod, int32 indent) const { StmtNode::DumpBase(mod, indent); const MIRSymbol *st = mod.CurFunction()->GetLocalOrGlobalSymbol(elemStIdx); ASSERT(st != nullptr, "null ptr check"); - LogInfo::MapleLogger() << " %" << st->GetName().c_str(); + LogInfo::MapleLogger() << " %" << st->GetName(); st = mod.CurFunction()->GetLocalOrGlobalSymbol(arrayStIdx); ASSERT(st != nullptr, "null ptr check"); LogInfo::MapleLogger() << (arrayStIdx.Islocal() ? " %" : " $"); - LogInfo::MapleLogger() << st->GetName().c_str(); + LogInfo::MapleLogger() << st->GetName(); loopBody->Dump(mod, indent + 1); } diff --git a/src/maple_ir/src/mir_pragma.cpp b/src/maple_ir/src/mir_pragma.cpp index 44ccf33be7455739b2a3ef793d42d0c34fc4e3b4..ef321678b026f8bbbe1046e93215acdba2da1387 100644 --- a/src/maple_ir/src/mir_pragma.cpp +++ b/src/maple_ir/src/mir_pragma.cpp @@ -210,55 +210,55 @@ void MIRPragmaElement::Dump(int indent) const { std::string str = GetKind(valueType); switch (valueType) { case kValueByte: - LogInfo::MapleLogger() << str.c_str() << " " << val.i; + LogInfo::MapleLogger() << str << " " << val.i; break; case kValueShort: - LogInfo::MapleLogger() << str.c_str() << " " << val.i; + LogInfo::MapleLogger() << str << " " << val.i; break; case kValueChar: - LogInfo::MapleLogger() << str.c_str() << " " << val.u; + LogInfo::MapleLogger() << str << " " << val.u; break; case kValueInt: - LogInfo::MapleLogger() << str.c_str() << " " << val.i; + LogInfo::MapleLogger() << str << " " << val.i; break; case kValueLong: - LogInfo::MapleLogger() << str.c_str() << " " << val.j; + LogInfo::MapleLogger() << str << " " << val.j; break; case kValueFloat: - LogInfo::MapleLogger() << std::setiosflags(std::ios::scientific) << str.c_str() << " " + LogInfo::MapleLogger() << std::setiosflags(std::ios::scientific) << str << " " << std::setprecision(floatPrec) << val.f << "f"; break; case kValueDouble: - LogInfo::MapleLogger() << std::setiosflags(std::ios::scientific) << str.c_str() << " " + LogInfo::MapleLogger() << std::setiosflags(std::ios::scientific) << str << " " << std::setprecision(doublePrec) << val.d; break; case kValueMethodType: - LogInfo::MapleLogger() << str.c_str() << " $" << std::hex << "0x" << val.u << std::dec; + LogInfo::MapleLogger() << str << " $" << std::hex << "0x" << val.u << std::dec; break; case kValueMethodHandle: - LogInfo::MapleLogger() << str.c_str() << " " << std::hex << "0x" << val.u << std::dec; + LogInfo::MapleLogger() << str << " " << std::hex << "0x" << val.u << std::dec; break; case kValueString: gStrIdx.SetIdx(val.u); - LogInfo::MapleLogger() << str.c_str() << " \"" << GlobalTables::GetStrTable().GetStringFromStrIdx(gStrIdx).c_str() + LogInfo::MapleLogger() << str << " \"" << GlobalTables::GetStrTable().GetStringFromStrIdx(gStrIdx) << "\""; break; case kValueType: gStrIdx.SetIdx(val.u); - LogInfo::MapleLogger() << str.c_str() << " <$" << GlobalTables::GetStrTable().GetStringFromStrIdx(gStrIdx).c_str() + LogInfo::MapleLogger() << str << " <$" << GlobalTables::GetStrTable().GetStringFromStrIdx(gStrIdx) << ">"; break; case kValueField: gStrIdx.SetIdx(val.u); - LogInfo::MapleLogger() << str.c_str() << " @" << GlobalTables::GetStrTable().GetStringFromStrIdx(gStrIdx).c_str(); + LogInfo::MapleLogger() << str << " @" << GlobalTables::GetStrTable().GetStringFromStrIdx(gStrIdx); break; case kValueMethod: gStrIdx.SetIdx(val.u); - LogInfo::MapleLogger() << str.c_str() << " &" << GlobalTables::GetStrTable().GetStringFromStrIdx(gStrIdx).c_str(); + LogInfo::MapleLogger() << str << " &" << GlobalTables::GetStrTable().GetStringFromStrIdx(gStrIdx); break; case kValueEnum: gStrIdx.SetIdx(val.u); - LogInfo::MapleLogger() << str.c_str() << " " << GlobalTables::GetStrTable().GetStringFromStrIdx(gStrIdx).c_str(); + LogInfo::MapleLogger() << str << " " << GlobalTables::GetStrTable().GetStringFromStrIdx(gStrIdx); break; case kValueArray: { size_t num = subElemVec.size(); @@ -287,7 +287,7 @@ void MIRPragmaElement::Dump(int indent) const { case kValueAnnotation: { size_t num = subElemVec.size(); LogInfo::MapleLogger() << "annotation <$"; - LogInfo::MapleLogger() << GlobalTables::GetStrTable().GetStringFromStrIdx(typeStrIdx).c_str() << "> [" << num; + LogInfo::MapleLogger() << GlobalTables::GetStrTable().GetStringFromStrIdx(typeStrIdx) << "> [" << num; if (num) { if (num > 1) { LogInfo::MapleLogger() << ",\n"; @@ -300,7 +300,7 @@ void MIRPragmaElement::Dump(int indent) const { PrintIndentation(indent + indentOffset); } LogInfo::MapleLogger() << "@" - << GlobalTables::GetStrTable().GetStringFromStrIdx(subElemVec[i]->nameStrIdx).c_str() + << GlobalTables::GetStrTable().GetStringFromStrIdx(subElemVec[i]->nameStrIdx) << " "; subElemVec[i]->Dump(indent + indentOffset); if (i != num - 1) { @@ -313,10 +313,10 @@ void MIRPragmaElement::Dump(int indent) const { break; } case kValueNull: - LogInfo::MapleLogger() << str.c_str() << " nullptr"; + LogInfo::MapleLogger() << str << " nullptr"; break; case kValueBoolean: - LogInfo::MapleLogger() << str.c_str() << " " << val.u; + LogInfo::MapleLogger() << str << " " << val.u; break; } } diff --git a/src/maple_ir/src/mir_symbol.cpp b/src/maple_ir/src/mir_symbol.cpp index 3e6bee81af01c1419b96bb0b0a69175fb1694c83..f4b7aeb2c72d76b536c45485999742ec50062795 100644 --- a/src/maple_ir/src/mir_symbol.cpp +++ b/src/maple_ir/src/mir_symbol.cpp @@ -27,6 +27,11 @@ namespace maple { using namespace NameMangler; +bool MIRSymbol::IsTypeVolatile(int fieldID) const { + const MIRType *ty = GlobalTables::GetTypeTable().GetTypeFromTyIdx(GetTyIdx()); + return ty->IsVolatile(fieldID); +} + void MIRSymbol::SetNameStrIdx(const std::string &name) { nameStrIdx = GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(name); } diff --git a/src/maple_ir/src/mir_type.cpp b/src/maple_ir/src/mir_type.cpp index 4ac0a5ccccd2b170df6c17de2be9753094e2adc8..89f393888201d7df9087d69ab51b16c52587f0ee 100644 --- a/src/maple_ir/src/mir_type.cpp +++ b/src/maple_ir/src/mir_type.cpp @@ -569,6 +569,13 @@ MIRType *MIRPtrType::GetPointedType() const { return GlobalTables::GetTypeTable().GetTypeFromTyIdx(pointedTyIdx); } +bool MIRType::IsVolatile(int fieldID) const { + if (fieldID == 0) { + return HasVolatileField(); + } + return static_cast(this)->IsFieldVolatile(fieldID); +} + bool MIRPtrType::HasTypeParam() const { return GetPointedType()->HasTypeParam(); } @@ -1282,7 +1289,7 @@ FieldPair MIRStructType::TraverseToField(GStrIdx fieldStrIdx) const { return { GStrIdx(0), TyIdxFieldAttrPair(TyIdx(0), FieldAttrs()) }; } -bool MIRStructType::HasVolatileFieldInFields(const FieldVector &fieldsOfStruct) { +bool MIRStructType::HasVolatileFieldInFields(const FieldVector &fieldsOfStruct) const { for (const auto &field : fieldsOfStruct) { if (field.second.second.GetAttr(FLDATTR_volatile) || GlobalTables::GetTypeTable().GetTypeFromTyIdx(field.second.first)->HasVolatileField()) { @@ -1295,7 +1302,7 @@ bool MIRStructType::HasVolatileFieldInFields(const FieldVector &fieldsOfStruct) } // go through all the fields to check if there is volatile attribute set; -bool MIRStructType::HasVolatileField() { +bool MIRStructType::HasVolatileField() const { if (hasVolatileFieldSet) { return hasVolatileField; } @@ -1310,13 +1317,13 @@ static bool ParentTypeHasVolatileField(const TyIdx parentTyIdx, bool &hasVolatil } // go through all the fields to check if there is volatile attribute set; -bool MIRClassType::HasVolatileField() { +bool MIRClassType::HasVolatileField() const { return MIRStructType::HasVolatileField() || (parentTyIdx != 0 && ParentTypeHasVolatileField(parentTyIdx, hasVolatileField)); } // go through all the fields to check if there is volatile attribute set; -bool MIRInterfaceType::HasVolatileField() { +bool MIRInterfaceType::HasVolatileField() const { if (MIRStructType::HasVolatileField()) { return true; } @@ -1379,6 +1386,11 @@ FieldPair MIRInterfaceType::TraverseToFieldRef(FieldID &fieldID) const { return { GStrIdx(0), TyIdxFieldAttrPair(TyIdx(0), FieldAttrs()) }; } +bool MIRPtrType::IsPointedTypeVolatile(int fieldID) const { + MIRType *pointedTy = GlobalTables::GetTypeTable().GetTypeFromTyIdx(GetPointedTyIdx()); + return pointedTy->IsVolatile(fieldID); +} + TyIdxFieldAttrPair MIRPtrType::GetPointedTyIdxFldAttrPairWithFieldID(FieldID fieldID) const { if (fieldID == 0) { return TyIdxFieldAttrPair(pointedTyIdx, FieldAttrs()); diff --git a/src/maple_ir/src/option.cpp b/src/maple_ir/src/option.cpp index f0078d8ac6163a0b9b447f8cec074de2722c027b..3b7c8d23bf88746d47fadbbb558b303e24d99d2e 100644 --- a/src/maple_ir/src/option.cpp +++ b/src/maple_ir/src/option.cpp @@ -111,7 +111,7 @@ bool Options::ParseOptions(int argc, char **argv, std::string &fileName) const { bool result = true; OptionParser optionParser(kUsage); int ret = optionParser.Parse(argc, argv); - CHECK_FATAL(ret == ErrorCode::kErrorNoError, "option parser error"); + CHECK_FATAL(ret == kErrorNoError, "option parser error"); for (auto opt : optionParser.GetOptions()) { switch (opt.Index()) { case kHelp: { @@ -201,7 +201,7 @@ void Options::DumpOptions() const { LogInfo::MapleLogger() << "default phase sequence\n"; } else { for (size_t i = 0; i < phaseSeq.size(); ++i) { - LogInfo::MapleLogger() << " " << phaseSeq[i].c_str(); + LogInfo::MapleLogger() << " " << phaseSeq[i]; } } LogInfo::MapleLogger() << "\n"; diff --git a/src/maple_me/include/bb.h b/src/maple_me/include/bb.h index 1710f162da8d02eacc9ca20a7e7c10900082018e..03343360b68a294f43abfb85037344d2bc59cad9 100644 --- a/src/maple_me/include/bb.h +++ b/src/maple_me/include/bb.h @@ -108,10 +108,6 @@ class BB { return kind == kBBGoto; } - virtual bool IsFuncEntry() const { - return false; - } - virtual bool AddBackEndTry() const { return GetAttributes(kBBAttrIsTryEnd); } @@ -148,7 +144,7 @@ class BB { return static_cast(id); } - StmtNode *GetTheOnlyStmtNode() const; + StmtNode *GetTheOnlyStmtNode(); bool IsEmpty() const { return stmtNodeList.empty(); } @@ -161,12 +157,22 @@ class BB { stmtNodeList.update_back(stmt); } - StmtNode *GetFirst() { - return &(stmtNodeList.front()); + // should test IsEmpty first + StmtNode &GetFirst() { + return stmtNodeList.front(); + } + // should test IsEmpty first + const StmtNode &GetFirst() const { + return stmtNodeList.front(); } - StmtNode *GetLast() { - return &(stmtNodeList.back()); + // should test IsEmpty first + StmtNode &GetLast() { + return stmtNodeList.back(); + } + // should test IsEmpty first + const StmtNode &GetLast() const { + return stmtNodeList.back(); } void SetFirstMe(MeStmt *stmt); @@ -236,8 +242,8 @@ class BB { void RemoveMeStmt(MeStmt *meStmt); void AddMeStmtFirst(MeStmt *meStmt); void AddMeStmtLast(MeStmt *meStmt); - void InsertMeStmtBefore(MeStmt *meStmt, MeStmt *inStmt); - void InsertMeStmtAfter(MeStmt *meStmt, MeStmt *inStmt); + void InsertMeStmtBefore(const MeStmt *meStmt, MeStmt *inStmt); + void InsertMeStmtAfter(const MeStmt *meStmt, MeStmt *inStmt); void InsertMeStmtLastBr(MeStmt *inStmt); void ReplaceMeStmt(MeStmt *stmt, MeStmt *newStmt); void DumpMeVarPhiList(IRMap *irMap); @@ -417,6 +423,20 @@ class SCCOfBBs { MapleSet predSCC; MapleSet succSCC; }; + +inline bool ControlFlowInInfiniteLoop(const BB& bb, Opcode opcode) { + switch (opcode) { + // goto always return true + case OP_goto: + return true; + case OP_brtrue: + case OP_brfalse: + case OP_switch: + return bb.GetAttributes(kBBAttrWontExit); + default: + return false; + } +} } // namespace maple namespace std { diff --git a/src/maple_me/include/me_ir.h b/src/maple_me/include/me_ir.h index 9320af4f0c80ed172b0d49f99642befd2f2d987e..8af23142fbd11f093d71bf8b53bf68d30009020a 100644 --- a/src/maple_me/include/me_ir.h +++ b/src/maple_me/include/me_ir.h @@ -1280,7 +1280,7 @@ class MeStmt { return next; } - const Opcode GetOp() const { + Opcode GetOp() const { return op; } diff --git a/src/maple_me/include/me_irmap.h b/src/maple_me/include/me_irmap.h index a1a7430c4ba4bb2954b10a0da9e89c8f46d7d183..8b633a0256338feffde49008ccb572a5561d0d62 100644 --- a/src/maple_me/include/me_irmap.h +++ b/src/maple_me/include/me_irmap.h @@ -39,8 +39,8 @@ class MeIRMap : public IRMap { void DumpBB(const BB &bb); void Dump() override; - void EmitBB(const BB&, BlockNode&); - void EmitBBStmts(const BB&, BlockNode&); + void EmitBB(BB&, BlockNode&); + void EmitBBStmts(BB&, BlockNode&); MeFunction &GetFunc() { return func; diff --git a/src/maple_me/include/me_rc_lowering.h b/src/maple_me/include/me_rc_lowering.h index 0cbbbaf15af886879e5392a83b4e1eb96f2c3370..3f33574e2886b4640fe81b05432c0570bbb3445b 100644 --- a/src/maple_me/include/me_rc_lowering.h +++ b/src/maple_me/include/me_rc_lowering.h @@ -98,6 +98,9 @@ class RCLowering { // used to store initialized map, help to optimize dec ref in first assignment std::unordered_map*> initializedFields{}; bool enabledDebug; + bool checkRefFormal = false; + bool checkRefAssign = false; + bool checkRefReturn = false; }; class MeDoRCLowering : public MeFuncPhase { diff --git a/src/maple_me/include/me_ssa_tab.h b/src/maple_me/include/me_ssa_tab.h index f3132d96d5d35f10945b7786f643d4d1e784fa2f..e6c4e04bbc8213764bfe8b47636db78cb4e94784 100644 --- a/src/maple_me/include/me_ssa_tab.h +++ b/src/maple_me/include/me_ssa_tab.h @@ -27,7 +27,7 @@ class MeDoSSATab : public MeFuncPhase { private: AnalysisResult *Run(MeFunction *func, MeFuncResultMgr *funcResMgr, ModuleResultMgr *moduleResMgr) override; std::string PhaseName() const override { - return "ssaTab"; + return "ssatab"; } }; } // namespace maple diff --git a/src/maple_me/include/me_ssa_update.h b/src/maple_me/include/me_ssa_update.h index 782ec89b45c74babbf1557663126f42604304ea7..22207fea9edc03b2be0c0560c45a055873396232 100644 --- a/src/maple_me/include/me_ssa_update.h +++ b/src/maple_me/include/me_ssa_update.h @@ -42,9 +42,9 @@ class MeSSAUpdate { void InsertPhis(); void RenamePhi(const BB &bb); MeExpr *RenameExpr(MeExpr &meExpr, bool &changed); - void RenameStmts(const BB &bb); + void RenameStmts(BB &bb); void RenamePhiOpndsInSucc(const BB &bb); - void RenameBB(const BB &bb); + void RenameBB(BB &bb); MeFunction &func; IRMap &irMap; SSATab &ssaTab; diff --git a/src/maple_me/include/ssa.h b/src/maple_me/include/ssa.h index 6bfc00b8090d26a039f471b1b851f38e734a04b5..21377ad7e57c1825e95127cb508914dae537b8d9 100644 --- a/src/maple_me/include/ssa.h +++ b/src/maple_me/include/ssa.h @@ -38,6 +38,9 @@ class PhiNode { VersionSt *GetResult() { return result; } + const VersionSt *GetResult() const { + return result; + } void SetResult(VersionSt &resultPara) { result = &resultPara; @@ -46,11 +49,18 @@ class PhiNode { MapleVector &GetPhiOpnds() { return phiOpnds; } + const MapleVector &GetPhiOpnds() const { + return phiOpnds; + } VersionSt *GetPhiOpnd(size_t index) { ASSERT(index < phiOpnds.size(), "out of range in PhiNode::GetPhiOpnd"); return phiOpnds.at(index); } + const VersionSt *GetPhiOpnd(size_t index) const { + ASSERT(index < phiOpnds.size(), "out of range in PhiNode::GetPhiOpnd"); + return phiOpnds.at(index); + } void SetPhiOpnd(size_t index, VersionSt &opnd) { ASSERT(index < phiOpnds.size(), "out of range in PhiNode::SetPhiOpnd"); diff --git a/src/maple_me/include/ssa_mir_nodes.h b/src/maple_me/include/ssa_mir_nodes.h index a4bd41981196a989a7ac220d3d5dbab876aaaa02..1b0ab3e7ba17172aba53a11e9c1b367aa0cdd4cd 100644 --- a/src/maple_me/include/ssa_mir_nodes.h +++ b/src/maple_me/include/ssa_mir_nodes.h @@ -29,14 +29,23 @@ class MayDefNode { VersionSt *GetOpnd() { return opnd; } + const VersionSt *GetOpnd() const { + return opnd; + } VersionSt *GetResult() { return result; } + const VersionSt *GetResult() const { + return result; + } StmtNode *GetStmt() { return stmt; } + const StmtNode *GetStmt() const { + return stmt; + } void SetOpnd(VersionSt *sym) { opnd = sym; @@ -46,14 +55,6 @@ class MayDefNode { result = sym; } - bool IsRequired() const { - return result->IsLive(); - } - - void MarkRequired() { - result->MarkLive(); - } - void Dump(const MIRModule *mod) const { result->Dump(mod); LogInfo::MapleLogger() << " = MAYD("; @@ -103,6 +104,9 @@ class MustDefNode { VersionSt *GetResult() { return result; } + const VersionSt *GetResult() const { + return result; + } void SetResult(VersionSt *sym) { result = sym; @@ -111,13 +115,8 @@ class MustDefNode { StmtNode *GetStmt() { return stmt; } - - bool IsRequired() const { - return result->IsLive(); - } - - void MarkRequired() { - result->MarkLive(); + const StmtNode *GetStmt() const { + return stmt; } void Dump(const MIRModule *mod) const { @@ -154,7 +153,6 @@ class AccessSSANodes { virtual const MapleVector &GetMustDefNodes() const { CHECK_FATAL(false, "No mustDefNodes"); } - virtual MapleVector &GetMustDefNodes() { CHECK_FATAL(false, "No mustDefNodes"); } @@ -243,7 +241,6 @@ class MustDefPart : public AccessSSANodes { const MapleVector &GetMustDefNodes() const override { return mustDefNodes; } - MapleVector &GetMustDefNodes() override { return mustDefNodes; } @@ -361,7 +358,6 @@ class MayDefMayUseMustDefPart : public AccessSSANodes { const MapleVector &GetMustDefNodes() const override { return mustDefNodes; } - MapleVector &GetMustDefNodes() override { return mustDefNodes; } @@ -391,6 +387,9 @@ class StmtsSSAPart { AccessSSANodes *SSAPartOf(const StmtNode &stmt) { return ssaPart[stmt.GetStmtID()]; } + const AccessSSANodes *SSAPartOf(const StmtNode &stmt) const { + return ssaPart.at(stmt.GetStmtID()); + } bool HasMayDef(const StmtNode &stmt) { return kOpcodeInfo.HasSSADef(stmt.GetOpCode()) && !GetMayDefNodesOf(stmt).empty(); @@ -405,11 +404,17 @@ class StmtsSSAPart { } MapleVector &GetMustDefNodesOf(const StmtNode &stmt) { - return ssaPart[stmt.GetStmtID()]->GetMustDefNodes(); + return ssaPart.at(stmt.GetStmtID())->GetMustDefNodes(); + } + const MapleVector &GetMustDefNodesOf(const StmtNode &stmt) const { + return ssaPart.at(stmt.GetStmtID())->GetMustDefNodes(); } VersionSt *GetAssignedVarOf(const StmtNode &stmt) { - return ssaPart[stmt.GetStmtID()]->GetSSAVar(); + return ssaPart.at(stmt.GetStmtID())->GetSSAVar(); + } + const VersionSt *GetAssignedVarOf(const StmtNode &stmt) const { + return ssaPart.at(stmt.GetStmtID())->GetSSAVar(); } template @@ -437,103 +442,118 @@ class StmtsSSAPart { MapleMap ssaPart; // key is stmtID }; -// The following expression nodes need extra fields to represent SSA -class AddrofSSANode : public AddrofNode { +class SSANode : public BaseNode { public: - explicit AddrofSSANode(const AddrofNode *addrofNode) : AddrofNode(addrofNode->GetOpCode()) { - SetPrimType(addrofNode->GetPrimType()); - SetStIdx(addrofNode->GetStIdx()); - SetFieldID(addrofNode->GetFieldID()); - ssaVar = nullptr; - } + SSANode(Opcode op, PrimType typ, uint8 numOpr) : BaseNode(op, typ, numOpr) {} - ~AddrofSSANode() override = default; + ~SSANode() override = default; - void Dump(const MIRModule &mod, int32 indent) const override { - AddrofNode::Dump(mod, indent); - if (ssaVar != nullptr) { - ssaVar->Dump(&mod, true); - } + VersionSt *GetSSAVar() { + return ssaVar; } - const VersionSt *GetSSAVar() const { return ssaVar; } - VersionSt *GetSSAVar() { - return ssaVar; + + void SetSSAVar(VersionSt &ssaVarPara) { + ssaVar = &ssaVarPara; } - void SetSSAVar(VersionSt *ssaVarPara) { - ssaVar = ssaVarPara; + + bool IsSSANode() const override { + return true; } - private: - VersionSt *ssaVar; + // MIRSymbol query + const MIRSymbol &GetMIRSymbol() const { + return *(GetSSAVar()->GetOrigSt()->GetMIRSymbol()); + } + + protected: + VersionSt *ssaVar = nullptr; }; -class IreadSSANode : public IreadNode { +// The following expression nodes need extra fields to represent SSA +class AddrofSSANode : public SSANode { public: - IreadSSANode(MapleAllocator *alloc, IreadNode *iNode) : IreadNode(iNode->GetOpCode()), ssaVar(nullptr) { - SetPrimType(iNode->GetPrimType()); - tyIdx = iNode->GetTyIdx(); - fieldID = iNode->GetFieldID(); - SetOpnd(iNode->Opnd()); - } + explicit AddrofSSANode(AddrofNode &addrNode) + : SSANode(addrNode.GetOpCode(), addrNode.GetPrimType(), addrNode.NumOpnds()), addrofNode(&addrNode) {} - ~IreadSSANode() override = default; + ~AddrofSSANode() override = default; void Dump(const MIRModule &mod, int32 indent) const override { - if (ssaVar != nullptr) { - ssaVar->Dump(&mod, true); + addrofNode->Dump(mod, indent); + if (GetSSAVar() != nullptr) { + GetSSAVar()->Dump(&mod, true); } - IreadNode::Dump(mod, indent); } - VersionSt *GetSSAVar() { - return ssaVar; + StIdx GetStIdx() const { + return addrofNode->GetStIdx(); } - void SetSSAVar(VersionSt *ssaVarPara) { - ssaVar = ssaVarPara; + FieldID GetFieldID() const { + return addrofNode->GetFieldID(); } - private: - VersionSt *ssaVar; + AddrofNode *addrofNode; }; -class RegreadSSANode : public RegreadNode { +class IreadSSANode : public SSANode { public: - explicit RegreadSSANode(const RegreadNode *readNode) : RegreadNode() { - SetPrimType(readNode->GetPrimType()); - SetRegIdx(readNode->GetRegIdx()); - } + explicit IreadSSANode(IreadNode &iread) + : SSANode(iread.GetOpCode(), iread.GetPrimType(), iread.NumOpnds()), ireadNode(&iread) {} - ~RegreadSSANode() override = default; + ~IreadSSANode() override = default; void Dump(const MIRModule &mod, int32 indent) const override { - RegreadNode::Dump(mod, indent); - if (ssaVar != nullptr) { - ssaVar->Dump(&mod, true); + if (GetSSAVar() != nullptr) { + GetSSAVar()->Dump(&mod, true); } + ireadNode->Dump(mod, indent); } - const VersionSt *GetSSAVar() const { - return ssaVar; + FieldID GetFieldID() const { + return ireadNode->GetFieldID(); } - VersionSt *GetSSAVar() { - return ssaVar; + TyIdx GetTyIdx() const { + return ireadNode->GetTyIdx(); } - void SetSSAVar(VersionSt *ssaVarPara) { - ssaVar = ssaVarPara; + BaseNode *Opnd(size_t idx) const override { + return ireadNode->Opnd(idx); } + void SetOpnd(BaseNode *node, size_t i = 0) override { + ireadNode->SetOpnd(node, i); + } private: - VersionSt *ssaVar = nullptr; + IreadNode *ireadNode; +}; + +class RegreadSSANode : public SSANode { + public: + explicit RegreadSSANode(RegreadNode ®Read) + : SSANode(regRead.GetOpCode(), regRead.GetPrimType(), regRead.GetNumOpnds()), regreadNode(®Read) {} + + ~RegreadSSANode() override = default; + + void Dump(const MIRModule &mod, int32 indent) const override { + regreadNode->Dump(mod, indent); + if (GetSSAVar() != nullptr) { + GetSSAVar()->Dump(&mod, true); + } + } + + PregIdx GetRegIdx() const { + return regreadNode->GetRegIdx(); + } + private: + RegreadNode *regreadNode; }; void GenericSSAPrint(MIRModule &mod, const StmtNode &stmtNode, int32 indent, StmtsSSAPart &stmtsSSAPart); -MapleMap *SSAGenericGetMayDefsFromVersionSt(VersionSt &sym, StmtsSSAPart &stmtsSSAPart); +MapleMap *SSAGenericGetMayDefsFromVersionSt(const VersionSt &sym, StmtsSSAPart &stmtsSSAPart); bool HasMayUseOpnd(const BaseNode &baseNode, SSATab &func); } // namespace maple #endif // MAPLE_ME_INCLUDE_SSA_MIR_NODES_H diff --git a/src/maple_me/include/ssa_tab.h b/src/maple_me/include/ssa_tab.h index 150dac52a7d2b0b3a34def398288d449a5217617..405559c78d6903ee24182061430407e5abf9b98c 100644 --- a/src/maple_me/include/ssa_tab.h +++ b/src/maple_me/include/ssa_tab.h @@ -73,6 +73,11 @@ class SSATab : public AnalysisResult { return originalStTable.GetMIRSymbolFromOriginalSt(ost); } + PrimType GetPrimType(OStIdx idx) const { + const MIRSymbol *symbol = GetMIRSymbolFromID(idx); + return symbol->GetType()->GetPrimType(); + } + const MIRSymbol *GetMIRSymbolFromID(OStIdx id) const { return originalStTable.GetMIRSymbolFromID(id); } @@ -99,6 +104,18 @@ class SSATab : public AnalysisResult { StmtsSSAPart &GetStmtsSSAPart() { return stmtsSSAPart; } + const StmtsSSAPart &GetStmtsSSAPart() const { + return stmtsSSAPart; + } + + // should check HasSSAUse first + const MapleMap &GetStmtMayUseNodes(const StmtNode &stmt) const { + return stmtsSSAPart.SSAPartOf(stmt)->GetMayUseNodes(); + } + // should check IsCallAssigned first + MapleVector &GetStmtMustDefNodes(const StmtNode &stmt) { + return stmtsSSAPart.GetMustDefNodesOf(stmt); + } bool IsWholeProgramScope() const { return wholeProgramScope; @@ -128,6 +145,11 @@ class SSATab : public AnalysisResult { originalStTable.UpdateVarOstMap(ostIdx, varOstMap); } + // MIRSymbol query + const MIRSymbol &GetStmtMIRSymbol(const StmtNode &stmt) const { + return *(GetStmtsSSAPart().GetAssignedVarOf(stmt)->GetOrigSt()->GetMIRSymbol()); + } + private: MIRModule &mirModule; VersionStTable versionStTable; // this uses special versMp because it will be freed earlier diff --git a/src/maple_me/include/ver_symbol.h b/src/maple_me/include/ver_symbol.h index 4615de2409f0f664441ed4b37a4acbf3e400885c..51ced72d6eed9439735f5934b99bdf0747edb741 100644 --- a/src/maple_me/include/ver_symbol.h +++ b/src/maple_me/include/ver_symbol.h @@ -65,10 +65,6 @@ class VersionSt { void DumpDefStmt(const MIRModule *mod) const; - bool IsLive() const { - return live; - } - bool IsInitVersion() const { return version == kInitVersion; } @@ -81,14 +77,6 @@ class VersionSt { this->defType = defType; } - void MarkLive() { - live = true; - } - - void MarkDead() { - live = false; - } - OStIdx GetOrigIdx() const { return ost->GetIndex(); } @@ -174,7 +162,6 @@ class VersionSt { MustDefNode *mustDef; } defStmt; // only valid after SSA - bool live = false; // helper of dse bool isReturn = false; // the symbol will return in its function }; diff --git a/src/maple_me/src/alias_class.cpp b/src/maple_me/src/alias_class.cpp index 5b6c553ea71e46c71a3c3b27263d1e54238965b4..58784b3cdc7f9c9df6b948860a72bad6c0948608 100644 --- a/src/maple_me/src/alias_class.cpp +++ b/src/maple_me/src/alias_class.cpp @@ -123,7 +123,7 @@ AliasElem *AliasClass::CreateAliasElemsExpr(BaseNode &expr) { return (oSt.IsSpecialPreg()) ? nullptr : FindOrCreateAliasElem(oSt); } case OP_iread: { - auto &iread = static_cast(expr); + auto &iread = static_cast(expr); return FindOrCreateExtraLevAliasElem(*iread.Opnd(0), iread.GetTyIdx(), iread.GetFieldID()); } case OP_iaddrof: { @@ -144,8 +144,9 @@ AliasElem *AliasClass::CreateAliasElemsExpr(BaseNode &expr) { } case OP_intrinsicop: { auto &intrn = static_cast(expr); - if (intrn.GetIntrinsic() == INTRN_JAVA_MERGE && intrn.NumOpnds() == 1 && - intrn.GetNopndAt(0)->GetOpCode() == OP_dread) { + if (intrn.GetIntrinsic() == INTRN_MPL_READ_OVTABLE_ENTRY || + (intrn.GetIntrinsic() == INTRN_JAVA_MERGE && intrn.NumOpnds() == 1 && + intrn.GetNopndAt(0)->GetOpCode() == OP_dread)) { return CreateAliasElemsExpr(*intrn.GetNopndAt(0)); } // fall-through @@ -620,7 +621,7 @@ void AliasClass::InsertMayUseExpr(BaseNode &expr) { rhsAe = FindOrCreateDummyNADSAe(); } auto &ireadNode = static_cast(expr); - ireadNode.SetSSAVar(ssaTab.GetVersionStTable().GetVersionStFromID(rhsAe->GetOriginalSt().GetZeroVersionIndex())); + ireadNode.SetSSAVar(*ssaTab.GetVersionStTable().GetVersionStFromID(rhsAe->GetOriginalSt().GetZeroVersionIndex())); ASSERT(ireadNode.GetSSAVar() != nullptr, "AliasClass::InsertMayUseExpr(): iread cannot have empty mayuse"); } @@ -819,13 +820,15 @@ void AliasClass::InsertMayDefUseSyncOps(StmtNode &stmt) { // collect the full alias set first for (size_t i = 0; i < stmt.NumOpnds(); ++i) { BaseNode *addrBase = stmt.Opnd(i); - if (addrBase->GetOpCode() == OP_addrof || addrBase->GetOpCode() == OP_dread || - addrBase->GetOpCode() == OP_regread) { - OriginalSt *ost = (addrBase->GetOpCode() == OP_regread) - ? static_cast(addrBase)->GetSSAVar()->GetOrigSt() - : static_cast(addrBase)->GetSSAVar()->GetOrigSt(); - if (addrBase->GetOpCode() != OP_addrof) { - for (OriginalSt *nextLevelOst : *(GetAliasAnalysisTable()->GetNextLevelNodes(*ost))) { + if (addrBase->IsSSANode()) { + OriginalSt *oSt = static_cast(addrBase)->GetSSAVar()->GetOrigSt(); + if (addrBase->GetOpCode() == OP_addrof) { + AliasElem *opndAE = osym2Elem[oSt->GetIndex().idx]; + if (opndAE->GetClassSet() != nullptr) { + aliasSet.insert(opndAE->GetClassSet()->cbegin(), opndAE->GetClassSet()->cend()); + } + } else { + for (OriginalSt *nextLevelOst : *(GetAliasAnalysisTable()->GetNextLevelNodes(*oSt))) { AliasElem *opndAE = osym2Elem[nextLevelOst->GetIndex().idx]; if (opndAE->GetClassSet() != nullptr) { aliasSet.insert(opndAE->GetClassSet()->cbegin(), opndAE->GetClassSet()->cend()); @@ -879,8 +882,6 @@ void AliasClass::CollectMayDefForMustDefs(const StmtNode &stmt, std::set &mayUseOsts) { for (size_t i = 0; i < stmt.NumOpnds(); ++i) { BaseNode *expr = stmt.Opnd(i); - InsertMayUseExpr(*expr); - if (!IsPotentialAddress(expr->GetPrimType())) { continue; } @@ -1005,12 +1006,15 @@ void AliasClass::InsertMayDefUseClinitCheck(IntrinsiccallNode &stmt) { } void AliasClass::GenericInsertMayDefUse(StmtNode &stmt, BBId bbID) { + for (size_t i = 0; i < stmt.NumOpnds(); ++i) { + InsertMayUseExpr(*stmt.Opnd(i)); + } switch (stmt.GetOpCode()) { case OP_return: { InsertMayUseReturn(stmt); // insert mayuses caused by its return operand being a pointer InsertReturnOpndMayUse(stmt); - break; + return; } case OP_throw: { if (mirModule.GetSrcLang() != kSrcLangJs && lessThrowAlias) { @@ -1022,7 +1026,7 @@ void AliasClass::GenericInsertMayDefUse(StmtNode &stmt, BBId bbID) { } else { InsertMayUseAll(stmt); } - break; + return; } case OP_gosub: case OP_retsub: { @@ -1057,7 +1061,7 @@ void AliasClass::GenericInsertMayDefUse(StmtNode &stmt, BBId bbID) { InsertMayDefUseClinitCheck(intrnNode); } InsertMayDefUseIntrncall(stmt); - break; + return; } case OP_intrinsiccall: case OP_xintrinsiccall: @@ -1065,27 +1069,24 @@ void AliasClass::GenericInsertMayDefUse(StmtNode &stmt, BBId bbID) { case OP_xintrinsiccallassigned: case OP_intrinsiccallwithtypeassigned: { InsertMayDefUseIntrncall(stmt); - break; + return; } case OP_maydassign: case OP_dassign: { InsertMayDefDassign(stmt); - break; + return; } case OP_iassign: { InsertMayDefIassign(stmt); - break; + return; } case OP_syncenter: case OP_syncexit: { InsertMayDefUseSyncOps(stmt); - break; + return; } default: - break; - } - for (size_t i = 0; i < stmt.NumOpnds(); ++i) { - InsertMayUseExpr(*stmt.Opnd(i)); + return; } } } // namespace maple diff --git a/src/maple_me/src/bb.cpp b/src/maple_me/src/bb.cpp index 1e91c4bc853e0c583311200d26541d9caa725e1a..7816c836ea36f37d8a2623cf33255b1d59e5f210 100644 --- a/src/maple_me/src/bb.cpp +++ b/src/maple_me/src/bb.cpp @@ -185,7 +185,7 @@ void BB::PrependMeStmt(MeStmt *meStmt) { // if the bb contains only one stmt other than comment, return that stmt // otherwise return nullptr -StmtNode *BB::GetTheOnlyStmtNode() const { +StmtNode *BB::GetTheOnlyStmtNode() { StmtNode *onlyStmtNode = nullptr; for (auto &stmtNode : stmtNodeList) { if (stmtNode.GetOpCode() == OP_comment) { @@ -208,7 +208,7 @@ void BB::RemoveStmtNode(StmtNode *stmt) { void BB::InsertStmtBefore(StmtNode *stmt, StmtNode *newStmt) { CHECK_FATAL(newStmt != nullptr, "null ptr check"); CHECK_FATAL(stmt != nullptr, "null ptr check"); - stmtNodeList.insert(StmtNodes::iterator(stmt), newStmt); + stmtNodeList.insert(stmt, newStmt); } void BB::ReplaceStmt(StmtNode *stmt, StmtNode *newStmt) { @@ -304,14 +304,14 @@ void BB::AddMeStmtLast(MeStmt *meStmt) { meStmt->SetBB(this); } -void BB::InsertMeStmtBefore(MeStmt *meStmt, MeStmt *inStmt) { +void BB::InsertMeStmtBefore(const MeStmt *meStmt, MeStmt *inStmt) { CHECK_FATAL(meStmt != nullptr, "null ptr check"); CHECK_FATAL(inStmt != nullptr, "null ptr check"); meStmtList.insert(meStmt, inStmt); inStmt->SetBB(this); } -void BB::InsertMeStmtAfter(MeStmt *meStmt, MeStmt *inStmt) { +void BB::InsertMeStmtAfter(const MeStmt *meStmt, MeStmt *inStmt) { meStmtList.insertAfter(meStmt, inStmt); inStmt->SetBB(this); } diff --git a/src/maple_me/src/me_cfg.cpp b/src/maple_me/src/me_cfg.cpp index 4f1f0795ac46fd85440215ef9d87d69e61e9df81..1ec98652992f838e7bd1e803d057a3ad449b7438 100644 --- a/src/maple_me/src/me_cfg.cpp +++ b/src/maple_me/src/me_cfg.cpp @@ -310,7 +310,7 @@ void MeCFG::FixMirCFG() { func.GetMirFunc()->IncTempCount(); std::string tempStr = std::string("tempRet").append(std::to_string(func.GetMirFunc()->GetTempCount())); MIRBuilder *builder = func.GetMirFunc()->GetModule()->GetMIRBuilder(); - MIRSymbol *targetSt = builder->GetOrCreateLocalDecl(tempStr.c_str(), *sym->GetType()); + MIRSymbol *targetSt = builder->GetOrCreateLocalDecl(tempStr, *sym->GetType()); targetSt->ResetIsDeleted(); if (stmt->GetOpCode() == OP_dassign) { auto *rhs = static_cast(stmt)->GetRHS(); @@ -440,21 +440,87 @@ void MeCFG::FixMirCFG() { } +// analyse the CFG to find the BBs that are not reachable from function entries +// and delete them +void MeCFG::UnreachCodeAnalysis(bool updatePhi) { + std::vector visitedBBs(func.NumBBs(), false); + func.GetCommonEntryBB()->FindReachableBBs(visitedBBs); + // delete the unreached bb + auto eIt = func.valid_end(); + for (auto bIt = func.valid_begin(); bIt != eIt; ++bIt) { + if (bIt == func.common_exit()) { + continue; + } + auto *bb = *bIt; + BBId idx = bb->GetBBId(); + if (!visitedBBs[idx] && !bb->GetAttributes(kBBAttrIsEntry)) { + bb->SetAttributes(kBBAttrWontExit); + // avoid redundant pred before adding to common_exit_bb's pred list + size_t pi = 0; + for (; pi < func.GetCommonExitBB()->GetPred().size(); ++pi) { + if (bb == func.GetCommonExitBB()->GetPred(pi)) { + break; + } + } + if (pi == func.GetCommonExitBB()->GetPred().size()) { + func.GetCommonExitBB()->GetPred().push_back(bb); + } + if (!MeOption::quiet) { + LogInfo::MapleLogger() << "#### BB " << bb->GetBBId() << " deleted because unreachable\n"; + } + if (bb->GetAttributes(kBBAttrIsTryEnd)) { + // unreachable bb has try end info + auto bbIt = std::find(func.rbegin(), func.rend(), bb); + auto prevIt = ++bbIt; + for (auto it = prevIt; it != func.rend(); ++it) { + if (*it != nullptr) { + // move entrytry tag to previous bb with try + if ((*it)->GetAttributes(kBBAttrIsTry) && !(*it)->GetAttributes(kBBAttrIsTryEnd)) { + (*it)->SetAttributes(kBBAttrIsTryEnd); + func.SetTryBBByOtherEndTryBB(*it, bb); + } + break; + } + } + } + func.DeleteBasicBlock(*bb); + // remove the bb from its succ's pred_ list + for (auto it = bb->GetSucc().begin(); it != bb->GetSucc().end(); ++it) { + BB *sucBB = *it; + if (!updatePhi) { + bb->RemoveBBFromVector(sucBB->GetPred()); + } else { + sucBB->RemoveBBFromPred(bb); + if (sucBB->GetPred().empty()) { + sucBB->ClearPhiList(); + } else if (sucBB->GetPred().size() == 1) { + ConvertPhis2IdentityAssigns(*sucBB); + } + } + } + // remove the bb from common_exit_bb's pred list if it is there + for (auto it = func.GetCommonExitBB()->GetPred().begin(); + it != func.GetCommonExitBB()->GetPred().end(); ++it) { + if (*it == bb) { + func.GetCommonExitBB()->RemoveBBFromPred(bb); + break; + } + } + } + } +} + void MeCFG::ConvertPhiList2IdentityAssigns(BB &meBB) const { auto phiIt = meBB.GetPhiList().begin(); while (phiIt != meBB.GetPhiList().end()) { - if (!(*phiIt).second.GetResult()->IsLive()) { - ++phiIt; - continue; - } // replace phi with identify assignment as it only has 1 opnd const OriginalSt *ost = (*phiIt).first; if (ost->IsSymbolOst() && ost->GetIndirectLev() == 0) { const MIRSymbol *st = ost->GetMIRSymbol(); MIRType *type = GlobalTables::GetTypeTable().GetTypeFromTyIdx(st->GetTyIdx()); AddrofNode *dread = func.GetMIRModule().GetMIRBuilder()->CreateDread(*st, GetRegPrimType(type->GetPrimType())); - auto *dread2 = func.GetMirFunc()->GetCodeMemPool()->New(dread); - dread2->SetSSAVar((*phiIt).second.GetPhiOpnd(0)); + auto *dread2 = func.GetMirFunc()->GetCodeMemPool()->New(*dread); + dread2->SetSSAVar(*(*phiIt).second.GetPhiOpnd(0)); DassignNode *dassign = func.GetMIRModule().GetMIRBuilder()->CreateStmtDassign(*st, 0, dread2); func.GetMeSSATab()->GetStmtsSSAPart().SetSSAPartOf( *dassign, func.GetMeSSATab()->GetStmtsSSAPart().GetSSAPartMp()->New( @@ -472,10 +538,6 @@ void MeCFG::ConvertPhiList2IdentityAssigns(BB &meBB) const { void MeCFG::ConvertMevarPhiList2IdentityAssigns(BB &meBB) const { auto varPhiIt = meBB.GetMevarPhiList().begin(); while (varPhiIt != meBB.GetMevarPhiList().end()) { - if (!(*varPhiIt).second->GetIsLive()) { - ++varPhiIt; - continue; - } // replace phi with identify assignment as it only has 1 opnd const OriginalSt *ost = func.GetMeSSATab()->GetOriginalStFromID(varPhiIt->first); if (ost->IsSymbolOst() && ost->GetIndirectLev() == 0) { @@ -495,10 +557,6 @@ void MeCFG::ConvertMevarPhiList2IdentityAssigns(BB &meBB) const { void MeCFG::ConvertMeregphiList2IdentityAssigns(BB &meBB) const { auto regPhiIt = meBB.GetMeRegPhiList().begin(); while (regPhiIt != meBB.GetMeRegPhiList().end()) { - if (!(*regPhiIt).second->GetIsLive()) { - ++regPhiIt; - continue; - } // replace phi with identify assignment as it only has 1 opnd const OriginalSt *ost = func.GetMeSSATab()->GetOriginalStFromID(regPhiIt->first); if (ost->IsSymbolOst() && ost->GetIndirectLev() == 0) { @@ -522,76 +580,6 @@ void MeCFG::ConvertPhis2IdentityAssigns(BB &meBB) const { ConvertMeregphiList2IdentityAssigns(meBB); } -// analyse the CFG to find the BBs that are not reachable from function entries -// and delete them -void MeCFG::UnreachCodeAnalysis(bool updatePhi) { - std::vector visitedBBs(func.NumBBs(), false); - func.GetCommonEntryBB()->FindReachableBBs(visitedBBs); - // delete the unreached bb - auto eIt = func.valid_end(); - for (auto bIt = func.valid_begin(); bIt != eIt; ++bIt) { - if (bIt == func.common_exit()) { - continue; - } - auto *bb = *bIt; - BBId idx = bb->GetBBId(); - if (!visitedBBs[idx] && !bb->GetAttributes(kBBAttrIsEntry)) { - bb->SetAttributes(kBBAttrWontExit); - // avoid redundant pred before adding to common_exit_bb's pred list - size_t pi = 0; - for (; pi < func.GetCommonExitBB()->GetPred().size(); ++pi) { - if (bb == func.GetCommonExitBB()->GetPred(pi)) { - break; - } - } - if (pi == func.GetCommonExitBB()->GetPred().size()) { - func.GetCommonExitBB()->GetPred().push_back(bb); - } - if (!MeOption::quiet) { - LogInfo::MapleLogger() << "#### BB " << bb->GetBBId() << " deleted because unreachable\n"; - } - if (bb->GetAttributes(kBBAttrIsTryEnd)) { - // unreachable bb has try end info - auto bbIt = std::find(func.rbegin(), func.rend(), bb); - auto prevIt = ++bbIt; - for (auto it = prevIt; it != func.rend(); ++it) { - if (*it != nullptr) { - // move entrytry tag to previous bb with try - if ((*it)->GetAttributes(kBBAttrIsTry) && !(*it)->GetAttributes(kBBAttrIsTryEnd)) { - (*it)->SetAttributes(kBBAttrIsTryEnd); - func.SetTryBBByOtherEndTryBB(*it, bb); - } - break; - } - } - } - func.DeleteBasicBlock(*bb); - // remove the bb from its succ's pred_ list - for (auto it = bb->GetSucc().begin(); it != bb->GetSucc().end(); ++it) { - BB *sucBB = *it; - if (!updatePhi) { - bb->RemoveBBFromVector(sucBB->GetPred()); - } else { - sucBB->RemoveBBFromPred(bb); - if (sucBB->GetPred().size() == 1) { - ConvertPhis2IdentityAssigns(*sucBB); - } else if (sucBB->GetPred().empty()) { - sucBB->ClearPhiList(); - } - } - } - // remove the bb from common_exit_bb's pred list if it is there - for (auto it = func.GetCommonExitBB()->GetPred().begin(); - it != func.GetCommonExitBB()->GetPred().end(); ++it) { - if (*it == bb) { - func.GetCommonExitBB()->RemoveBBFromPred(bb); - break; - } - } - } - } -} - // analyse the CFG to find the BBs that will not reach any function exit; these // are BBs inside infinite loops; mark their wontExit flag and create // artificial edges from them to common_exit_bb @@ -782,9 +770,6 @@ void MeCFG::DumpToFileInStrs(std::ofstream &cfgFile) const { const auto &eIt = func.valid_end(); for (auto bIt = func.valid_begin(); bIt != eIt; ++bIt) { auto *bb = *bIt; - if (bb->IsEmpty()) { - continue; - } if (bb->GetKind() == kBBCondGoto) { cfgFile << "BB" << bb->GetBBId() << "[shape=diamond,label= \" BB" << bb->GetBBId() << ":\n{ "; } else { @@ -820,9 +805,9 @@ void MeCFG::DumpToFile(const std::string &prefix, bool dumpInStrs) const { std::streambuf *buf = cfgFile.rdbuf(); LogInfo::MapleLogger().rdbuf(buf); const std::string &fileName = ConstructFileNameToDump(prefix); - cfgFile.open(fileName.c_str(), std::ios::trunc); + cfgFile.open(fileName, std::ios::trunc); cfgFile << "digraph {\n"; - cfgFile << " # /*" << func.GetName().c_str() << " (red line is exception handler)*/\n"; + cfgFile << " # /*" << func.GetName() << " (red line is exception handler)*/\n"; // dump edge auto eIt = func.valid_end(); for (auto bIt = func.valid_begin(); bIt != eIt; ++bIt) { diff --git a/src/maple_me/src/me_irmap.cpp b/src/maple_me/src/me_irmap.cpp index a5e0e7ede3ff9975e98ee00e41b362f05df1b783..34a828527c635e59efc7a175499e9fafe95465e7 100644 --- a/src/maple_me/src/me_irmap.cpp +++ b/src/maple_me/src/me_irmap.cpp @@ -58,7 +58,7 @@ void MeIRMap::Dump() { } // this function only emits statement -void MeIRMap::EmitBBStmts(const BB &bb, BlockNode &curblk) { +void MeIRMap::EmitBBStmts(BB &bb, BlockNode &curblk) { auto &meStmts = bb.GetMeStmts(); for (auto &meStmt : meStmts) { if (!GetNeedAnotherPass()) { @@ -73,7 +73,7 @@ void MeIRMap::EmitBBStmts(const BB &bb, BlockNode &curblk) { } } -void MeIRMap::EmitBB(const BB &bb, BlockNode &curblk) { +void MeIRMap::EmitBB(BB &bb, BlockNode &curblk) { // emit head. label LabelIdx labidx = bb.GetBBLabel(); if (labidx != 0) { diff --git a/src/maple_me/src/me_phase_manager.cpp b/src/maple_me/src/me_phase_manager.cpp index 4fe1ece6bb591f23947e29346f439ad3872560fc..a2f68b03dd4ccea1fae40f2545878b205a0d7436 100644 --- a/src/maple_me/src/me_phase_manager.cpp +++ b/src/maple_me/src/me_phase_manager.cpp @@ -88,7 +88,7 @@ void MeFuncPhaseManager::AddPhases(const std::unordered_set &skipPh }; if (mePhaseType == kMePhaseMainopt) { // default phase sequence - addPhase("ssaTab"); + addPhase("ssatab"); addPhase("aliasclass"); addPhase("ssa"); addPhase("rclowering"); diff --git a/src/maple_me/src/me_ssa_update.cpp b/src/maple_me/src/me_ssa_update.cpp index b013bfa23f7c5058d48a3da11b273e4ac26a6822..248502447d7fceed031486d99d6d8df65a4db1d0 100644 --- a/src/maple_me/src/me_ssa_update.cpp +++ b/src/maple_me/src/me_ssa_update.cpp @@ -74,7 +74,7 @@ void MeSSAUpdate::RenamePhi(const BB &bb) { phi->SetIsLive(true); // always make it live, for correctness if (phi->GetLHS() == nullptr) { // create a new VarMeExpr defined by this phi - VarMeExpr *newVar = irMap.CreateNewVarMeExpr(it2->first, PTY_ref, 0); + VarMeExpr *newVar = irMap.CreateNewVarMeExpr(it2->first, ssaTab.GetPrimType(it2->first), 0); phi->UpdateLHS(*newVar); it1->second->push(newVar); // push the stack } else { @@ -156,7 +156,7 @@ MeExpr *MeSSAUpdate::RenameExpr(MeExpr &meExpr, bool &changed) { } } -void MeSSAUpdate::RenameStmts(const BB &bb) { +void MeSSAUpdate::RenameStmts(BB &bb) { for (auto &stmt : bb.GetMeStmts()) { // rename the expressions bool changed = false; @@ -222,7 +222,7 @@ void MeSSAUpdate::RenamePhiOpndsInSucc(const BB &bb) { } } -void MeSSAUpdate::RenameBB(const BB &bb) { +void MeSSAUpdate::RenameBB(BB &bb) { // for recording stack height on entering this BB, to pop back to same height // when backing up the dominator tree std::map origStackSize; diff --git a/src/maple_me/src/ssa.cpp b/src/maple_me/src/ssa.cpp index cb7b8b745f520a3b8a91bc195875682214bf3348..f13735a1fad681fa2335193ff63a6b944e6df168 100644 --- a/src/maple_me/src/ssa.cpp +++ b/src/maple_me/src/ssa.cpp @@ -99,14 +99,6 @@ void SSA::RenameMustDefs(const StmtNode &stmt, BB &defBB) { } void SSA::RenameMayUses(BaseNode &node) { - if (node.GetOpCode() == OP_iread) { - auto &iRead = static_cast(node); - VersionSt *vSym = iRead.GetSSAVar(); - CHECK_FATAL(vSym != nullptr, "SSA::RenameMayUses: iRead has no mayUse opnd"); - CHECK_FATAL(vSym->GetOrigIdx().idx < vstStacks.size(), "index out of range in SSA::RenameMayUses"); - iRead.SetSSAVar(vstStacks[vSym->GetOrigIdx().idx]->top()); - return; - } MapleMap &mayUseList = ssaTab->GetStmtsSSAPart().GetMayUseNodesOf(static_cast(node)); MapleMap::iterator it = mayUseList.begin(); for (; it != mayUseList.end(); it++) { @@ -118,22 +110,11 @@ void SSA::RenameMayUses(BaseNode &node) { } void SSA::RenameExpr(BaseNode &expr) { - if (expr.GetOpCode() == OP_addrof || expr.GetOpCode() == OP_dread) { - auto &addrofNode = static_cast(expr); - VersionSt *vSym = addrofNode.GetSSAVar(); + if (expr.IsSSANode()) { + auto &ssaNode = static_cast(expr); + VersionSt *vSym = ssaNode.GetSSAVar(); CHECK_FATAL(vSym->GetOrigIdx().idx < vstStacks.size(), "index out of range in SSA::RenameExpr"); - addrofNode.SetSSAVar(vstStacks[vSym->GetOrigIdx().idx]->top()); - return; - } - if (expr.GetOpCode() == OP_regread) { - auto ®Node = static_cast(expr); - VersionSt *vSym = regNode.GetSSAVar(); - CHECK_FATAL(vSym->GetOrigIdx().idx < vstStacks.size(), "index out of range in SSA::RenameExpr"); - regNode.SetSSAVar(vstStacks[vSym->GetOrigIdx().idx]->top()); - return; - } - if (expr.GetOpCode() == OP_iread) { - RenameMayUses(expr); + ssaNode.SetSSAVar(*vstStacks[vSym->GetOrigIdx().idx]->top()); } for (size_t i = 0; i < expr.NumOpnds(); ++i) { RenameExpr(*expr.Opnd(i)); diff --git a/src/maple_me/src/ssa_mir_nodes.cpp b/src/maple_me/src/ssa_mir_nodes.cpp index 8eb4ba98fcac0bf3c4d96b77fd58366bd3b3b571..94ad94c63553d8fa196ebc37cd53a6af0ac1b4a8 100644 --- a/src/maple_me/src/ssa_mir_nodes.cpp +++ b/src/maple_me/src/ssa_mir_nodes.cpp @@ -63,30 +63,30 @@ void GenericSSAPrint(MIRModule &mod, const StmtNode &stmtNode, int32 indent, Stm } } -static MapleMap *SSAGenericGetMayDefsFromVersionSt(VersionSt &vst, StmtsSSAPart &stmtsSSAPart, - std::unordered_set &visited) { +static MapleMap *SSAGenericGetMayDefsFromVersionSt(const VersionSt &vst, + StmtsSSAPart &stmtsSSAPart, std::unordered_set &visited) { if (vst.IsInitVersion() || visited.find(&vst) != visited.end()) { return nullptr; } visited.insert(&vst); if (vst.GetDefType() == VersionSt::kPhi) { - PhiNode *phi = vst.GetPhi(); + const PhiNode *phi = vst.GetPhi(); for (size_t i = 0; i < phi->GetPhiOpnds().size(); ++i) { - VersionSt *vSym = phi->GetPhiOpnd(i); + const VersionSt *vSym = phi->GetPhiOpnd(i); MapleMap *mayDefs = SSAGenericGetMayDefsFromVersionSt(*vSym, stmtsSSAPart, visited); if (mayDefs != nullptr) { return mayDefs; } } } else if (vst.GetDefType() == VersionSt::kMayDef) { - MayDefNode *mayDef = vst.GetMayDef(); + const MayDefNode *mayDef = vst.GetMayDef(); return &stmtsSSAPart.GetMayDefNodesOf(*mayDef->GetStmt()); } return nullptr; } -MapleMap *SSAGenericGetMayDefsFromVersionSt(VersionSt &sym, StmtsSSAPart &stmtsSSAPart) { - std::unordered_set visited; +MapleMap *SSAGenericGetMayDefsFromVersionSt(const VersionSt &sym, StmtsSSAPart &stmtsSSAPart) { + std::unordered_set visited; return SSAGenericGetMayDefsFromVersionSt(sym, stmtsSSAPart, visited); } diff --git a/src/maple_me/src/ssa_tab.cpp b/src/maple_me/src/ssa_tab.cpp index 1b79368c6dee87520db5db34e46a942dd1356a17..ec86524d952e0ad3849e3af128ea335d7f94d1fc 100644 --- a/src/maple_me/src/ssa_tab.cpp +++ b/src/maple_me/src/ssa_tab.cpp @@ -27,28 +27,28 @@ namespace maple { BaseNode *SSATab::CreateSSAExpr(BaseNode &expr) { if (expr.GetOpCode() == OP_addrof || expr.GetOpCode() == OP_dread) { + if (expr.IsSSANode()) { + return mirModule.CurFunction()->GetCodeMemPool()->New(static_cast(expr)); + } auto &addrofNode = static_cast(expr); - AddrofSSANode *ssaNode = mirModule.CurFunction()->GetCodeMemPool()->New(&addrofNode); + AddrofSSANode *ssaNode = mirModule.CurFunction()->GetCodeMemPool()->New(addrofNode); MIRSymbol *st = mirModule.CurFunction()->GetLocalOrGlobalSymbol(ssaNode->GetStIdx()); OriginalSt *ost = FindOrCreateSymbolOriginalSt(*st, mirModule.CurFunction()->GetPuidx(), ssaNode->GetFieldID()); VersionSt *vst = versionStTable.FindOrCreateVersionSt(ost, kInitVersion); - ssaNode->SetSSAVar(vst); + ssaNode->SetSSAVar(*vst); return ssaNode; - } - if (expr.GetOpCode() == OP_regread) { + } else if (expr.GetOpCode() == OP_regread) { auto ®ReadNode = static_cast(expr); - RegreadSSANode *ssaNode = mirModule.CurFunction()->GetCodeMemPool()->New(®ReadNode); + RegreadSSANode *ssaNode = mirModule.CurFunction()->GetCodeMemPool()->New(regReadNode); OriginalSt *ost = originalStTable.FindOrCreatePregOriginalSt(ssaNode->GetRegIdx(), mirModule.CurFunction()->GetPuidx()); VersionSt *vst = versionStTable.FindOrCreateVersionSt(ost, kInitVersion); - ssaNode->SetSSAVar(vst); + ssaNode->SetSSAVar(*vst); return ssaNode; - } - if (expr.GetOpCode() == OP_iread) { + } else if (expr.GetOpCode() == OP_iread) { auto &ireadNode = static_cast(expr); - IreadSSANode *ssaNode = mirModule.CurFunction()->GetCodeMempool()->New( - mirModule.CurFuncCodeMemPoolAllocator(), &ireadNode); - BaseNode *newOpnd = CreateSSAExpr(*expr.Opnd(0)); + IreadSSANode *ssaNode = mirModule.CurFunction()->GetCodeMempool()->New(ireadNode); + BaseNode *newOpnd = CreateSSAExpr(*ireadNode.Opnd(0)); if (newOpnd != nullptr) { ssaNode->SetOpnd(newOpnd, 0); } diff --git a/src/maple_phase/include/phase.h b/src/maple_phase/include/phase.h index 6b5067de2d65d336709b1d87c73e8b683948b9c1..d556d94fa201c2135cc9a722a573b1b6b0339970 100644 --- a/src/maple_phase/include/phase.h +++ b/src/maple_phase/include/phase.h @@ -64,7 +64,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); memPools.push_back(memPool); return memPool; } diff --git a/src/maple_util/include/option_parser.h b/src/maple_util/include/option_parser.h index 8c435111f8e58d2315f2137312a9f00df33cb392..49b07dfd17e4585ab8f37bfcce86221c312c7ed3 100644 --- a/src/maple_util/include/option_parser.h +++ b/src/maple_util/include/option_parser.h @@ -213,7 +213,8 @@ class OptionParser { private: bool HandleKeyValue(const std::string &key, const std::string &value, bool isValueEmpty, - std::vector &inputOption, const std::string &exeName); + std::vector &inputOption, const std::string &exeName, + bool isAllOption = true); bool CheckOpt(const std::string option, std::string &lastKey, bool &isLastMatch, std::vector &inputOption, const std::string &exeName); void InsertOption(const std::string &opt, const Descriptor &usage) { diff --git a/src/maple_util/include/ptr_list_ref.h b/src/maple_util/include/ptr_list_ref.h index 1f58e60e04362c26c64053b81a629ae8fc5076c8..4465ffdcaaab9dd52583ac4c89498b154ae2ca1a 100644 --- a/src/maple_util/include/ptr_list_ref.h +++ b/src/maple_util/include/ptr_list_ref.h @@ -130,8 +130,12 @@ class PtrListRefIterator { using const_reference = const T&; PtrListRefIterator() = default; + explicit PtrListRefIterator(pointer _Ptr) : ptr(_Ptr) {} + template >::value>> + PtrListRefIterator(const PtrListRefIterator &_Iter) : ptr(_Iter.d()) {} + ~PtrListRefIterator() = default; pointer d() const { @@ -187,12 +191,12 @@ class PtrListRef { using size_type = size_t; using difference_type = std::ptrdiff_t; using pointer = T*; - using const_pointer = T *const; + using const_pointer = const T*; using reference = T&; using const_reference = const T&; using iterator = PtrListRefIterator; - using const_iterator = const iterator; + using const_iterator = PtrListRefIterator; using reverse_iterator = ReversePtrListRefIterator; using const_reverse_iterator = ReversePtrListRefIterator; @@ -232,11 +236,11 @@ class PtrListRef { } const_reverse_iterator rbegin() const { - return const_reverse_iterator(iterator(this->last)); + return const_reverse_iterator(const_iterator(this->last)); } const_reverse_iterator crbegin() const { - return const_reverse_iterator(iterator(this->last)); + return const_reverse_iterator(const_iterator(this->last)); } reverse_iterator rend() { @@ -244,11 +248,11 @@ class PtrListRef { } const_reverse_iterator rend() const { - return const_reverse_iterator(iterator(this->first == nullptr ? nullptr : this->first->GetPrev())); + return const_reverse_iterator(const_iterator(this->first == nullptr ? nullptr : this->first->GetPrev())); } const_reverse_iterator crend() const { - return const_reverse_iterator(iterator(this->first == nullptr ? nullptr : this->first->GetPrev())); + return const_reverse_iterator(const_iterator(this->first == nullptr ? nullptr : this->first->GetPrev())); } reference front() { @@ -337,61 +341,67 @@ class PtrListRef { } } - void insert(iterator _Where, pointer _Value) { - if (_Where == iterator(this->first)) { + void insert(const_iterator _Where, pointer _Value) { + if (_Where == const_iterator(this->first)) { this->push_front(_Value); - } else if (_Where == this->end()) { + } else if (_Where == this->cend()) { this->push_back(_Value); } else { - _Value->SetPrev(_Where->GetPrev()); - _Value->SetNext(&(*_Where)); + // `_Where` stands for the position, however we made the data and node combined, so a const_cast is needed. + auto *ptr = const_cast(&*_Where); + _Value->SetPrev(ptr->GetPrev()); + _Value->SetNext(ptr); _Value->GetPrev()->SetNext(_Value); - _Where->SetPrev(_Value); + ptr->SetPrev(_Value); } } - void insert(pointer _Where, pointer _Value) { - this->insert(iterator(_Where), _Value); + void insert(const_pointer _Where, pointer _Value) { + this->insert(const_iterator(_Where), _Value); } - void insertAfter(iterator _Where, pointer _Value) { - if (_Where == iterator(nullptr)) { + void insertAfter(const_iterator _Where, pointer _Value) { + if (_Where == const_iterator(nullptr)) { this->push_front(_Value); - } else if (_Where == iterator(this->last)) { + } else if (_Where == const_iterator(this->last)) { this->push_back(_Value); } else { - _Value->SetPrev(&(*_Where)); - _Value->SetNext(_Where->GetNext()); + // `_Where` stands for the position, however we made the data and node combined, so a const_cast is needed. + auto *ptr = const_cast(&*_Where); + _Value->SetPrev(ptr); + _Value->SetNext(ptr->GetNext()); _Value->GetNext()->SetPrev(_Value); - _Where->SetNext(_Value); + ptr->SetNext(_Value); } } - void insertAfter(pointer _Where, pointer _Value) { - this->insertAfter(iterator(_Where), _Value); + void insertAfter(const_pointer _Where, pointer _Value) { + this->insertAfter(const_iterator(_Where), _Value); } - void splice(iterator where, PtrListRef &values) { - ASSERT(!values.empty(), "NYI"); + void splice(const_iterator _Where, PtrListRef &_Other) { + ASSERT(!_Other.empty(), "NYI"); if (this->empty()) { - this->first = &(values.front()); - this->last = &(values.back()); - } else if (where == this->end() || where == iterator(this->last)) { - this->last->SetNext(&(values.front())); - values.front().SetPrev(this->last); - this->last = &(values.back()); + this->first = &(_Other.front()); + this->last = &(_Other.back()); + } else if (_Where == this->cend() || _Where == const_iterator(this->last)) { + this->last->SetNext(&(_Other.front())); + _Other.front().SetPrev(this->last); + this->last = &(_Other.back()); } else { - ASSERT(to_ptr(where) != nullptr, "null ptr check"); - ASSERT(where->GetNext() != nullptr, "null ptr check"); - values.front().SetPrev(&(*where)); - values.back().SetNext(where->GetNext()); - where->GetNext()->SetPrev(&(values.back())); - where->SetNext(&(values.front())); + ASSERT(to_ptr(_Where) != nullptr, "null ptr check"); + ASSERT(_Where->GetNext() != nullptr, "null ptr check"); + // `_Where` stands for the position, however we made the data and node combined, so a const_cast is needed. + auto *ptr = const_cast(&*_Where); + _Other.front().SetPrev(ptr); + _Other.back().SetNext(ptr->GetNext()); + ptr->GetNext()->SetPrev(&(_Other.back())); + ptr->SetNext(&(_Other.front())); } } - void splice(pointer where, PtrListRef &values) { - splice(iterator(where), values); + void splice(const_pointer _Where, PtrListRef &_Other) { + splice(const_iterator(_Where), _Other); } void clear() { @@ -399,26 +409,30 @@ class PtrListRef { this->last = nullptr; } - iterator erase(iterator _Where) { - if (_Where == this->begin() && _Where == this->rbegin().base()) { + iterator erase(const_iterator _Where) { + if (_Where == this->cbegin() && _Where == this->rbegin().base()) { this->first = nullptr; this->last = nullptr; - } else if (_Where == this->begin()) { - this->first = _Where->GetNext(); + } else if (_Where == this->cbegin()) { + // `_Where` stands for the position, however we made the data and node combined, so a const_cast is needed. + auto *ptr = const_cast(&*_Where); + this->first = ptr->GetNext(); ASSERT(this->first != nullptr, "null ptr check"); this->first->SetPrev(nullptr); } else if (_Where == this->rbegin().base()) { pop_back(); } else { ASSERT(_Where->GetPrev() != nullptr, "null ptr check"); - _Where->GetPrev()->SetNext(_Where->GetNext()); - _Where->GetNext()->SetPrev(_Where->GetPrev()); + // `_Where` stands for the position, however we made the data and node combined, so a const_cast is needed. + auto *ptr = const_cast(&*_Where); + ptr->GetPrev()->SetNext(ptr->GetNext()); + ptr->GetNext()->SetPrev(ptr->GetPrev()); } return iterator(nullptr); } - iterator erase(pointer _Where) { - return this->erase(iterator(_Where)); + iterator erase(const_pointer _Where) { + return this->erase(const_iterator(_Where)); } private: diff --git a/src/mempool/include/mempool.h b/src/mempool/include/mempool.h index 0a2d392df720c8da4b0cdcb7a45f85d6cb906ddf..23e807d60eeea846aaf2a0484053a8bcba0818b6 100644 --- a/src/mempool/include/mempool.h +++ b/src/mempool/include/mempool.h @@ -92,6 +92,7 @@ class MemPool { template T *Clone(const T &t) { void *p = Malloc(sizeof(T)); + CHECK_FATAL(p != nullptr, "ERROR: New error"); p = new (p) T(t); // Call clone constructor return static_cast(p); } diff --git a/src/mpl2mpl/include/vtable_analysis.h b/src/mpl2mpl/include/vtable_analysis.h index 981c7972af480958d5c0afcb265e97ac023edcbf..975593914a6335baf7989f30f1ff9db57c88e31a 100644 --- a/src/mpl2mpl/include/vtable_analysis.h +++ b/src/mpl2mpl/include/vtable_analysis.h @@ -43,7 +43,7 @@ class VtableAnalysis : public FuncOptimizeImpl { void GenTableSymbol(const std::string &prefix, const std::string klassName, MIRAggConst &newConst) const; void GenVtableDefinition(const Klass &klass); void GenItableDefinition(const Klass &klass); - + void AddNullPointExceptionCheck(MIRFunction &func, StmtNode &stmt) const; BaseNode *GenVtabItabBaseAddr(BaseNode &obj, bool isVirtual); void ReplaceVirtualInvoke(CallNode &stmt); void ReplaceInterfaceInvoke(CallNode &stmt); diff --git a/src/mpl2mpl/src/class_init.cpp b/src/mpl2mpl/src/class_init.cpp index 05a91875f9787c39a257fb22fd4f444cb5482418..d0ec3bc1a2a6cab84b665f67dee14526d119d89a 100644 --- a/src/mpl2mpl/src/class_init.cpp +++ b/src/mpl2mpl/src/class_init.cpp @@ -166,7 +166,7 @@ MIRSymbol *ClassInit::GetClassInfo(const std::string &classname) { const std::string &classInfoName = CLASSINFO_PREFIX_STR + classname; MIRType *classInfoType = GlobalTables::GetTypeTable().GetOrCreateClassType(NameMangler::kClassMetadataTypeName, GetMIRModule()); - MIRSymbol *classInfo = builder->GetOrCreateGlobalDecl(classInfoName.c_str(), *classInfoType); + MIRSymbol *classInfo = builder->GetOrCreateGlobalDecl(classInfoName, *classInfoType); Klass *klass = klassHierarchy->GetKlassFromName(classname); if (klass == nullptr || !klass->GetMIRStructType()->IsLocal()) { classInfo->SetStorageClass(kScExtern); diff --git a/src/mpl2mpl/src/java_eh_lower.cpp b/src/mpl2mpl/src/java_eh_lower.cpp index 55b05dfe5916fec29b8205aee4f083d479e30ca1..14442589a259f4af7aaf58d40ee0f259de99d175 100644 --- a/src/mpl2mpl/src/java_eh_lower.cpp +++ b/src/mpl2mpl/src/java_eh_lower.cpp @@ -55,7 +55,7 @@ BaseNode *JavaEHLowerer::DoLowerDiv(BinaryNode &expr, BlockNode &blknode) { blknode.AddStatement(regassDivnode); divOpnd = mirBuilder->CreateExprRegread(ptype, pregIdx); } else { - MIRSymbol *divOpndSymbol = mirBuilder->CreateSymbol(TyIdx(ptype), opnd1name.c_str(), kStVar, kScAuto, + MIRSymbol *divOpndSymbol = mirBuilder->CreateSymbol(TyIdx(ptype), opnd1name, kStVar, kScAuto, GetMIRModule().CurFunction(), kScopeLocal); DassignNode *dssDivNode = mirBuilder->CreateStmtDassign(*divOpndSymbol, 0, divOpnd); blknode.AddStatement(dssDivNode); @@ -72,7 +72,7 @@ BaseNode *JavaEHLowerer::DoLowerDiv(BinaryNode &expr, BlockNode &blknode) { } else { std::string resName(strDivRes); resName.append(std::to_string(divSTIndex++)); - MIRSymbol *divResSymbol = mirBuilder->CreateSymbol(TyIdx(ptype), resName.c_str(), kStVar, kScAuto, + MIRSymbol *divResSymbol = mirBuilder->CreateSymbol(TyIdx(ptype), resName, kStVar, kScAuto, GetMIRModule().CurFunction(), kScopeLocal); // Put expr result to dssnode. divStmt = mirBuilder->CreateStmtDassign(*divResSymbol, 0, &expr); diff --git a/src/mpl2mpl/src/muid_replacement.cpp b/src/mpl2mpl/src/muid_replacement.cpp index c5007d9d83ff4c8a0a995aaf6b4eed2ed9c81375..412a77dac7ed6fe6dd21237c6a0b19530707cdf0 100644 --- a/src/mpl2mpl/src/muid_replacement.cpp +++ b/src/mpl2mpl/src/muid_replacement.cpp @@ -240,7 +240,7 @@ void MUIDReplacement::CollectImplicitUndefClassInfo(StmtNode &stmt) { std::string classInfoName = CLASSINFO_PREFIX_STR + classType->GetName(); MIRSymbol *classSym = GetSymbolFromName(classInfoName); if (classSym == nullptr) { - classSym = builder->CreateGlobalDecl(classInfoName.c_str(), *GlobalTables::GetTypeTable().GetPtr()); + classSym = builder->CreateGlobalDecl(classInfoName, *GlobalTables::GetTypeTable().GetPtr()); classSym->SetStorageClass(kScExtern); AddUndefData(classSym); } @@ -362,25 +362,25 @@ void MUIDReplacement::GenerateFuncDefTable() { } if (!funcDefTabConst->GetConstVec().empty()) { std::string funcDefTabName = NameMangler::kMuidFuncDefTabPrefixStr + GetMIRModule().GetFileNameAsPostfix(); - funcDefTabSym = builder->CreateGlobalDecl(funcDefTabName.c_str(), arrayType); + funcDefTabSym = builder->CreateGlobalDecl(funcDefTabName, arrayType); funcDefTabSym->SetKonst(funcDefTabConst); funcDefTabSym->SetStorageClass(kScFstatic); } if (!funcInfTabConst->GetConstVec().empty()) { std::string funcInfTabName = NameMangler::kMuidFuncInfTabPrefixStr + GetMIRModule().GetFileNameAsPostfix(); - funcInfTabSym = builder->CreateGlobalDecl(funcInfTabName.c_str(), funcInfArrayType); + funcInfTabSym = builder->CreateGlobalDecl(funcInfTabName, funcInfArrayType); funcInfTabSym->SetKonst(funcInfTabConst); funcInfTabSym->SetStorageClass(kScFstatic); } if (!funcDefMuidTabConst->GetConstVec().empty()) { std::string funcDefMuidTabName = NameMangler::kMuidFuncDefMuidTabPrefixStr + GetMIRModule().GetFileNameAsPostfix(); - funcDefMuidTabSym = builder->CreateGlobalDecl(funcDefMuidTabName.c_str(), muidArrayType); + funcDefMuidTabSym = builder->CreateGlobalDecl(funcDefMuidTabName, muidArrayType); funcDefMuidTabSym->SetKonst(funcDefMuidTabConst); funcDefMuidTabSym->SetStorageClass(kScFstatic); } if (!muidIdxTabConst->GetConstVec().empty()) { std::string muidIdxTabName = NameMangler::kMuidFuncMuidIdxTabPrefixStr + GetMIRModule().GetFileNameAsPostfix(); - funcMuidIdxTabSym = builder->CreateGlobalDecl(muidIdxTabName.c_str(), muidIdxArrayType); + funcMuidIdxTabSym = builder->CreateGlobalDecl(muidIdxTabName, muidIdxArrayType); funcMuidIdxTabSym->SetKonst(muidIdxTabConst); funcMuidIdxTabSym->SetStorageClass(kScFstatic); } @@ -465,13 +465,13 @@ void MUIDReplacement::GenerateDataDefTable() { } if (!dataDefTabConst->GetConstVec().empty()) { std::string dataDefTabName = NameMangler::kMuidDataDefTabPrefixStr + GetMIRModule().GetFileNameAsPostfix(); - dataDefTabSym = builder->CreateGlobalDecl(dataDefTabName.c_str(), arrayType); + dataDefTabSym = builder->CreateGlobalDecl(dataDefTabName, arrayType); dataDefTabSym->SetKonst(dataDefTabConst); dataDefTabSym->SetStorageClass(kScFstatic); } if (!dataDefMuidTabConst->GetConstVec().empty()) { std::string dataDefMuidTabName = NameMangler::kMuidDataDefMuidTabPrefixStr + GetMIRModule().GetFileNameAsPostfix(); - dataDefMuidTabSym = builder->CreateGlobalDecl(dataDefMuidTabName.c_str(), muidArrayType); + dataDefMuidTabSym = builder->CreateGlobalDecl(dataDefMuidTabName, muidArrayType); dataDefMuidTabSym->SetKonst(dataDefMuidTabConst); dataDefMuidTabSym->SetStorageClass(kScFstatic); } @@ -568,14 +568,14 @@ void MUIDReplacement::GenerateUnifiedUndefTable() { } if (!funcUndefTabConst->GetConstVec().empty()) { std::string funcUndefTabName = NameMangler::kMuidFuncUndefTabPrefixStr + GetMIRModule().GetFileNameAsPostfix(); - funcUndefTabSym = builder->CreateGlobalDecl(funcUndefTabName.c_str(), funcArrayType); + funcUndefTabSym = builder->CreateGlobalDecl(funcUndefTabName, funcArrayType); funcUndefTabSym->SetKonst(funcUndefTabConst); funcUndefTabSym->SetStorageClass(kScFstatic); } if (!funcUndefMuidTabConst->GetConstVec().empty()) { std::string funcUndefMuidTabName = NameMangler::kMuidFuncUndefMuidTabPrefixStr + GetMIRModule().GetFileNameAsPostfix(); - funcUndefMuidTabSym = builder->CreateGlobalDecl(funcUndefMuidTabName.c_str(), funcMuidArrayType); + funcUndefMuidTabSym = builder->CreateGlobalDecl(funcUndefMuidTabName, funcMuidArrayType); funcUndefMuidTabSym->SetKonst(funcUndefMuidTabConst); funcUndefMuidTabSym->SetStorageClass(kScFstatic); } @@ -609,14 +609,14 @@ void MUIDReplacement::GenerateUnifiedUndefTable() { } if (!dataUndefTabConst->GetConstVec().empty()) { std::string dataUndefTabName = NameMangler::kMuidDataUndefTabPrefixStr + GetMIRModule().GetFileNameAsPostfix(); - dataUndefTabSym = builder->CreateGlobalDecl(dataUndefTabName.c_str(), dataArrayType); + dataUndefTabSym = builder->CreateGlobalDecl(dataUndefTabName, dataArrayType); dataUndefTabSym->SetKonst(dataUndefTabConst); dataUndefTabSym->SetStorageClass(kScFstatic); } if (!dataUndefMuidTabConst->GetConstVec().empty()) { std::string dataUndefMuidTabName = NameMangler::kMuidDataUndefMuidTabPrefixStr + GetMIRModule().GetFileNameAsPostfix(); - dataUndefMuidTabSym = builder->CreateGlobalDecl(dataUndefMuidTabName.c_str(), dataMuidArrayType); + dataUndefMuidTabSym = builder->CreateGlobalDecl(dataUndefMuidTabName, dataMuidArrayType); dataUndefMuidTabSym->SetKonst(dataUndefMuidTabConst); dataUndefMuidTabSym->SetStorageClass(kScFstatic); } @@ -700,7 +700,7 @@ void MUIDReplacement::GenerateRangeTable() { if (!rangeTabConst->GetConstVec().empty()) { rangeArrayType.SetSizeArrayItem(0, rangeTabConst->GetConstVec().size()); std::string rangeTabName = NameMangler::kMuidRangeTabPrefixStr + GetMIRModule().GetFileNameAsPostfix(); - rangeTabSym = builder->CreateGlobalDecl(rangeTabName.c_str(), rangeArrayType); + rangeTabSym = builder->CreateGlobalDecl(rangeTabName, rangeArrayType); rangeTabSym->SetKonst(rangeTabConst); rangeTabSym->SetStorageClass(kScFstatic); } @@ -910,7 +910,7 @@ void MUIDReplacement::ReplaceDirectInvokeOrAddroffunc(MIRFunction ¤tFunc, // Local function is accessed through funcDefTab // Add a comment to store the original function name std::string commentLabel = NameMangler::kMarkMuidFuncDefStr + calleeFunc->GetName(); - currentFunc.GetBody()->InsertBefore(&stmt, builder->CreateStmtComment(commentLabel.c_str())); + currentFunc.GetBody()->InsertBefore(&stmt, builder->CreateStmtComment(commentLabel)); std::string moduleName = GetMIRModule().GetFileNameAsPostfix(); std::string baseName = calleeFunc->GetBaseClassName(); @@ -922,7 +922,7 @@ void MUIDReplacement::ReplaceDirectInvokeOrAddroffunc(MIRFunction ¤tFunc, // External function is accessed through funcUndefTab // Add a comment to store the original function name std::string commentLabel = NameMangler::kMarkMuidFuncUndefStr + calleeFunc->GetName(); - currentFunc.GetBody()->InsertBefore(&stmt, builder->CreateStmtComment(commentLabel.c_str())); + currentFunc.GetBody()->InsertBefore(&stmt, builder->CreateStmtComment(commentLabel)); baseExpr = builder->CreateExprAddrof(0, *funcUndefTabSym, GetMIRModule().GetMemPool()); ASSERT(calleeFunc->GetFuncSymbol() != nullptr, "null ptr check!"); @@ -979,8 +979,7 @@ void MUIDReplacement::ReplaceDassign(MIRFunction ¤tFunc, DassignNode &dass return; } // Add a comment to store the original symbol name - currentFunc.GetBody()->InsertBefore(&dassignNode, - builder->CreateStmtComment(("Assign to: " + mirSymbol->GetName()).c_str())); + currentFunc.GetBody()->InsertBefore(&dassignNode, builder->CreateStmtComment("Assign to: " + mirSymbol->GetName())); // Load the symbol pointer AddrofNode *baseExpr = nullptr; uint32 index = 0; @@ -1113,7 +1112,7 @@ BaseNode *MUIDReplacement::ReplaceDread(MIRFunction ¤tFunc, StmtNode *stmt return opnd; } // Add a comment to store the original symbol name - currentFunc.GetBody()->InsertBefore(stmt, builder->CreateStmtComment(("Read from: " + mirSymbol->GetName()).c_str())); + currentFunc.GetBody()->InsertBefore(stmt, builder->CreateStmtComment("Read from: " + mirSymbol->GetName())); // Load the symbol pointer AddrofNode *baseExpr = nullptr; uint32 index = 0; @@ -1207,7 +1206,7 @@ void MUIDReplacement::GenerateGlobalRootList() { } std::string gcRootsName = NameMangler::kGcRootList; if (!newConst->GetConstVec().empty()) { - MIRSymbol *gcRootsSt = builder->CreateSymbol(newConst->GetType().GetTypeIndex(), gcRootsName.c_str(), kStVar, + MIRSymbol *gcRootsSt = builder->CreateSymbol(newConst->GetType().GetTypeIndex(), gcRootsName, kStVar, kScAuto, nullptr, kScopeGlobal); arrayType->SetSizeArrayItem(0, newConst->GetConstVec().size()); gcRootsSt->SetKonst(newConst); @@ -1225,7 +1224,7 @@ void MUIDReplacement::GenerateCompilerVersionNum() { newConst->PushBack(firstConst); newConst->PushBack(secondConst); std::string symName = NameMangler::kCompilerVersionNum + GetMIRModule().GetFileNameAsPostfix(); - MIRSymbol *versionNum = builder->CreateGlobalDecl(symName.c_str(), arrayType); + MIRSymbol *versionNum = builder->CreateGlobalDecl(symName, arrayType); versionNum->SetKonst(newConst); } diff --git a/src/mpl2mpl/src/native_stub_func.cpp b/src/mpl2mpl/src/native_stub_func.cpp index 0f17c7e2baf1409d8fd150c2f01c585426e40c2c..2df99db9d1a07624badd40d6887ad5befa48d1a0 100644 --- a/src/mpl2mpl/src/native_stub_func.cpp +++ b/src/mpl2mpl/src/native_stub_func.cpp @@ -45,7 +45,7 @@ MIRFunction &NativeStubFuncGeneration::GetOrCreateDefaultNativeFunc(MIRFunction } std::string nativeName = NameMangler::NativeJavaName(stubFunc.GetName().c_str()); // No need to create a default function with exact arguments here - MIRFunction *nativeFunc = builder->GetOrCreateFunction(nativeName.c_str(), stubFunc.GetReturnTyIdx()); + MIRFunction *nativeFunc = builder->GetOrCreateFunction(nativeName, stubFunc.GetReturnTyIdx()); ASSERT(nativeFunc != nullptr, "null ptr check!"); nativeFunc->GetSrcPosition().SetMplLineNum(stubFunc.GetSrcPosition().MplLineNum()); if (nativeFunc->GetBody() == nullptr) { @@ -75,7 +75,7 @@ MIRFunction &NativeStubFuncGeneration::GetOrCreateDefaultNativeFunc(MIRFunction } findNativeFunc->SetAttr(FUNCATTR_nosideeffect); // fatal message parameter - std::string nativeSymbolName = stubFunc.GetName().c_str(); + std::string nativeSymbolName = stubFunc.GetName(); UStrIdx strIdx = GlobalTables::GetUStrTable().GetOrCreateStrIdxFromName(nativeSymbolName); auto *signatureNode = nativeFunc->GetCodeMempool()->New(strIdx); signatureNode->SetPrimType(PTY_ptr); @@ -288,7 +288,7 @@ void NativeStubFuncGeneration::GenerateRegFuncTabEntryType() { *GlobalTables::GetTypeTable().GetOrCreateArrayType(*GlobalTables::GetTypeTable().GetVoidPtr(), 0); regFuncTabConst = GetMIRModule().GetMemPool()->New(GetMIRModule(), arrayType); std::string regFuncTab = NameMangler::kRegJNIFuncTabPrefixStr + GetMIRModule().GetFileNameAsPostfix(); - regFuncSymbol = builder->CreateSymbol(regFuncTabConst->GetType().GetTypeIndex(), regFuncTab.c_str(), kStVar, + regFuncSymbol = builder->CreateSymbol(regFuncTabConst->GetType().GetTypeIndex(), regFuncTab, kStVar, kScGlobal, nullptr, kScopeGlobal); } @@ -640,7 +640,7 @@ void NativeStubFuncGeneration::GenerateRegTable() { auto &arrayType = static_cast(regTableConst->GetType()); arrayType.SetSizeArrayItem(0, regTableConst->GetConstVec().size()); std::string regJniTabName = NameMangler::kRegJNITabPrefixStr + GetMIRModule().GetFileNameAsPostfix(); - MIRSymbol *regJNISt = builder->CreateSymbol(regTableConst->GetType().GetTypeIndex(), regJniTabName.c_str(), kStVar, + MIRSymbol *regJNISt = builder->CreateSymbol(regTableConst->GetType().GetTypeIndex(), regJniTabName, kStVar, kScGlobal, nullptr, kScopeGlobal); regJNISt->SetKonst(regTableConst); } @@ -653,7 +653,7 @@ void NativeStubFuncGeneration::InitStaticBindingMethodList() { if (!IsStaticBindingListMode()) { return; } - std::fstream file(Options::staticBindingList.c_str()); + std::fstream file(Options::staticBindingList); std::string content; while (std::getline(file, content)) { staticBindingMethodsSet.insert(content); diff --git a/src/mpl2mpl/src/reflection_analysis.cpp b/src/mpl2mpl/src/reflection_analysis.cpp index 103b8c48cabe6700adb467c40938ba2934db7083..aa2c5e70fee5427162e00f8c654ba7c75a0ac63a 100644 --- a/src/mpl2mpl/src/reflection_analysis.cpp +++ b/src/mpl2mpl/src/reflection_analysis.cpp @@ -318,7 +318,7 @@ bool ReflectionAnalysis::IsPrivateClass(const MIRClassType &classType) const { } static inline GStrIdx GetOrCreateGStrIdxFromName(const std::string &name) { - return GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(NameMangler::GetInternalNameLiteral(name.c_str())); + return GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(NameMangler::GetInternalNameLiteral(name)); } static bool IsFinalize(const std::string &funcName, const std::string &signature) { @@ -879,7 +879,7 @@ void ReflectionAnalysis::GenFieldOffsetConst(MIRAggConst &newConst, const Klass MIRClassType *mirClassType = klass.GetMIRClassType(); ASSERT(mirClassType != nullptr, "GetMIRClassType() returns null"); FieldID fldID = mirBuilder.GetStructFieldIDFromNameAndTypeParentFirstFoundInChild( - *mirClassType, originFieldname.c_str(), fieldP.second.first); + *mirClassType, originFieldname, fieldP.second.first); // set LSB 0, and set LSB 1 in muid_replacement fldID = fldID * 2; mirBuilder.AddIntFieldConst(type, newConst, metaFieldID, fldID); @@ -907,7 +907,7 @@ MIRSymbol *ReflectionAnalysis::GenFieldOffsetData(const Klass &klass, std::pair< } else { MIRClassType *mirClassType = klass.GetMIRClassType(); FieldID fldID = mirBuilder.GetStructFieldIDFromNameAndTypeParentFirstFoundInChild( - *mirClassType, originFieldname.c_str(), fieldP.second.first); + *mirClassType, originFieldname, fieldP.second.first); fieldOffsetSymbolName += klass.GetKlassName() + "_FieldID_" + std::to_string(fldID); } MIRSymbol *fieldsOffsetSt = GetOrCreateSymbol(fieldOffsetSymbolName, fieldOffsetArrayType.GetTypeIndex(), true); @@ -1045,13 +1045,13 @@ MIRSymbol *ReflectionAnalysis::GenFieldsMetaData(const Klass &klass) { for (; i < fields.size(); ++i) { std::string fieldname = GlobalTables::GetStrTable().GetStringFromStrIdx(fields[i].first); ConvertFieldName(fieldname, false); - uint32 hashcode = GetCharHashIndex(fieldname.c_str()); + uint32 hashcode = GetCharHashIndex(fieldname); fieldHashvec[i] = std::make_pair(fields[i], hashcode); } for (size_t j = 0; j < staticFields.size(); ++j) { std::string fieldname = GlobalTables::GetStrTable().GetStringFromStrIdx(staticFields[j].first); ConvertFieldName(fieldname, true); - uint32 hashcode = GetCharHashIndex(fieldname.c_str()); + uint32 hashcode = GetCharHashIndex(fieldname); fieldHashvec[i++] = std::make_pair(staticFields[j], hashcode); } GenAllFieldHash(fieldHashvec); @@ -1074,7 +1074,7 @@ MIRSymbol *ReflectionAnalysis::GenFieldsMetaData(const Klass &klass) { } ++j; } - ASSERT(i == size, "In class %s: %d fields seen, BUT %d fields declared", klass.GetKlassName().c_str(), i, size); + ASSERT(i == size, "In class %s: %d fields seen, BUT %d fields declared", klass.GetKlassName(), i, size); MIRSymbol *fieldsArraySt = GenFieldsMeta(klass, fieldinfoVec, fieldHashvec); return fieldsArraySt; } diff --git a/src/mpl2mpl/src/vtable_analysis.cpp b/src/mpl2mpl/src/vtable_analysis.cpp index 83797706891f0672beccdbf4f50dda18206c0756..e53cc6dbd5f27da68c35f37b00f41cca5d2ec817 100644 --- a/src/mpl2mpl/src/vtable_analysis.cpp +++ b/src/mpl2mpl/src/vtable_analysis.cpp @@ -191,8 +191,8 @@ void VtableAnalysis::GenVtableDefinition(const Klass &klass) { } std::string VtableAnalysis::DecodeBaseNameWithType(const MIRFunction &func) { - const std::string &baseName = NameMangler::DecodeName(func.GetBaseFuncName().c_str()); - std::string signatureName = NameMangler::DecodeName(func.GetSignature().c_str()); + const std::string &baseName = NameMangler::DecodeName(func.GetBaseFuncName()); + std::string signatureName = NameMangler::DecodeName(func.GetSignature()); ReflectionAnalysis::ConvertMethodSig(signatureName); std::string baseNameWithType = baseName + "|" + signatureName; return baseNameWithType; @@ -333,7 +333,7 @@ void VtableAnalysis::GenTableSymbol(const std::string &prefix, const std::string MIRAggConst &newConst) const { size_t arraySize = newConst.GetConstVec().size(); MIRArrayType *arrayType = GlobalTables::GetTypeTable().GetOrCreateArrayType(*voidPtrType, arraySize); - MIRSymbol *vtabSt = builder->CreateGlobalDecl((prefix + klassName).c_str(), *arrayType); + MIRSymbol *vtabSt = builder->CreateGlobalDecl(prefix + klassName, *arrayType); if (klassName == NameMangler::GetInternalNameLiteral(NameMangler::kJavaLangObjectStr)) { vtabSt->SetStorageClass(kScGlobal); } else { @@ -351,6 +351,17 @@ void VtableAnalysis ::DumpVtableList(const Klass &klass) const { } } +// add Null-Point-Exception check +void VtableAnalysis::AddNullPointExceptionCheck(MIRFunction &func, StmtNode &stmt) const { + CallNode *cNode = static_cast(&stmt); + MIRFunction *callee = GlobalTables::GetFunctionTable().GetFunctionFromPuidx(cNode->GetPUIdx()); + if (!callee->IsStatic() && !callee->GetBaseClassName().empty()) { + BaseNode *inputOpnd = cNode->Opnd(0); + UnaryStmtNode *nullCheck = builder->CreateStmtUnary(OP_assertnonnull, inputOpnd); + func.GetBody()->InsertBefore(&stmt, nullCheck); + } +} + void VtableAnalysis::ProcessFunc(MIRFunction *func) { if (func->IsEmpty()) { return; @@ -377,6 +388,11 @@ void VtableAnalysis::ProcessFunc(MIRFunction *func) { ReplacePolymorphicInvoke(*(static_cast(stmt))); break; } + case OP_call: + case OP_callassigned: { + AddNullPointExceptionCheck(*func, *stmt); // npe check + break; + } default: break; }