diff --git a/src/bin/maple b/src/bin/maple index c38af607d42b164ddd0c8f0d72ad6fc4ac2c3bc7..2cc300711346f586f9d5c1596d643115b52097f0 100755 Binary files a/src/bin/maple and b/src/bin/maple differ diff --git a/src/maple_be/include/cg/aarch64/aarch64_cgfunc.h b/src/maple_be/include/cg/aarch64/aarch64_cgfunc.h index 51b8010dfb4190d2393b963f1367264a9638861d..6500ca75f59869f119474d91648d134b189e060b 100644 --- a/src/maple_be/include/cg/aarch64/aarch64_cgfunc.h +++ b/src/maple_be/include/cg/aarch64/aarch64_cgfunc.h @@ -312,6 +312,8 @@ class AArch64CGFunc : public CGFunc { return *memPool->New(op, amount, bitLen); } + void SplitMovImmOpndInstruction(int64 immVal, RegOperand &destReg); + Operand &GetOrCreateFuncNameOpnd(const MIRSymbol &symbol); void GenerateYieldpoint(BB &bb) override; Operand &ProcessReturnReg(PrimType primType) override; @@ -576,7 +578,6 @@ class AArch64CGFunc : public CGFunc { void SelectCopyMemOpnd(Operand &dest, PrimType dtype, uint32 dsize, Operand &src, PrimType stype); void SelectCopyRegOpnd(Operand &dest, PrimType dtype, Operand::OperandType opndType, uint32 dsize, Operand &src, PrimType stype); - void SplitMovImmOpndInstruction(int64 immVal, RegOperand &destReg); bool GenerateCompareWithZeroInstruction(Opcode jmpOp, Opcode cmpOp, bool is64Bits, LabelOperand &targetOpnd, Operand &opnd0); void SelectMPLClinitCheck(IntrinsiccallNode&); diff --git a/src/maple_be/include/cg/aarch64/aarch64_ebo.h b/src/maple_be/include/cg/aarch64/aarch64_ebo.h index ad12b65fb8aefdb9cda8ebe2516b7e0b88f96afc..872c72af04b839a8b8b990ba2059383d31c67a7c 100644 --- a/src/maple_be/include/cg/aarch64/aarch64_ebo.h +++ b/src/maple_be/include/cg/aarch64/aarch64_ebo.h @@ -64,6 +64,8 @@ class AArch64Ebo : public Ebo { static constexpr int32 kMaxCallerSaveReg = 45; bool IsZeroRegister(const Operand &opnd) const; bool CheckCondCode(const CondOperand &cond) const; + bool SimplifyBothConst(BB &bb, Insn &insn, const AArch64ImmOperand &immOperand0, const AArch64ImmOperand &immOperand1, + uint32 opndSize); AArch64CC_t GetReverseCond(const CondOperand &cond) const; }; } /* namespace maplebe */ diff --git a/src/maple_be/include/cg/cg_phasemanager.h b/src/maple_be/include/cg/cg_phasemanager.h index b565a9ba2b903ab79a8ac7fe277978c481646f13..9a7abdc24b9d0d77694e7d9050b10c6dec6ebcf4 100644 --- a/src/maple_be/include/cg/cg_phasemanager.h +++ b/src/maple_be/include/cg/cg_phasemanager.h @@ -37,7 +37,8 @@ class CgFuncPhaseManager : public PhaseManager { : PhaseManager(memPool, "cg manager"), cgPhaseType(kCgPhaseInvalid), arFuncManager(GetMemAllocator()), - module(mod) {} + module(mod), + extraPhasesTimer(GetMemAllocator()->Adapter()) {} ~CgFuncPhaseManager() { arFuncManager.InvalidAllResults(); @@ -58,22 +59,23 @@ class CgFuncPhaseManager : public PhaseManager { void Run(CGFunc &func); void Run() override {} - void SetExtraTotalTime(int64 total) { - extraTotal = total; + auto &GetExtraPhasesTimer() { + return extraPhasesTimer; } int64 GetOptimizeTotalTime() const; + int64 GetExtraPhasesTotalTime() const; int64 DumpCGTimers(); CgFuncResultMgr *GetAnalysisResultManager() { return &arFuncManager; } CgPhaseType cgPhaseType; - + static time_t parserTime; private: /* analysis phase result manager */ CgFuncResultMgr arFuncManager; MIRModule &module; - int64 extraTotal = 0L; + MapleMap extraPhasesTimer; }; } /* namespace maplebe */ diff --git a/src/maple_be/src/cg/aarch64/aarch64_ebo.cpp b/src/maple_be/src/cg/aarch64/aarch64_ebo.cpp index 24a0f53474a2c4601c3271ddc13222a59b3f3d69..c410a67c58d35bdd563547172e6d50335b2cc3be 100644 --- a/src/maple_be/src/cg/aarch64/aarch64_ebo.cpp +++ b/src/maple_be/src/cg/aarch64/aarch64_ebo.cpp @@ -454,39 +454,18 @@ bool AArch64Ebo::SimplifyConstOperand(Insn &insn, const MapleVector &o op = &(insn.GetOperand(kInsnSecondOpnd)); } } else if (bothConstant) { - /* i) special orr insn, one of imm is 0: - * orr resOp, imm1, #0 | orr resOp, #0, imm1 - * =======> - * mov resOp, imm1 - * - * ii) special orr insn, both of imm is 0: - * orr resOp, #0, #0 - * =======> - * mov resOp, #0 */ - if ((insn.GetMachineOpcode() == MOP_wiorrri12) || (insn.GetMachineOpcode() == MOP_xiorrri13) || - (insn.GetMachineOpcode() == MOP_xiorri13r) || (insn.GetMachineOpcode() == MOP_wiorri12r)) { - AArch64ImmOperand *immOpnd0 = static_cast(op0); - AArch64ImmOperand *immOpnd1 = static_cast(op1); - immOpnd = immOpnd1; - op = op0; - if (immOpnd0->IsZero()) { - op = op1; - immOpnd = immOpnd0; - } - MOperator mOp = opndSize == k64BitSize ? MOP_xmovri64 : MOP_xmovri32; - Insn &newInsn = cgFunc->GetCG()->BuildInstruction(mOp, *res, *op); - bb->ReplaceInsn(insn, newInsn); - return true; - } else { - return false; - } + AArch64ImmOperand *immOpnd0 = static_cast(op0); + AArch64ImmOperand *immOpnd1 = static_cast(op1); + return SimplifyBothConst(*insn.GetBB(), insn, *immOpnd0, *immOpnd1, opndSize); } CHECK_FATAL(immOpnd != nullptr, "constant operand required!"); CHECK_FATAL(op != nullptr, "constant operand required!"); - /* For orr insn and one of the opnd is zero */ + /* For orr insn and one of the opnd is zero + * orr resOp, imm1, #0 | orr resOp, #0, imm1 + * =======> + * mov resOp, imm1 */ if (((insn.GetMachineOpcode() == MOP_wiorrri12) || (insn.GetMachineOpcode() == MOP_xiorrri13) || - (insn.GetMachineOpcode() == MOP_xiorri13r) || (insn.GetMachineOpcode() == MOP_wiorri12r)) && - immOpnd->IsZero()) { + (insn.GetMachineOpcode() == MOP_xiorri13r) || (insn.GetMachineOpcode() == MOP_wiorri12r)) && immOpnd->IsZero()) { MOperator mOp = opndSize == k64BitSize ? MOP_xmovrr : MOP_wmovrr; Insn &newInsn = cgFunc->GetCG()->BuildInstruction(mOp, *res, *op); bb->ReplaceInsn(insn, newInsn); @@ -578,6 +557,53 @@ bool AArch64Ebo::CheckCondCode(const CondOperand &cond) const { } } +bool AArch64Ebo::SimplifyBothConst(BB &bb, Insn &insn, const AArch64ImmOperand &immOperand0, + const AArch64ImmOperand &immOperand1, uint32 opndSize) { + MOperator mOp = insn.GetMachineOpcode(); + int64 val = 0; + /* do not support negative const simplify yet */ + if (immOperand0.GetValue() < 0 || immOperand1.GetValue() < 0) { + return false; + } + switch (mOp) { + case MOP_weorrri12: + case MOP_weorrrr: + case MOP_xeorrri13: + case MOP_xeorrrr: + val = immOperand0.GetValue() ^ immOperand1.GetValue(); + break; + case MOP_wandrri12: + case MOP_waddrri24: + case MOP_wandrrr: + case MOP_xandrri13: + case MOP_xandrrr: + val = immOperand0.GetValue() & immOperand1.GetValue(); + break; + case MOP_wiorrri12: + case MOP_wiorri12r: + case MOP_wiorrrr: + case MOP_xiorrri13: + case MOP_xiorri13r: + case MOP_xiorrrr: + val = immOperand0.GetValue() | immOperand1.GetValue(); + break; + default: + return false; + } + Operand *res = insn.GetResult(0); + AArch64ImmOperand *immOperand = &a64CGFunc->CreateImmOperand(val, opndSize, false); + if (!immOperand->IsSingleInstructionMovable()) { + ASSERT(res->IsRegister(), " expect a register operand"); + static_cast(cgFunc)->SplitMovImmOpndInstruction(val, *(static_cast(res))); + bb.RemoveInsn(insn); + } else { + MOperator newmOp = opndSize == k64BitSize ? MOP_xmovri64 : MOP_xmovri32; + Insn &newInsn = cgFunc->GetCG()->BuildInstruction(newmOp, *res, *immOperand); + bb.ReplaceInsn(insn, newInsn); + } + return true; +} + /* Do some special pattern */ bool AArch64Ebo::SpecialSequence(Insn &insn, const MapleVector &origInfos) { MOperator opCode = insn.GetMachineOpcode(); diff --git a/src/maple_be/src/cg/cg_phasemanager.cpp b/src/maple_be/src/cg/cg_phasemanager.cpp index 2c2bbc78fec5d3d461cc1720aee75d0382423d2a..6f08319c2d20dec5afcdf6a821979f1e812a1bbd 100644 --- a/src/maple_be/src/cg/cg_phasemanager.cpp +++ b/src/maple_be/src/cg/cg_phasemanager.cpp @@ -203,6 +203,11 @@ void CgFuncPhaseManager::Run(CGFunc &func) { bool skipFromFlag = false; bool skipAfterFlag = false; MPLTimer timer; + MPLTimer iteratorTimer; + if (timePhases) { + iteratorTimer.Start(); + } + time_t loopBodyTime = 0; for (auto it = PhaseSequenceBegin(); it != PhaseSequenceEnd(); it++, ++phaseIndex) { PhaseID id = GetPhaseId(it); if (id == kCGFuncPhaseEMIT) { @@ -237,6 +242,7 @@ void CgFuncPhaseManager::Run(CGFunc &func) { timer.Stop(); CHECK_FATAL(phaseIndex < phaseTimers.size(), "invalid index for phaseTimers"); phaseTimers[phaseIndex] += timer.ElapsedMicroseconds(); + loopBodyTime += timer.ElapsedMicroseconds(); } bool dumpPhases = CGOptions::DumpPhase(phaseName); if (((CGOptions::IsDumpAfter() && dumpPhase) || dumpPhases) && dumpFunc) { @@ -262,6 +268,10 @@ void CgFuncPhaseManager::Run(CGFunc &func) { --it; /* restore iterator */ } } + if (timePhases) { + iteratorTimer.Stop(); + extraPhasesTimer["iterator"] += iteratorTimer.ElapsedMicroseconds() - loopBodyTime; + } } void CgFuncPhaseManager::ClearPhaseNameInfo() { @@ -283,22 +293,56 @@ int64 CgFuncPhaseManager::GetOptimizeTotalTime() const { return total; } +int64 CgFuncPhaseManager::GetExtraPhasesTotalTime() const { + int64 total = 0; + for (auto &timer : extraPhasesTimer) { + total += timer.second; + } + return total; +} + +time_t CgFuncPhaseManager::parserTime = 0; + int64 CgFuncPhaseManager::DumpCGTimers() { - int64 total = GetOptimizeTotalTime(); - total += extraTotal; - std::ios::fmtflags flag(std::cout.flags()); + int64 parseTimeTotal = parserTime; + auto TimeLogger = [](const std::string &itemName, time_t itemTimeUs, time_t totalTimeUs) { + LogInfo::MapleLogger() << std::left << std::setw(25) << itemName << + std::setw(10) << std::right << std::fixed << std::setprecision(2) << + (kPercent * itemTimeUs / totalTimeUs) << "%" << std::setw(10) << + std::setprecision(0) << (itemTimeUs / kMicroSecPerMilliSec) << "ms\n"; + }; + LogInfo::MapleLogger() << "==================== PARSER ====================\n"; + CHECK_FATAL(parseTimeTotal != 0, "calculation check"); + TimeLogger("parser", parserTime, parseTimeTotal); + + int64 phasesTotal = GetOptimizeTotalTime(); + phasesTotal += GetExtraPhasesTotalTime(); + std::ios::fmtflags flag(LogInfo::MapleLogger().flags()); + LogInfo::MapleLogger() << "================== TIMEPHASES ==================\n"; + for (auto &extraTimer : extraPhasesTimer) { + TimeLogger(extraTimer.first, extraTimer.second, phasesTotal); + } + LogInfo::MapleLogger() << "================================================\n"; for (size_t i = 0; i < phaseTimers.size(); ++i) { - CHECK_FATAL(total != 0, "calculation check"); + CHECK_FATAL(phasesTotal != 0, "calculation check"); /* * output information by specified format, setw function parameter specifies show width * setprecision function parameter specifies precision */ - LogInfo::MapleLogger() << std::left << std::setw(25) << registeredPhases[phaseSequences[i]]->PhaseName() << - std::setw(10) << std::right << std::fixed << std::setprecision(2) << - (kPercent * phaseTimers[i] / total) << "%" << std::setw(10) << std::setprecision(0) << - (phaseTimers[i] / kMicroSecPerMilliSec) << "ms" << "\n"; + TimeLogger(registeredPhases[phaseSequences[i]]->PhaseName(), phaseTimers[i], phasesTotal); } - (void)std::cout.flags(flag); - return total; + LogInfo::MapleLogger() << "================================================\n"; + LogInfo::MapleLogger() << "=================== SUMMARY ====================\n"; + std::vector> timeSum; + timeSum.emplace_back(std::pair{ "parser", parseTimeTotal }); + timeSum.emplace_back(std::pair{ "cgphase", phasesTotal }); + int64 total = parseTimeTotal + phasesTotal; + timeSum.emplace_back(std::pair{ "Total", total }); + for (size_t i = 0; i < timeSum.size(); ++i) { + TimeLogger(timeSum[i].first, timeSum[i].second, total); + } + LogInfo::MapleLogger() << "================================================\n"; + LogInfo::MapleLogger().flags(flag); + return phasesTotal; } } /* namespace maplebe */ diff --git a/src/maple_driver/src/driver_runner.cpp b/src/maple_driver/src/driver_runner.cpp index 5400b23a95a1f483f5ae9ef98c083ce799230586..527d0d90bd1c4c37a1b656574ef018180980be42 100644 --- a/src/maple_driver/src/driver_runner.cpp +++ b/src/maple_driver/src/driver_runner.cpp @@ -57,11 +57,11 @@ using namespace maplebe; phases.push_back(std::string(name)); \ } -#define ADD_EXTRA_PHASE(name, timephases, timeStart) \ - if (timephases) { \ - auto duration = std::chrono::system_clock::now() - (timeStart); \ - extraPhasesTime.push_back(std::chrono::duration_cast(duration).count()); \ - extraPhasesName.push_back(name); \ +#define ADD_EXTRA_PHASE(name, timephases, timeStart) \ + if (timephases) { \ + auto duration = std::chrono::system_clock::now() - (timeStart); \ + extraPhasesTime.emplace_back(std::chrono::duration_cast(duration).count()); \ + extraPhasesName.emplace_back(name); \ } namespace maple { @@ -133,7 +133,12 @@ ErrorCode DriverRunner::ParseInput(const std::string &outputFile, const std::str ErrorCode ret = kErrorNoError; bool parsed; if (!fileParsed) { + MPLTimer parseMirTimer; + parseMirTimer.Start(); parsed = parser.ParseMIR(0, 0, false, true); + parseMirTimer.Stop(); + InterleavedManager::interleavedTimer.emplace_back( + std::pair("parseMpl", parseMirTimer.ElapsedMicroseconds())); if (!parsed) { ret = kErrorExit; parser.EmitError(outputFile); @@ -141,7 +146,6 @@ ErrorCode DriverRunner::ParseInput(const std::string &outputFile, const std::str } timer.Stop(); LogInfo::MapleLogger() << "Parse consumed " << timer.Elapsed() << "s" << '\n'; - return ret; } @@ -150,24 +154,26 @@ void DriverRunner::ProcessMpl2mplAndMePhases(const std::string &outputFile, cons theMIRModule = theModule; if (mpl2mplOptions != nullptr || meOptions != nullptr) { LogInfo::MapleLogger() << "Processing mpl2mpl&mplme" << '\n'; - MPLTimer timer; - timer.Start(); InterleavedManager mgr(optMp, theModule, meInput, timePhases); std::vector phases; #include "phases.def" InitPhases(mgr, phases); + MPLTimer timer; + timer.Start(); mgr.Run(); - + MPLTimer emitVtableMplTimer; + emitVtableMplTimer.Start(); // emit after module phase if (printOutExe == kMpl2mpl || printOutExe == kMplMe) { theModule->Emit(outputFile); } else if (genVtableImpl || Options::emitVtableImpl) { theModule->Emit(vtableImplFile); } - + emitVtableMplTimer.Stop(); + mgr.SetEmitVtableImplTime(emitVtableMplTimer.ElapsedMicroseconds()); timer.Stop(); - LogInfo::MapleLogger() << "Mpl2mpl&mplme consumed " << timer.Elapsed() << "s" << '\n'; + LogInfo::MapleLogger() << " Mpl2mpl&mplme consumed " << timer.Elapsed() << "s" << '\n'; } } @@ -254,8 +260,9 @@ void DriverRunner::ProcessCGPhase(const std::string &outputFile, const std::stri cgfpm.SetCGPhase(kCgPhaseMainOpt); cgfpm.AddPhases(cgOptions->GetSequence()); + std::chrono::system_clock::time_point timeStart = std::chrono::system_clock::now(); CG *cg = CreateCGAndBeCommon(outputFile, originBaseName); - + ADD_EXTRA_PHASE("createcg&becommon", CGOptions::IsEnableTimePhases(), timeStart); if (cgOptions->IsRunCG()) { // Generate the output file CHECK_FATAL(cg != nullptr, "cg is null"); @@ -267,7 +274,7 @@ void DriverRunner::ProcessCGPhase(const std::string &outputFile, const std::stri RunCGFunctions(*cg, cgfpm, extraPhasesTime, extraPhasesName); // Emit global info - std::chrono::system_clock::time_point timeStart = std::chrono::system_clock::now(); + timeStart = std::chrono::system_clock::now(); EmitGlobalInfo(*cg); ADD_EXTRA_PHASE("emitglobalinfo", CGOptions::IsEnableTimePhases(), timeStart); } else { @@ -466,24 +473,8 @@ void DriverRunner::ProcessExtraTime(const std::vector &extraPhasesTime, return; } - long total = 0; - for (size_t i = 0; i < extraPhasesTime.size(); ++i) { - total += extraPhasesTime[i]; - } - - cgfpm.SetExtraTotalTime(total); - total += cgfpm.GetOptimizeTotalTime(); - CHECK_FATAL(total > 0, "Error in DriverRunner::ProcessExtraTime while counting total time"); - - std::ios::fmtflags f(std::cout.flags()); for (size_t i = 0; i < extraPhasesTime.size(); ++i) { - LogInfo::MapleLogger() << std::left << std::setw(25) << extraPhasesName[i] << std::setw(10) << std::right - << std::fixed << std::setprecision(2) << (100.0 * extraPhasesTime[i] / total) << "%" - << std::setw(10) << std::setprecision(0) << (extraPhasesTime[i] / 1000.0) << "ms" - << '\n'; + cgfpm.GetExtraPhasesTimer().insert({ extraPhasesName[i], extraPhasesTime[i] }); } - std::cout.flags(f); - - LogInfo::MapleLogger() << '\n'; } } // namespace maple diff --git a/src/maple_driver/src/mplcg_compiler.cpp b/src/maple_driver/src/mplcg_compiler.cpp index d56535abaae87a79370bf375d43c4eb618d4825c..fbacc1ff91aa1467e1d094f247039221f8a1627d 100644 --- a/src/maple_driver/src/mplcg_compiler.cpp +++ b/src/maple_driver/src/mplcg_compiler.cpp @@ -133,6 +133,7 @@ ErrorCode MplcgCompiler::Compile(const MplOptions &options, std::unique_ptr &phases, bool isModulePhase, bool timePhases = false, bool genMpl = false); void Run(); + void RunMeOptimize(MeFuncPhaseManager &fpm); const PhaseManager *GetSupportPhaseManager(const std::string &phase); - + long GetEmitVtableImplTime() const { + return emitVtableImplMplTime; + } + void SetEmitVtableImplTime(long time) { + emitVtableImplMplTime = time; + } + static std::vector> interleavedTimer; private: void InitSupportPhaseManagers(); void OptimizeFuncs(MeFuncPhaseManager &fpm, MapleVector &compList); @@ -65,6 +72,8 @@ class InterleavedManager { MapleVector supportPhaseManagers; // Used to check whether a phase is supported and by which manager std::string meInput; bool timePasses = false; + time_t genMeMplTime = 0; + time_t emitVtableImplMplTime = 0; }; } // namespace maple #endif // MAPLE_IPA_INCLUDE_INTERLEAVED_MANAGER_H diff --git a/src/maple_ipa/src/interleaved_manager.cpp b/src/maple_ipa/src/interleaved_manager.cpp index bea6c8544b99d2bd53af3e2bde4668f754552728..7371b9aa0dd4463d4bddf856e97ff4342826f147 100644 --- a/src/maple_ipa/src/interleaved_manager.cpp +++ b/src/maple_ipa/src/interleaved_manager.cpp @@ -24,6 +24,7 @@ #include "mpl_timer.h" namespace maple { +std::vector> InterleavedManager::interleavedTimer; void InterleavedManager::AddPhases(const std::vector &phases, bool isModulePhase, bool timePhases, bool genMpl) { ModuleResultMgr *mrm = nullptr; @@ -72,59 +73,88 @@ void InterleavedManager::OptimizeFuncs(MeFuncPhaseManager &fpm, MapleVector(pm); if (fpm == nullptr) { + optTimer.Start(); pm->Run(); + optTimer.Stop(); + LogInfo::MapleLogger() << "[mpl2mpl]" << " Module phases cost " << optTimer.ElapsedMilliseconds() << "ms\n"; continue; } if (fpm->GetPhaseSequence()->empty()) { continue; } - MapleVector *compList; - if (!mirModule.GetCompilationList().empty()) { - if ((mirModule.GetCompilationList().size() != mirModule.GetFunctionList().size()) && - (mirModule.GetCompilationList().size() != - mirModule.GetFunctionList().size() - mirModule.GetOptFuncsSize())) { - ASSERT(false, "should be equal"); - } - compList = &mirModule.GetCompilationList(); - } else { - compList = &mirModule.GetFunctionList(); - } + RunMeOptimize(*fpm); + } +} - MPLTimer optTimer; - optTimer.Start(); - std::string logPrefix = mirModule.IsInIPA() ? "[ipa]" : "[me]"; - OptimizeFuncs(*fpm, *compList); - optTimer.Stop(); - LogInfo::MapleLogger() << logPrefix << " Function phases cost " << optTimer.ElapsedMilliseconds() << "ms\n"; - if (fpm->GetGenMeMpl()) { - mirModule.Emit("comb.me.mpl"); +void InterleavedManager::RunMeOptimize(MeFuncPhaseManager &fpm) { + MapleVector *compList; + if (!mirModule.GetCompilationList().empty()) { + if ((mirModule.GetCompilationList().size() != mirModule.GetFunctionList().size()) && + (mirModule.GetCompilationList().size() != + mirModule.GetFunctionList().size() - mirModule.GetOptFuncsSize())) { + ASSERT(false, "should be equal"); } + compList = &mirModule.GetCompilationList(); + } else { + compList = &mirModule.GetFunctionList(); } + MPLTimer optTimer; + optTimer.Start(); + std::string logPrefix = mirModule.IsInIPA() ? "[ipa]" : "[me]"; + OptimizeFuncs(fpm, *compList); + optTimer.Stop(); + LogInfo::MapleLogger() << logPrefix << " Function phases cost " << optTimer.ElapsedMilliseconds() << "ms\n"; + optTimer.Start(); + if (fpm.GetGenMeMpl()) { + mirModule.Emit("comb.me.mpl"); + } + optTimer.Stop(); + genMeMplTime += optTimer.ElapsedMicroseconds(); } void InterleavedManager::DumpTimers() { std::ios_base::fmtflags f(LogInfo::MapleLogger().flags()); + auto TimeLogger = [](const std::string &itemName, time_t itemTimeUs, time_t totalTimeUs) { + LogInfo::MapleLogger() << std::left << std::setw(25) << itemName << std::setw(10) + << std::right << std::fixed << std::setprecision(2) + << (100.0 * itemTimeUs / totalTimeUs) << "%" << std::setw(10) + << std::setprecision(0) << (itemTimeUs / 1000.0) << "ms\n"; + }; std::vector> timeVec; long total = 0; - LogInfo::MapleLogger() << "=================== TIMEPHASES =================\n"; + long parserTotal = 0; + LogInfo::MapleLogger() << "==================== PARSER ====================\n"; + for (const auto &parserTimer : interleavedTimer) { + parserTotal += parserTimer.second; + } + for (const auto &parserTimer : interleavedTimer) { + TimeLogger(parserTimer.first, parserTimer.second, parserTotal); + } + total += parserTotal; + timeVec.emplace_back(std::pair("parser", parserTotal)); + LogInfo::MapleLogger() << "================== TIMEPHASES ==================\n"; for (auto *manager : phaseManagers) { long temp = manager->DumpTimers(); total += temp; timeVec.push_back(std::pair(manager->GetMgrName(), temp)); LogInfo::MapleLogger() << "================================================\n"; } - LogInfo::MapleLogger() << "==================== SUMMARY ===================\n"; + total += genMeMplTime; + total += emitVtableImplMplTime; + timeVec.emplace_back(std::pair("genMeMplFile", genMeMplTime)); + timeVec.emplace_back(std::pair("emitVtableImplMpl", emitVtableImplMplTime)); + timeVec.emplace_back(std::pair("Total", total)); + LogInfo::MapleLogger() << "=================== SUMMARY ====================\n"; CHECK_FATAL(total != 0, "calculation check"); for (const auto &lapse : timeVec) { - LogInfo::MapleLogger() << std::left << std::setw(25) << lapse.first << std::setw(10) << std::right << std::fixed - << std::setprecision(2) << (100.0 * lapse.second / total) << "%" << std::setw(10) - << (lapse.second / 1000) << "ms" << "\n"; + TimeLogger(lapse.first, lapse.second, total); } LogInfo::MapleLogger() << "================================================\n"; LogInfo::MapleLogger().flags(f); diff --git a/src/maple_ir/include/option.h b/src/maple_ir/include/option.h index b0d06d12cc89c15466e797eeb1a4991f541c1a43..10de0a5a1d096d93a0d6c2782a9f7ef126360d2d 100644 --- a/src/maple_ir/include/option.h +++ b/src/maple_ir/include/option.h @@ -92,6 +92,7 @@ class Options : public MapleDriverOptionBase { static bool nativeOpt; static bool O2; static bool noDot; + static bool decoupleStatic; static std::string proFileData; static std::string proFileFuncData; static std::string proFileClassData; diff --git a/src/maple_me/include/alias_class.h b/src/maple_me/include/alias_class.h index d2f3526491a8e328d53b95f9c2d591d3b888eb10..906c5d30ea4047ebbf88ab0587b376a91f534a4f 100644 --- a/src/maple_me/include/alias_class.h +++ b/src/maple_me/include/alias_class.h @@ -178,28 +178,27 @@ class AliasClass : public AnalysisResult { AliasElem &FindOrCreateAliasElemOfAddrofOSt(OriginalSt &oSt); void CollectMayDefForMustDefs(const StmtNode &stmt, std::set &mayDefOsts); void CollectMayUseForCallOpnd(const StmtNode &stmt, std::set &mayUseOsts); - void InsertMayDefNodeForCall(std::set &mayDefOsts, MapleMap &mayDefNodes, + void InsertMayDefNodeForCall(std::set &mayDefOsts, TypeOfMayDefList &mayDefNodes, StmtNode &stmt, bool hasNoPrivateDefEffect); void InsertMayUseExpr(BaseNode &expr); void CollectMayUseFromGlobalsAffectedByCalls(std::set &mayUseOsts); void CollectMayUseFromNADS(std::set &mayUseOsts); void CollectMayUseFromDefinedFinalField(std::set &mayUseOsts); - void InsertMayUseNode(std::set &mayUseOsts, MapleMap &mayUseNodes); + void InsertMayUseNode(std::set &mayUseOsts, TypeOfMayUseList &mayUseNodes); void InsertMayUseReturn(const StmtNode &stmt); void CollectPtsToOfReturnOpnd(const OriginalSt &ost, std::set &mayUseOsts); void InsertReturnOpndMayUse(const StmtNode &stmt); void InsertMayUseAll(const StmtNode &stmt); void CollectMayDefForDassign(const StmtNode &stmt, std::set &mayDefOsts); - void InsertMayDefNode(std::set &mayDefOsts, MapleMap &mayDefNodes, StmtNode &stmt); + void InsertMayDefNode(std::set &mayDefOsts, TypeOfMayDefList &mayDefNodes, StmtNode &stmt); void InsertMayDefDassign(StmtNode &stmt); bool IsEquivalentField(TyIdx tyIdxA, FieldID fldA, TyIdx tyIdxB, FieldID fldB) const; void CollectMayDefForIassign(StmtNode &stmt, std::set &mayDefOsts); - void InsertMayDefNodeExcludeFinalOst(std::set &mayDefOsts, MapleMap &mayDefNodes, + void InsertMayDefNodeExcludeFinalOst(std::set &mayDefOsts, TypeOfMayDefList &mayDefNodes, StmtNode &stmt); void InsertMayDefIassign(StmtNode &stmt); void InsertMayDefUseSyncOps(StmtNode &stmt); - void InsertMayUseNodeExcludeFinalOst(const std::set &mayUseOsts, - MapleMap &mayUseNodes); + void InsertMayUseNodeExcludeFinalOst(const std::set &mayUseOsts, TypeOfMayUseList &mayUseNodes); void InsertMayDefUseIntrncall(StmtNode &stmt); void InsertMayDefUseClinitCheck(IntrinsiccallNode &stmt); virtual BB *GetBB(BBId id) = 0; diff --git a/src/maple_me/include/dse.h b/src/maple_me/include/dse.h index 36f823d8c6afb25b6b8b9fd7c297494369ece9b6..dbc010666be6a607ccd773d32ff25c788193e2bb 100644 --- a/src/maple_me/include/dse.h +++ b/src/maple_me/include/dse.h @@ -27,12 +27,13 @@ namespace maple { class DSE { public: DSE(std::vector &&bbVec, BB &commonEntryBB, BB &commonExitBB, SSATab &ssaTab, - Dominance &postDom, bool enableDebug = false) + Dominance &postDom, bool enableDebug = false, bool decouple = false) : enableDebug(enableDebug), bbVec(bbVec), commonEntryBB(commonEntryBB), commonExitBB(commonExitBB), ssaTab(ssaTab), postDom(postDom), bbRequired(bbVec.size(), false), - exprRequired(ssaTab.GetVersionStTableSize(), false) {} + exprRequired(ssaTab.GetVersionStTableSize(), false), + decoupleStatic(decouple) {} ~DSE() = default; @@ -132,6 +133,7 @@ class DSE { // NPE will be throw if the value of this node is nullptr when stmt is executed // Or the node is opnd of a same type node static const uint8 kNodeTypeNotNull = 2; + bool decoupleStatic = false; }; } // namespace maple #endif // MAPLE_ME_INCLUDE_DSE_H diff --git a/src/maple_me/include/hdse.h b/src/maple_me/include/hdse.h index 7e5eeee5ee6811531f34e866f421677e439b6d2b..836068196bef338ed7818ed315f12ac478b0f4c0 100644 --- a/src/maple_me/include/hdse.h +++ b/src/maple_me/include/hdse.h @@ -23,7 +23,7 @@ class MeIRMap; class HDSE { public: HDSE(MIRModule &mod, const MapleVector &bbVec, BB &commonEntryBB, BB &commonExitBB, SSATab &ssaTab, - Dominance &pDom, IRMap &map, bool enabledDebug = false) + Dominance &pDom, IRMap &map, bool enabledDebug = false, bool decouple = false) : hdseDebug(enabledDebug), mirModule(mod), bbVec(bbVec), @@ -32,7 +32,8 @@ class HDSE { ssaTab(ssaTab), postDom(pDom), irMap(map), - bbRequired(bbVec.size(), false) {} + bbRequired(bbVec.size(), false), + decoupleStatic(decouple) {} virtual ~HDSE() = default; @@ -63,7 +64,7 @@ class HDSE { void MarkLastBranchStmtInBBRequired(BB &bb); void MarkLastStmtInPDomBBRequired(const BB &bb); void MarkLastUnconditionalGotoInPredBBRequired(const BB &bb); - void MarkVarDefByStmt(VarMeExpr &varMeExpr); + void MarkDefStmt(ScalarMeExpr &scalarExpr); void MarkRegDefByStmt(RegMeExpr ®MeExpr); void CollectNotNullExpr(MeStmt &stmt); // NotNullExpr means it is impossible value of the expr is nullptr after go through this stmt. @@ -78,6 +79,14 @@ class HDSE { exprLive.at(static_cast(static_cast(meExpr.GetExprID()))) = true; } + void AddNewUse(MeExpr &meExpr) { + if (IsExprNeeded(meExpr)) { + return; + } + SetExprNeeded(meExpr); + workList.push_front(&meExpr); + } + void PropagateLive() { while (!workList.empty()) { MeExpr *meExpr = workList.front(); @@ -86,6 +95,8 @@ class HDSE { } } + void RemoveNotRequiredCallAssignPart(MeStmt &stmt); + void RemoveNotRequiredStmts() { for (auto *bb : bbVec) { if (bb == nullptr) { @@ -114,6 +125,7 @@ class HDSE { // NPE will be throw if the value of this meExpr is nullptr when stmt is executed // Or the meExpr is opnd of a same type meExpr static const uint8 kExprTypeNotNull = 2; + bool decoupleStatic = false; }; } // namespace maple #endif // MAPLE_ME_INCLUDE_HDSE_H diff --git a/src/maple_me/include/irmap.h b/src/maple_me/include/irmap.h index 4cc604152c7824c10206bbe5fb399d385dfd4db6..bee3bac2157e88462de5050255cbeab954bd5cdf 100755 --- a/src/maple_me/include/irmap.h +++ b/src/maple_me/include/irmap.h @@ -240,9 +240,9 @@ class IRMap : public AnalysisResult { RegMeExpr *CreateRefRegMeExpr(const MIRSymbol&); VarMeExpr *GetOrCreateVarFromVerSt(const VersionSt &vst); RegMeExpr *GetOrCreateRegFromVerSt(const VersionSt &vst); - void BuildChiList(MeStmt&, MapleMap&, MapleMap&); - void BuildMustDefList(MeStmt &meStmt, MapleVector&, MapleVector&); - void BuildMuList(MapleMap&, MapleMap&); + void BuildChiList(MeStmt&, TypeOfMayDefList&, MapleMap&); + void BuildMustDefList(MeStmt &meStmt, TypeOfMustDefList&, MapleVector&); + void BuildMuList(TypeOfMayUseList&, MapleMap&); void BuildPhiMeNode(BB&); BB *GetFalseBrBB(const CondGotoMeStmt&); void SetMeExprOpnds(MeExpr &meExpr, BaseNode &mirNode); diff --git a/src/maple_me/include/me_cfg.h b/src/maple_me/include/me_cfg.h index cd5340f7113d6c2ba9c9adc4771d234940fbb63b..ac70d53d6f10b6c925b14af1997143884538e5a7 100755 --- a/src/maple_me/include/me_cfg.h +++ b/src/maple_me/include/me_cfg.h @@ -20,10 +20,12 @@ namespace maple { class MeCFG { public: - explicit MeCFG(MeFunction &f) : func(f) {} + explicit MeCFG(MeFunction &f) : patternSet(f.GetAlloc().Adapter()), func(f) {} ~MeCFG() = default; + bool IfReplaceWithAssertNonNull(const BB &bb) const; + void ReplaceWithAssertnonnull(); void BuildMirCFG(); void FixMirCFG(); void ConvertPhis2IdentityAssigns(BB &meBB) const; @@ -59,6 +61,7 @@ class MeCFG { void ConvertMePhiList2IdentityAssigns(BB &meBB) const; bool IsStartTryBB(BB &meBB) const; void FixTryBB(BB &startBB, BB &nextBB); + MapleSet patternSet; MeFunction &func; bool hasDoWhile = false; }; diff --git a/src/maple_me/include/me_function.h b/src/maple_me/include/me_function.h index df1d9e551aa28c830cba48208c1682ad0f7f2fd7..eb06124d16d65dd1413dcaa5406c84e8e372337a 100644 --- a/src/maple_me/include/me_function.h +++ b/src/maple_me/include/me_function.h @@ -280,6 +280,9 @@ class MeFunction : public FuncEmit { return nextBBId; } + void DumpFunction() const; + void DumpFunctionNoSSA() const; + void DumpMayDUFunction() const; void Dump(bool DumpSimpIr = false) const; virtual void Prepare(unsigned long rangeNum); void Verify() const; diff --git a/src/maple_me/include/me_hdse.h b/src/maple_me/include/me_hdse.h index 447bb6afb44562434b9516f82d4801aff9566b29..2acd814f956a1771cf1bce99223891acdb436f9a 100644 --- a/src/maple_me/include/me_hdse.h +++ b/src/maple_me/include/me_hdse.h @@ -27,7 +27,7 @@ class MeHDSE : public HDSE { public: MeHDSE(MeFunction &f, Dominance &pDom, IRMap &map, bool enabledDebug) : HDSE(f.GetMIRModule(), f.GetAllBBs(), *f.GetCommonEntryBB(), *f.GetCommonExitBB(), *f.GetMeSSATab(), - pDom, map, enabledDebug) {} + pDom, map, enabledDebug, MeOption::decoupleStatic) {} virtual ~MeHDSE() = default; void RunHDSE(); diff --git a/src/maple_me/include/me_option.h b/src/maple_me/include/me_option.h index 0f61d5b4175b4230367090c2038718f065ca3eac..4318733c5505db5a2877ebf045022198e928bfce 100644 --- a/src/maple_me/include/me_option.h +++ b/src/maple_me/include/me_option.h @@ -98,6 +98,7 @@ class MeOption : public MapleDriverOptionBase { static bool lpreSpeculate; static bool spillAtCatch; static bool optDirectCall; + static bool decoupleStatic; private: void DecideMeRealLevel(const std::vector &inputOptions) const; std::unordered_set skipPhases; diff --git a/src/maple_me/include/orig_symbol.h b/src/maple_me/include/orig_symbol.h index fe3edd9ad34b4f6ba5d4760ab8dc9d191ea0b150..16fb4421050bea3251d613dbdef8d3a06b0e839c 100644 --- a/src/maple_me/include/orig_symbol.h +++ b/src/maple_me/include/orig_symbol.h @@ -231,34 +231,28 @@ class OriginalSt { class SymbolFieldPair { public: - SymbolFieldPair(uint32 stIndex, FieldID fld) : stIdx(stIndex), fldID(fld) {} + SymbolFieldPair(const StIdx &stIdx, FieldID fld) : stIdx(stIdx), fldID(fld) {} ~SymbolFieldPair() = default; bool operator==(const SymbolFieldPair& pairA) const { return (pairA.stIdx == stIdx) && (pairA.fldID == fldID); } - uint32 GetSymbolIndex() const { + const StIdx &GetStIdx() const { return stIdx; } FieldID GetFieldID() const { return fldID; } + private: - uint32 stIdx; + StIdx stIdx; FieldID fldID; }; struct HashSymbolFieldPair { size_t operator()(const SymbolFieldPair& symbolFldID) const { - return symbolFldID.GetSymbolIndex(); - } -}; - -struct EqualSymbolFieldPair { - bool operator()(const SymbolFieldPair& symbolFldIDA, const SymbolFieldPair& symbolFldIDB) const { - return symbolFldIDA.GetSymbolIndex() == symbolFldIDB.GetSymbolIndex() && - symbolFldIDA.GetFieldID() == symbolFldIDB.GetFieldID(); + return symbolFldID.GetStIdx().FullIdx(); } }; @@ -338,7 +332,7 @@ class OriginalStTable { MIRModule &mirModule; MapleVector originalStVector; // the vector that map a OriginalSt's index to its pointer // mir symbol to original table, this only exists for no-original variables. - MapleUnorderedMap mirSt2Ost; + MapleUnorderedMap mirSt2Ost; MapleUnorderedMap preg2Ost; // mir type to virtual variables in original table. this only exists for no-original variables. MapleMap pType2Ost; diff --git a/src/maple_me/include/prop.h b/src/maple_me/include/prop.h index 739ad5f494825abe22f96bbfb189d4944568e6be..33ba53e71b93259dac0f3c5254d830e5d187f0c4 100644 --- a/src/maple_me/include/prop.h +++ b/src/maple_me/include/prop.h @@ -67,6 +67,7 @@ class Prop { MeExpr &PropMeExpr(MeExpr &meExpr, bool &isproped, bool atParm); MeExpr *SimplifyMeExpr(OpMeExpr &opMeExpr) const; MeExpr *SimplifyCvtMeExpr(const OpMeExpr &opMeExpr) const; + MeExpr *SimplifyCompareConstWithConst(OpMeExpr &opMeExpr) const; MeExpr *SimplifyCompareConstWithAddress(const OpMeExpr &opMeExpr) const; MeExpr *SimplifyCompareWithZero(const OpMeExpr &opMeExpr) const; MeExpr *SimplifyCompareMeExpr(OpMeExpr &opMeExpr) const; diff --git a/src/maple_me/include/ssa_mir_nodes.h b/src/maple_me/include/ssa_mir_nodes.h index e9606d7c0e9a57abca2daf0c9fc48faa6618ba46..275c3a2d4709dfa42fba605a7fe3b8f0b6117c2b 100644 --- a/src/maple_me/include/ssa_mir_nodes.h +++ b/src/maple_me/include/ssa_mir_nodes.h @@ -129,31 +129,34 @@ class MustDefNode { StmtNode *stmt = nullptr; }; +using TypeOfMayUseList = MapleVector; +using TypeOfMayDefList = MapleVector; +using TypeOfMustDefList = MapleVector; class AccessSSANodes { public: AccessSSANodes() = default; virtual ~AccessSSANodes() = default; - virtual const MapleMap &GetMayDefNodes() const { + virtual const TypeOfMayDefList &GetMayDefNodes() const { CHECK_FATAL(false, "No mayDefNodes"); } - virtual MapleMap &GetMayDefNodes() { + virtual TypeOfMayDefList &GetMayDefNodes() { CHECK_FATAL(false, "No mayDefNodes"); } - virtual const MapleMap &GetMayUseNodes() const { + virtual const TypeOfMayUseList &GetMayUseNodes() const { CHECK_FATAL(false, "No mayUseNodes"); } - virtual MapleMap &GetMayUseNodes() { + virtual TypeOfMayUseList &GetMayUseNodes() { CHECK_FATAL(false, "No mayUseNodes"); } - virtual const MapleVector &GetMustDefNodes() const { + virtual const TypeOfMustDefList &GetMustDefNodes() const { CHECK_FATAL(false, "No mustDefNodes"); } - virtual MapleVector &GetMustDefNodes() { + virtual TypeOfMustDefList &GetMustDefNodes() { CHECK_FATAL(false, "No mustDefNodes"); } @@ -171,13 +174,13 @@ class AccessSSANodes { virtual void DumpMayDefNodes(const MIRModule&) const { for (const auto &mayDefNode : GetMayDefNodes()) { - mayDefNode.second.Dump(); + mayDefNode.Dump(); } } virtual void DumpMayUseNodes(const MIRModule&) const { for (const auto &mapItem : GetMayUseNodes()) { - mapItem.second.Dump(); + mapItem.Dump(); } } @@ -189,48 +192,48 @@ class AccessSSANodes { virtual void InsertMayDefNode(VersionSt *vst, StmtNode *stmtNode) { CHECK_FATAL(vst != nullptr, "null ptr check"); - (void)GetMayDefNodes().insert(std::make_pair(vst->GetOrigSt()->GetIndex(), MayDefNode(vst, stmtNode))); + GetMayDefNodes().emplace_back(MayDefNode(vst, stmtNode)); } virtual void InsertMustDefNode(VersionSt *sym, StmtNode *s) { - GetMustDefNodes().push_back(MustDefNode(sym, s)); + GetMustDefNodes().emplace_back(MustDefNode(sym, s)); } }; class MayDefPart : public AccessSSANodes { public: - explicit MayDefPart(MapleAllocator *alloc) : mayDefNodes(std::less(), alloc->Adapter()) {} + explicit MayDefPart(MapleAllocator *alloc) : mayDefNodes(alloc->Adapter()) {} ~MayDefPart() override = default; - const MapleMap &GetMayDefNodes() const override { + const TypeOfMayDefList &GetMayDefNodes() const override { return mayDefNodes; } - MapleMap &GetMayDefNodes() override { + TypeOfMayDefList &GetMayDefNodes() override { return mayDefNodes; } private: - MapleMap mayDefNodes; + TypeOfMayDefList mayDefNodes; }; class MayUsePart : public AccessSSANodes { public: - explicit MayUsePart(MapleAllocator *alloc) : mayUseNodes(std::less(), alloc->Adapter()) {} + explicit MayUsePart(MapleAllocator *alloc) : mayUseNodes(alloc->Adapter()) {} ~MayUsePart() override = default; - const MapleMap &GetMayUseNodes() const override { + const TypeOfMayUseList &GetMayUseNodes() const override { return mayUseNodes; } - MapleMap &GetMayUseNodes() override { + TypeOfMayUseList &GetMayUseNodes() override { return mayUseNodes; } private: - MapleMap mayUseNodes; + TypeOfMayUseList mayUseNodes; }; class MustDefPart : public AccessSSANodes { @@ -239,29 +242,29 @@ class MustDefPart : public AccessSSANodes { ~MustDefPart() override = default; - const MapleVector &GetMustDefNodes() const override { + const TypeOfMustDefList &GetMustDefNodes() const override { return mustDefNodes; } - MapleVector &GetMustDefNodes() override { + + TypeOfMustDefList &GetMustDefNodes() override { return mustDefNodes; } private: - MapleVector mustDefNodes; + TypeOfMustDefList mustDefNodes; }; class MayDefPartWithVersionSt : public AccessSSANodes { public: - explicit MayDefPartWithVersionSt(MapleAllocator *alloc) - : mayDefNodes(std::less(), alloc->Adapter()) {} + explicit MayDefPartWithVersionSt(MapleAllocator *alloc) : mayDefNodes(alloc->Adapter()) {} ~MayDefPartWithVersionSt() override = default; - const MapleMap &GetMayDefNodes() const override { + const TypeOfMayDefList &GetMayDefNodes() const override { return mayDefNodes; } - MapleMap &GetMayDefNodes() override { + TypeOfMayDefList &GetMayDefNodes() override { return mayDefNodes; } @@ -279,7 +282,7 @@ class MayDefPartWithVersionSt : public AccessSSANodes { private: VersionSt *ssaVar = nullptr; - MapleMap mayDefNodes; + TypeOfMayDefList mayDefNodes; }; class VersionStPart : public AccessSSANodes { @@ -306,67 +309,67 @@ class VersionStPart : public AccessSSANodes { class MayDefMayUsePart : public AccessSSANodes { public: explicit MayDefMayUsePart(MapleAllocator *alloc) - : mayDefNodes(std::less(), alloc->Adapter()), mayUseNodes(std::less(), alloc->Adapter()) {} + : mayDefNodes(alloc->Adapter()), mayUseNodes(alloc->Adapter()) {} ~MayDefMayUsePart() override = default; - const MapleMap &GetMayDefNodes() const override { + const TypeOfMayDefList &GetMayDefNodes() const override { return mayDefNodes; } - MapleMap &GetMayDefNodes() override { + TypeOfMayDefList &GetMayDefNodes() override { return mayDefNodes; } - const MapleMap &GetMayUseNodes() const override { + const TypeOfMayUseList &GetMayUseNodes() const override { return mayUseNodes; } - MapleMap &GetMayUseNodes() override { + TypeOfMayUseList &GetMayUseNodes() override { return mayUseNodes; } private: - MapleMap mayDefNodes; - MapleMap mayUseNodes; + TypeOfMayDefList mayDefNodes; + TypeOfMayUseList mayUseNodes; }; class MayDefMayUseMustDefPart : public AccessSSANodes { public: explicit MayDefMayUseMustDefPart(MapleAllocator *alloc) - : mayDefNodes(std::less(), alloc->Adapter()), - mayUseNodes(std::less(), alloc->Adapter()), + : mayDefNodes(alloc->Adapter()), + mayUseNodes(alloc->Adapter()), mustDefNodes(alloc->Adapter()) {} ~MayDefMayUseMustDefPart() override = default; - const MapleMap &GetMayDefNodes() const override { + const TypeOfMayDefList &GetMayDefNodes() const override { return mayDefNodes; } - MapleMap &GetMayDefNodes() override { + TypeOfMayDefList &GetMayDefNodes() override { return mayDefNodes; } - const MapleMap &GetMayUseNodes() const override { + const TypeOfMayUseList &GetMayUseNodes() const override { return mayUseNodes; } - MapleMap &GetMayUseNodes() override { + TypeOfMayUseList &GetMayUseNodes() override { return mayUseNodes; } - const MapleVector &GetMustDefNodes() const override { + const TypeOfMustDefList &GetMustDefNodes() const override { return mustDefNodes; } - MapleVector &GetMustDefNodes() override { + TypeOfMustDefList &GetMustDefNodes() override { return mustDefNodes; } private: - MapleMap mayDefNodes; - MapleMap mayUseNodes; - MapleVector mustDefNodes; + TypeOfMayDefList mayDefNodes; + TypeOfMayUseList mayUseNodes; + TypeOfMustDefList mustDefNodes; }; // statement nodes are covered by StmtsSSAPart @@ -396,11 +399,11 @@ class StmtsSSAPart { return kOpcodeInfo.HasSSADef(stmt.GetOpCode()) && !GetMayDefNodesOf(stmt).empty(); } - MapleMap &GetMayDefNodesOf(const StmtNode &stmt) { + TypeOfMayDefList &GetMayDefNodesOf(const StmtNode &stmt) { return ssaPart[stmt.GetStmtID()]->GetMayDefNodes(); } - MapleMap &GetMayUseNodesOf(const StmtNode &stmt) { + TypeOfMayUseList &GetMayUseNodesOf(const StmtNode &stmt) { return ssaPart[stmt.GetStmtID()]->GetMayUseNodes(); } @@ -554,7 +557,7 @@ class RegreadSSANode : public SSANode { }; void GenericSSAPrint(const MIRModule &mod, const StmtNode &stmtNode, int32 indent, StmtsSSAPart &stmtsSSAPart); -MapleMap *SSAGenericGetMayDefsFromVersionSt(const VersionSt &sym, StmtsSSAPart &stmtsSSAPart); +TypeOfMayDefList *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 e4b71b0412fb099fd938c7bd5e2af5fd32e3d4a5..cd7834c7a131af5f40750dbd0cf19ceeaafbc1a9 100644 --- a/src/maple_me/include/ssa_tab.h +++ b/src/maple_me/include/ssa_tab.h @@ -113,7 +113,7 @@ class SSATab : public AnalysisResult { } // should check HasSSAUse first - const MapleMap &GetStmtMayUseNodes(const StmtNode &stmt) const { + const TypeOfMayUseList &GetStmtMayUseNodes(const StmtNode &stmt) const { return stmtsSSAPart.SSAPartOf(stmt)->GetMayUseNodes(); } // should check IsCallAssigned first diff --git a/src/maple_me/src/alias_class.cpp b/src/maple_me/src/alias_class.cpp index 87c01f75fe974340dee69b2c2c80a3bb41975c3e..75b671ce909f462462f7326a09fb01baf8128ff2 100644 --- a/src/maple_me/src/alias_class.cpp +++ b/src/maple_me/src/alias_class.cpp @@ -676,10 +676,10 @@ void AliasClass::CollectMayUseFromDefinedFinalField(std::set &mayUs } // insert the ost of mayUseOsts into mayUseNodes -void AliasClass::InsertMayUseNode(std::set &mayUseOsts, MapleMap &mayUseNodes) { +void AliasClass::InsertMayUseNode(std::set &mayUseOsts, TypeOfMayUseList &mayUseNodes) { for (OriginalSt *ost : mayUseOsts) { - (void)mayUseNodes.insert(std::make_pair( - ost->GetIndex(), MayUseNode(ssaTab.GetVersionStTable().GetVersionStFromID(ost->GetZeroVersionIndex())))); + mayUseNodes.emplace_back( + MayUseNode(ssaTab.GetVersionStTable().GetVersionStFromID(ost->GetZeroVersionIndex()))); } } @@ -698,7 +698,7 @@ void AliasClass::InsertMayUseReturn(const StmtNode &stmt) { if (mirModule.CurFunction()->IsConstructor()) { CollectMayUseFromDefinedFinalField(mayUseOsts); } - MapleMap &mayUseNodes = ssaTab.GetStmtsSSAPart().GetMayUseNodesOf(stmt); + TypeOfMayUseList &mayUseNodes = ssaTab.GetStmtsSSAPart().GetMayUseNodesOf(stmt); InsertMayUseNode(mayUseOsts, mayUseNodes); } @@ -735,19 +735,18 @@ void AliasClass::InsertReturnOpndMayUse(const StmtNode &stmt) { } } // insert mayUses - MapleMap &mayUseNodes = ssaTab.GetStmtsSSAPart().GetMayUseNodesOf(stmt); + TypeOfMayUseList &mayUseNodes = ssaTab.GetStmtsSSAPart().GetMayUseNodesOf(stmt); InsertMayUseNode(mayUseOsts, mayUseNodes); } } } void AliasClass::InsertMayUseAll(const StmtNode &stmt) { - MapleMap &mayUseNodes = ssaTab.GetStmtsSSAPart().GetMayUseNodesOf(stmt); + TypeOfMayUseList &mayUseNodes = ssaTab.GetStmtsSSAPart().GetMayUseNodesOf(stmt); for (AliasElem *aliasElem : id2Elem) { if (aliasElem->GetOriginalSt().GetIndirectLev() >= 0 && !aliasElem->GetOriginalSt().IsPregOst()) { - (void)mayUseNodes.insert(std::make_pair( - aliasElem->GetOriginalSt().GetIndex(), - MayUseNode(ssaTab.GetVersionStTable().GetVersionStFromID(aliasElem->GetOriginalSt().GetZeroVersionIndex())))); + mayUseNodes.emplace_back( + MayUseNode(ssaTab.GetVersionStTable().GetVersionStFromID(aliasElem->GetOriginalSt().GetZeroVersionIndex()))); } } } @@ -769,19 +768,18 @@ void AliasClass::CollectMayDefForDassign(const StmtNode &stmt, std::set &mayDefOsts, MapleMap &mayDefNodes, +void AliasClass::InsertMayDefNode(std::set &mayDefOsts, TypeOfMayDefList &mayDefNodes, StmtNode &stmt) { for (OriginalSt *mayDefOst : mayDefOsts) { - (void)mayDefNodes.insert(std::make_pair( - mayDefOst->GetIndex(), - MayDefNode(ssaTab.GetVersionStTable().GetVersionStFromID(mayDefOst->GetZeroVersionIndex()), &stmt))); + mayDefNodes.emplace_back( + MayDefNode(ssaTab.GetVersionStTable().GetVersionStFromID(mayDefOst->GetZeroVersionIndex()), &stmt)); } } void AliasClass::InsertMayDefDassign(StmtNode &stmt) { std::set mayDefOsts; CollectMayDefForDassign(stmt, mayDefOsts); - MapleMap &mayDefNodes = ssaTab.GetStmtsSSAPart().GetMayDefNodesOf(stmt); + TypeOfMayDefList &mayDefNodes = ssaTab.GetStmtsSSAPart().GetMayDefNodesOf(stmt); InsertMayDefNode(mayDefOsts, mayDefNodes, stmt); } @@ -828,12 +826,11 @@ void AliasClass::CollectMayDefForIassign(StmtNode &stmt, std::set & } void AliasClass::InsertMayDefNodeExcludeFinalOst(std::set &mayDefOsts, - MapleMap &mayDefNodes, StmtNode &stmt) { + TypeOfMayDefList &mayDefNodes, StmtNode &stmt) { for (OriginalSt *mayDefOst : mayDefOsts) { if (!mayDefOst->IsFinal()) { - (void)mayDefNodes.insert(std::make_pair( - mayDefOst->GetIndex(), - MayDefNode(ssaTab.GetVersionStTable().GetVersionStFromID(mayDefOst->GetZeroVersionIndex()), &stmt))); + mayDefNodes.emplace_back( + MayDefNode(ssaTab.GetVersionStTable().GetVersionStFromID(mayDefOst->GetZeroVersionIndex()), &stmt)); } } } @@ -841,7 +838,7 @@ void AliasClass::InsertMayDefNodeExcludeFinalOst(std::set &mayDefOs void AliasClass::InsertMayDefIassign(StmtNode &stmt) { std::set mayDefOsts; CollectMayDefForIassign(stmt, mayDefOsts); - MapleMap &mayDefNodes = ssaTab.GetStmtsSSAPart().GetMayDefNodesOf(stmt); + TypeOfMayDefList &mayDefNodes = ssaTab.GetStmtsSSAPart().GetMayDefNodesOf(stmt); if (mayDefOsts.size() == 1) { InsertMayDefNode(mayDefOsts, mayDefNodes, stmt); } else { @@ -886,10 +883,9 @@ void AliasClass::InsertMayDefUseSyncOps(StmtNode &stmt) { AliasElem *aliasElem = id2Elem[elemID]; OriginalSt &ostOfAliasAE = aliasElem->GetOriginalSt(); if (!ostOfAliasAE.IsFinal()) { - OStIdx ostIdx = ostOfAliasAE.GetIndex(); VersionSt *vst0 = ssaTab.GetVersionStTable().GetVersionStFromID(ostOfAliasAE.GetZeroVersionIndex()); - (void)theSSAPart->GetMayUseNodes().insert(std::make_pair(ostIdx, MayUseNode(vst0))); - (void)theSSAPart->GetMayDefNodes().insert(std::make_pair(ostIdx, MayDefNode(vst0, &stmt))); + theSSAPart->GetMayUseNodes().emplace_back(MayUseNode(vst0)); + theSSAPart->GetMayDefNodes().emplace_back(MayDefNode(vst0, &stmt)); } } } @@ -966,13 +962,12 @@ void AliasClass::CollectMayUseForCallOpnd(const StmtNode &stmt, std::set &mayDefOsts, MapleMap &mayDefNodes, +void AliasClass::InsertMayDefNodeForCall(std::set &mayDefOsts, TypeOfMayDefList &mayDefNodes, StmtNode &stmt, bool hasNoPrivateDefEffect) { for (OriginalSt *mayDefOst : mayDefOsts) { if (!hasNoPrivateDefEffect || !mayDefOst->IsPrivate()) { - (void)mayDefNodes.insert(std::make_pair( - mayDefOst->GetIndex(), - MayDefNode(ssaTab.GetVersionStTable().GetVersionStFromID(mayDefOst->GetZeroVersionIndex()), &stmt))); + mayDefNodes.emplace_back( + MayDefNode(ssaTab.GetVersionStTable().GetVersionStFromID(mayDefOst->GetZeroVersionIndex()), &stmt)); } } } @@ -1009,12 +1004,11 @@ void AliasClass::InsertMayDefUseCall(StmtNode &stmt, bool hasSideEffect, bool ha } void AliasClass::InsertMayUseNodeExcludeFinalOst(const std::set &mayUseOsts, - MapleMap &mayUseNodes) { + TypeOfMayUseList &mayUseNodes) { for (OriginalSt *mayUseOst : mayUseOsts) { if (!mayUseOst->IsFinal()) { - (void)mayUseNodes.insert( - std::make_pair(mayUseOst->GetIndex(), - MayUseNode(ssaTab.GetVersionStTable().GetVersionStFromID(mayUseOst->GetZeroVersionIndex())))); + mayUseNodes.emplace_back( + MayUseNode(ssaTab.GetVersionStTable().GetVersionStFromID(mayUseOst->GetZeroVersionIndex()))); } } } @@ -1044,16 +1038,15 @@ void AliasClass::InsertMayDefUseIntrncall(StmtNode &stmt) { } void AliasClass::InsertMayDefUseClinitCheck(IntrinsiccallNode &stmt) { - MapleMap &mayDefNodes = ssaTab.GetStmtsSSAPart().GetMayDefNodesOf(stmt); + TypeOfMayDefList &mayDefNodes = ssaTab.GetStmtsSSAPart().GetMayDefNodesOf(stmt); for (OStIdx ostIdx : globalsMayAffectedByClinitCheck) { AliasElem *aliasElem = osym2Elem[ostIdx]; OriginalSt &ostOfAE = aliasElem->GetOriginalSt(); std::string typeNameOfOst = ostOfAE.GetMIRSymbol()->GetName(); std::string typeNameOfStmt = GlobalTables::GetTypeTable().GetTypeFromTyIdx(stmt.GetTyIdx())->GetName(); if (typeNameOfOst.find(typeNameOfStmt) != std::string::npos) { - (void)mayDefNodes.insert(std::make_pair( - ostOfAE.GetIndex(), - MayDefNode(ssaTab.GetVersionStTable().GetVersionStFromID(ostOfAE.GetZeroVersionIndex()), &stmt))); + mayDefNodes.emplace_back( + MayDefNode(ssaTab.GetVersionStTable().GetVersionStFromID(ostOfAE.GetZeroVersionIndex()), &stmt)); } } } diff --git a/src/maple_me/src/dse.cpp b/src/maple_me/src/dse.cpp index f54b8094d93e2d928b0c56eefe64d6171820816b..001dda067d7a0aea1cab984a110dbeff6e9e9165 100644 --- a/src/maple_me/src/dse.cpp +++ b/src/maple_me/src/dse.cpp @@ -61,7 +61,7 @@ bool DSE::ExprNonDeletable(const BaseNode &expr) const { case OP_dread: { auto &dread = static_cast(expr); const MIRSymbol &sym = dread.GetMIRSymbol(); - return sym.IsVolatile() || sym.IsTypeVolatile(dread.GetFieldID()); + return sym.IsVolatile() || sym.IsTypeVolatile(dread.GetFieldID()) || (decoupleStatic && sym.IsGlobal()); } case OP_iread: { auto &iread = static_cast(expr); @@ -324,7 +324,7 @@ void DSE::MarkSingleUseLive(const BaseNode &mirNode) { auto *mayDefList = SSAGenericGetMayDefsFromVersionSt(ToRef(verSt), ssaTab.GetStmtsSSAPart()); if (mayDefList != nullptr) { for (auto it = mayDefList->begin(); it != mayDefList->end(); ++it) { - AddToWorkList(it->second.GetResult()); + AddToWorkList(it->GetResult()); } } } @@ -346,8 +346,7 @@ void DSE::MarkStmtUseLive(const StmtNode &stmt) { } if (kOpcodeInfo.HasSSAUse(stmt.GetOpCode())) { - for (auto &pair : ssaTab.GetStmtMayUseNodes(stmt)) { - const MayUseNode &mayUse = pair.second; + for (auto &mayUse : ssaTab.GetStmtMayUseNodes(stmt)) { AddToWorkList(mayUse.GetOpnd()); } } diff --git a/src/maple_me/src/hdse.cpp b/src/maple_me/src/hdse.cpp index 50ec401609de5754b74987e4fa3867f7f66c3e39..b74042f98b75927a094d325e1446f915c311986f 100755 --- a/src/maple_me/src/hdse.cpp +++ b/src/maple_me/src/hdse.cpp @@ -36,6 +36,22 @@ namespace maple { using namespace utils; +void HDSE::RemoveNotRequiredCallAssignPart(MeStmt &stmt) { + if (!kOpcodeInfo.IsCallAssigned(stmt.GetOp())) { + return; + } + auto *assignPart = stmt.GetMustDefList(); + bool assignPartRequired = false; + for (auto it = assignPart->begin(); it != assignPart->end(); ++it) { + if (IsExprNeeded(*it->GetLHS())) { + assignPartRequired = true; + } + } + if (!assignPartRequired) { + assignPart->clear(); + } +} + void HDSE::RemoveNotRequiredStmtsInBB(BB &bb) { for (auto &meStmt : bb.GetMeStmts()) { if (!meStmt.GetIsLive()) { @@ -43,7 +59,7 @@ void HDSE::RemoveNotRequiredStmtsInBB(BB &bb) { mirModule.GetOut() << "========== HSSA DSE is deleting this stmt: "; meStmt.Dump(&irMap); } - if (meStmt.GetOp() != OP_dassign && (meStmt.IsCondBr() || meStmt.GetOp() == OP_switch)) { + if (meStmt.IsCondBr() || meStmt.GetOp() == OP_switch) { // update CFG while (bb.GetSucc().size() != 1) { BB *succ = bb.GetSucc().back(); @@ -67,6 +83,7 @@ void HDSE::RemoveNotRequiredStmtsInBB(BB &bb) { } bb.RemoveMeStmt(&meStmt); } + RemoveNotRequiredCallAssignPart(meStmt); } } @@ -87,7 +104,7 @@ bool HDSE::NeedNotNullCheck(MeExpr &meExpr, const BB &bb) { void HDSE::MarkMuListRequired(MapleMap &muList) { for (auto &pair : muList) { - workList.push_front(pair.second); + AddNewUse(*pair.second); } } @@ -96,7 +113,7 @@ void HDSE::MarkChiNodeRequired(ChiMeNode &chiNode) { return; } chiNode.SetIsLive(true); - workList.push_front(chiNode.GetRHS()); + AddNewUse(*chiNode.GetRHS()); MeStmt *meStmt = chiNode.GetBase(); MarkStmtRequired(*meStmt); } @@ -115,30 +132,25 @@ void HDSE::MarkPhiRequired(VarOrRegPhiNode &mePhiNode) { MarkControlDependenceLive(*mePhiNode.GetDefBB()); } -void HDSE::MarkVarDefByStmt(VarMeExpr &varExpr) { - switch (varExpr.GetDefBy()) { +void HDSE::MarkDefStmt(ScalarMeExpr &scalarExpr) { + switch (scalarExpr.GetDefBy()) { case kDefByNo: break; case kDefByStmt: { - auto *defStmt = varExpr.GetDefStmt(); - if (defStmt != nullptr) { - MarkStmtRequired(*defStmt); - } + auto *defStmt = scalarExpr.GetDefStmt(); + MarkStmtRequired(*defStmt); break; } case kDefByPhi: { - MarkPhiRequired(varExpr.GetDefPhi()); + MarkPhiRequired(scalarExpr.GetDefPhi()); break; } case kDefByChi: { - auto *defChi = &varExpr.GetDefChi(); - if (defChi != nullptr) { - MarkChiNodeRequired(*defChi); - } + MarkChiNodeRequired(scalarExpr.GetDefChi()); break; } case kDefByMustDef: { - auto *mustDef = &varExpr.GetDefMustDef(); + auto *mustDef = &scalarExpr.GetDefMustDef(); if (!mustDef->GetIsLive()) { mustDef->SetIsLive(true); MarkStmtRequired(*mustDef->GetBase()); @@ -151,62 +163,28 @@ void HDSE::MarkVarDefByStmt(VarMeExpr &varExpr) { } } -void HDSE::MarkRegDefByStmt(RegMeExpr ®MeExpr) { - PregIdx regIdx = regMeExpr.GetRegIdx(); - if (regIdx == -kSregRetval0) { - if (regMeExpr.GetDefStmt()) { - MarkStmtRequired(*regMeExpr.GetDefStmt()); - } - return; - } - switch (regMeExpr.GetDefBy()) { - case kDefByNo: - break; - case kDefByStmt: { - auto *defStmt = regMeExpr.GetDefStmt(); - if (defStmt != nullptr) { - MarkStmtRequired(*defStmt); - } - break; - } - case kDefByPhi: - MarkPhiRequired(regMeExpr.GetDefPhi()); - break; - case kDefByMustDef: { - MustDefMeNode *mustDef = ®MeExpr.GetDefMustDef(); - if (!mustDef->GetIsLive()) { - mustDef->SetIsLive(true); - MarkStmtRequired(*mustDef->GetBase()); - } - break; - } - default: - ASSERT(false, "MarkRegDefByStmt unexpected defBy value"); - break; - } -} - // Find all stmt contains ivar and save to stmt2NotNullExpr // Find all not null expr used as ivar's base、OP_array's or OP_assertnonnull's opnd // And save to notNullExpr2Stmt void HDSE::CollectNotNullExpr(MeStmt &stmt) { size_t opndNum = stmt.NumMeStmtOpnds(); - uint8 exprType = kExprTypeNormal; - for (size_t i = 0; i < opndNum; ++i) { + size_t i = 0; + if (opndNum > 0 && instance_of(stmt)) { + CallMeStmt &callStmt = static_cast(stmt); + if (callStmt.GetTargetFunction().IsStatic()) { + CollectNotNullExpr(stmt, ToRef(stmt.GetOpnd(0)), kExprTypeNormal); + } + CollectNotNullExpr(stmt, ToRef(stmt.GetOpnd(0)), kExprTypeNotNull); + ++i; + } + for (; i < opndNum; ++i) { MeExpr *opnd = stmt.GetOpnd(i); - if (i == 0 && instance_of(stmt)) { - // A non-static call's first opnd is this, should be not null - CallMeStmt &callStmt = static_cast(stmt); - exprType = callStmt.GetTargetFunction().IsStatic() ? kExprTypeNormal : kExprTypeNotNull; - } else { - // A normal opnd not sure - MeExprOp meOp = opnd->GetMeOp(); - if (meOp == kMeOpVar || meOp == kMeOpReg) { - continue; - } - exprType = kExprTypeNormal; + // A normal opnd not sure + MeExprOp meOp = opnd->GetMeOp(); + if (meOp == kMeOpVar || meOp == kMeOpReg) { + continue; } - CollectNotNullExpr(stmt, ToRef(opnd), exprType); + CollectNotNullExpr(stmt, ToRef(opnd), kExprTypeNormal); } } @@ -235,7 +213,7 @@ void HDSE::CollectNotNullExpr(MeStmt &stmt, MeExpr &meExpr, uint8 exprType) { } default: { if (exprType != kExprTypeNormal) { - // Ref expr used in ivar、array or assertnotnull + // Ref expr used in ivar array or assertnotnull PrimType type = meExpr.GetPrimType(); if (type == PTY_ref || type == PTY_ptr) { notNullExpr2Stmt[&meExpr].push_back(&stmt); @@ -256,14 +234,9 @@ void HDSE::CollectNotNullExpr(MeStmt &stmt, MeExpr &meExpr, uint8 exprType) { void HDSE::PropagateUseLive(MeExpr &meExpr) { switch (meExpr.GetMeOp()) { - case kMeOpVar: { - auto &varMeExpr = static_cast(meExpr); - MarkVarDefByStmt(varMeExpr); - return; - } + case kMeOpVar: case kMeOpReg: { - auto ®MeExpr = static_cast(meExpr); - MarkRegDefByStmt(regMeExpr); + MarkDefStmt(static_cast(meExpr)); return; } default: { @@ -302,7 +275,8 @@ bool HDSE::ExprNonDeletable(const MeExpr &meExpr) const { } case kMeOpVar: { auto &varMeExpr = static_cast(meExpr); - return varMeExpr.IsVolatile(ssaTab); + return varMeExpr.IsVolatile(ssaTab) || + (decoupleStatic && ssaTab.GetSymbolOriginalStFromID(varMeExpr.GetOStIdx())->GetMIRSymbol()->IsGlobal()); } case kMeOpIvar: { auto &opIvar = static_cast(meExpr); @@ -334,7 +308,8 @@ bool HDSE::HasNonDeletableExpr(const MeStmt &meStmt) const { auto &dasgn = static_cast(meStmt); VarMeExpr *varMeExpr = dasgn.GetVarLHS(); return (varMeExpr != nullptr && varMeExpr->IsVolatile(ssaTab)) || ExprNonDeletable(*dasgn.GetRHS()) || - (hdseKeepRef && dasgn.Propagated()) || dasgn.GetWasMayDassign(); + (hdseKeepRef && dasgn.Propagated()) || dasgn.GetWasMayDassign() || + (decoupleStatic && ssaTab.GetSymbolOriginalStFromID(varMeExpr->GetOStIdx())->GetMIRSymbol()->IsGlobal()); } case OP_regassign: { auto &rasgn = static_cast(meStmt); @@ -417,14 +392,16 @@ void HDSE::MarkSingleUseLive(MeExpr &meExpr) { case kMeOpVar: case kMeOpReg: { workList.push_front(&meExpr); - break; + return; } case kMeOpIvar: { auto *base = static_cast(meExpr).GetBase(); if (base != nullptr) { MarkSingleUseLive(*base); } - break; + + MarkSingleUseLive(*static_cast(meExpr).GetMu()); + return; } default: break; @@ -463,6 +440,10 @@ void HDSE::MarkStmtRequired(MeStmt &meStmt) { if (meStmt.GetOp() == OP_comment) { return; } + auto *prev = meStmt.GetPrev(); + if (prev != nullptr && prev->GetOp() == OP_comment) { + prev->SetIsLive(true); + } // mark use MarkStmtUseLive(meStmt); @@ -474,7 +455,7 @@ void HDSE::MarkStmtRequired(MeStmt &meStmt) { bool HDSE::StmtMustRequired(const MeStmt &meStmt, const BB &bb) const { Opcode op = meStmt.GetOp(); // special opcode cannot be eliminated - if (IsStmtMustRequire(op) || op == OP_comment) { + if (IsStmtMustRequire(op)) { return true; } // control flow in an infinite loop cannot be eliminated @@ -496,10 +477,10 @@ void HDSE::MarkSpecialStmtRequired() { auto &meStmtNodes = bb->GetMeStmts(); for (auto itStmt = meStmtNodes.rbegin(); itStmt != meStmtNodes.rend(); ++itStmt) { MeStmt *pStmt = to_ptr(itStmt); - CollectNotNullExpr(*pStmt); if (pStmt->GetIsLive()) { continue; } + CollectNotNullExpr(*pStmt); if (StmtMustRequired(*pStmt, *bb)) { MarkStmtRequired(*pStmt); } diff --git a/src/maple_me/src/irmap.cpp b/src/maple_me/src/irmap.cpp index 8489cac08e8995e95ace053bda4bc581b01943d0..24eca2fced4bed801c5713d4bb4aa36929ee9770 100755 --- a/src/maple_me/src/irmap.cpp +++ b/src/maple_me/src/irmap.cpp @@ -373,10 +373,9 @@ IvarMeExpr *IRMap::BuildLHSIvarFromIassMeStmt(IassignMeStmt &iassignMeStmt) { } // build Me chilist from MayDefNode list -void IRMap::BuildChiList(MeStmt &meStmt, MapleMap &mayDefNodes, +void IRMap::BuildChiList(MeStmt &meStmt, TypeOfMayDefList &mayDefNodes, MapleMap &outList) { - for (auto it = mayDefNodes.begin(); it != mayDefNodes.end(); ++it) { - MayDefNode &mayDefNode = it->second; + for (auto &mayDefNode : mayDefNodes) { VersionSt *opndSt = mayDefNode.GetOpnd(); VersionSt *resSt = mayDefNode.GetResult(); auto *chiMeStmt = New(&meStmt); @@ -389,10 +388,9 @@ void IRMap::BuildChiList(MeStmt &meStmt, MapleMap &mayDefNod } } -void IRMap::BuildMustDefList(MeStmt &meStmt, MapleVector &mustDefList, +void IRMap::BuildMustDefList(MeStmt &meStmt, TypeOfMustDefList &mustDefList, MapleVector &mustDefMeList) { - for (auto it = mustDefList.begin(); it != mustDefList.end(); ++it) { - MustDefNode &mustDefNode = *it; + for (auto &mustDefNode : mustDefList) { VersionSt *vst = mustDefNode.GetResult(); VarMeExpr *lhs = GetOrCreateVarFromVerSt(*vst); ASSERT(lhs->GetMeOp() == kMeOpReg || lhs->GetMeOp() == kMeOpVar, "unexpected opcode"); @@ -574,9 +572,8 @@ MeStmt *IRMap::BuildMeStmt(StmtNode &stmt) { return func(this, stmt, *ssaPart); } -void IRMap::BuildMuList(MapleMap &mayUseList, MapleMap &muList) { - for (std::pair mapItem : mayUseList) { - MayUseNode &mayUseNode = mapItem.second; +void IRMap::BuildMuList(TypeOfMayUseList &mayUseList, MapleMap &muList) { + for (auto &mayUseNode : mayUseList) { VersionSt *vst = mayUseNode.GetOpnd(); VarMeExpr *varMeExpr = GetOrCreateVarFromVerSt(*vst); muList.insert(std::make_pair(varMeExpr->GetOStIdx(), varMeExpr)); diff --git a/src/maple_me/src/me_cfg.cpp b/src/maple_me/src/me_cfg.cpp index 648d75957f512288e501aaaa54b0e6b7d724fff1..4fa33ba0d232fed3e142a6a92c9d0c2836fd09ce 100755 --- a/src/maple_me/src/me_cfg.cpp +++ b/src/maple_me/src/me_cfg.cpp @@ -37,6 +37,11 @@ static bool CaseValOfSwitchIsSuccInt(const maple::CaseVector &switchTable) { } namespace maple { +// determine if need to be replaced by assertnonnull +bool MeCFG::IfReplaceWithAssertNonNull(const BB &bb) const { + (void) bb; + return false; +} void MeCFG::ReplaceSwitchContainsOneCaseBranchWithBrtrue(maple::BB &bb, MapleVector &exitBlocks) { StmtNode &lastStmt = bb.GetStmtNodes().back(); @@ -182,6 +187,10 @@ void MeCFG::BuildMirCFG() { } else { bb->AddSucc(*meBB); } + // can the gotostmt be replaced by assertnonnull ? + if (IfReplaceWithAssertNonNull(*meBB)) { + patternSet.insert(lblIdx); + } break; } case kBBSwitch: { @@ -516,6 +525,11 @@ void MeCFG::FixMirCFG() { } } + +// replace "if() throw NPE()" with assertnonnull +void MeCFG::ReplaceWithAssertnonnull() { +} + bool MeCFG::IsStartTryBB(maple::BB &meBB) const { if (!meBB.GetAttributes(kBBAttrIsTry) || meBB.GetAttributes(kBBAttrIsTryEnd)) { return false; diff --git a/src/maple_me/src/me_critical_edge.cpp b/src/maple_me/src/me_critical_edge.cpp index 1af410e86c5b9099b539e08d66d3c19b4ab0edd0..765d9886b8cb1269e82b464c16906fe6609386cf 100644 --- a/src/maple_me/src/me_critical_edge.cpp +++ b/src/maple_me/src/me_critical_edge.cpp @@ -158,6 +158,7 @@ AnalysisResult *MeDoSplitCEdge::Run(MeFunction *func, MeFuncResultMgr *m, Module if (!criticalEdge.empty()) { if (DEBUGFUNC(func)) { LogInfo::MapleLogger() << "*******************before break dump function*****************\n"; + func->DumpFunctionNoSSA(); func->GetTheCfg()->DumpToFile("cfgbeforebreak"); } for (auto it = criticalEdge.begin(); it != criticalEdge.end(); ++it) { @@ -168,11 +169,7 @@ AnalysisResult *MeDoSplitCEdge::Run(MeFunction *func, MeFuncResultMgr *m, Module func->Dump(true); func->GetTheCfg()->DumpToFile("cfgafterbreak"); } - if (func->GetMIRModule().IsInIPA()) { - m->InvalidAnalysisResult(MeFuncPhase_DOMINANCE, func); - } else { - m->InvalidAllResults(); - } + m->InvalidAnalysisResult(MeFuncPhase_DOMINANCE, func); } return nullptr; } diff --git a/src/maple_me/src/me_function.cpp b/src/maple_me/src/me_function.cpp index f90c50fff31d41d2b45f4936ef2800d27a13bd42..f0346e0a4d368f7f983a5ba3c31854ffd33690a8 100755 --- a/src/maple_me/src/me_function.cpp +++ b/src/maple_me/src/me_function.cpp @@ -35,7 +35,7 @@ void MeFunction::PartialInit(bool isSecondPass) { regNum = 0; hasEH = false; secondPass = isSecondPass; - if ((mirModule.GetSrcLang() == kSrcLangJava) && (!mirModule.CurFunction()->GetInfoVector().empty())) { + if (mirModule.IsJavaModule() && (!mirModule.CurFunction()->GetInfoVector().empty())) { std::string string("INFO_registers"); GStrIdx strIdx = GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(string); regNum = mirModule.CurFunction()->GetInfo(strIdx); @@ -46,10 +46,69 @@ void MeFunction::PartialInit(bool isSecondPass) { } } +void MeFunction::DumpFunction() const { + if (meSSATab == nullptr) { + LogInfo::MapleLogger() << "no ssa info, just dump simpfunction\n"; + DumpFunctionNoSSA(); + return; + } + auto eIt = valid_end(); + for (auto bIt = valid_begin(); bIt != eIt; ++bIt) { + auto *bb = *bIt; + bb->DumpHeader(&mirModule); + for (auto &phiPair : bb->GetPhiList()) { + phiPair.second.Dump(); + } + for (auto &stmt : bb->GetStmtNodes()) { + GenericSSAPrint(mirModule, stmt, 1, meSSATab->GetStmtsSSAPart()); + } + } +} + +void MeFunction::DumpFunctionNoSSA() const { + auto eIt = valid_end(); + for (auto bIt = valid_begin(); bIt != eIt; ++bIt) { + auto *bb = *bIt; + bb->DumpHeader(&mirModule); + for (auto &phiPair : bb->GetPhiList()) { + phiPair.second.Dump(); + } + for (auto &stmt : bb->GetStmtNodes()) { + stmt.Dump(1); + } + } +} + +void MeFunction::DumpMayDUFunction() const { + auto eIt = valid_end(); + for (auto bIt = valid_begin(); bIt != eIt; ++bIt) { + auto *bb = *bIt; + bb->DumpHeader(&mirModule); + bool skipStmt = false; + CHECK_FATAL(meSSATab != nullptr, "meSSATab is null"); + for (auto &stmt : bb->GetStmtNodes()) { + if (meSSATab->GetStmtsSSAPart().HasMayDef(stmt) || HasMayUseOpnd(stmt, *meSSATab) || + kOpcodeInfo.NotPure(stmt.GetOpCode())) { + if (skipStmt) { + mirModule.GetOut() << "......\n"; + } + GenericSSAPrint(mirModule, stmt, 1, meSSATab->GetStmtsSSAPart()); + skipStmt = false; + } else { + skipStmt = true; + } + } + if (skipStmt) { + mirModule.GetOut() << "......\n"; + } + } +} void MeFunction::Dump(bool DumpSimpIr) const { LogInfo::MapleLogger() << ">>>>> Dump IR for Function " << mirFunc->GetName() << "<<<<<\n"; if (irmap == nullptr || DumpSimpIr) { + LogInfo::MapleLogger() << "no ssa or irmap info, just dump simp function\n"; + DumpFunction(); return; } auto eIt = valid_end(); @@ -192,7 +251,7 @@ void MeFunction::CreateBasicBlocks() { break; } case OP_endtry: - if (mirModule.GetSrcLang() == kSrcLangJava) { + if (mirModule.IsJavaModule()) { if (tryStmt == nullptr) { break; } @@ -309,7 +368,7 @@ void MeFunction::CreateBasicBlocks() { curBB->GetStmtNodes().rbegin().base().d() == lastStmt), "something wrong building BB"); if (curBB->GetStmtNodes().rbegin().base().d() == nullptr && (lastStmt->GetOpCode() != OP_label)) { - if (mirModule.GetSrcLang() == kSrcLangJava && lastStmt->GetOpCode() == OP_endtry) { + if (mirModule.IsJavaModule() && lastStmt->GetOpCode() == OP_endtry) { if (curBB->GetStmtNodes().empty()) { curBB->SetLast(nullptr); } else { @@ -414,6 +473,7 @@ void MeFunction::Prepare(unsigned long rangeNum) { if (MeOption::optLevel > mapleOption::kLevelZero) { theCFG->FixMirCFG(); } + theCFG->ReplaceWithAssertnonnull(); theCFG->VerifyLabels(); theCFG->UnreachCodeAnalysis(); theCFG->WontExitAnalysis(); @@ -497,7 +557,6 @@ void MeFunction::CloneBasicBlock(BB &newBB, const BB &orig) { } void MeFunction::SplitBBPhysically(BB &bb, StmtNode &splitPoint, BB &newBB) { - StmtNode *newBBStart = splitPoint.GetNext(); // Fix Stmt in BB. if (newBBStart != nullptr) { diff --git a/src/maple_me/src/me_option.cpp b/src/maple_me/src/me_option.cpp index a7de7333a5a2a71e55a22ed6d54055acf9d84f1c..778e83a0b7c2036e1f7f8aa679b83de78604263a 100644 --- a/src/maple_me/src/me_option.cpp +++ b/src/maple_me/src/me_option.cpp @@ -70,6 +70,7 @@ bool MeOption::rcLowering = true; bool MeOption::optDirectCall = false; bool MeOption::propAtPhi = true; bool MeOption::dseKeepRef = false; +bool MeOption::decoupleStatic = false; enum OptionIndex { kMeHelp = kCommonOptionEnd + 1, diff --git a/src/maple_me/src/me_phase_manager.cpp b/src/maple_me/src/me_phase_manager.cpp index abd5c6da4d2bbaf206b6116a41ddc57b88d899c9..0c22260611440c3b422c1d8ccc3f53ffda95a4b4 100644 --- a/src/maple_me/src/me_phase_manager.cpp +++ b/src/maple_me/src/me_phase_manager.cpp @@ -137,6 +137,13 @@ void MeFuncPhaseManager::Run(MIRFunction *mirFunc, uint64 rangeNum, const std::s LogInfo::MapleLogger() << ">>>>>>>>>>>>>>>>>>>>>>>>>>>>> Optimizing Function < " << mirFunc->GetName() << " id=" << mirFunc->GetPuidxOrigin() << " >---\n"; } + MPLTimer runPhasetimer; + MPLTimer funcPrepareTimer; + MPLTimer iteratorTimer; + MPLTimer invalidTimer; + if (timePhases) { + funcPrepareTimer.Start(); + } MemPool *funcMP = localMpCtrler.NewMemPool("maple_me per-function mempool"); MemPool *versMP = localMpCtrler.NewMemPool("first verst mempool"); MeFunction &func = *(funcMP->New(&mirModule, mirFunc, funcMP, versMP, meInput)); @@ -146,6 +153,10 @@ void MeFuncPhaseManager::Run(MIRFunction *mirFunc, uint64 rangeNum, const std::s globalFunc = &func; #endif func.Prepare(rangeNum); + if (timePhases) { + funcPrepareTimer.Stop(); + extraMeTimers["prepareFunc"] += funcPrepareTimer.ElapsedMicroseconds(); + } if (ipa) { mirFunc->SetMeFunc(&func); } @@ -154,19 +165,20 @@ void MeFuncPhaseManager::Run(MIRFunction *mirFunc, uint64 rangeNum, const std::s // each function level phase bool dumpFunc = FuncFilter(MeOption::dumpFunc, func.GetName()); size_t phaseIndex = 0; + if (timePhases) { + iteratorTimer.Start(); + } + long runPhasesTime = 0; for (auto it = PhaseSequenceBegin(); it != PhaseSequenceEnd(); ++it, ++phaseIndex) { + if (timePhases) { + runPhasetimer.Start(); + } PhaseID id = GetPhaseId(it); auto *p = static_cast(GetPhase(id)); p->SetPreviousPhaseName(phaseName); // prev phase name is for filename used in emission after phase phaseName = p->PhaseName(); // new phase name bool dumpPhase = MeOption::DumpPhase(phaseName); - MPLTimer timer; - timer.Start(); RunFuncPhase(&func, p); - if (timePhases) { - timer.Stop(); - phaseTimers[phaseIndex] += timer.ElapsedMicroseconds(); - } if ((MeOption::dumpAfter || dumpPhase) && dumpFunc) { LogInfo::MapleLogger() << ">>>>> Dump after " << phaseName << " <<<<<\n"; if (phaseName != "emit") { @@ -179,20 +191,45 @@ void MeFuncPhaseManager::Run(MIRFunction *mirFunc, uint64 rangeNum, const std::s p->ClearChangeCFG(); break; } + if (timePhases) { + runPhasetimer.Stop(); + phaseTimers[phaseIndex] += runPhasetimer.ElapsedMicroseconds(); + runPhasesTime += runPhasetimer.ElapsedMicroseconds(); + } + } + if (timePhases) { + iteratorTimer.Stop(); + extraMeTimers["iterator"] += iteratorTimer.ElapsedMicroseconds() - runPhasesTime; + runPhasesTime = 0; } + if (!ipa) { + invalidTimer.Start(); GetAnalysisResultManager()->InvalidAllResults(); + invalidTimer.Stop(); + extraMeTimers["invalidResult"] += invalidTimer.ElapsedMicroseconds(); } if (changeCFGPhase != nullptr) { if (ipa) { CHECK_FATAL(false, "phases in ipa will not chang cfg."); } + if (timePhases) { + funcPrepareTimer.Start(); + } // do all the phases start over MemPool *versMemPool = localMpCtrler.NewMemPool("second verst mempool"); MeFunction function(&mirModule, mirFunc, funcMP, versMemPool, meInput); function.PartialInit(true); function.Prepare(rangeNum); + if (timePhases) { + funcPrepareTimer.Stop(); + extraMeTimers["prepareFunc"] += funcPrepareTimer.ElapsedMicroseconds(); + iteratorTimer.Start(); + } for (auto it = PhaseSequenceBegin(); it != PhaseSequenceEnd(); ++it) { + if (timePhases) { + runPhasetimer.Start(); + } PhaseID id = GetPhaseId(it); auto *p = static_cast(GetPhase(id)); if (p == changeCFGPhase) { @@ -209,11 +246,37 @@ void MeFuncPhaseManager::Run(MIRFunction *mirFunc, uint64 rangeNum, const std::s } LogInfo::MapleLogger() << ">>>>> Second time Dump after End <<<<<\n\n"; } + if (timePhases) { + runPhasetimer.Stop(); + phaseTimers[phaseIndex] += runPhasetimer.ElapsedMicroseconds(); + runPhasesTime += runPhasetimer.ElapsedMicroseconds(); + } + } + if (timePhases) { + iteratorTimer.Stop(); + extraMeTimers["iterator"] += iteratorTimer.ElapsedMicroseconds() - runPhasesTime; + runPhasesTime = 0; + invalidTimer.Start(); } + GetAnalysisResultManager()->InvalidAllResults(); + + if (timePhases) { + invalidTimer.Stop(); + extraMeTimers["invalidResult"] += invalidTimer.ElapsedMicroseconds(); + } } if (!ipa) { + if (timePhases) { + invalidTimer.Start(); + } + localMpCtrler.DeleteMemPool(funcMP); + + if (timePhases) { + invalidTimer.Stop(); + extraMeTimers["invalidResult"] += invalidTimer.ElapsedMicroseconds(); + } } } diff --git a/src/maple_me/src/me_prop.cpp b/src/maple_me/src/me_prop.cpp index d400b123a3224bef7c6c885fb9ccb0728d8d3595..f223af1c22091a902992354838cee7c6d8dd6795 100644 --- a/src/maple_me/src/me_prop.cpp +++ b/src/maple_me/src/me_prop.cpp @@ -31,9 +31,9 @@ AnalysisResult *MeDoMeProp::Run(MeFunction *func, MeFuncResultMgr *m, ModuleResu CHECK_NULL_FATAL(dom); auto *hMap = static_cast(m->GetAnalysisResult(MeFuncPhase_IRMAP, func)); CHECK_NULL_FATAL(hMap); - MeProp meProp(*hMap, *dom, *NewMemPool(), Prop::PropConfig { MeOption::propBase, - MeOption::propIloadRef, MeOption::propGlobalRef, MeOption::propFinaliLoadRef, - MeOption::propIloadRefNonParm, MeOption::propAtPhi }); + bool propIloadRef = MeOption::propIloadRef; + MeProp meProp(*hMap, *dom, *NewMemPool(), Prop::PropConfig { MeOption::propBase, propIloadRef, + MeOption::propGlobalRef, MeOption::propFinaliLoadRef, MeOption::propIloadRefNonParm, MeOption::propAtPhi }); meProp.DoProp(); if (DEBUGFUNC(func)) { LogInfo::MapleLogger() << "\n============== After Copy Propagation =============" << '\n'; diff --git a/src/maple_me/src/me_ssa.cpp b/src/maple_me/src/me_ssa.cpp index 5bbc320d091d6969fa23954d8115f552c2f3d54d..eeca0024ed530b74df624bb6bda93052c8370fb0 100644 --- a/src/maple_me/src/me_ssa.cpp +++ b/src/maple_me/src/me_ssa.cpp @@ -64,15 +64,17 @@ void MeSSA::CollectDefBBs(std::map> &ostDefBBs) { if (!kOpcodeInfo.HasSSADef(stmt.GetOpCode())) { continue; } - MapleMap &mayDefs = GetSSATab()->GetStmtsSSAPart().GetMayDefNodesOf(stmt); + TypeOfMayDefList &mayDefs = GetSSATab()->GetStmtsSSAPart().GetMayDefNodesOf(stmt); for (auto iter = mayDefs.begin(); iter != mayDefs.end(); ++iter) { - const OriginalSt *ost = func->GetMeSSATab()->GetOriginalStFromID(iter->first); + auto &mayDef = *iter; + OStIdx ostIdx = mayDef.GetResult()->GetOrigIdx(); + const OriginalSt *ost = func->GetMeSSATab()->GetOriginalStFromID(ostIdx); if (ost != nullptr && (!ost->IsFinal() || func->GetMirFunc()->IsConstructor())) { - ostDefBBs[iter->first].insert(bb->GetBBId()); + ostDefBBs[ostIdx].insert(bb->GetBBId()); } else if (stmt.GetOpCode() == OP_intrinsiccallwithtype) { auto &inNode = static_cast(stmt); if (inNode.GetIntrinsic() == INTRN_JAVA_CLINIT_CHECK) { - ostDefBBs[iter->first].insert(bb->GetBBId()); + ostDefBBs[ostIdx].insert(bb->GetBBId()); } } } @@ -228,6 +230,9 @@ AnalysisResult *MeDoSSA::Run(MeFunction *func, MeFuncResultMgr *funcResMgr, Modu if (DEBUGFUNC(func)) { ssaTab->GetVersionStTable().Dump(&ssaTab->GetModule()); } + if (DEBUGFUNC(func)) { + func->DumpFunction(); + } return ssa; } } // namespace maple diff --git a/src/maple_me/src/orig_symbol.cpp b/src/maple_me/src/orig_symbol.cpp index e29b8ddb9b768953e771fbeef4ba129a72431962..24d28c7df17fb0709ebcbe6524aff426af77dfec 100644 --- a/src/maple_me/src/orig_symbol.cpp +++ b/src/maple_me/src/orig_symbol.cpp @@ -65,7 +65,7 @@ void OriginalStTable::Dump() { } OriginalSt *OriginalStTable::FindOrCreateSymbolOriginalSt(MIRSymbol &mirst, PUIdx pidx, FieldID fld) { - auto it = mirSt2Ost.find(SymbolFieldPair(mirst.GetStIndex(), fld)); + auto it = mirSt2Ost.find(SymbolFieldPair(mirst.GetStIdx(), fld)); if (it == mirSt2Ost.end()) { // create a new OriginalSt return CreateSymbolOriginalSt(mirst, pidx, fld); @@ -96,7 +96,7 @@ OriginalSt *OriginalStTable::CreateSymbolOriginalSt(MIRSymbol &mirst, PUIdx pidx ost->SetIsPrivate(fattrs.GetAttr(FLDATTR_private)); } originalStVector.push_back(ost); - mirSt2Ost[SymbolFieldPair(mirst.GetStIndex(), fld)] = ost->GetIndex(); + mirSt2Ost[SymbolFieldPair(mirst.GetStIdx(), fld)] = ost->GetIndex(); return ost; } @@ -113,7 +113,7 @@ OriginalSt *OriginalStTable::CreatePregOriginalSt(PregIdx regidx, PUIdx pidx) { } OriginalSt *OriginalStTable::FindSymbolOriginalSt(MIRSymbol &mirst) { - auto it = mirSt2Ost.find(SymbolFieldPair(mirst.GetStIndex(), 0)); + auto it = mirSt2Ost.find(SymbolFieldPair(mirst.GetStIdx(), 0)); if (it == mirSt2Ost.end()) { return nullptr; } diff --git a/src/maple_me/src/prop.cpp b/src/maple_me/src/prop.cpp index efbf5b2e310ba6d8f4455d66970ea0b8e8b7aa1c..d6fa9ff98b4006fbf6e608c11ad1da82f8b0a0b0 100755 --- a/src/maple_me/src/prop.cpp +++ b/src/maple_me/src/prop.cpp @@ -15,7 +15,6 @@ #include "prop.h" #include "me_irmap.h" #include "dominance.h" -#define JAVALANG (irMap.GetSSATab().GetModule().IsJavaModule()) namespace { using namespace maple; @@ -73,6 +72,10 @@ Prop::Prop(IRMap &irMap, Dominance &dom, MemPool &memPool, std::vector &&bb MeExpr *Prop::SimplifyCvtMeExpr(const OpMeExpr &opMeExpr) const { MeExpr *opnd0 = opMeExpr.GetOpnd(0); + // convert a const expr + if (opnd0->GetMeOp() == kMeOpConst) { + return nullptr; + } // convert a convert expr if (opnd0->GetOp() == OP_cvt) { @@ -129,6 +132,10 @@ MeExpr *Prop::SimplifyCompareSelectConstMeExpr(const OpMeExpr &opMeExpr, const M return irMap.HashMeExpr(newopMeExpr); } +MeExpr *Prop::SimplifyCompareConstWithConst(OpMeExpr &opMeExpr) const { + return nullptr; +} + MeExpr *Prop::SimplifyCompareConstWithAddress(const OpMeExpr &opMeExpr) const { MeExpr *opnd0 = opMeExpr.GetOpnd(0); MeExpr *opnd1 = opMeExpr.GetOpnd(1); @@ -168,6 +175,11 @@ MeExpr *Prop::SimplifyCompareWithZero(const OpMeExpr &opMeExpr) const { } MeExpr *Prop::SimplifyCompareMeExpr(OpMeExpr &opMeExpr) const { + // compare constant with constant + auto *newConstExpr = SimplifyCompareConstWithConst(opMeExpr); + if (newConstExpr != nullptr) { + return newConstExpr; + } // compare constant with addrof auto *newOpExpr = SimplifyCompareConstWithAddress(opMeExpr); @@ -231,7 +243,7 @@ void Prop::PropUpdateDef(MeExpr &meExpr) { void Prop::PropUpdateChiListDef(const MapleMap &chiList) { for (auto it = chiList.begin(); it != chiList.end(); ++it) { - PropUpdateDef(*static_cast(it->second->GetLHS())); + PropUpdateDef(*it->second->GetLHS()); } } @@ -262,23 +274,17 @@ void Prop::CollectSubVarMeExpr(const MeExpr &meExpr, std::vector // warning: I suppose the vector vervec is on the stack, otherwise would cause memory leak bool Prop::IsVersionConsistent(const std::vector &vstVec, const std::vector> &vstLiveStack) const { - for (auto it = vstVec.begin(); it != vstVec.end(); ++it) { + for (auto *subExpr : vstVec) { // iterate each cur defintion of related symbols of rhs, check the version - const MeExpr *subExpr = *it; CHECK_FATAL(subExpr->GetMeOp() == kMeOpVar || subExpr->GetMeOp() == kMeOpReg, "error: sub expr error"); - uint32 stackIdx = 0; - if (subExpr->GetMeOp() == kMeOpVar) { - stackIdx = static_cast(subExpr)->GetOStIdx(); - } else { - stackIdx = static_cast(subExpr)->GetOstIdx(); - } + uint32 stackIdx = static_cast(subExpr)->GetOStIdx(); auto &pStack = vstLiveStack.at(stackIdx); if (pStack.empty()) { // no definition so far go ahead continue; } SafeMeExprPtr curDef = pStack.top(); - CHECK_FATAL(curDef->GetMeOp() == kMeOpVar || curDef->GetMeOp() == kMeOpReg, "error: cur def error"); + ASSERT(curDef->GetMeOp() == subExpr->GetMeOp(), "error: cur def error"); if (subExpr != curDef.get()) { return false; } @@ -345,7 +351,7 @@ bool Prop::Propagatable(const MeExpr &expr, const BB &fromBB, bool atParm) const if (!IsVersionConsistent(varMeExprVec, vstLiveStackVec)) { return false; } - break; + return true; } case kMeOpIvar: { auto &ivarMeExpr = static_cast(expr); @@ -404,6 +410,10 @@ MeExpr &Prop::PropVar(VarMeExpr &varMeExpr, bool atParm, bool checkPhi) const { if (rhs->GetDepth() <= kPropTreeLevel && Propagatable(utils::ToRef(rhs), utils::ToRef(defStmt->GetBB()), atParm)) { // mark propagated for iread ref + if (rhs->GetMeOp() == kMeOpVar) { + auto &preRHS = PropVar(static_cast(*rhs), atParm, checkPhi); + return preRHS; + } if (rhs->GetMeOp() == kMeOpIvar && rhs->GetPrimType() == PTY_ref) { defStmt->SetPropagated(true); } @@ -567,14 +577,12 @@ void Prop::TraversalMeStmt(MeStmt &meStmt) { case OP_return: { auto &retMeStmt = static_cast(meStmt); const MapleVector &opnds = retMeStmt.GetOpnds(); - // java return operand cannot be expression because cleanup intrinsic is - // inserted before the return statement - if (JAVALANG && opnds.size() == 1 && opnds[0]->GetMeOp() == kMeOpVar) { - break; - } for (size_t i = 0; i < opnds.size(); ++i) { MeExpr *opnd = opnds[i]; - retMeStmt.SetOpnd(i, &PropMeExpr(utils::ToRef(opnd), subProped, false)); + auto &propedExpr = PropMeExpr(utils::ToRef(opnd), subProped, false); + if (propedExpr.GetMeOp() == kMeOpVar) { + retMeStmt.SetOpnd(i, &propedExpr); + } } break; } diff --git a/src/maple_me/src/ssa.cpp b/src/maple_me/src/ssa.cpp index b37b0a7d81f2f8a2c07920e26e2ad527d915aab8..64e84d3a722887996d8d2977c4103be632f69635 100644 --- a/src/maple_me/src/ssa.cpp +++ b/src/maple_me/src/ssa.cpp @@ -72,9 +72,9 @@ void SSA::RenameDefs(StmtNode &stmt, BB &defBB) { theSSAPart->SetSSAVar(*newVersionSym); } if (kOpcodeInfo.HasSSADef(opcode)) { - MapleMap &mayDefList = theSSAPart->GetMayDefNodes(); + TypeOfMayDefList &mayDefList = theSSAPart->GetMayDefNodes(); for (auto it = mayDefList.begin(); it != mayDefList.end(); ++it) { - MayDefNode &mayDef = it->second; + MayDefNode &mayDef = *it; VersionSt *vSym = mayDef.GetResult(); CHECK_FATAL(vSym->GetOrigIdx() < vstStacks.size(), "index out of range in SSA::RenameMayDefs"); mayDef.SetOpnd(vstStacks[vSym->GetOrigIdx()]->top()); @@ -100,10 +100,10 @@ void SSA::RenameMustDefs(const StmtNode &stmt, BB &defBB) { } void SSA::RenameMayUses(BaseNode &node) { - MapleMap &mayUseList = ssaTab->GetStmtsSSAPart().GetMayUseNodesOf(static_cast(node)); - MapleMap::iterator it = mayUseList.begin(); + TypeOfMayUseList &mayUseList = ssaTab->GetStmtsSSAPart().GetMayUseNodesOf(static_cast(node)); + auto it = mayUseList.begin(); for (; it != mayUseList.end(); ++it) { - MayUseNode &mayUse = it->second; + MayUseNode &mayUse = *it; VersionSt *vSym = mayUse.GetOpnd(); CHECK_FATAL(vSym->GetOrigIdx() < vstStacks.size(), "index out of range in SSA::RenameMayUses"); mayUse.SetOpnd(vstStacks.at(vSym->GetOrigIdx())->top()); diff --git a/src/maple_me/src/ssa_mir_nodes.cpp b/src/maple_me/src/ssa_mir_nodes.cpp index 2cc75157671d26a2cce56f5e35344402ec131ace..b0f60bdf643c62def886c3bed24d438742ef5420 100644 --- a/src/maple_me/src/ssa_mir_nodes.cpp +++ b/src/maple_me/src/ssa_mir_nodes.cpp @@ -65,7 +65,7 @@ void GenericSSAPrint(const MIRModule &mod, const StmtNode &stmtNode, int32 inden } } -static MapleMap *SSAGenericGetMayDefsFromVersionSt(const VersionSt &vst, +static TypeOfMayDefList *SSAGenericGetMayDefsFromVersionSt(const VersionSt &vst, StmtsSSAPart &stmtsSSAPart, std::unordered_set &visited) { if (vst.IsInitVersion() || visited.find(&vst) != visited.end()) { return nullptr; @@ -75,7 +75,7 @@ static MapleMap *SSAGenericGetMayDefsFromVersionSt(const Ver const PhiNode *phi = vst.GetPhi(); for (size_t i = 0; i < phi->GetPhiOpnds().size(); ++i) { const VersionSt *vSym = phi->GetPhiOpnd(i); - MapleMap *mayDefs = SSAGenericGetMayDefsFromVersionSt(*vSym, stmtsSSAPart, visited); + TypeOfMayDefList *mayDefs = SSAGenericGetMayDefsFromVersionSt(*vSym, stmtsSSAPart, visited); if (mayDefs != nullptr) { return mayDefs; } @@ -87,7 +87,7 @@ static MapleMap *SSAGenericGetMayDefsFromVersionSt(const Ver return nullptr; } -MapleMap *SSAGenericGetMayDefsFromVersionSt(const VersionSt &sym, StmtsSSAPart &stmtsSSAPart) { +TypeOfMayDefList *SSAGenericGetMayDefsFromVersionSt(const VersionSt &sym, StmtsSSAPart &stmtsSSAPart) { std::unordered_set visited; return SSAGenericGetMayDefsFromVersionSt(sym, stmtsSSAPart, visited); } @@ -95,7 +95,7 @@ MapleMap *SSAGenericGetMayDefsFromVersionSt(const VersionSt bool HasMayUseOpnd(const BaseNode &baseNode, SSATab &func) { const auto &stmtNode = static_cast(baseNode); if (kOpcodeInfo.HasSSAUse(stmtNode.GetOpCode())) { - MapleMap &mayUses = func.GetStmtsSSAPart().GetMayUseNodesOf(stmtNode); + TypeOfMayUseList &mayUses = func.GetStmtsSSAPart().GetMayUseNodesOf(stmtNode); if (!mayUses.empty()) { return true; } diff --git a/src/maple_phase/include/phase_manager.h b/src/maple_phase/include/phase_manager.h index ca4bac4c11a49bd634f6d90d66e97b78081b31ce..0c005817f9fdb6a25258a31bf7f997cf5b654abb 100644 --- a/src/maple_phase/include/phase_manager.h +++ b/src/maple_phase/include/phase_manager.h @@ -26,7 +26,8 @@ class PhaseManager { allocator(&memPool), registeredPhases(std::less(), allocator.Adapter()), phaseSequences(allocator.Adapter()), - phaseTimers(allocator.Adapter()) {} + phaseTimers(allocator.Adapter()), + extraMeTimers(allocator.Adapter()) {} virtual ~PhaseManager() = default; @@ -130,20 +131,34 @@ class PhaseManager { } long DumpTimers() { + auto TimeLogger = [](const std::string &itemName, time_t itemTimeUs, time_t totalTimeUs) { + LogInfo::MapleLogger() << std::left << std::setw(25) << itemName << std::setw(10) + << std::right << std::fixed << std::setprecision(2) + << (100.0 * itemTimeUs / totalTimeUs) << "%" << std::setw(10) + << std::setprecision(0) << (itemTimeUs / 1000.0) << "ms\n"; + }; long total = 0; + // extra timer + for (auto it = extraMeTimers.cbegin(); it != extraMeTimers.cend(); ++it) { + total += it->second; + } + bool isMePM = total > 0; for (size_t i = 0; i < phaseTimers.size(); ++i) { total += phaseTimers[i]; } + // Dump extra timer + ASSERT(total != 0, "calculation check"); + std::ios::fmtflags f(LogInfo::MapleLogger().flags()); + if (isMePM) { + for (auto it = extraMeTimers.cbegin(); it != extraMeTimers.cend(); ++it) { + TimeLogger(it->first, it->second, total); + } + } for (size_t i = 0; i < phaseTimers.size(); ++i) { - ASSERT(total != 0, "calculation check"); ASSERT(registeredPhases[phaseSequences[i]] != nullptr, "Phase null ptr check"); - std::ios::fmtflags f(LogInfo::MapleLogger().flags()); - LogInfo::MapleLogger() << std::left << std::setw(25) << - registeredPhases[phaseSequences[i]]->PhaseName() << std::setw(10) << std::right << std::fixed << - std::setprecision(2) << (100.0 * phaseTimers[i] / total) << "%" << std::setw(10) << - std::setprecision(0) << (phaseTimers[i] / 1000.0) << "ms" << '\n'; - LogInfo::MapleLogger().flags(f); + TimeLogger(registeredPhases[phaseSequences[i]]->PhaseName(), phaseTimers[i], total); } + LogInfo::MapleLogger().flags(f); return total; } @@ -157,6 +172,7 @@ class PhaseManager { MapleMap registeredPhases; MapleVector phaseSequences; MapleVector phaseTimers; + MapleMap extraMeTimers; }; } // namespace maple #endif // MAPLE_PHASE_INCLUDE_PHASE_MANAGER_H diff --git a/src/mplfe/common/include/basic_io.h b/src/mplfe/common/include/basic_io.h index e994e4d06c2b03fb99846a962da92751a17e9d5e..fac70d6f65e3ea10ac207d8eecef44d7ce712c31 100644 --- a/src/mplfe/common/include/basic_io.h +++ b/src/mplfe/common/include/basic_io.h @@ -93,7 +93,7 @@ class BasicIOMapFile { public: explicit BasicIOMapFile(const std::string &name); BasicIOMapFile(const std::string &name, const uint8 *ptrIn, long lengthIn); - ~BasicIOMapFile(); + virtual ~BasicIOMapFile(); bool OpenAndMap(); void Close(); static std::unique_ptr GenFileInMemory(const std::string &name, const uint8 *buf, size_t len); @@ -118,7 +118,7 @@ class BasicIOMapFile { return fileName; } - private: + protected: int fd; const uint8 *ptr; uint8 *ptrMemMap; @@ -175,6 +175,11 @@ class BasicIORead { return file.GetPtrOffset(pos); } + const uint8 *GetSafeBufferAt(uint32 pos0, uint32 size) const { + CHECK_FATAL(pos0 + size <= file.GetLength(), "not enough data"); + return file.GetPtrOffset(pos0); + } + uint32 GetPos() const { return pos; } diff --git a/src/mplfe/common/src/mplfe.cpp b/src/mplfe/common/src/mplfe.cpp index 66463b5eb539bb495875a8d4d80a6ea86420f80b..4e25e5d212f079c8715b70148352caebaa19cb8c 100644 --- a/src/mplfe/common/src/mplfe.cpp +++ b/src/mplfe/common/src/mplfe.cpp @@ -37,8 +37,11 @@ int main(int argc, char **argv) { compiler.CheckInput(); compiler.SetupOutputPathAndName(); success = success && compiler.LoadMplt(); - std::unique_ptr jbcCompilerComp = std::make_unique(module); - compiler.RegisterCompilerComponent(std::move(jbcCompilerComp)); + if (FEOptions::GetInstance().GetInputClassFiles().size() != 0 || + FEOptions::GetInstance().GetInputJarFiles().size() != 0) { + std::unique_ptr jbcCompilerComp = std::make_unique(module); + compiler.RegisterCompilerComponent(std::move(jbcCompilerComp)); + } compiler.InitFromOptions(); compiler.ParseInputs(); compiler.PreProcessDecls(); diff --git a/src/mplfe/test/mplfe_ut_options.cpp b/src/mplfe/test/mplfe_ut_options.cpp index b0030b9e217f032d016357806f9b2b5c0f75f794..bbcc3d8d85bae432c93e96a925de8ceeedb9b12e 100644 --- a/src/mplfe/test/mplfe_ut_options.cpp +++ b/src/mplfe/test/mplfe_ut_options.cpp @@ -62,7 +62,7 @@ MPLFEUTOptions::MPLFEUTOptions() } void MPLFEUTOptions::DumpUsage() const { - for (unsigned int i = 0; kUsage[i].help != ""; i++) { + for (unsigned int i = 0; !kUsage[i].help.empty(); i++) { std::cout << kUsage[i].help << std::endl; } exit(1);