From a210a47bf167bae0949956afcb458791745f9677 Mon Sep 17 00:00:00 2001 From: Frederick Chow Date: Tue, 26 Jan 2021 21:25:06 -0800 Subject: [PATCH] Separated irmap.cpp into irmap_build.cpp and irmap.cpp The irmap phase is renamed to irmapbuild phase. Methods in irmap_build.cpp are invoked only in the irmapbuild phase. irmap.cpp provides the methods for supporting HSSA (hashed SSA) used all over maple_me. --- src/mapleall/maple_me/BUILD.gn | 2 + src/mapleall/maple_me/include/bb.h | 1 + src/mapleall/maple_me/include/irmap.h | 59 +-- src/mapleall/maple_me/include/irmap_build.h | 70 +++ src/mapleall/maple_me/include/me_irmap.h | 18 +- .../maple_me/include/me_irmap_build.h | 36 ++ src/mapleall/maple_me/include/me_phases.def | 2 +- src/mapleall/maple_me/src/irmap.cpp | 423 ----------------- src/mapleall/maple_me/src/irmap_build.cpp | 445 ++++++++++++++++++ src/mapleall/maple_me/src/irmap_emit.cpp | 28 ++ src/mapleall/maple_me/src/me_abco.cpp | 2 +- src/mapleall/maple_me/src/me_analyze_rc.cpp | 2 +- src/mapleall/maple_me/src/me_analyzector.cpp | 2 +- src/mapleall/maple_me/src/me_emit.cpp | 2 +- src/mapleall/maple_me/src/me_hdse.cpp | 2 +- src/mapleall/maple_me/src/me_irmap.cpp | 81 ---- src/mapleall/maple_me/src/me_irmap_build.cpp | 67 +++ .../maple_me/src/me_phase_manager.cpp | 2 +- src/mapleall/maple_me/src/me_profile_gen.cpp | 2 +- src/mapleall/maple_me/src/me_prop.cpp | 2 +- src/mapleall/maple_me/src/me_rc_lowering.cpp | 2 +- src/mapleall/maple_me/src/me_rename2preg.cpp | 4 +- .../maple_me/src/me_ssa_devirtual.cpp | 2 +- src/mapleall/maple_me/src/me_ssa_epre.cpp | 2 +- src/mapleall/maple_me/src/me_ssa_lpre.cpp | 2 +- src/mapleall/maple_me/src/me_stmt_pre.cpp | 2 +- src/mapleall/maple_me/src/me_store_pre.cpp | 2 +- src/mapleall/maple_me/src/preg_renamer.cpp | 2 +- 28 files changed, 683 insertions(+), 583 deletions(-) create mode 100644 src/mapleall/maple_me/include/irmap_build.h create mode 100644 src/mapleall/maple_me/include/me_irmap_build.h create mode 100644 src/mapleall/maple_me/src/irmap_build.cpp create mode 100644 src/mapleall/maple_me/src/me_irmap_build.cpp diff --git a/src/mapleall/maple_me/BUILD.gn b/src/mapleall/maple_me/BUILD.gn index 13753a45a6..9f61721401 100644 --- a/src/mapleall/maple_me/BUILD.gn +++ b/src/mapleall/maple_me/BUILD.gn @@ -44,6 +44,7 @@ src_libmplme = [ "src/me_function.cpp", "src/me_loop_analysis.cpp", "src/me_irmap.cpp", + "src/me_irmap_build.cpp", "src/me_analyzector.cpp", "src/me_loop_canon.cpp", "src/me_option.cpp", @@ -81,6 +82,7 @@ src_libmplmewpo = [ "src/dominance.cpp", "src/func_emit.cpp", "src/irmap.cpp", + "src/irmap_build.cpp", "src/irmap_emit.cpp", "src/me_builder.cpp", "src/me_ir.cpp", diff --git a/src/mapleall/maple_me/include/bb.h b/src/mapleall/maple_me/include/bb.h index 0228972154..4572e415c5 100755 --- a/src/mapleall/maple_me/include/bb.h +++ b/src/mapleall/maple_me/include/bb.h @@ -297,6 +297,7 @@ class BB { void ReplaceMeStmt(const MeStmt *stmt, MeStmt *newStmt); void DumpMePhiList(const IRMap *irMap); void DumpMeVarPiList(const IRMap *irMap); + void EmitBB(SSATab &ssaTab, BlockNode &curblk, bool needAnotherPass); StmtNodes &GetStmtNodes() { return stmtNodeList; } diff --git a/src/mapleall/maple_me/include/irmap.h b/src/mapleall/maple_me/include/irmap.h index 877463af1d..5520489aa6 100755 --- a/src/mapleall/maple_me/include/irmap.h +++ b/src/mapleall/maple_me/include/irmap.h @@ -18,41 +18,31 @@ #include "ver_symbol.h" #include "ssa_tab.h" #include "me_ir.h" -#include "dominance.h" #include "me_builder.h" namespace maple { +class IRMapBuild; + class IRMap : public AnalysisResult { + friend IRMapBuild; public: - IRMap(SSATab &ssaTab, Dominance &dom, MemPool &memPool, MemPool &tmpMemPool, uint32 hashTableSize) + IRMap(SSATab &ssaTab, MemPool &memPool, uint32 hashTableSize) : AnalysisResult(&memPool), ssaTab(ssaTab), mirModule(ssaTab.GetModule()), - dom(dom), irMapAlloc(&memPool), - tempAlloc(&tmpMemPool), mapHashLength(hashTableSize), hashTable(mapHashLength, nullptr, irMapAlloc.Adapter()), vst2MeExprTable(ssaTab.GetVersionStTableSize(), nullptr, irMapAlloc.Adapter()), regMeExprTable(irMapAlloc.Adapter()), lpreTmps(irMapAlloc.Adapter()), vst2Decrefs(irMapAlloc.Adapter()), - meBuilder(irMapAlloc) { - static auto stmtBuildPolicyLoader = InitMeStmtFactory(); - (void)stmtBuildPolicyLoader; - } + meBuilder(irMapAlloc) {} virtual ~IRMap() = default; virtual BB *GetBB(BBId id) = 0; virtual BB *GetBBForLabIdx(LabelIdx lidx, PUIdx pidx = 0) = 0; - - Dominance &GetDominance() { - return dom; - } - MeExpr *HashMeExpr(MeExpr &meExpr); - void BuildBB(BB &bb, std::vector &bbIRMapProcessed); - MeExpr *BuildExpr(BaseNode&); IvarMeExpr *BuildIvarFromOpMeExpr(OpMeExpr &opMeExpr); IvarMeExpr *BuildLHSIvarFromIassMeStmt(IassignMeStmt &iassignMeStmt); IvarMeExpr *BuildLHSIvar(MeExpr &baseAddr, IassignMeStmt &iassignMeStmt, FieldID fieldID); @@ -94,6 +84,15 @@ class IRMap : public AnalysisResult { void InsertMeStmtBefore(BB&, MeStmt&, MeStmt&); MePhiNode *CreateMePhi(ScalarMeExpr&); + void DumpBB(const BB &bb) { + int i = 0; + for (const auto &meStmt : bb.GetMeStmts()) { + if (GetDumpStmtNum()) { + LogInfo::MapleLogger() << "(" << i++ << ") "; + } + meStmt.Dump(this); + } + } virtual void Dump() = 0; virtual void SetCurFunction(const BB&) {} @@ -136,11 +135,6 @@ class IRMap : public AnalysisResult { MapleAllocator &GetIRMapAlloc() { return irMapAlloc; } - - MapleAllocator &GetTempAlloc() { - return tempAlloc; - } - int32 GetExprID() const { return exprID; } @@ -216,9 +210,7 @@ class IRMap : public AnalysisResult { private: SSATab &ssaTab; MIRModule &mirModule; - Dominance &dom; MapleAllocator irMapAlloc; - MapleAllocator tempAlloc; int32 exprID = 0; // for allocating exprid_ in MeExpr uint32 mapHashLength; // size of hashTable MapleVector hashTable; // the value number hash table @@ -232,32 +224,9 @@ class IRMap : public AnalysisResult { MeBuilder meBuilder; bool ReplaceMeExprStmtOpnd(uint32, MeStmt&, const MeExpr&, MeExpr&); - MeExpr *BuildLHSVar(const VersionSt &vst, DassignMeStmt &defMeStmt); void PutToBucket(uint32, MeExpr&); - MeStmt *BuildMeStmtWithNoSSAPart(StmtNode &stmt); - MeStmt *BuildMeStmt(StmtNode&); - MeExpr *BuildLHSReg(const VersionSt &vst, RegassignMeStmt &defMeStmt, const RegassignNode ®assign); RegMeExpr *CreateRefRegMeExpr(const MIRSymbol&); - VarMeExpr *GetOrCreateVarFromVerSt(const VersionSt &vst); - RegMeExpr *GetOrCreateRegFromVerSt(const VersionSt &vst); - 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); - static bool InitMeStmtFactory(); - MeStmt *BuildDassignMeStmt(StmtNode &stmt, AccessSSANodes &ssaPart); - MeStmt *BuildRegassignMeStmt(StmtNode &stmt, AccessSSANodes &ssaPart); - MeStmt *BuildIassignMeStmt(StmtNode &stmt, AccessSSANodes &ssaPart); - MeStmt *BuildMaydassignMeStmt(StmtNode &stmt, AccessSSANodes &ssaPart); - MeStmt *BuildCallMeStmt(StmtNode &stmt, AccessSSANodes &ssaPart); - MeStmt *BuildNaryMeStmt(StmtNode &stmt, AccessSSANodes &ssaPart); - MeStmt *BuildRetMeStmt(StmtNode &stmt, AccessSSANodes &ssaPart); - MeStmt *BuildWithMuMeStmt(StmtNode &stmt, AccessSSANodes &ssaPart); - MeStmt *BuildGosubMeStmt(StmtNode &stmt, AccessSSANodes &ssaPart); - MeStmt *BuildThrowMeStmt(StmtNode &stmt, AccessSSANodes &ssaPart); - MeStmt *BuildSyncMeStmt(StmtNode &stmt, AccessSSANodes &ssaPart); MeExpr *ReplaceMeExprExpr(MeExpr &origExpr, MeExpr &newExpr, size_t opndsSize, const MeExpr &meExpr, MeExpr &repExpr); }; } // namespace maple diff --git a/src/mapleall/maple_me/include/irmap_build.h b/src/mapleall/maple_me/include/irmap_build.h new file mode 100644 index 0000000000..6b1c39f19f --- /dev/null +++ b/src/mapleall/maple_me/include/irmap_build.h @@ -0,0 +1,70 @@ +/* + * Copyright (c) [2020] Huawei Technologies Co., Ltd. All rights reserved. + * + * OpenArkCompiler is licensed under the Mulan Permissive Software License v2. + * You can use this software according to the terms and conditions of the MulanPSL - 2.0. + * You may obtain a copy of MulanPSL - 2.0 at: + * + * https://opensource.org/licenses/MulanPSL-2.0 + * + * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER + * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR + * FIT FOR A PARTICULAR PURPOSE. + * See the MulanPSL - 2.0 for more details. + */ + +#ifndef MAPLE_ME_INCLUDE_IRMAP_BUILD_H +#define MAPLE_ME_INCLUDE_IRMAP_BUILD_H +#include "irmap.h" +#include "dominance.h" + +namespace maple { + +// This class contains methods to convert Maple IR to MeIR. +class IRMapBuild { + public: + IRMapBuild(IRMap *hmap, Dominance *dom) : irMap(hmap), + mirModule(hmap->GetMIRModule()), ssaTab(irMap->GetSSATab()), dominance(*dom), curBB(nullptr) { + static auto stmtBuildPolicyLoader = InitMeStmtFactory(); + (void)stmtBuildPolicyLoader; + } + ~IRMapBuild() {} + void BuildBB(BB &bb, std::vector &bbIRMapProcessed); + + private: + VarMeExpr *GetOrCreateVarFromVerSt(const VersionSt &vst); + RegMeExpr *GetOrCreateRegFromVerSt(const VersionSt &vst); + + MeExpr *BuildLHSVar(const VersionSt &vst, DassignMeStmt &defMeStmt); + MeExpr *BuildLHSReg(const VersionSt &vst, RegassignMeStmt &defMeStmt, const RegassignNode ®assign); + void BuildChiList(MeStmt&, TypeOfMayDefList&, MapleMap&); + void BuildMustDefList(MeStmt &meStmt, TypeOfMustDefList&, MapleVector&); + void BuildMuList(TypeOfMayUseList&, MapleMap&); + void BuildPhiMeNode(BB&); + void SetMeExprOpnds(MeExpr &meExpr, BaseNode &mirNode); + static bool InitMeStmtFactory(); + MeStmt *BuildDassignMeStmt(StmtNode &stmt, AccessSSANodes &ssaPart); + MeStmt *BuildRegassignMeStmt(StmtNode &stmt, AccessSSANodes &ssaPart); + MeStmt *BuildIassignMeStmt(StmtNode &stmt, AccessSSANodes &ssaPart); + MeStmt *BuildMaydassignMeStmt(StmtNode &stmt, AccessSSANodes &ssaPart); + MeStmt *BuildCallMeStmt(StmtNode &stmt, AccessSSANodes &ssaPart); + MeStmt *BuildNaryMeStmt(StmtNode &stmt, AccessSSANodes &ssaPart); + MeStmt *BuildRetMeStmt(StmtNode &stmt, AccessSSANodes &ssaPart); + MeStmt *BuildWithMuMeStmt(StmtNode &stmt, AccessSSANodes &ssaPart); + MeStmt *BuildGosubMeStmt(StmtNode &stmt, AccessSSANodes &ssaPart); + MeStmt *BuildThrowMeStmt(StmtNode &stmt, AccessSSANodes &ssaPart); + MeStmt *BuildSyncMeStmt(StmtNode &stmt, AccessSSANodes &ssaPart); + MeStmt *BuildMeStmtWithNoSSAPart(StmtNode &stmt); + MeStmt *BuildMeStmt(StmtNode&); + MeExpr *BuildExpr(BaseNode&); + + private: + IRMap *irMap; + MIRModule &mirModule; + SSATab &ssaTab; + Dominance &dominance; + BB *curBB; // current mapleme::BB being visited +}; + +} // namespace maple +#endif // MAPLE_ME_INCLUDE_IRMAP_BUILD_H diff --git a/src/mapleall/maple_me/include/me_irmap.h b/src/mapleall/maple_me/include/me_irmap.h index 4a1f6fadb2..df297f7c0e 100644 --- a/src/mapleall/maple_me/include/me_irmap.h +++ b/src/mapleall/maple_me/include/me_irmap.h @@ -22,8 +22,8 @@ namespace maple { class MeIRMap : public IRMap { public: static const uint32 kHmapHashLength = 5107; - MeIRMap(MeFunction &f, Dominance &dom, MemPool &memPool, MemPool &tmpMemPool) - : IRMap(*f.GetMeSSATab(), dom, memPool, tmpMemPool, kHmapHashLength), func(f) { + MeIRMap(MeFunction &f, MemPool &memPool) + : IRMap(*f.GetMeSSATab(), memPool, kHmapHashLength), func(f) { SetDumpStmtNum(MeOption::stmtNum); } @@ -37,10 +37,7 @@ class MeIRMap : public IRMap { return func.GetLabelBBAt(lidx); } - void DumpBB(const BB &bb); void Dump() override; - void EmitBB(BB&, BlockNode&); - void EmitBBStmts(BB&, BlockNode&); MeFunction &GetFunc() const { return func; @@ -50,16 +47,5 @@ class MeIRMap : public IRMap { MeFunction &func; }; -class MeDoIRMap : public MeFuncPhase { - public: - explicit MeDoIRMap(MePhaseID id) : MeFuncPhase(id) {} - - ~MeDoIRMap() = default; - - AnalysisResult *Run(MeFunction *func, MeFuncResultMgr *funcResMgr, ModuleResultMgr *moduleResMgr) override; - std::string PhaseName() const override { - return "irmap"; - } -}; } // namespace maple #endif // MAPLE_ME_INCLUDE_ME_IRMAP_H diff --git a/src/mapleall/maple_me/include/me_irmap_build.h b/src/mapleall/maple_me/include/me_irmap_build.h new file mode 100644 index 0000000000..1f19446fe1 --- /dev/null +++ b/src/mapleall/maple_me/include/me_irmap_build.h @@ -0,0 +1,36 @@ +/* + * Copyright (c) [2020] Huawei Technologies Co., Ltd. All rights reserved. + * + * OpenArkCompiler is licensed under the Mulan Permissive Software License v2. + * You can use this software according to the terms and conditions of the MulanPSL - 2.0. + * You may obtain a copy of MulanPSL - 2.0 at: + * + * https://opensource.org/licenses/MulanPSL-2.0 + * + * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER + * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR + * FIT FOR A PARTICULAR PURPOSE. + * See the MulanPSL - 2.0 for more details. + */ + +#ifndef MAPLE_ME_INCLUDE_ME_IRMAP_BUILD_H +#define MAPLE_ME_INCLUDE_ME_IRMAP_BUILD_H +#include "me_function.h" +#include "me_irmap.h" +#include "irmap_build.h" + +namespace maple { + +class MeDoIRMapBuild : public MeFuncPhase { + public: + explicit MeDoIRMapBuild(MePhaseID id) : MeFuncPhase(id) {} + + ~MeDoIRMapBuild() = default; + + AnalysisResult *Run(MeFunction *func, MeFuncResultMgr *funcResMgr, ModuleResultMgr *moduleResMgr) override; + std::string PhaseName() const override { + return "irmapbuild"; + } +}; +} // namespace maple +#endif // MAPLE_ME_INCLUDE_ME_IRMAP_BUILD_H diff --git a/src/mapleall/maple_me/include/me_phases.def b/src/mapleall/maple_me/include/me_phases.def index 8562b00214..a8490395d9 100644 --- a/src/mapleall/maple_me/include/me_phases.def +++ b/src/mapleall/maple_me/include/me_phases.def @@ -16,7 +16,7 @@ FUNCAPHASE(MeFuncPhase_DOMINANCE, MeDoDominance) FUNCAPHASE(MeFuncPhase_SSATAB, MeDoSSATab) FUNCAPHASE(MeFuncPhase_ALIASCLASS, MeDoAliasClass) FUNCAPHASE(MeFuncPhase_SSA, MeDoSSA) -FUNCAPHASE(MeFuncPhase_IRMAP, MeDoIRMap) +FUNCAPHASE(MeFuncPhase_IRMAPBUILD, MeDoIRMapBuild) FUNCAPHASE(MeFuncPhase_BBLAYOUT, MeDoBBLayout) FUNCAPHASE(MeFuncPhase_MELOOP, MeDoMeLoop) FUNCTPHASE(MeFuncPhase_BYPATHEH, MeDoBypathEH) diff --git a/src/mapleall/maple_me/src/irmap.cpp b/src/mapleall/maple_me/src/irmap.cpp index ba30ea3258..84ff505754 100755 --- a/src/mapleall/maple_me/src/irmap.cpp +++ b/src/mapleall/maple_me/src/irmap.cpp @@ -14,66 +14,10 @@ */ #include "irmap.h" #include -#include "ssa_mir_nodes.h" #include "ssa.h" #include "mir_builder.h" -#include "factory.h" namespace maple { -using MeStmtFactory = FunctionFactory; - -// recursively invoke itself in a pre-order traversal of the dominator tree of -// the CFG to build the HSSA representation for the code in each BB -void IRMap::BuildBB(BB &bb, std::vector &bbIRMapProcessed) { - BBId bbID = bb.GetBBId(); - if (bbIRMapProcessed[bbID]) { - return; - } - bbIRMapProcessed[bbID] = true; - curBB = &bb; - SetCurFunction(bb); - // iterate phi list to update the definition by phi - BuildPhiMeNode(bb); - if (!bb.IsEmpty()) { - for (auto &stmt : bb.GetStmtNodes()) { - MeStmt *meStmt = BuildMeStmt(stmt); - bb.AddMeStmtLast(meStmt); - } - } - // travesal bb's dominated tree - ASSERT(bbID < dom.GetDomChildrenSize(), " index out of range in IRMap::BuildBB"); - const MapleSet &domChildren = dom.GetDomChildren(bbID); - for (auto bbIt = domChildren.begin(); bbIt != domChildren.end(); ++bbIt) { - BBId childBBId = *bbIt; - BuildBB(*GetBB(childBBId), bbIRMapProcessed); - } -} - -void IRMap::BuildPhiMeNode(BB &bb) { - for (auto &phi : bb.GetPhiList()) { - const OriginalSt *oSt = ssaTab.GetOriginalStFromID(phi.first); - VersionSt *vSt = phi.second.GetResult(); - - auto *phiMeNode = NewInPool(); - phiMeNode->SetDefBB(&bb); - (void)bb.GetMePhiList().insert(std::make_pair(oSt->GetIndex(), phiMeNode)); - if (oSt->IsPregOst()) { - RegMeExpr *meDef = GetOrCreateRegFromVerSt(*vSt); - phiMeNode->UpdateLHS(*meDef); - // build phi operands - for (VersionSt *opnd : phi.second.GetPhiOpnds()) { - phiMeNode->GetOpnds().push_back(GetOrCreateRegFromVerSt(*opnd)); - } - } else { - VarMeExpr *meDef = GetOrCreateVarFromVerSt(*vSt); - phiMeNode->UpdateLHS(*meDef); - // build phi operands - for (VersionSt *opnd : phi.second.GetPhiOpnds()) { - phiMeNode->GetOpnds().push_back(GetOrCreateVarFromVerSt(*opnd)); - } - } - } -} VarMeExpr *IRMap::CreateVarMeExprVersion(const VarMeExpr &origExpr) { auto *varMeExpr = New(&irMapAlloc, exprID++, origExpr.GetOStIdx(), vst2MeExprTable.size()); @@ -277,23 +221,6 @@ RegMeExpr *IRMap::CreateRegRefMeExpr(const MeExpr &meExpr) { return CreateRegRefMeExpr(*mirType); } -VarMeExpr *IRMap::GetOrCreateVarFromVerSt(const VersionSt &vst) { - size_t vindex = vst.GetIndex(); - ASSERT(vindex < vst2MeExprTable.size(), "GetOrCreateVarFromVerSt: index %d is out of range", vindex); - MeExpr *meExpr = vst2MeExprTable.at(vindex); - if (meExpr != nullptr) { - return static_cast(meExpr); - } - const OriginalSt *ost = vst.GetOrigSt(); - ASSERT(ost->IsSymbolOst(), "GetOrCreateVarFromVerSt: wrong ost_type"); - auto *varx = New(&irMapAlloc, exprID++, ost->GetIndex(), vindex); - ASSERT(!GlobalTables::GetTypeTable().GetTypeTable().empty(), "container check"); - varx->InitBase(OP_dread, GlobalTables::GetTypeTable().GetTypeFromTyIdx(ost->GetTyIdx())->GetPrimType(), 0); - varx->SetFieldID(ost->GetFieldID()); - vst2MeExprTable[vindex] = varx; - return varx; -} - VarMeExpr *IRMap::GetOrCreateZeroVersionVarMeExpr(const OriginalSt &ost) { ASSERT(ost.GetZeroVersionIndex() < vst2MeExprTable.size(), "GetOrCreateZeroVersionVarMeExpr: version index of osym's kInitVersion out of range"); @@ -314,40 +241,6 @@ VarMeExpr *IRMap::GetOrCreateZeroVersionVarMeExpr(const OriginalSt &ost) { return static_cast(vst2MeExprTable[ost.GetZeroVersionIndex()]); } -RegMeExpr *IRMap::GetOrCreateRegFromVerSt(const VersionSt &vst) { - size_t vindex = vst.GetIndex(); - ASSERT(vindex < vst2MeExprTable.size(), " GetOrCreateRegFromVerSt: index %d is out of range", vindex); - MeExpr *meExpr = vst2MeExprTable[vindex]; - if (meExpr != nullptr) { - return static_cast(meExpr); - } - const OriginalSt *ost = vst.GetOrigSt(); - ASSERT(ost->IsPregOst(), "GetOrCreateRegFromVerSt: PregOST expected"); - auto *regx = - NewInPool(exprID++, ost->GetPregIdx(), mirModule.CurFunction()->GetPuidx(), ost->GetIndex(), vindex); - regx->InitBase(OP_regread, ost->GetMIRPreg()->GetPrimType(), 0); - regMeExprTable.push_back(regx); - vst2MeExprTable[vindex] = regx; - return regx; -} - -MeExpr *IRMap::BuildLHSVar(const VersionSt &vst, DassignMeStmt &defMeStmt) { - VarMeExpr *meDef = GetOrCreateVarFromVerSt(vst); - meDef->SetDefStmt(&defMeStmt); - meDef->SetDefBy(kDefByStmt); - vst2MeExprTable.at(vst.GetIndex()) = meDef; - return meDef; -} - -MeExpr *IRMap::BuildLHSReg(const VersionSt &vst, RegassignMeStmt &defMeStmt, const RegassignNode ®assign) { - RegMeExpr *meDef = GetOrCreateRegFromVerSt(vst); - meDef->SetPtyp(regassign.GetPrimType()); - meDef->SetDefStmt(&defMeStmt); - meDef->SetDefBy(kDefByStmt); - vst2MeExprTable.at(vst.GetIndex()) = meDef; - return meDef; -} - IvarMeExpr *IRMap::BuildLHSIvar(MeExpr &baseAddr, IassignMeStmt &iassignMeStmt, FieldID fieldID) { auto *meDef = New(exprID++); meDef->SetFieldID(fieldID); @@ -372,286 +265,6 @@ IvarMeExpr *IRMap::BuildLHSIvarFromIassMeStmt(IassignMeStmt &iassignMeStmt) { return BuildLHSIvar(*iassignMeStmt.GetLHSVal()->GetBase(), iassignMeStmt, iassignMeStmt.GetLHSVal()->GetFieldID()); } -// build Me chilist from MayDefNode list -void IRMap::BuildChiList(MeStmt &meStmt, TypeOfMayDefList &mayDefNodes, - MapleMap &outList) { - for (auto &mayDefNode : mayDefNodes) { - VersionSt *opndSt = mayDefNode.GetOpnd(); - VersionSt *resSt = mayDefNode.GetResult(); - auto *chiMeStmt = New(&meStmt); - chiMeStmt->SetRHS(GetOrCreateVarFromVerSt(*opndSt)); - VarMeExpr *lhs = GetOrCreateVarFromVerSt(*resSt); - lhs->SetDefBy(kDefByChi); - lhs->SetDefChi(*chiMeStmt); - chiMeStmt->SetLHS(lhs); - outList.insert(std::make_pair(lhs->GetOStIdx(), chiMeStmt)); - } -} - -void IRMap::BuildMustDefList(MeStmt &meStmt, TypeOfMustDefList &mustDefList, - MapleVector &mustDefMeList) { - for (auto &mustDefNode : mustDefList) { - VersionSt *vst = mustDefNode.GetResult(); - VarMeExpr *lhs = GetOrCreateVarFromVerSt(*vst); - ASSERT(lhs->GetMeOp() == kMeOpReg || lhs->GetMeOp() == kMeOpVar, "unexpected opcode"); - mustDefMeList.push_back(MustDefMeNode(lhs, &meStmt)); - } -} - -MeStmt *IRMap::BuildMeStmtWithNoSSAPart(StmtNode &stmt) { - Opcode op = stmt.GetOpCode(); - switch (op) { - case OP_jscatch: - case OP_finally: - case OP_endtry: - case OP_cleanuptry: - case OP_membaracquire: - case OP_membarrelease: - case OP_membarstorestore: - case OP_membarstoreload: - return New(&stmt); - case OP_goto: - return New(&stmt); - case OP_comment: - return NewInPool(&stmt); - case OP_jstry: - return New(&stmt); - case OP_catch: - return NewInPool(&stmt); - case OP_brfalse: - case OP_brtrue: { - auto &condGotoNode = static_cast(stmt); - auto *condGotoMeStmt = New(&stmt); - condGotoMeStmt->SetOpnd(0, BuildExpr(*condGotoNode.Opnd(0))); - return condGotoMeStmt; - } - case OP_try: { - auto &tryNode = static_cast(stmt); - auto *tryMeStmt = NewInPool(&stmt); - for (size_t i = 0; i < tryNode.GetOffsetsCount(); ++i) { - tryMeStmt->OffsetsPushBack(tryNode.GetOffset(i)); - } - return tryMeStmt; - } - case OP_assertnonnull: - case OP_eval: - case OP_free: - case OP_switch: { - auto &unaryStmt = static_cast(stmt); - auto *unMeStmt = - static_cast((op == OP_switch) ? NewInPool(&stmt) : New(&stmt)); - unMeStmt->SetOpnd(0, BuildExpr(*unaryStmt.Opnd(0))); - return unMeStmt; - } - default: - CHECK_FATAL(false, "NYI"); - } -} - -MeStmt *IRMap::BuildDassignMeStmt(StmtNode &stmt, AccessSSANodes &ssaPart) { - auto *meStmt = NewInPool(&stmt); - auto &dassiNode = static_cast(stmt); - meStmt->SetRHS(BuildExpr(*dassiNode.GetRHS())); - auto *varLHS = static_cast(BuildLHSVar(*ssaPart.GetSSAVar(), *meStmt)); - meStmt->SetLHS(varLHS); - BuildChiList(*meStmt, ssaPart.GetMayDefNodes(), *meStmt->GetChiList()); - return meStmt; -} - -MeStmt *IRMap::BuildRegassignMeStmt(StmtNode &stmt, AccessSSANodes &ssaPart) { - auto *meStmt = New(&stmt); - auto ®Node = static_cast(stmt); - meStmt->SetRHS(BuildExpr(*regNode.Opnd(0))); - auto *regLHS = static_cast(BuildLHSReg(*ssaPart.GetSSAVar(), *meStmt, regNode)); - meStmt->SetLHS(regLHS); - return meStmt; -} - -MeStmt *IRMap::BuildIassignMeStmt(StmtNode &stmt, AccessSSANodes &ssaPart) { - auto &iasNode = static_cast(stmt); - auto *meStmt = NewInPool(&stmt); - meStmt->SetTyIdx(iasNode.GetTyIdx()); - meStmt->SetRHS(BuildExpr(*iasNode.GetRHS())); - meStmt->SetLHSVal(BuildLHSIvar(*BuildExpr(*iasNode.Opnd(0)), *meStmt, iasNode.GetFieldID())); - BuildChiList(*meStmt, ssaPart.GetMayDefNodes(), *(meStmt->GetChiList())); - return meStmt; -} - -MeStmt *IRMap::BuildMaydassignMeStmt(StmtNode &stmt, AccessSSANodes &ssaPart) { - auto *meStmt = NewInPool(&stmt); - auto &dassiNode = static_cast(stmt); - meStmt->SetRHS(BuildExpr(*dassiNode.GetRHS())); - meStmt->SetMayDassignSym(ssaPart.GetSSAVar()->GetOrigSt()); - meStmt->SetFieldID(dassiNode.GetFieldID()); - BuildChiList(*meStmt, ssaPart.GetMayDefNodes(), *(meStmt->GetChiList())); - return meStmt; -} - -MeStmt *IRMap::BuildCallMeStmt(StmtNode &stmt, AccessSSANodes &ssaPart) { - auto *callMeStmt = NewInPool(&stmt); - auto &intrinNode = static_cast(stmt); - callMeStmt->SetPUIdx(intrinNode.GetPUIdx()); - for (size_t i = 0; i < intrinNode.NumOpnds(); ++i) { - callMeStmt->PushBackOpnd(BuildExpr(*intrinNode.Opnd(i))); - } - BuildMuList(ssaPart.GetMayUseNodes(), *(callMeStmt->GetMuList())); - if (kOpcodeInfo.IsCallAssigned(stmt.GetOpCode())) { - BuildMustDefList(*callMeStmt, ssaPart.GetMustDefNodes(), *(callMeStmt->GetMustDefList())); - } - BuildChiList(*callMeStmt, ssaPart.GetMayDefNodes(), *(callMeStmt->GetChiList())); - return callMeStmt; -} - - -MeStmt *IRMap::BuildNaryMeStmt(StmtNode &stmt, AccessSSANodes &ssaPart) { - Opcode op = stmt.GetOpCode(); - NaryMeStmt *naryMeStmt = (op == OP_icall || op == OP_icallassigned) - ? static_cast(NewInPool(&stmt)) - : static_cast(NewInPool(&stmt)); - auto &naryStmtNode = static_cast(stmt); - for (size_t i = 0; i < naryStmtNode.NumOpnds(); ++i) { - naryMeStmt->PushBackOpnd(BuildExpr(*naryStmtNode.Opnd(i))); - } - BuildMuList(ssaPart.GetMayUseNodes(), *(naryMeStmt->GetMuList())); - if (kOpcodeInfo.IsCallAssigned(op)) { - BuildMustDefList(*naryMeStmt, ssaPart.GetMustDefNodes(), *(naryMeStmt->GetMustDefList())); - } - BuildChiList(*naryMeStmt, ssaPart.GetMayDefNodes(), *(naryMeStmt->GetChiList())); - return naryMeStmt; -} - -MeStmt *IRMap::BuildRetMeStmt(StmtNode &stmt, AccessSSANodes &ssaPart) { - auto &retStmt = static_cast(stmt); - auto *meStmt = NewInPool(&stmt); - for (size_t i = 0; i < retStmt.NumOpnds(); ++i) { - meStmt->PushBackOpnd(BuildExpr(*retStmt.Opnd(i))); - } - BuildMuList(ssaPart.GetMayUseNodes(), *(meStmt->GetMuList())); - return meStmt; -} - -MeStmt *IRMap::BuildWithMuMeStmt(StmtNode &stmt, AccessSSANodes &ssaPart) { - auto *retSub = NewInPool(&stmt); - BuildMuList(ssaPart.GetMayUseNodes(), *(retSub->GetMuList())); - return retSub; -} - -MeStmt *IRMap::BuildGosubMeStmt(StmtNode &stmt, AccessSSANodes &ssaPart) { - auto *goSub = NewInPool(&stmt); - BuildMuList(ssaPart.GetMayUseNodes(), *(goSub->GetMuList())); - return goSub; -} - -MeStmt *IRMap::BuildThrowMeStmt(StmtNode &stmt, AccessSSANodes &ssaPart) { - auto &unaryNode = static_cast(stmt); - auto *tmeStmt = NewInPool(&stmt); - tmeStmt->SetMeStmtOpndValue(BuildExpr(*unaryNode.Opnd(0))); - BuildMuList(ssaPart.GetMayUseNodes(), *(tmeStmt->GetMuList())); - return tmeStmt; -} - -MeStmt *IRMap::BuildSyncMeStmt(StmtNode &stmt, AccessSSANodes &ssaPart) { - auto &naryNode = static_cast(stmt); - auto *naryStmt = NewInPool(&stmt); - for (size_t i = 0; i < naryNode.NumOpnds(); ++i) { - naryStmt->PushBackOpnd(BuildExpr(*naryNode.Opnd(i))); - } - BuildMuList(ssaPart.GetMayUseNodes(), *(naryStmt->GetMuList())); - BuildChiList(*naryStmt, ssaPart.GetMayDefNodes(), *(naryStmt->GetChiList())); - return naryStmt; -} - -MeStmt *IRMap::BuildMeStmt(StmtNode &stmt) { - AccessSSANodes *ssaPart = ssaTab.GetStmtsSSAPart().SSAPartOf(stmt); - if (ssaPart == nullptr) { - return BuildMeStmtWithNoSSAPart(stmt); - } - - auto func = CreateProductFunction(stmt.GetOpCode()); - CHECK_FATAL(func != nullptr, "func nullptr check"); - return func(this, stmt, *ssaPart); -} - -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)); - } -} - -MeExpr *IRMap::BuildExpr(BaseNode &mirNode) { - Opcode op = mirNode.GetOpCode(); - if (op == OP_dread) { - auto &addrOfNode = static_cast(mirNode); - VersionSt *vst = addrOfNode.GetSSAVar(); - VarMeExpr *varMeExpr = GetOrCreateVarFromVerSt(*vst); - varMeExpr->InitBase(mirNode.GetOpCode(), mirNode.GetPrimType(), mirNode.GetNumOpnds()); - if (vst->GetOrigSt()->IsRealSymbol()) { - ASSERT(!vst->GetOrigSt()->IsPregOst(), "not expect preg symbol here"); - varMeExpr->SetPtyp(GlobalTables::GetTypeTable().GetTypeFromTyIdx(vst->GetOrigSt()->GetTyIdx())->GetPrimType()); - varMeExpr->SetFieldID(addrOfNode.GetFieldID()); - } - return varMeExpr; - } - - if (op == OP_regread) { - auto ®Node = static_cast(mirNode); - VersionSt *vst = regNode.GetSSAVar(); - RegMeExpr *regMeExpr = GetOrCreateRegFromVerSt(*vst); - regMeExpr->InitBase(mirNode.GetOpCode(), mirNode.GetPrimType(), mirNode.GetNumOpnds()); - return regMeExpr; - } - - MeExpr *meExpr = meBuilder.BuildMeExpr(mirNode); - SetMeExprOpnds(*meExpr, mirNode); - - if (op == OP_iread) { - auto *ivarMeExpr = static_cast(meExpr); - auto &iReadSSANode = static_cast(mirNode); - ivarMeExpr->SetBase(BuildExpr(*iReadSSANode.Opnd(0))); - VersionSt *verSt = iReadSSANode.GetSSAVar(); - if (verSt != nullptr) { - VarMeExpr *varMeExpr = GetOrCreateVarFromVerSt(*verSt); - ivarMeExpr->SetMuVal(varMeExpr); - } - } - - MeExpr *retMeExpr = HashMeExpr(*meExpr); - - if (op == OP_iread) { - ASSERT(static_cast(retMeExpr)->GetMu() != nullptr, "BuildExpr: ivar node cannot have mu == nullptr"); - } - - return retMeExpr; -} - -void IRMap::SetMeExprOpnds(MeExpr &meExpr, BaseNode &mirNode) { - auto &opMeExpr = static_cast(meExpr); - if (mirNode.IsUnaryNode()) { - if (mirNode.GetOpCode() != OP_iread) { - opMeExpr.SetOpnd(0, BuildExpr(*static_cast(mirNode).Opnd(0))); - } - } else if (mirNode.IsBinaryNode()) { - auto &binaryNode = static_cast(mirNode); - opMeExpr.SetOpnd(0, BuildExpr(*binaryNode.Opnd(0))); - opMeExpr.SetOpnd(1, BuildExpr(*binaryNode.Opnd(1))); - } else if (mirNode.IsTernaryNode()) { - auto &ternaryNode = static_cast(mirNode); - opMeExpr.SetOpnd(0, BuildExpr(*ternaryNode.Opnd(0))); - opMeExpr.SetOpnd(1, BuildExpr(*ternaryNode.Opnd(1))); - opMeExpr.SetOpnd(2, BuildExpr(*ternaryNode.Opnd(2))); - } else if (mirNode.IsNaryNode()) { - auto &naryMeExpr = static_cast(meExpr); - auto &naryNode = static_cast(mirNode); - for (size_t i = 0; i < naryNode.NumOpnds(); ++i) { - naryMeExpr.GetOpnds().push_back(BuildExpr(*naryNode.Opnd(i))); - } - } else { - // No need to do anything - } -} - void IRMap::PutToBucket(uint32 hashIdx, MeExpr &meExpr) { MeExpr *headExpr = hashTable[hashIdx]; if (headExpr != nullptr) { @@ -927,40 +540,4 @@ MeExpr *IRMap::CreateAddrofMeExprFromSymbol(MIRSymbol &st, PUIdx puIdx) { return HashMeExpr(addrOfMe); } -bool IRMap::InitMeStmtFactory() { - RegisterFactoryFunction(OP_dassign, &IRMap::BuildDassignMeStmt); - RegisterFactoryFunction(OP_regassign, &IRMap::BuildRegassignMeStmt); - RegisterFactoryFunction(OP_iassign, &IRMap::BuildIassignMeStmt); - RegisterFactoryFunction(OP_maydassign, &IRMap::BuildMaydassignMeStmt); - RegisterFactoryFunction(OP_call, &IRMap::BuildCallMeStmt); - RegisterFactoryFunction(OP_virtualcall, &IRMap::BuildCallMeStmt); - RegisterFactoryFunction(OP_virtualicall, &IRMap::BuildCallMeStmt); - RegisterFactoryFunction(OP_superclasscall, &IRMap::BuildCallMeStmt); - RegisterFactoryFunction(OP_interfacecall, &IRMap::BuildCallMeStmt); - RegisterFactoryFunction(OP_interfaceicall, &IRMap::BuildCallMeStmt); - RegisterFactoryFunction(OP_customcall, &IRMap::BuildCallMeStmt); - RegisterFactoryFunction(OP_polymorphiccall, &IRMap::BuildCallMeStmt); - RegisterFactoryFunction(OP_callassigned, &IRMap::BuildCallMeStmt); - RegisterFactoryFunction(OP_virtualcallassigned, &IRMap::BuildCallMeStmt); - RegisterFactoryFunction(OP_virtualicallassigned, &IRMap::BuildCallMeStmt); - RegisterFactoryFunction(OP_superclasscallassigned, &IRMap::BuildCallMeStmt); - RegisterFactoryFunction(OP_interfacecallassigned, &IRMap::BuildCallMeStmt); - RegisterFactoryFunction(OP_interfaceicallassigned, &IRMap::BuildCallMeStmt); - RegisterFactoryFunction(OP_customcallassigned, &IRMap::BuildCallMeStmt); - RegisterFactoryFunction(OP_polymorphiccallassigned, &IRMap::BuildCallMeStmt); - RegisterFactoryFunction(OP_icall, &IRMap::BuildNaryMeStmt); - RegisterFactoryFunction(OP_icallassigned, &IRMap::BuildNaryMeStmt); - RegisterFactoryFunction(OP_intrinsiccall, &IRMap::BuildNaryMeStmt); - RegisterFactoryFunction(OP_xintrinsiccall, &IRMap::BuildNaryMeStmt); - RegisterFactoryFunction(OP_intrinsiccallwithtype, &IRMap::BuildNaryMeStmt); - RegisterFactoryFunction(OP_intrinsiccallassigned, &IRMap::BuildNaryMeStmt); - RegisterFactoryFunction(OP_intrinsiccallwithtypeassigned, &IRMap::BuildNaryMeStmt); - RegisterFactoryFunction(OP_return, &IRMap::BuildRetMeStmt); - RegisterFactoryFunction(OP_retsub, &IRMap::BuildWithMuMeStmt); - RegisterFactoryFunction(OP_gosub, &IRMap::BuildGosubMeStmt); - RegisterFactoryFunction(OP_throw, &IRMap::BuildThrowMeStmt); - RegisterFactoryFunction(OP_syncenter, &IRMap::BuildSyncMeStmt); - RegisterFactoryFunction(OP_syncexit, &IRMap::BuildSyncMeStmt); - return true; -} } // namespace maple diff --git a/src/mapleall/maple_me/src/irmap_build.cpp b/src/mapleall/maple_me/src/irmap_build.cpp new file mode 100644 index 0000000000..dc628a4d8e --- /dev/null +++ b/src/mapleall/maple_me/src/irmap_build.cpp @@ -0,0 +1,445 @@ +/* + * Copyright (c) [2020] Huawei Technologies Co., Ltd. All rights reserved. + * + * OpenArkCompiler is licensed under the Mulan Permissive Software License v2. + * You can use this software according to the terms and conditions of the MulanPSL - 2.0. + * You may obtain a copy of MulanPSL - 2.0 at: + * + * https://opensource.org/licenses/MulanPSL-2.0 + * + * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER + * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR + * FIT FOR A PARTICULAR PURPOSE. + * See the MulanPSL - 2.0 for more details. + */ + +#include "factory.h" +#include "irmap_build.h" + +// Methods to convert Maple IR to MeIR + +namespace maple { +using MeStmtFactory = FunctionFactory; + +VarMeExpr *IRMapBuild::GetOrCreateVarFromVerSt(const VersionSt &vst) { + size_t vindex = vst.GetIndex(); + ASSERT(vindex < irMap->vst2MeExprTable.size(), "GetOrCreateVarFromVerSt: index %d is out of range", vindex); + MeExpr *meExpr = irMap->vst2MeExprTable.at(vindex); + if (meExpr != nullptr) { + return static_cast(meExpr); + } + const OriginalSt *ost = vst.GetOrigSt(); + ASSERT(ost->IsSymbolOst(), "GetOrCreateVarFromVerSt: wrong ost_type"); + auto *varx = irMap->New(&irMap->irMapAlloc, irMap->exprID++, ost->GetIndex(), vindex); + ASSERT(!GlobalTables::GetTypeTable().GetTypeTable().empty(), "container check"); + varx->InitBase(OP_dread, GlobalTables::GetTypeTable().GetTypeFromTyIdx(ost->GetTyIdx())->GetPrimType(), 0); + varx->SetFieldID(ost->GetFieldID()); + irMap->vst2MeExprTable[vindex] = varx; + return varx; +} + +RegMeExpr *IRMapBuild::GetOrCreateRegFromVerSt(const VersionSt &vst) { + size_t vindex = vst.GetIndex(); + ASSERT(vindex < irMap->vst2MeExprTable.size(), " GetOrCreateRegFromVerSt: index %d is out of range", vindex); + MeExpr *meExpr = irMap->vst2MeExprTable[vindex]; + if (meExpr != nullptr) { + return static_cast(meExpr); + } + const OriginalSt *ost = vst.GetOrigSt(); + ASSERT(ost->IsPregOst(), "GetOrCreateRegFromVerSt: PregOST expected"); + auto *regx = + irMap->NewInPool(irMap->exprID++, ost->GetPregIdx(), mirModule.CurFunction()->GetPuidx(), ost->GetIndex(), vindex); + regx->InitBase(OP_regread, ost->GetMIRPreg()->GetPrimType(), 0); + irMap->regMeExprTable.push_back(regx); + irMap->vst2MeExprTable[vindex] = regx; + return regx; +} + +MeExpr *IRMapBuild::BuildLHSVar(const VersionSt &vst, DassignMeStmt &defMeStmt) { + VarMeExpr *meDef = GetOrCreateVarFromVerSt(vst); + meDef->SetDefStmt(&defMeStmt); + meDef->SetDefBy(kDefByStmt); + irMap->vst2MeExprTable.at(vst.GetIndex()) = meDef; + return meDef; +} + +MeExpr *IRMapBuild::BuildLHSReg(const VersionSt &vst, RegassignMeStmt &defMeStmt, const RegassignNode ®assign) { + RegMeExpr *meDef = GetOrCreateRegFromVerSt(vst); + meDef->SetPtyp(regassign.GetPrimType()); + meDef->SetDefStmt(&defMeStmt); + meDef->SetDefBy(kDefByStmt); + irMap->vst2MeExprTable.at(vst.GetIndex()) = meDef; + return meDef; +} + +// build Me chilist from MayDefNode list +void IRMapBuild::BuildChiList(MeStmt &meStmt, TypeOfMayDefList &mayDefNodes, + MapleMap &outList) { + for (auto &mayDefNode : mayDefNodes) { + VersionSt *opndSt = mayDefNode.GetOpnd(); + VersionSt *resSt = mayDefNode.GetResult(); + auto *chiMeStmt = irMap->New(&meStmt); + chiMeStmt->SetRHS(GetOrCreateVarFromVerSt(*opndSt)); + VarMeExpr *lhs = GetOrCreateVarFromVerSt(*resSt); + lhs->SetDefBy(kDefByChi); + lhs->SetDefChi(*chiMeStmt); + chiMeStmt->SetLHS(lhs); + outList.insert(std::make_pair(lhs->GetOStIdx(), chiMeStmt)); + } +} + +void IRMapBuild::BuildMustDefList(MeStmt &meStmt, TypeOfMustDefList &mustDefList, + MapleVector &mustDefMeList) { + for (auto &mustDefNode : mustDefList) { + VersionSt *vst = mustDefNode.GetResult(); + VarMeExpr *lhs = GetOrCreateVarFromVerSt(*vst); + ASSERT(lhs->GetMeOp() == kMeOpReg || lhs->GetMeOp() == kMeOpVar, "unexpected opcode"); + mustDefMeList.push_back(MustDefMeNode(lhs, &meStmt)); + } +} + +void IRMapBuild::BuildPhiMeNode(BB &bb) { + for (auto &phi : bb.GetPhiList()) { + const OriginalSt *oSt = ssaTab.GetOriginalStFromID(phi.first); + VersionSt *vSt = phi.second.GetResult(); + + auto *phiMeNode = irMap->NewInPool(); + phiMeNode->SetDefBB(&bb); + (void)bb.GetMePhiList().insert(std::make_pair(oSt->GetIndex(), phiMeNode)); + if (oSt->IsPregOst()) { + RegMeExpr *meDef = GetOrCreateRegFromVerSt(*vSt); + phiMeNode->UpdateLHS(*meDef); + // build phi operands + for (VersionSt *opnd : phi.second.GetPhiOpnds()) { + phiMeNode->GetOpnds().push_back(GetOrCreateRegFromVerSt(*opnd)); + } + } else { + VarMeExpr *meDef = GetOrCreateVarFromVerSt(*vSt); + phiMeNode->UpdateLHS(*meDef); + // build phi operands + for (VersionSt *opnd : phi.second.GetPhiOpnds()) { + phiMeNode->GetOpnds().push_back(GetOrCreateVarFromVerSt(*opnd)); + } + } + } +} + +void IRMapBuild::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)); + } +} + +void IRMapBuild::SetMeExprOpnds(MeExpr &meExpr, BaseNode &mirNode) { + auto &opMeExpr = static_cast(meExpr); + if (mirNode.IsUnaryNode()) { + if (mirNode.GetOpCode() != OP_iread) { + opMeExpr.SetOpnd(0, BuildExpr(*static_cast(mirNode).Opnd(0))); + } + } else if (mirNode.IsBinaryNode()) { + auto &binaryNode = static_cast(mirNode); + opMeExpr.SetOpnd(0, BuildExpr(*binaryNode.Opnd(0))); + opMeExpr.SetOpnd(1, BuildExpr(*binaryNode.Opnd(1))); + } else if (mirNode.IsTernaryNode()) { + auto &ternaryNode = static_cast(mirNode); + opMeExpr.SetOpnd(0, BuildExpr(*ternaryNode.Opnd(0))); + opMeExpr.SetOpnd(1, BuildExpr(*ternaryNode.Opnd(1))); + opMeExpr.SetOpnd(2, BuildExpr(*ternaryNode.Opnd(2))); + } else if (mirNode.IsNaryNode()) { + auto &naryMeExpr = static_cast(meExpr); + auto &naryNode = static_cast(mirNode); + for (size_t i = 0; i < naryNode.NumOpnds(); ++i) { + naryMeExpr.GetOpnds().push_back(BuildExpr(*naryNode.Opnd(i))); + } + } else { + // No need to do anything + } +} + +MeExpr *IRMapBuild::BuildExpr(BaseNode &mirNode) { + Opcode op = mirNode.GetOpCode(); + if (op == OP_dread) { + auto &addrOfNode = static_cast(mirNode); + VersionSt *vst = addrOfNode.GetSSAVar(); + VarMeExpr *varMeExpr = GetOrCreateVarFromVerSt(*vst); + varMeExpr->InitBase(mirNode.GetOpCode(), mirNode.GetPrimType(), mirNode.GetNumOpnds()); + if (vst->GetOrigSt()->IsRealSymbol()) { + ASSERT(!vst->GetOrigSt()->IsPregOst(), "not expect preg symbol here"); + varMeExpr->SetPtyp(GlobalTables::GetTypeTable().GetTypeFromTyIdx(vst->GetOrigSt()->GetTyIdx())->GetPrimType()); + varMeExpr->SetFieldID(addrOfNode.GetFieldID()); + } + return varMeExpr; + } + + if (op == OP_regread) { + auto ®Node = static_cast(mirNode); + VersionSt *vst = regNode.GetSSAVar(); + RegMeExpr *regMeExpr = GetOrCreateRegFromVerSt(*vst); + regMeExpr->InitBase(mirNode.GetOpCode(), mirNode.GetPrimType(), mirNode.GetNumOpnds()); + return regMeExpr; + } + + MeExpr *meExpr = irMap->meBuilder.BuildMeExpr(mirNode); + SetMeExprOpnds(*meExpr, mirNode); + + if (op == OP_iread) { + auto *ivarMeExpr = static_cast(meExpr); + auto &iReadSSANode = static_cast(mirNode); + ivarMeExpr->SetBase(BuildExpr(*iReadSSANode.Opnd(0))); + VersionSt *verSt = iReadSSANode.GetSSAVar(); + if (verSt != nullptr) { + VarMeExpr *varMeExpr = GetOrCreateVarFromVerSt(*verSt); + ivarMeExpr->SetMuVal(varMeExpr); + } + } + + MeExpr *retMeExpr = irMap->HashMeExpr(*meExpr); + + if (op == OP_iread) { + ASSERT(static_cast(retMeExpr)->GetMu() != nullptr, "BuildExpr: ivar node cannot have mu == nullptr"); + } + + return retMeExpr; +} + +MeStmt *IRMapBuild::BuildMeStmtWithNoSSAPart(StmtNode &stmt) { + Opcode op = stmt.GetOpCode(); + switch (op) { + case OP_jscatch: + case OP_finally: + case OP_endtry: + case OP_cleanuptry: + case OP_membaracquire: + case OP_membarrelease: + case OP_membarstorestore: + case OP_membarstoreload: + return irMap->New(&stmt); + case OP_goto: + return irMap->New(&stmt); + case OP_comment: + return irMap->NewInPool(&stmt); + case OP_jstry: + return irMap->New(&stmt); + case OP_catch: + return irMap->NewInPool(&stmt); + case OP_brfalse: + case OP_brtrue: { + auto &condGotoNode = static_cast(stmt); + auto *condGotoMeStmt = irMap->New(&stmt); + condGotoMeStmt->SetOpnd(0, BuildExpr(*condGotoNode.Opnd(0))); + return condGotoMeStmt; + } + case OP_try: { + auto &tryNode = static_cast(stmt); + auto *tryMeStmt = irMap->NewInPool(&stmt); + for (size_t i = 0; i < tryNode.GetOffsetsCount(); ++i) { + tryMeStmt->OffsetsPushBack(tryNode.GetOffset(i)); + } + return tryMeStmt; + } + case OP_assertnonnull: + case OP_eval: + case OP_free: + case OP_switch: { + auto &unaryStmt = static_cast(stmt); + auto *unMeStmt = + static_cast((op == OP_switch) ? irMap->NewInPool(&stmt) : irMap->New(&stmt)); + unMeStmt->SetOpnd(0, BuildExpr(*unaryStmt.Opnd(0))); + return unMeStmt; + } + default: + CHECK_FATAL(false, "NYI"); + } +} + +MeStmt *IRMapBuild::BuildDassignMeStmt(StmtNode &stmt, AccessSSANodes &ssaPart) { + auto *meStmt = irMap->NewInPool(&stmt); + auto &dassiNode = static_cast(stmt); + meStmt->SetRHS(BuildExpr(*dassiNode.GetRHS())); + auto *varLHS = static_cast(BuildLHSVar(*ssaPart.GetSSAVar(), *meStmt)); + meStmt->SetLHS(varLHS); + BuildChiList(*meStmt, ssaPart.GetMayDefNodes(), *meStmt->GetChiList()); + return meStmt; +} + +MeStmt *IRMapBuild::BuildRegassignMeStmt(StmtNode &stmt, AccessSSANodes &ssaPart) { + auto *meStmt = irMap->New(&stmt); + auto ®Node = static_cast(stmt); + meStmt->SetRHS(BuildExpr(*regNode.Opnd(0))); + auto *regLHS = static_cast(BuildLHSReg(*ssaPart.GetSSAVar(), *meStmt, regNode)); + meStmt->SetLHS(regLHS); + return meStmt; +} + +MeStmt *IRMapBuild::BuildIassignMeStmt(StmtNode &stmt, AccessSSANodes &ssaPart) { + auto &iasNode = static_cast(stmt); + auto *meStmt = irMap->NewInPool(&stmt); + meStmt->SetTyIdx(iasNode.GetTyIdx()); + meStmt->SetRHS(BuildExpr(*iasNode.GetRHS())); + meStmt->SetLHSVal(irMap->BuildLHSIvar(*BuildExpr(*iasNode.Opnd(0)), *meStmt, iasNode.GetFieldID())); + BuildChiList(*meStmt, ssaPart.GetMayDefNodes(), *(meStmt->GetChiList())); + return meStmt; +} + +MeStmt *IRMapBuild::BuildMaydassignMeStmt(StmtNode &stmt, AccessSSANodes &ssaPart) { + auto *meStmt = irMap->NewInPool(&stmt); + auto &dassiNode = static_cast(stmt); + meStmt->SetRHS(BuildExpr(*dassiNode.GetRHS())); + meStmt->SetMayDassignSym(ssaPart.GetSSAVar()->GetOrigSt()); + meStmt->SetFieldID(dassiNode.GetFieldID()); + BuildChiList(*meStmt, ssaPart.GetMayDefNodes(), *(meStmt->GetChiList())); + return meStmt; +} + +MeStmt *IRMapBuild::BuildCallMeStmt(StmtNode &stmt, AccessSSANodes &ssaPart) { + auto *callMeStmt = irMap->NewInPool(&stmt); + auto &intrinNode = static_cast(stmt); + callMeStmt->SetPUIdx(intrinNode.GetPUIdx()); + for (size_t i = 0; i < intrinNode.NumOpnds(); ++i) { + callMeStmt->PushBackOpnd(BuildExpr(*intrinNode.Opnd(i))); + } + BuildMuList(ssaPart.GetMayUseNodes(), *(callMeStmt->GetMuList())); + if (kOpcodeInfo.IsCallAssigned(stmt.GetOpCode())) { + BuildMustDefList(*callMeStmt, ssaPart.GetMustDefNodes(), *(callMeStmt->GetMustDefList())); + } + BuildChiList(*callMeStmt, ssaPart.GetMayDefNodes(), *(callMeStmt->GetChiList())); + return callMeStmt; +} + + +MeStmt *IRMapBuild::BuildNaryMeStmt(StmtNode &stmt, AccessSSANodes &ssaPart) { + Opcode op = stmt.GetOpCode(); + NaryMeStmt *naryMeStmt = (op == OP_icall || op == OP_icallassigned) + ? static_cast(irMap->NewInPool(&stmt)) + : static_cast(irMap->NewInPool(&stmt)); + auto &naryStmtNode = static_cast(stmt); + for (size_t i = 0; i < naryStmtNode.NumOpnds(); ++i) { + naryMeStmt->PushBackOpnd(BuildExpr(*naryStmtNode.Opnd(i))); + } + BuildMuList(ssaPart.GetMayUseNodes(), *(naryMeStmt->GetMuList())); + if (kOpcodeInfo.IsCallAssigned(op)) { + BuildMustDefList(*naryMeStmt, ssaPart.GetMustDefNodes(), *(naryMeStmt->GetMustDefList())); + } + BuildChiList(*naryMeStmt, ssaPart.GetMayDefNodes(), *(naryMeStmt->GetChiList())); + return naryMeStmt; +} + +MeStmt *IRMapBuild::BuildRetMeStmt(StmtNode &stmt, AccessSSANodes &ssaPart) { + auto &retStmt = static_cast(stmt); + auto *meStmt = irMap->NewInPool(&stmt); + for (size_t i = 0; i < retStmt.NumOpnds(); ++i) { + meStmt->PushBackOpnd(BuildExpr(*retStmt.Opnd(i))); + } + BuildMuList(ssaPart.GetMayUseNodes(), *(meStmt->GetMuList())); + return meStmt; +} + +MeStmt *IRMapBuild::BuildWithMuMeStmt(StmtNode &stmt, AccessSSANodes &ssaPart) { + auto *retSub = irMap->NewInPool(&stmt); + BuildMuList(ssaPart.GetMayUseNodes(), *(retSub->GetMuList())); + return retSub; +} + +MeStmt *IRMapBuild::BuildGosubMeStmt(StmtNode &stmt, AccessSSANodes &ssaPart) { + auto *goSub = irMap->NewInPool(&stmt); + BuildMuList(ssaPart.GetMayUseNodes(), *(goSub->GetMuList())); + return goSub; +} + +MeStmt *IRMapBuild::BuildThrowMeStmt(StmtNode &stmt, AccessSSANodes &ssaPart) { + auto &unaryNode = static_cast(stmt); + auto *tmeStmt = irMap->NewInPool(&stmt); + tmeStmt->SetMeStmtOpndValue(BuildExpr(*unaryNode.Opnd(0))); + BuildMuList(ssaPart.GetMayUseNodes(), *(tmeStmt->GetMuList())); + return tmeStmt; +} + +MeStmt *IRMapBuild::BuildSyncMeStmt(StmtNode &stmt, AccessSSANodes &ssaPart) { + auto &naryNode = static_cast(stmt); + auto *naryStmt = irMap->NewInPool(&stmt); + for (size_t i = 0; i < naryNode.NumOpnds(); ++i) { + naryStmt->PushBackOpnd(BuildExpr(*naryNode.Opnd(i))); + } + BuildMuList(ssaPart.GetMayUseNodes(), *(naryStmt->GetMuList())); + BuildChiList(*naryStmt, ssaPart.GetMayDefNodes(), *(naryStmt->GetChiList())); + return naryStmt; +} + +MeStmt *IRMapBuild::BuildMeStmt(StmtNode &stmt) { + AccessSSANodes *ssaPart = ssaTab.GetStmtsSSAPart().SSAPartOf(stmt); + if (ssaPart == nullptr) { + return BuildMeStmtWithNoSSAPart(stmt); + } + + auto func = CreateProductFunction(stmt.GetOpCode()); + CHECK_FATAL(func != nullptr, "func nullptr check"); + return func(this, stmt, *ssaPart); +} + +bool IRMapBuild::InitMeStmtFactory() { + RegisterFactoryFunction(OP_dassign, &IRMapBuild::BuildDassignMeStmt); + RegisterFactoryFunction(OP_regassign, &IRMapBuild::BuildRegassignMeStmt); + RegisterFactoryFunction(OP_iassign, &IRMapBuild::BuildIassignMeStmt); + RegisterFactoryFunction(OP_maydassign, &IRMapBuild::BuildMaydassignMeStmt); + RegisterFactoryFunction(OP_call, &IRMapBuild::BuildCallMeStmt); + RegisterFactoryFunction(OP_virtualcall, &IRMapBuild::BuildCallMeStmt); + RegisterFactoryFunction(OP_virtualicall, &IRMapBuild::BuildCallMeStmt); + RegisterFactoryFunction(OP_superclasscall, &IRMapBuild::BuildCallMeStmt); + RegisterFactoryFunction(OP_interfacecall, &IRMapBuild::BuildCallMeStmt); + RegisterFactoryFunction(OP_interfaceicall, &IRMapBuild::BuildCallMeStmt); + RegisterFactoryFunction(OP_customcall, &IRMapBuild::BuildCallMeStmt); + RegisterFactoryFunction(OP_polymorphiccall, &IRMapBuild::BuildCallMeStmt); + RegisterFactoryFunction(OP_callassigned, &IRMapBuild::BuildCallMeStmt); + RegisterFactoryFunction(OP_virtualcallassigned, &IRMapBuild::BuildCallMeStmt); + RegisterFactoryFunction(OP_virtualicallassigned, &IRMapBuild::BuildCallMeStmt); + RegisterFactoryFunction(OP_superclasscallassigned, &IRMapBuild::BuildCallMeStmt); + RegisterFactoryFunction(OP_interfacecallassigned, &IRMapBuild::BuildCallMeStmt); + RegisterFactoryFunction(OP_interfaceicallassigned, &IRMapBuild::BuildCallMeStmt); + RegisterFactoryFunction(OP_customcallassigned, &IRMapBuild::BuildCallMeStmt); + RegisterFactoryFunction(OP_polymorphiccallassigned, &IRMapBuild::BuildCallMeStmt); + RegisterFactoryFunction(OP_icall, &IRMapBuild::BuildNaryMeStmt); + RegisterFactoryFunction(OP_icallassigned, &IRMapBuild::BuildNaryMeStmt); + RegisterFactoryFunction(OP_intrinsiccall, &IRMapBuild::BuildNaryMeStmt); + RegisterFactoryFunction(OP_xintrinsiccall, &IRMapBuild::BuildNaryMeStmt); + RegisterFactoryFunction(OP_intrinsiccallwithtype, &IRMapBuild::BuildNaryMeStmt); + RegisterFactoryFunction(OP_intrinsiccallassigned, &IRMapBuild::BuildNaryMeStmt); + RegisterFactoryFunction(OP_intrinsiccallwithtypeassigned, &IRMapBuild::BuildNaryMeStmt); + RegisterFactoryFunction(OP_return, &IRMapBuild::BuildRetMeStmt); + RegisterFactoryFunction(OP_retsub, &IRMapBuild::BuildWithMuMeStmt); + RegisterFactoryFunction(OP_gosub, &IRMapBuild::BuildGosubMeStmt); + RegisterFactoryFunction(OP_throw, &IRMapBuild::BuildThrowMeStmt); + RegisterFactoryFunction(OP_syncenter, &IRMapBuild::BuildSyncMeStmt); + RegisterFactoryFunction(OP_syncexit, &IRMapBuild::BuildSyncMeStmt); + return true; +} + +// recursively invoke itself in a pre-order traversal of the dominator tree of +// the CFG to build the HSSA representation for the code in each BB +void IRMapBuild::BuildBB(BB &bb, std::vector &bbIRMapProcessed) { + BBId bbID = bb.GetBBId(); + if (bbIRMapProcessed[bbID]) { + return; + } + bbIRMapProcessed[bbID] = true; + curBB = &bb; + irMap->SetCurFunction(bb); + // iterate phi list to update the definition by phi + BuildPhiMeNode(bb); + if (!bb.IsEmpty()) { + for (auto &stmt : bb.GetStmtNodes()) { + MeStmt *meStmt = BuildMeStmt(stmt); + bb.AddMeStmtLast(meStmt); + } + } + // travesal bb's dominated tree + ASSERT(bbID < dominance.GetDomChildrenSize(), " index out of range in IRMapBuild::BuildBB"); + const MapleSet &domChildren = dominance.GetDomChildren(bbID); + for (auto bbIt = domChildren.begin(); bbIt != domChildren.end(); ++bbIt) { + BBId childBBId = *bbIt; + BuildBB(*irMap->GetBB(childBBId), bbIRMapProcessed); + } +} + +} // namespace maple diff --git a/src/mapleall/maple_me/src/irmap_emit.cpp b/src/mapleall/maple_me/src/irmap_emit.cpp index e8e3454d92..830e3322dc 100755 --- a/src/mapleall/maple_me/src/irmap_emit.cpp +++ b/src/mapleall/maple_me/src/irmap_emit.cpp @@ -564,4 +564,32 @@ StmtNode &AssertMeStmt::EmitStmt(SSATab &ssaTab) { assertStmt->SetSrcPos(GetSrcPosition()); return *assertStmt; } + +void BB::EmitBB(SSATab &ssaTab, BlockNode &curblk, bool needAnotherPass) { + // emit head. label + LabelIdx labidx = GetBBLabel(); + if (labidx != 0) { + LabelNode *lbnode = ssaTab.GetModule().CurFunction()->GetCodeMempool()->New(); + lbnode->SetLabelIdx(labidx); + curblk.AddStatement(lbnode); + } + auto &meStmts = GetMeStmts(); + for (auto &meStmt : meStmts) { + if (!needAnotherPass) { + if (meStmt.GetOp() == OP_interfaceicall) { + meStmt.SetOp(OP_icall); + } else if (meStmt.GetOp() == OP_interfaceicallassigned) { + meStmt.SetOp(OP_icallassigned); + } + } + StmtNode &stmt = meStmt.EmitStmt(ssaTab); + curblk.AddStatement(&stmt); + } + if (GetAttributes(kBBAttrIsTryEnd)) { + // generate op_endtry + StmtNode *endtry = ssaTab.GetModule().CurFunction()->GetCodeMempool()->New(OP_endtry); + curblk.AddStatement(endtry); + } +} + } // namespace maple diff --git a/src/mapleall/maple_me/src/me_abco.cpp b/src/mapleall/maple_me/src/me_abco.cpp index 34b0c8766b..e293b9c1a3 100755 --- a/src/mapleall/maple_me/src/me_abco.cpp +++ b/src/mapleall/maple_me/src/me_abco.cpp @@ -1070,7 +1070,7 @@ AnalysisResult *MeDoABCOpt::Run(MeFunction *func, MeFuncResultMgr *frm, ModuleRe CHECK_FATAL(frm != nullptr, "frm is nullptr"); auto *dom = static_cast(frm->GetAnalysisResult(MeFuncPhase_DOMINANCE, func)); CHECK_FATAL(dom != nullptr, "dominance phase has problem"); - auto *irMap = static_cast(frm->GetAnalysisResult(MeFuncPhase_IRMAP, func)); + auto *irMap = static_cast(frm->GetAnalysisResult(MeFuncPhase_IRMAPBUILD, func)); CHECK_FATAL(irMap != nullptr, "irMap phase has problem"); MemPool *abcoMemPool = NewMemPool(); MeABC meABC(*func, *dom, *irMap, *abcoMemPool); diff --git a/src/mapleall/maple_me/src/me_analyze_rc.cpp b/src/mapleall/maple_me/src/me_analyze_rc.cpp index b7b07c85c0..894521f056 100755 --- a/src/mapleall/maple_me/src/me_analyze_rc.cpp +++ b/src/mapleall/maple_me/src/me_analyze_rc.cpp @@ -436,7 +436,7 @@ AnalysisResult *MeDoAnalyzeRC::Run(MeFunction *func, MeFuncResultMgr *m, ModuleR ASSERT(dom != nullptr, "dominance phase has problem"); auto *aliasClass = static_cast(m->GetAnalysisResult(MeFuncPhase_ALIASCLASS, func)); ASSERT(aliasClass != nullptr, "aliasClass phase has problem"); - ASSERT_NOT_NULL(m->GetAnalysisResult(MeFuncPhase_IRMAP, func)); + ASSERT_NOT_NULL(m->GetAnalysisResult(MeFuncPhase_IRMAPBUILD, func)); if (DEBUGFUNC(func)) { LogInfo::Info() << " Processing " << func->GetMirFunc()->GetName() << '\n'; } diff --git a/src/mapleall/maple_me/src/me_analyzector.cpp b/src/mapleall/maple_me/src/me_analyzector.cpp index 4664f54025..bf1407f4eb 100644 --- a/src/mapleall/maple_me/src/me_analyzector.cpp +++ b/src/mapleall/maple_me/src/me_analyzector.cpp @@ -84,7 +84,7 @@ AnalysisResult *MeDoAnalyzeCtor::Run(MeFunction *func, MeFuncResultMgr *m, Modul auto *dom = static_cast(m->GetAnalysisResult(MeFuncPhase_DOMINANCE, func)); auto *kh = static_cast(moduleResultMgr->GetAnalysisResult(MoPhase_CHA, &func->GetMIRModule())); ASSERT_NOT_NULL(dom); - ASSERT_NOT_NULL(m->GetAnalysisResult(MeFuncPhase_IRMAP, func)); + ASSERT_NOT_NULL(m->GetAnalysisResult(MeFuncPhase_IRMAPBUILD, func)); AnalyzeCtor analyzeCtor(*func, *dom, *kh); analyzeCtor.ProcessFunc(); return nullptr; diff --git a/src/mapleall/maple_me/src/me_emit.cpp b/src/mapleall/maple_me/src/me_emit.cpp index f21ac0b7c1..e47871b954 100644 --- a/src/mapleall/maple_me/src/me_emit.cpp +++ b/src/mapleall/maple_me/src/me_emit.cpp @@ -41,7 +41,7 @@ AnalysisResult *MeDoEmit::Run(MeFunction *func, MeFuncResultMgr*, ModuleResultMg } for (BB *bb : layoutBBs) { ASSERT(bb != nullptr, "Check bblayout phase"); - func->GetIRMap()->EmitBB(*bb, *mirFunction->GetBody()); + bb->EmitBB(*func->GetMeSSATab(), *mirFunction->GetBody(), false); } if (DEBUGFUNC(func)) { LogInfo::MapleLogger() << "\n==============after meemit =============" << '\n'; diff --git a/src/mapleall/maple_me/src/me_hdse.cpp b/src/mapleall/maple_me/src/me_hdse.cpp index 5e2bdb02af..2eada8ff53 100755 --- a/src/mapleall/maple_me/src/me_hdse.cpp +++ b/src/mapleall/maple_me/src/me_hdse.cpp @@ -96,7 +96,7 @@ void MeHDSE::RunHDSE() { AnalysisResult *MeDoHDSE::Run(MeFunction *func, MeFuncResultMgr *m, ModuleResultMgr*) { auto *postDom = static_cast(m->GetAnalysisResult(MeFuncPhase_DOMINANCE, func)); CHECK_NULL_FATAL(postDom); - auto *hMap = static_cast(m->GetAnalysisResult(MeFuncPhase_IRMAP, func)); + auto *hMap = static_cast(m->GetAnalysisResult(MeFuncPhase_IRMAPBUILD, func)); CHECK_NULL_FATAL(hMap); MeHDSE hdse(*func, *postDom, *hMap, DEBUGFUNC(func)); hdse.RunHDSE(); diff --git a/src/mapleall/maple_me/src/me_irmap.cpp b/src/mapleall/maple_me/src/me_irmap.cpp index c65ef93cf4..ef0205420d 100755 --- a/src/mapleall/maple_me/src/me_irmap.cpp +++ b/src/mapleall/maple_me/src/me_irmap.cpp @@ -13,19 +13,8 @@ * See the Mulan PSL v2 for more details. */ #include "me_irmap.h" -#include "dominance.h" -#include "mir_builder.h" namespace maple { -void MeIRMap::DumpBB(const BB &bb) { - int i = 0; - for (const auto &meStmt : bb.GetMeStmts()) { - if (GetDumpStmtNum()) { - LogInfo::MapleLogger() << "(" << i++ << ") "; - } - meStmt.Dump(this); - } -} void MeIRMap::Dump() { // back up mempool and use a new mempool every time @@ -56,74 +45,4 @@ void MeIRMap::Dump() { mirFunction->SetMemPool(backup); } -// this function only emits statement -void MeIRMap::EmitBBStmts(BB &bb, BlockNode &curblk) { - auto &meStmts = bb.GetMeStmts(); - for (auto &meStmt : meStmts) { - if (!GetNeedAnotherPass()) { - if (meStmt.GetOp() == OP_interfaceicall) { - meStmt.SetOp(OP_icall); - } else if (meStmt.GetOp() == OP_interfaceicallassigned) { - meStmt.SetOp(OP_icallassigned); - } - } - StmtNode &stmt = meStmt.EmitStmt(GetSSATab()); - curblk.AddStatement(&stmt); - } -} - -void MeIRMap::EmitBB(BB &bb, BlockNode &curblk) { - // emit head. label - LabelIdx labidx = bb.GetBBLabel(); - if (labidx != 0) { - // not a empty bb - LabelNode *lbnode = GetSSATab().GetModule().CurFunction()->GetCodeMempool()->New(); - lbnode->SetLabelIdx(labidx); - curblk.AddStatement(lbnode); - } - EmitBBStmts(bb, curblk); - if (bb.GetAttributes(kBBAttrIsTryEnd)) { - // generate op_endtry - StmtNode *endtry = GetSSATab().GetModule().CurFunction()->GetCodeMempool()->New(OP_endtry); - curblk.AddStatement(endtry); - } -} - -AnalysisResult *MeDoIRMap::Run(MeFunction *func, MeFuncResultMgr *funcResMgr, ModuleResultMgr*) { - auto *dom = static_cast(funcResMgr->GetAnalysisResult(MeFuncPhase_DOMINANCE, func)); - ASSERT(dom != nullptr, "dominance phase has problem"); - MemPool *irMapMemPool = NewMemPool(); - MeIRMap *irMap = irMapMemPool->New(*func, *dom, *irMapMemPool, *NewMemPool()); - func->SetIRMap(irMap); -#if DEBUG - globalIRMap = irMap; -#endif - std::vector bbIRMapProcessed(func->NumBBs(), false); - irMap->BuildBB(*func->GetCommonEntryBB(), bbIRMapProcessed); - if (DEBUGFUNC(func)) { - irMap->Dump(); - } - irMap->GetTempAlloc().SetMemPool(nullptr); - // delete input IR code for current function - MIRFunction *mirFunc = func->GetMirFunc(); - mirFunc->GetCodeMempool()->Release(); - mirFunc->SetCodeMemPool(nullptr); - // delete versionst_table -#if MIR_FEATURE_FULL - // nullify all references to the versionst_table contents - for (size_t i = 0; i < func->GetMeSSATab()->GetVersionStTable().GetVersionStVectorSize(); ++i) { - func->GetMeSSATab()->GetVersionStTable().SetVersionStVectorItem(i, nullptr); - } - // clear BB's phi_list_ which uses versionst; nullify first_stmt_, last_stmt_ - auto eIt = func->valid_end(); - for (auto bIt = func->valid_begin(); bIt != eIt; ++bIt) { - auto *bb = *bIt; - bb->ClearPhiList(); - bb->SetFirst(nullptr); - bb->SetLast(nullptr); - } -#endif - func->GetMeSSATab()->GetVersionStTable().GetVSTAlloc().GetMemPool()->Release(); - return irMap; -} } // namespace maple diff --git a/src/mapleall/maple_me/src/me_irmap_build.cpp b/src/mapleall/maple_me/src/me_irmap_build.cpp new file mode 100644 index 0000000000..2050e30776 --- /dev/null +++ b/src/mapleall/maple_me/src/me_irmap_build.cpp @@ -0,0 +1,67 @@ +/* + * Copyright (c) [2020] Huawei Technologies Co., Ltd. All rights reserved. + * + * OpenArkCompiler is licensed under the Mulan Permissive Software License v2. + * You can use this software according to the terms and conditions of the MulanPSL - 2.0. + * You may obtain a copy of MulanPSL - 2.0 at: + * + * https://opensource.org/licenses/MulanPSL-2.0 + * + * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER + * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR + * FIT FOR A PARTICULAR PURPOSE. + * See the MulanPSL - 2.0 for more details. + */ + +#include "me_irmap_build.h" +#include "me_ssa.h" +#include "me_prop.h" +#include "me_alias_class.h" +#include "me_dse.h" + +// This phase converts Maple IR to MeIR. + +namespace maple { + +AnalysisResult *MeDoIRMapBuild::Run(MeFunction *func, MeFuncResultMgr *funcResMgr, ModuleResultMgr *moduleResMgr) { + Dominance *dom = static_cast(funcResMgr->GetAnalysisResult(MeFuncPhase_DOMINANCE, func)); + CHECK_FATAL(dom, "dominance phase has problem"); + + MemPool *irmapmp = NewMemPool(); + + MeIRMap *irMap = irmapmp->New(*func, *irmapmp); + func->SetIRMap(irMap); +#if DEBUG + globalIRMap = irMap; +#endif + IRMapBuild irmapbuild(irMap, dom); + std::vector bbIrmapProcessed(func->NumBBs(), false); + irmapbuild.BuildBB(*func->GetCommonEntryBB(), bbIrmapProcessed); + if (DEBUGFUNC(func)) { + irMap->Dump(); + } + + // delete mempool for meirmap temporaries + // delete input IR code for current function + MIRFunction *mirFunc = func->GetMirFunc(); + mirFunc->GetCodeMempool()->Release(); + mirFunc->SetCodeMemPool(nullptr); + + // delete versionst_table + // nullify all references to the versionst_table contents + for (uint32 i = 0; i < func->GetMeSSATab()->GetVersionStTable().GetVersionStVectorSize(); i++) { + func->GetMeSSATab()->GetVersionStTable().SetVersionStVectorItem(i, nullptr); + } + // clear BB's phiList which uses versionst; nullify first_stmt_, last_stmt_ + auto eIt = func->valid_end(); + for (auto bIt = func->valid_begin(); bIt != eIt; ++bIt) { + auto *bb = *bIt; + bb->ClearPhiList(); + bb->SetFirst(nullptr); + bb->SetLast(nullptr); + } + func->GetMeSSATab()->GetVersionStTable().GetVSTAlloc().GetMemPool()->Release(); + return irMap; +} + +} // namespace maple diff --git a/src/mapleall/maple_me/src/me_phase_manager.cpp b/src/mapleall/maple_me/src/me_phase_manager.cpp index 3111b0e214..4c9f24f4cd 100644 --- a/src/mapleall/maple_me/src/me_phase_manager.cpp +++ b/src/mapleall/maple_me/src/me_phase_manager.cpp @@ -44,7 +44,7 @@ #include "me_may2dassign.h" #include "me_loop_analysis.h" #include "me_ssa.h" -#include "me_irmap.h" +#include "me_irmap_build.h" #include "me_bb_layout.h" #include "me_emit.h" #include "me_rc_lowering.h" diff --git a/src/mapleall/maple_me/src/me_profile_gen.cpp b/src/mapleall/maple_me/src/me_profile_gen.cpp index 8e6bb280b0..8b2616ff8f 100644 --- a/src/mapleall/maple_me/src/me_profile_gen.cpp +++ b/src/mapleall/maple_me/src/me_profile_gen.cpp @@ -153,7 +153,7 @@ AnalysisResult *MeDoProfGen::Run(MeFunction *func, MeFuncResultMgr *m, ModuleRes return nullptr; } - auto *hMap = static_cast(m->GetAnalysisResult(MeFuncPhase_IRMAP, func)); + auto *hMap = static_cast(m->GetAnalysisResult(MeFuncPhase_IRMAPBUILD, func)); CHECK_FATAL(hMap != nullptr, "hssamap is nullptr"); MeProfGen profGen(*func, *tempMp, *hMap, DEBUGFUNC(func)); if (!profGen.CanInstrument()) { diff --git a/src/mapleall/maple_me/src/me_prop.cpp b/src/mapleall/maple_me/src/me_prop.cpp index ff5c1137f3..e81d8c4b19 100644 --- a/src/mapleall/maple_me/src/me_prop.cpp +++ b/src/mapleall/maple_me/src/me_prop.cpp @@ -29,7 +29,7 @@ AnalysisResult *MeDoMeProp::Run(MeFunction *func, MeFuncResultMgr *m, ModuleResu CHECK_NULL_FATAL(func); auto *dom = static_cast(m->GetAnalysisResult(MeFuncPhase_DOMINANCE, func)); CHECK_NULL_FATAL(dom); - auto *hMap = static_cast(m->GetAnalysisResult(MeFuncPhase_IRMAP, func)); + auto *hMap = static_cast(m->GetAnalysisResult(MeFuncPhase_IRMAPBUILD, func)); CHECK_NULL_FATAL(hMap); bool propIloadRef = MeOption::propIloadRef; MeProp meProp(*hMap, *dom, *NewMemPool(), Prop::PropConfig { MeOption::propBase, propIloadRef, diff --git a/src/mapleall/maple_me/src/me_rc_lowering.cpp b/src/mapleall/maple_me/src/me_rc_lowering.cpp index 46abe6f56d..2b30f3f352 100644 --- a/src/mapleall/maple_me/src/me_rc_lowering.cpp +++ b/src/mapleall/maple_me/src/me_rc_lowering.cpp @@ -1006,7 +1006,7 @@ VarMeExpr *RCLowering::CreateNewTmpVarMeExpr(bool isLocalRefVar) { AnalysisResult *MeDoRCLowering::Run(MeFunction *func, MeFuncResultMgr *funcResMgr, ModuleResultMgr *moduleResMgr) { if (func->GetIRMap() == nullptr) { - auto *hmap = static_cast(funcResMgr->GetAnalysisResult(MeFuncPhase_IRMAP, func)); + auto *hmap = static_cast(funcResMgr->GetAnalysisResult(MeFuncPhase_IRMAPBUILD, func)); CHECK_FATAL(hmap != nullptr, "hssamap has problem"); func->SetIRMap(hmap); } diff --git a/src/mapleall/maple_me/src/me_rename2preg.cpp b/src/mapleall/maple_me/src/me_rename2preg.cpp index 38f4badaa6..92eb146dd4 100755 --- a/src/mapleall/maple_me/src/me_rename2preg.cpp +++ b/src/mapleall/maple_me/src/me_rename2preg.cpp @@ -30,7 +30,7 @@ using namespace maple; // Part1: Generalize GetAnalysisResult from MeFuncResultMgr template struct ExtractPhaseClass {}; -template <> struct ExtractPhaseClass { +template <> struct ExtractPhaseClass { using Type = MeIRMap; }; @@ -231,7 +231,7 @@ class SSARename2Preg { bool emptyFunc = func.empty(); if (!emptyFunc) { MeFuncResultMgr &funcRst = utils::ToRef(pFuncRst); - MeIRMap &irMap = utils::ToRef(GetAnalysisResult(func, funcRst)); + MeIRMap &irMap = utils::ToRef(GetAnalysisResult(func, funcRst)); const AliasClass &aliasClass = utils::ToRef(GetAnalysisResult(func, funcRst)); cacheProxy.Init(utils::ToRef(ssaTab), irMap); diff --git a/src/mapleall/maple_me/src/me_ssa_devirtual.cpp b/src/mapleall/maple_me/src/me_ssa_devirtual.cpp index 6385c8388e..1a064301ac 100644 --- a/src/mapleall/maple_me/src/me_ssa_devirtual.cpp +++ b/src/mapleall/maple_me/src/me_ssa_devirtual.cpp @@ -20,7 +20,7 @@ namespace maple { AnalysisResult *MeDoSSADevirtual::Run(MeFunction *func, MeFuncResultMgr *frm, ModuleResultMgr *mrm) { auto *dom = static_cast(frm->GetAnalysisResult(MeFuncPhase_DOMINANCE, func)); ASSERT(dom != nullptr, "dominance phase has problem"); - auto *irMap = static_cast(frm->GetAnalysisResult(MeFuncPhase_IRMAP, func)); + auto *irMap = static_cast(frm->GetAnalysisResult(MeFuncPhase_IRMAPBUILD, func)); ASSERT(irMap != nullptr, "hssaMap has problem"); CHECK_FATAL(mrm != nullptr, "Needs module result manager for ipa"); auto *kh = static_cast(mrm->GetAnalysisResult(MoPhase_CHA, &func->GetMIRModule())); diff --git a/src/mapleall/maple_me/src/me_ssa_epre.cpp b/src/mapleall/maple_me/src/me_ssa_epre.cpp index 5a8a366794..e5f2ce56ea 100644 --- a/src/mapleall/maple_me/src/me_ssa_epre.cpp +++ b/src/mapleall/maple_me/src/me_ssa_epre.cpp @@ -66,7 +66,7 @@ AnalysisResult *MeDoSSAEPre::Run(MeFunction *func, MeFuncResultMgr *m, ModuleRes } auto *dom = static_cast(m->GetAnalysisResult(MeFuncPhase_DOMINANCE, func)); ASSERT(dom != nullptr, "dominance phase has problem"); - auto *irMap = static_cast(m->GetAnalysisResult(MeFuncPhase_IRMAP, func)); + auto *irMap = static_cast(m->GetAnalysisResult(MeFuncPhase_IRMAPBUILD, func)); ASSERT(irMap != nullptr, "irMap phase has problem"); KlassHierarchy *kh = static_cast(mrm->GetAnalysisResult(MoPhase_CHA, &func->GetMIRModule())); CHECK_FATAL(kh != nullptr, "KlassHierarchy phase has problem"); diff --git a/src/mapleall/maple_me/src/me_ssa_lpre.cpp b/src/mapleall/maple_me/src/me_ssa_lpre.cpp index 9603331e06..fc3a5f93cf 100755 --- a/src/mapleall/maple_me/src/me_ssa_lpre.cpp +++ b/src/mapleall/maple_me/src/me_ssa_lpre.cpp @@ -356,7 +356,7 @@ AnalysisResult *MeDoSSALPre::Run(MeFunction *irFunc, MeFuncResultMgr *funcMgr, M } auto *dom = static_cast(funcMgr->GetAnalysisResult(MeFuncPhase_DOMINANCE, irFunc)); CHECK_NULL_FATAL(dom); - auto *irMap = static_cast(funcMgr->GetAnalysisResult(MeFuncPhase_IRMAP, irFunc)); + auto *irMap = static_cast(funcMgr->GetAnalysisResult(MeFuncPhase_IRMAPBUILD, irFunc)); CHECK_NULL_FATAL(irMap); auto *identLoops = static_cast(funcMgr->GetAnalysisResult(MeFuncPhase_MELOOP, irFunc)); CHECK_NULL_FATAL(identLoops); diff --git a/src/mapleall/maple_me/src/me_stmt_pre.cpp b/src/mapleall/maple_me/src/me_stmt_pre.cpp index 5caf262d46..5ad849d27f 100755 --- a/src/mapleall/maple_me/src/me_stmt_pre.cpp +++ b/src/mapleall/maple_me/src/me_stmt_pre.cpp @@ -1060,7 +1060,7 @@ void MeStmtPre::RemoveUnnecessaryDassign(DassignMeStmt &dssMeStmt) { AnalysisResult *MeDoStmtPre::Run(MeFunction *func, MeFuncResultMgr *m, ModuleResultMgr*) { auto *dom = static_cast(m->GetAnalysisResult(MeFuncPhase_DOMINANCE, func)); ASSERT(dom != nullptr, "dominance phase has problem"); - auto *irMap = static_cast(m->GetAnalysisResult(MeFuncPhase_IRMAP, func)); + auto *irMap = static_cast(m->GetAnalysisResult(MeFuncPhase_IRMAPBUILD, func)); ASSERT(irMap != nullptr, "irMap phase has problem"); MeStmtPre ssaPre(*func, *irMap, *dom, *NewMemPool(), *NewMemPool(), MeOption::stmtprePULimit); if (DEBUGFUNC(func)) { diff --git a/src/mapleall/maple_me/src/me_store_pre.cpp b/src/mapleall/maple_me/src/me_store_pre.cpp index cf0f99ce94..2644fc151f 100755 --- a/src/mapleall/maple_me/src/me_store_pre.cpp +++ b/src/mapleall/maple_me/src/me_store_pre.cpp @@ -359,7 +359,7 @@ AnalysisResult *MeDoStorePre::Run(MeFunction *func, MeFuncResultMgr *m, ModuleRe ASSERT(dom != nullptr, "dominance phase has problem"); auto *aliasClass = static_cast(m->GetAnalysisResult(MeFuncPhase_ALIASCLASS, func)); ASSERT(aliasClass != nullptr, "aliasClass phase has problem"); - auto *meIrMap = static_cast(m->GetAnalysisResult(MeFuncPhase_IRMAP, func)); + auto *meIrMap = static_cast(m->GetAnalysisResult(MeFuncPhase_IRMAPBUILD, func)); CHECK_FATAL(meIrMap != nullptr, "irmap phase has problem"); MeStorePre storePre(*func, *dom, *aliasClass, *NewMemPool(), DEBUGFUNC(func)); storePre.ApplySSUPre(); diff --git a/src/mapleall/maple_me/src/preg_renamer.cpp b/src/mapleall/maple_me/src/preg_renamer.cpp index fd0c2b701c..86e182863d 100755 --- a/src/mapleall/maple_me/src/preg_renamer.cpp +++ b/src/mapleall/maple_me/src/preg_renamer.cpp @@ -118,7 +118,7 @@ void PregRenamer::RunSelf() const { } AnalysisResult *MeDoPregRename::Run(MeFunction *func, MeFuncResultMgr *m, ModuleResultMgr*) { - auto *irMap = static_cast(m->GetAnalysisResult(MeFuncPhase_IRMAP, func)); + auto *irMap = static_cast(m->GetAnalysisResult(MeFuncPhase_IRMAPBUILD, func)); PregRenamer pregRenamer(*NewMemPool(), *func, *irMap, DEBUGFUNC(func)); pregRenamer.RunSelf(); if (DEBUGFUNC(func)) { -- Gitee