diff --git a/BUILD.gn b/BUILD.gn index 8234000518b9dc231f4c0076d40f24c45466a9ce..c676707f30e1b6697a43603eaa4eb8d45b202a91 100644 --- a/BUILD.gn +++ b/BUILD.gn @@ -14,6 +14,12 @@ # group("maple") { deps = [ - "${MAPLE_ROOT}/src:mapleall", + "${MAPLE_ROOT}/src:maple", + ] +} + +group("irbuild") { + deps = [ + "${MAPLE_ROOT}/src:irbuild", ] } diff --git a/Makefile b/Makefile index 93e1c4f54164b3fd760ad15c06f48221edb9ea78..4476332ddf1953aa6e9c476238a963bc92af660a 100644 --- a/Makefile +++ b/Makefile @@ -18,12 +18,16 @@ GN_OPTIONS := \ .PHONY: default default: install -.PHONY: mapleall -mapleall: +.PHONY: maple +maple: $(call build_gn, ${GN_OPTIONS}, maple) +.PHONY: irbuild +irbuild: + $(call build_gn, ${GN_OPTIONS}, irbuild) + .PHONY: install -install: mapleall +install: maple $(shell cp -rf $(MAPLE_ROOT)/src/bin/java2jar $(MAPLE_ROOT)/output/bin/) $(shell cp -rf $(MAPLE_ROOT)/src/bin/jbc2mpl $(MAPLE_ROOT)/output/bin/) $(shell cp -rf $(MAPLE_ROOT)/src/bin/mplcg $(MAPLE_ROOT)/output/bin/) diff --git a/build/core/maple_variables.mk b/build/core/maple_variables.mk index ee8aad33aaab12a37a1d0aab76773cb0e6d0f0b9..a22709431047dccb5f149dd6805368d694770fde 100644 --- a/build/core/maple_variables.mk +++ b/build/core/maple_variables.mk @@ -1,4 +1,4 @@ -OPT := O2 +OPT := O0 TARGETS := $(APP) LIB_CORE_PATH := $(MAPLE_ROOT)/libjava-core LIB_CORE_JAR := $(LIB_CORE_PATH)/java-core.jar diff --git a/src/BUILD.gn b/src/BUILD.gn index 7eabe88f0288d70440bdbeb7155ea06af1381681..efd7c929f29a3456c0fd8d8f04b65352ab5d7b74 100644 --- a/src/BUILD.gn +++ b/src/BUILD.gn @@ -39,9 +39,14 @@ config("mapleallcompilecfg") { } } -group("mapleall") { +group("maple") { deps = [ "${MAPLEALL_ROOT}/maple_driver:maple", + ] +} + +group("irbuild") { + deps = [ "${MAPLEALL_ROOT}/maple_ir:irbuild", ] } diff --git a/src/bin/java2jar b/src/bin/java2jar index fc2f6ff4b00a6bea8383fb28fbf6ab4a2ca035f7..7a71b265d51f333ee8d53696d45d5b419e0d4d2f 100755 --- a/src/bin/java2jar +++ b/src/bin/java2jar @@ -1,4 +1,18 @@ #!/bin/bash +# +# Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved. +# +# OpenArkCompiler is licensed under the Mulan PSL v1. +# You can use this software according to the terms and conditions of the Mulan PSL v1. +# You may obtain a copy of Mulan PSL v1 at: +# +# http://license.coscl.org.cn/MulanPSL +# +# THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER +# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR +# FIT FOR A PARTICULAR PURPOSE. +# See the Mulan PSL v1 for more details. +# OUTPUT=$1 CORE_ALL_JAR=$2 shift 2 diff --git a/src/bin/jbc2mpl b/src/bin/jbc2mpl index 533b0e70294bee769f0a157593c237a1066d25fd..f237e75637a62d90494319513a0b5061a062c801 100755 Binary files a/src/bin/jbc2mpl and b/src/bin/jbc2mpl differ diff --git a/src/bin/maple b/src/bin/maple index 7b1df1d335758d9eca85649f2d95cf52f6e53235..c7babb022b31a154dc38c7b8e536ee2ac5bc1f33 100755 Binary files a/src/bin/maple and b/src/bin/maple differ diff --git a/src/deplibs/libmempool.a b/src/deplibs/libmempool.a index 066f7a9dabcc000800d57886e713198b1b695ea5..5e9b75bfaf73fb004915be4a57fc6cb13e3987b2 100644 Binary files a/src/deplibs/libmempool.a and b/src/deplibs/libmempool.a differ diff --git a/src/deplibs/libmplutil.a b/src/deplibs/libmplutil.a index edece5d0ce158215d482cf9b5fea3ec72caeb5ba..838dedf1acb41a13899bb28bb184efb2cd5b703d 100644 Binary files a/src/deplibs/libmplutil.a and b/src/deplibs/libmplutil.a differ diff --git a/src/maple_driver/include/compiler.h b/src/maple_driver/include/compiler.h index a02e31768a1ec83d456811279af5e6ee83f46e43..ae4875a788d09582de27a45cc80468e1f266885e 100644 --- a/src/maple_driver/include/compiler.h +++ b/src/maple_driver/include/compiler.h @@ -117,8 +117,7 @@ class MapleCombCompiler : public Compiler { private: std::string realRunningExe; void DecideMeRealLevel(MeOption &meOption, const std::vector &inputOptions); - void DecideMpl2MplRealLevel(Options &mpl2mplOption, const std::vector &inputOptions, - const MplOptions &options); + void DecideMpl2MplRealLevel(Options &mpl2mplOption, const std::vector &inputOptions) const; std::unordered_set GetFinalOutputs(const MplOptions &mplOptions) const override; void GetTmpFilesToDelete(const MplOptions &mplOptions, std::vector &tempFiles) const override; MeOption *MakeMeOptions(const MplOptions &options, MemPool &memPool); diff --git a/src/maple_driver/src/maple_comb_compiler.cpp b/src/maple_driver/src/maple_comb_compiler.cpp index 8e8db44416dd3a924b4af7fb4e9caa9dea14169c..a3657bf2f56d25de2d6e253fa064f7dd71dc25b4 100644 --- a/src/maple_driver/src/maple_comb_compiler.cpp +++ b/src/maple_driver/src/maple_comb_compiler.cpp @@ -279,8 +279,7 @@ MeOption *MapleCombCompiler::MakeMeOptions(const MplOptions &options, MemPool &o } void MapleCombCompiler::DecideMpl2MplRealLevel(Options &mpl2mplOption, - const std::vector &inputOptions, - const MplOptions &options) { + const std::vector &inputOptions) const { for (const mapleOption::Option &opt : inputOptions) { if (opt.Index() == kMpl2MplOptL2) { mpl2mplOption.O2 = true; @@ -297,7 +296,7 @@ Options *MapleCombCompiler::MakeMpl2MplOptions(const MplOptions &options, MemPoo LogInfo::MapleLogger() << "no mpl2mpl input options\n"; return mpl2mplOption; } - DecideMpl2MplRealLevel(*mpl2mplOption, it->second, options); + DecideMpl2MplRealLevel(*mpl2mplOption, it->second); for (const mapleOption::Option &opt : it->second) { if (options.HasSetDebugFlag()) { LogInfo::MapleLogger() << "mpl2mpl options: " << opt.Index() << " " << opt.OptionKey() << " " << opt.Args() diff --git a/src/maple_ipa/src/callgraph.cpp b/src/maple_ipa/src/callgraph.cpp index 340c9b2c1b68aedcdfea7354c0c32ab520bd737a..efd6061f4b628ab0820922c02ed45a133547f892 100644 --- a/src/maple_ipa/src/callgraph.cpp +++ b/src/maple_ipa/src/callgraph.cpp @@ -105,7 +105,7 @@ void CGNode::DumpDetail() const { CallInfo *ci = callSite.first; CGNode *node = cgIt; MIRFunction *mf = node->GetMIRFunction(); - if (mf) { + if (mf != nullptr) { LogInfo::MapleLogger() << "\tcallee in module : " << mf->GetName() << " "; } else { LogInfo::MapleLogger() << "\tcallee external: " << ci->GetCalleeName(); @@ -131,12 +131,12 @@ void CGNode::Dump(std::ofstream &fout) const { for (auto &cgIt : *callSite.second) { CallInfo *ci = callSite.first; CGNode *node = cgIt; - if (!node) { + if (node == nullptr) { continue; } MIRFunction *func = node->GetMIRFunction(); fout << "\"" << mirFunc->GetName() << "\" -> "; - if (func) { + if (func != nullptr) { if (node->GetSCCNode() != nullptr && node->GetSCCNode()->GetCGNodes().size() > 1) { fout << "\"" << func->GetName() << "\"[label=" << node->GetSCCNode()->id << " color=red];\n"; } else { @@ -447,7 +447,7 @@ void CallGraph::HandleBody(MIRFunction *func, BlockNode *body, CGNode *node, uin CallInfo *callInfo = GenCallInfo(kCallTypeVirtualCall, calleefunc, stmt, loopDepth, stmt->GetStmtID()); // Retype makes object type more inaccurate. StmtNode *stmtPrev = static_cast(stmt)->GetPrev(); - if (stmtPrev && stmtPrev->GetOpCode() == OP_dassign) { + if (stmtPrev != nullptr && stmtPrev->GetOpCode() == OP_dassign) { DassignNode *dassignNode = static_cast(stmtPrev); if (dassignNode->GetRHS()->GetOpCode() == OP_retype) { CallNode *callNode = static_cast(stmt); @@ -538,7 +538,7 @@ void CallGraph::HandleBody(MIRFunction *func, BlockNode *body, CGNode *node, uin } } } - if (!cands || cands->empty()) { + if (cands == nullptr || cands->empty()) { continue; // Fix CI } MIRFunction *actualMirfunc = cands->at(0); @@ -600,7 +600,7 @@ static void ResetInferredType(std::vector &inferredSymbols) { } static void ResetInferredType(std::vector &inferredSymbols, MIRSymbol *s) { - if (!s) { + if (s == nullptr) { return; } if (s->GetInferredTyIdx() == kInitTyIdx || s->GetInferredTyIdx() == kNoneTyIdx) { @@ -988,7 +988,7 @@ void DoDevirtual(const Klass *klass, const KlassHierarchy *klassh) { for (MIRFunction *const &method : iklass->GetMethods()) { if (calleefunc->GetBaseFuncNameWithTypeStrIdx() == method->GetBaseFuncNameWithTypeStrIdx() && !method->GetFuncAttrs().GetAttr(FUNCATTR_abstract)) { - if (!tmpInterface || klassh->IsSuperKlassForInterface(tmpInterface, iklass)) { + if (tmpInterface == nullptr || klassh->IsSuperKlassForInterface(tmpInterface, iklass)) { tmpInterface = iklass; tmpMethod = method; } @@ -1038,7 +1038,7 @@ void DoDevirtual(const Klass *klass, const KlassHierarchy *klassh) { } else { targetKlass = klassh->GetKlassFromTyIdx(retType->GetTypeIndex()); } - if (!targetKlass && !isCalleeScalar) { + if (targetKlass == nullptr && !isCalleeScalar) { CHECK_FATAL(targetKlass != nullptr, "null ptr check"); } Klass *curRetKlass = nullptr; @@ -1056,7 +1056,7 @@ void DoDevirtual(const Klass *klass, const KlassHierarchy *klassh) { } else { tmpKlass = klassh->GetKlassFromTyIdx(tmpType->GetTypeIndex()); } - if (!tmpKlass && !isCurrVtabScalar) { + if (tmpKlass == nullptr && !isCurrVtabScalar) { CHECK_FATAL(tmpKlass != nullptr, "null ptr check"); } if (isCalleeScalar || isCurrVtabScalar) { @@ -1087,7 +1087,7 @@ void DoDevirtual(const Klass *klass, const KlassHierarchy *klassh) { tmpMethod = method; } if (!tmpKlass->IsClass() && klassh->IsSuperKlassForInterface(tmpKlass, targetKlass) && - (!curRetKlass || klassh->IsSuperKlass(curRetKlass, tmpKlass))) { + (curRetKlass == nullptr || klassh->IsSuperKlass(curRetKlass, tmpKlass))) { curRetKlass = tmpKlass; tmpMethod = method; } @@ -1100,7 +1100,7 @@ void DoDevirtual(const Klass *klass, const KlassHierarchy *klassh) { << " is not found in DeVirtual!" << std::endl; stmt->SetOpCode(OP_callassigned); break; - } else if (!tmpMethod) { + } else if (tmpMethod == nullptr) { LogInfo::MapleLogger() << "Error: func " << calleefunc->GetName() << " is not found!" << std::endl; ASSERT(tmpMethod, "Must not be null"); } @@ -1272,7 +1272,7 @@ void CallGraph::GenCallGraph() { for (auto it = GlobalTables::GetFunctionTable().GetFuncTable().begin(); it != GlobalTables::GetFunctionTable().GetFuncTable().end(); it++) { MIRFunction *mirFunc = *it; - if (!mirFunc || !mirFunc->GetBody()) { + if (mirFunc == nullptr || mirFunc->GetBody() == nullptr) { continue; } mirModule->SetCurFunction(mirFunc); @@ -1394,7 +1394,7 @@ bool SCCNode::HasRecursion() const { for (auto &callSite : node->GetCallee()) { for (auto &cgIt : *callSite.second) { CGNode *calleeNode = cgIt; - if (!calleeNode) { + if (calleeNode == nullptr) { continue; } if (node == calleeNode) { @@ -1501,7 +1501,7 @@ void SCCNode::Setup() { for (auto &callSite : node->GetCallee()) { for (auto &cgIt : *callSite.second) { CGNode *calleeNode = cgIt; - if (!calleeNode) { + if (calleeNode == nullptr) { continue; } if (calleeNode->GetSCCNode() == this) { @@ -1534,7 +1534,7 @@ void CallGraph::BuildSCCDFS(CGNode *caller, uint32 &visitIndex, std::vectorGetCallee()) { for (auto &cgIt : *callSite.second) { CGNode *calleeNode = cgIt; - if (!calleeNode) { + if (calleeNode == nullptr) { continue; } uint32 calleeId = calleeNode->GetID(); @@ -1645,9 +1645,9 @@ void CGNode::AddCandsForCallNode(const KlassHierarchy *kh) { } CHECK_FATAL(mirFunc != nullptr, ""); Klass *klass = kh->GetKlassFromFunc(mirFunc); - if (klass) { + if (klass != nullptr) { MapleVector *v = klass->GetCandidates(mirFunc->GetBaseFuncNameWithTypeStrIdx()); - if (v) { + if (v != nullptr) { vcallCands = *v; // Vector copy } } @@ -1667,7 +1667,7 @@ MIRFunction *CGNode::HasOneCandidate() const { } if (!vcallCands[i]->IsEmpty()) { count++; - if (!cand) { + if (cand == nullptr) { cand = vcallCands[i]; } } diff --git a/src/maple_ir/include/intrinsics.def b/src/maple_ir/include/intrinsics.def index 5bb44c353218a73019335e5bdd3aab30aafe7d8c..fe33c4bfeb9af60bc3e3e16246d116d11919cc31 100644 --- a/src/maple_ir/include/intrinsics.def +++ b/src/maple_ir/include/intrinsics.def @@ -1,5 +1,5 @@ /* - * Copyright (c) [2019] Huawei Technologies Co.,Ltd.All rights reserved. + * Copyright (c) [2019-2020] Huawei Technologies Co.,Ltd.All rights reserved. * * OpenArkCompiler is licensed under the Mulan PSL v1. * You can use this software according to the terms and conditions of the Mulan PSL v1. @@ -18,7 +18,7 @@ DEF_MIR_INTRINSIC(UNDEFINED,\ DEF_MIR_INTRINSIC(MPL_ATOMIC_EXCHANGE_PTR,\ "__mpl_atomic_exchange_ptr", kIntrnIsAtomic, kArgTyPtr, kArgTyPtr, kArgTyUndef, kArgTyUndef, kArgTyUndef, kArgTyUndef, kArgTyUndef) DEF_MIR_INTRINSIC(MPL_CLINIT_CHECK,\ - "__mpl_clinit_check", INTRNISJAVA | INTRNNOSIDEEFFECT, kArgTyVoid, kArgTyDynany, kArgTyUndef, kArgTyUndef, kArgTyUndef, kArgTyUndef, kArgTyUndef) + "__mpl_clinit_check", INTRNISJAVA | INTRNNOSIDEEFFECT | INTRNISSPECIAL, kArgTyVoid, kArgTyDynany, kArgTyUndef, kArgTyUndef, kArgTyUndef, kArgTyUndef, kArgTyUndef) DEF_MIR_INTRINSIC(MPL_CLEAR_STACK,\ "__mpl_clear_stack", kIntrnUndef, kArgTyVoid, kArgTyDynany, kArgTyDynany, kArgTyUndef, kArgTyUndef, kArgTyUndef, kArgTyUndef) DEF_MIR_INTRINSIC(MPL_GET_VTAB_FUNC,\ @@ -32,7 +32,7 @@ DEF_MIR_INTRINSIC(MPL_READ_OVTABLE_ENTRY2,\ DEF_MIR_INTRINSIC(MPL_READ_OVTABLE_ENTRY_LAZY,\ "__mpl_const_offset_lazy", INTRNNOSIDEEFFECT, kArgTyA32, kArgTyDynany, kArgTyUndef, kArgTyUndef, kArgTyUndef, kArgTyUndef, kArgTyUndef) DEF_MIR_INTRINSIC(MPL_READ_OVTABLE_ENTRY_VTAB_LAZY,\ - "__mpl_const_offset_vtab_lazy", INTRNISPURE, kArgTyA32, kArgTyDynany, kArgTyDynany, kArgTyDynany, kArgTyUndef, kArgTyUndef, kArgTyUndef) + "__mpl_const_offset_vtab_lazy", INTRNISPURE, kArgTyDynany, kArgTyDynany, kArgTyDynany, kArgTyDynany, kArgTyUndef, kArgTyUndef, kArgTyUndef) DEF_MIR_INTRINSIC(MPL_READ_OVTABLE_ENTRY_FIELD_LAZY,\ "__mpl_const_offset_field_lazy", INTRNISPURE, kArgTyA32, kArgTyDynany, kArgTyDynany, kArgTyDynany, kArgTyUndef, kArgTyUndef, kArgTyUndef) DEF_MIR_INTRINSIC(MPL_BOUNDARY_CHECK,\ @@ -53,6 +53,8 @@ DEF_MIR_INTRINSIC(MCCSetObjectPermanent,\ "MCC_SetObjectPermanent", INTRNISRC | INTRNNOSIDEEFFECT, kArgTyVoid, kArgTyRef) // start of RC Intrinsics with two parameters +DEF_MIR_INTRINSIC(MCCCheckArrayStore,\ + "MCC_Reflect_Check_Arraystore", INTRNISRC | INTRNNOSIDEEFFECT, kArgTyVoid, kArgTyRef, kArgTyRef) DEF_MIR_INTRINSIC(MCCIncDecRef,\ "MCC_IncDecRef_NaiveRCFast", INTRNISRC | INTRNNOSIDEEFFECT, kArgTyVoid, kArgTyRef, kArgTyRef) DEF_MIR_INTRINSIC(MCCIncDecRefReset,\ @@ -109,19 +111,20 @@ DEF_MIR_INTRINSIC(MCCWriteWeak,\ "MCC_WriteWeakField", INTRNISRC | INTRNNOSIDEEFFECT, kArgTyVoid, kArgTyRef, kArgTyRef, kArgTyRef) DEF_MIR_INTRINSIC(MPL_CLEANUP_LOCALREFVARS,\ - "__mpl_cleanup_localrefvars", INTRNISJAVA | INTRNNOSIDEEFFECT, kArgTyUndef, kArgTyRef, kArgTyRef, kArgTyRef, kArgTyRef, kArgTyRef, kArgTyRef) + "__mpl_cleanup_localrefvars", INTRNISJAVA | INTRNNOSIDEEFFECT | INTRNISSPECIAL, kArgTyUndef, kArgTyRef, kArgTyRef, kArgTyRef, kArgTyRef, kArgTyRef, kArgTyRef) DEF_MIR_INTRINSIC(MPL_CLEANUP_LOCALREFVARS_SKIP,\ - "__mpl_cleanup_localrefvars_skip", INTRNISJAVA | INTRNNOSIDEEFFECT, kArgTyUndef, kArgTyRef, kArgTyRef, kArgTyRef, kArgTyRef, kArgTyRef, kArgTyRef) + "__mpl_cleanup_localrefvars_skip", INTRNISJAVA | INTRNNOSIDEEFFECT | INTRNISSPECIAL, kArgTyUndef, kArgTyRef, kArgTyRef, kArgTyRef, kArgTyRef, kArgTyRef, kArgTyRef) DEF_MIR_INTRINSIC(MPL_MEMSET_LOCALVAR,\ "", kIntrnUndef, kArgTyPtr, kArgTyU32, kArgTyU8, kArgTyU32, kArgTyUndef, kArgTyUndef, kArgTyUndef) DEF_MIR_INTRINSIC(MPL_SET_CLASS,\ "", kIntrnUndef, kArgTyPtr, kArgTyPtr, kArgTyUndef, kArgTyUndef, kArgTyUndef, kArgTyUndef, kArgTyUndef) DEF_MIR_INTRINSIC(MPL_CLEANUP_NORETESCOBJS,\ - "__mpl_cleanup_noretescobjs", INTRNISJAVA | INTRNNOSIDEEFFECT, kArgTyUndef, kArgTyRef, kArgTyRef,\ + "__mpl_cleanup_noretescobjs", INTRNISJAVA | INTRNNOSIDEEFFECT | INTRNISSPECIAL, kArgTyUndef, kArgTyRef, kArgTyRef,\ kArgTyRef, kArgTyRef, kArgTyRef, kArgTyRef) // start of GC Intrinsics #include "intrinsic_java.def" +#include "simplifyintrinsics.def" DEF_MIR_INTRINSIC(LAST,\ nullptr, kIntrnUndef, kArgTyUndef, kArgTyUndef, kArgTyUndef, kArgTyUndef, kArgTyUndef, kArgTyUndef, kArgTyUndef) diff --git a/src/maple_ir/include/intrinsics.h b/src/maple_ir/include/intrinsics.h index d9c3ae5ceac66b6ba3a5a28f74ae1d9f3b2ac1ff..90cd0d1bbfda80defc572e8aecf142cd24b984aa 100644 --- a/src/maple_ir/include/intrinsics.h +++ b/src/maple_ir/include/intrinsics.h @@ -1,5 +1,5 @@ /* - * Copyright (c) [2019] Huawei Technologies Co.,Ltd.All rights reserved. + * Copyright (c) [2019-2020] Huawei Technologies Co.,Ltd.All rights reserved. * * OpenArkCompiler is licensed under the Mulan PSL v1. * You can use this software according to the terms and conditions of the Mulan PSL v1. @@ -32,7 +32,8 @@ enum IntrinProperty { kIntrnIsPure, kIntrnNeverReturn, kIntrnIsAtomic, - kIntrnIsRC + kIntrnIsRC, + kIntrnIsSpecial }; enum IntrinArgType { @@ -85,6 +86,7 @@ constexpr uint32 INTRNISPURE = 1U << kIntrnIsPure; constexpr uint32 INTRNNEVERRETURN = 1U << kIntrnNeverReturn; constexpr uint32 INTRNATOMIC = 1U << kIntrnIsAtomic; constexpr uint32 INTRNISRC = 1U << kIntrnIsRC; +constexpr uint32 INTRNISSPECIAL = 1U << kIntrnIsSpecial; class MIRType; // circular dependency exists, no other choice class MIRModule; // circular dependency exists, no other choice struct IntrinDesc { @@ -93,47 +95,51 @@ struct IntrinDesc { uint32 properties; IntrinArgType argTypes[1 + kMaxArgsNum]; // argTypes[0] is the return type bool IsJS() const { - return properties & INTRNISJS; + return static_cast(properties & INTRNISJS); } bool IsJava() const { - return properties & INTRNISJAVA; + return static_cast(properties & INTRNISJAVA); } bool IsJsUnary() const { - return properties & INTRNISJSUNARY; + return static_cast(properties & INTRNISJSUNARY); } bool IsJsBinary() const { - return properties & INTRNISJSBINARY; + return static_cast(properties & INTRNISJSBINARY); } bool IsJsOp() const { - return (properties & INTRNISJSUNARY) || (properties & INTRNISJSBINARY); + return static_cast(properties & INTRNISJSUNARY) || static_cast(properties & INTRNISJSBINARY); } bool IsLoadMem() const { - return properties & INTRNLOADMEM; + return static_cast(properties & INTRNLOADMEM); } bool IsJsReturnStruct() const { - return properties & INTRNRETURNSTRUCT; + return static_cast(properties & INTRNRETURNSTRUCT); } bool IsPure() const { - return properties & INTRNISPURE; + return static_cast(properties & INTRNISPURE); } bool IsNeverReturn() const { - return properties & INTRNNEVERRETURN; + return static_cast(properties & INTRNNEVERRETURN); } bool IsAtomic() const { - return properties & INTRNATOMIC; + return static_cast(properties & INTRNATOMIC); } bool IsRC() const { - return properties & INTRNISRC; + return static_cast(properties & INTRNISRC); + } + + bool IsSpecial() const { + return static_cast(properties & INTRNISSPECIAL); } bool HasNoSideEffect() const { diff --git a/src/maple_ir/include/metadata_layout.h b/src/maple_ir/include/metadata_layout.h index c28e6a9c66c6651bd77436322042d96060c75aa3..beb8a402f36c9dbf040a15d820853429335ff8e8 100644 --- a/src/maple_ir/include/metadata_layout.h +++ b/src/maple_ir/include/metadata_layout.h @@ -123,11 +123,11 @@ struct DataRef32 { }; struct DataRef { - uint64_t refVal; + uintptr_t refVal; template inline T GetDataRef() const; template - inline void SetDataRef(T ref, DataRefFormat format = kDataRefIsDirect); + inline void SetDataRef(const T ref, const DataRefFormat format = kDataRefIsDirect); template inline T GetRawValue() const; }; @@ -157,18 +157,18 @@ struct GctibRef32 { }; struct GctibRef { - uint64_t refVal; + uintptr_t refVal; template inline T GetGctibRef() const; template - inline void SetGctibRef(T ref, GctibRefFormat format = kGctibRefIsOffset); + inline void SetGctibRef(const T ref, const GctibRefFormat format = kGctibRefIsOffset); }; // MByteRef is meant to represent a reference to data defined in maple file. It is a direct reference or an offset. // MByteRef is self-encoded/decoded and aligned to 1 byte. // Unlike DataRef, the format of MByteRef is determined by its value. struct MByteRef { - uint64_t refVal; // initializer prefers this field to be a pointer + uintptr_t refVal; // initializer prefers this field to be a pointer enum { kBiasBitPosition = sizeof(refVal) * 8 - 4, // the most significant 3 bits }; @@ -182,7 +182,7 @@ struct MByteRef { template inline T GetRef() const; template - inline void SetRef(T ref); + inline void SetRef(const T ref); inline bool IsOffset() const; }; @@ -315,7 +315,7 @@ struct ClassMetadata { }; union { - uint64_t initState; // a readable address for initState means initialized + uintptr_t initState; // a readable address for initState means initialized DataRef cacheTrueClass; }; @@ -325,13 +325,13 @@ struct ClassMetadata { return reinterpret_cast(&(base->initState)); } - uint64_t GetInitStateRawValue() { + uintptr_t GetInitStateRawValue() const { return __atomic_load_n(&initState, __ATOMIC_ACQUIRE); } template void SetInitStateRawValue(T val) { - __atomic_store_n(&initState, reinterpret_cast(val), __ATOMIC_RELEASE); + __atomic_store_n(&initState, reinterpret_cast(val), __ATOMIC_RELEASE); } }; diff --git a/src/maple_ir/include/mir_const.h b/src/maple_ir/include/mir_const.h index fa4524404ba1f82f7d7eeb5145abcbcf9d29e90a..af0a8d6a434b16e5088d5946f9341ec31db9e2fd 100644 --- a/src/maple_ir/include/mir_const.h +++ b/src/maple_ir/include/mir_const.h @@ -250,7 +250,7 @@ class MIRStrConst : public MIRConst { private: UStrIdx value; - static const PrimType kPrimType = PTY_a64; + static const PrimType kPrimType = PTY_ptr; }; class MIRStr16Const : public MIRConst { @@ -277,7 +277,7 @@ class MIRStr16Const : public MIRConst { } private: - static const PrimType kPrimType = PTY_a64; + static const PrimType kPrimType = PTY_ptr; U16StrIdx value; }; diff --git a/src/maple_ir/include/mir_module.h b/src/maple_ir/include/mir_module.h index faedf4e8cc50a2ac260eeeb5171818e491843650..310a8339c99e015e469182709d3dabc443f0bcdb 100644 --- a/src/maple_ir/include/mir_module.h +++ b/src/maple_ir/include/mir_module.h @@ -300,7 +300,7 @@ class MIRModule { return puIdxFieldInitializedMap[key]; } - std::ostream &GetOut() { + std::ostream &GetOut() const { return out; } diff --git a/src/maple_ir/include/mir_pragma.h b/src/maple_ir/include/mir_pragma.h index 75a2bb28b4ff33b31d6401e0f3ce5628a44186e5..2e3599189091aabb5238a258da35cb1754f23447 100644 --- a/src/maple_ir/include/mir_pragma.h +++ b/src/maple_ir/include/mir_pragma.h @@ -70,9 +70,10 @@ enum PragmaValueType { class MIRPragmaElement { public: - explicit MIRPragmaElement(MIRModule &m) - : subElemVec(m.GetPragmaMPAllocator().Adapter()) { - val.u = 0; + explicit MIRPragmaElement(MIRModule &m) : MIRPragmaElement(m.GetPragmaMPAllocator()) {} + + explicit MIRPragmaElement(MapleAllocator &subElemAllocator) + : val{.u = 0}, subElemVec(subElemAllocator.Adapter()) { subElemVec.clear(); } @@ -174,9 +175,11 @@ class MIRPragmaElement { class MIRPragma { public: - explicit MIRPragma(MIRModule &m) + explicit MIRPragma(MIRModule &m) : MIRPragma(m, m.GetPragmaMPAllocator()) {} + + MIRPragma(MIRModule &m, MapleAllocator &elemAllocator) : mod(&m), - elementVec(m.GetPragmaMPAllocator().Adapter()) {} + elementVec(elemAllocator.Adapter()) {} ~MIRPragma() = default; MIRPragmaElement *GetPragmaElemFromSignature(const std::string &signature); @@ -221,10 +224,6 @@ class MIRPragma { return elementVec[i]; } - MapleVector &GetElementVector() { - return elementVec; - } - void ElementVecPushBack(MIRPragmaElement *elem) { elementVec.push_back(elem); } diff --git a/src/maple_ir/include/simplifyintrinsics.def b/src/maple_ir/include/simplifyintrinsics.def new file mode 100644 index 0000000000000000000000000000000000000000..30c04a7c4576da4d1562a9e3f4ff346b3b3ad804 --- /dev/null +++ b/src/maple_ir/include/simplifyintrinsics.def @@ -0,0 +1,31 @@ +/* + * Copyright (c) [2019-2020] Huawei Technologies Co.,Ltd.All rights reserved. + * + * OpenArkCompiler is licensed under the Mulan PSL v1. + * You can use this software according to the terms and conditions of the Mulan PSL v1. + * You may obtain a copy of Mulan PSL v1 at: + * + * http://license.coscl.org.cn/MulanPSL + * + * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER + * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR + * FIT FOR A PARTICULAR PURPOSE. + * See the Mulan PSL v1 for more details. + */ + +/* INTRINSIC(STR, NAME) */ +DEF_MIR_INTRINSIC(GET_AND_ADDI, "Lsun_2Fmisc_2FUnsafe_3B_7CgetAndAddInt_7C_28Ljava_2Flang_2FObject_3BJI_29I",\ + INTRNISJAVA | INTRNISSPECIAL, kArgTyI32, kArgTyRef, kArgTyRef, kArgTyI64, kArgTyI32) +DEF_MIR_INTRINSIC(GET_AND_ADDL, "Lsun_2Fmisc_2FUnsafe_3B_7CgetAndAddLong_7C_28Ljava_2Flang_2FObject_3BJJ_29J",\ + INTRNISJAVA | INTRNISSPECIAL, kArgTyI64, kArgTyRef, kArgTyRef, kArgTyI64, kArgTyI64) +DEF_MIR_INTRINSIC(GET_AND_SETI, "Lsun_2Fmisc_2FUnsafe_3B_7CgetAndSetInt_7C_28Ljava_2Flang_2FObject_3BJI_29I",\ + INTRNISJAVA | INTRNISSPECIAL, kArgTyI32, kArgTyRef, kArgTyRef, kArgTyI64, kArgTyI32) +DEF_MIR_INTRINSIC(GET_AND_SETL, "Lsun_2Fmisc_2FUnsafe_3B_7CgetAndSetLong_7C_28Ljava_2Flang_2FObject_3BJJ_29J",\ + INTRNISJAVA | INTRNISSPECIAL, kArgTyI64, kArgTyRef, kArgTyRef, kArgTyI64, kArgTyI64) +DEF_MIR_INTRINSIC(COMP_AND_SWAPI, "Lsun_2Fmisc_2FUnsafe_3B_7CcompareAndSwapInt_7C_28Ljava_2Flang_2FObject_3BJII_29Z",\ + INTRNISJAVA | INTRNISSPECIAL, kArgTyU1, kArgTyRef, kArgTyRef, kArgTyI64, kArgTyI32, kArgTyI32) +DEF_MIR_INTRINSIC(COMP_AND_SWAPL, "Lsun_2Fmisc_2FUnsafe_3B_7CcompareAndSwapLong_7C_28Ljava_2Flang_2FObject_3BJJJ_29Z",\ + INTRNISJAVA | INTRNISSPECIAL, kArgTyU1, kArgTyRef, kArgTyRef, kArgTyI64, kArgTyI64, kArgTyI64) +DEF_MIR_INTRINSIC(STR_INDEXOF, "Ljava_2Flang_2FString_3B_7CindexOf_7C_28Ljava_2Flang_2FString_3B_29I",\ + INTRNISJAVA | INTRNISSPECIAL, kArgTyI32, kArgTyRef, kArgTyRef) + diff --git a/src/maple_me/include/bb.h b/src/maple_me/include/bb.h index 0c1e4f58f43e95aed785d98abc8f9325172c9313..7ed4022f8bc76803164d727b06b39fc0723a95b2 100644 --- a/src/maple_me/include/bb.h +++ b/src/maple_me/include/bb.h @@ -1,5 +1,5 @@ /* - * Copyright (c) [2019] Huawei Technologies Co.,Ltd.All rights reserved. + * Copyright (c) [2019-2020] Huawei Technologies Co.,Ltd.All rights reserved. * * OpenArkCompiler is licensed under the Mulan PSL v1. * You can use this software according to the terms and conditions of the Mulan PSL v1. @@ -115,7 +115,7 @@ class BB { void Dump(MIRModule *mod); void DumpHeader(MIRModule *mod) const; void DumpPhi(); - void DumpBBAttribute(MIRModule *mod) const; + void DumpBBAttribute(const MIRModule *mod) const; std::string StrAttribute() const; void AddPredBB(BB *predVal) { @@ -188,7 +188,7 @@ class BB { bool IsSuccBB(const BB &bb) const { return IsInList(bb.succ); } - void DumpMeBB(IRMap &irMap); + void DumpMeBB(const IRMap &irMap); void AddSuccBB(BB *succPara) { succ.push_back(succPara); @@ -239,16 +239,16 @@ class BB { const PhiNode *PhiofVerStInserted(const VersionSt &versionSt) const; void InsertPhi(MapleAllocator *alloc, VersionSt *versionSt); void PrependMeStmt(MeStmt *meStmt); - void RemoveMeStmt(MeStmt *meStmt); + void RemoveMeStmt(const MeStmt *meStmt); void AddMeStmtFirst(MeStmt *meStmt); void AddMeStmtLast(MeStmt *meStmt); void InsertMeStmtBefore(const MeStmt *meStmt, MeStmt *inStmt); void InsertMeStmtAfter(const MeStmt *meStmt, MeStmt *inStmt); void InsertMeStmtLastBr(MeStmt *inStmt); - void ReplaceMeStmt(MeStmt *stmt, MeStmt *newStmt); - void DumpMeVarPhiList(IRMap *irMap); - void DumpMeRegPhiList(IRMap *irMap); - void DumpMeVarPiList(IRMap *irMap); + void ReplaceMeStmt(const MeStmt *stmt, MeStmt *newStmt); + void DumpMeVarPhiList(const IRMap *irMap); + void DumpMeRegPhiList(const IRMap *irMap); + void DumpMeVarPiList(const IRMap *irMap); StmtNodes &GetStmtNodes() { return stmtNodeList; } diff --git a/src/maple_me/include/dominance.h b/src/maple_me/include/dominance.h index 25096d4bf2a9840ea47b5befec207d3eeb54359f..47059c88b2a871f86af6b9dc85a2fa8136faa296 100644 --- a/src/maple_me/include/dominance.h +++ b/src/maple_me/include/dominance.h @@ -58,7 +58,7 @@ class Dominance : public AnalysisResult { void ComputePdomChildren(); void ComputePdtPreorder(const BB &bb, size_t &num); void ComputePdtDfn(); - bool PostDominate(const BB &bb1, BB &bb2); // true if bb1 postdominates bb2 + bool PostDominate(const BB &bb1, const BB &bb2); // true if bb1 postdominates bb2 void DumpPdoms(); const MapleVector &GetBBVec() const { diff --git a/src/maple_me/include/dse.h b/src/maple_me/include/dse.h index ed87b8bacbb1bb6e3bed1ef15a2ebb442ca65aff..33b31557a3d57c7df75cbcc3fe1cd31e4c734650 100644 --- a/src/maple_me/include/dse.h +++ b/src/maple_me/include/dse.h @@ -103,10 +103,10 @@ class DSE { workList.push_front(symbol); } - bool ExprNonDeletable(const BaseNode &expr); - bool HasNonDeletableExpr(const StmtNode &stmt); - bool StmtMustRequired(const StmtNode &stmt, BB &bb); - void DumpStmt(const StmtNode &stmt, const std::string &msg); + bool ExprNonDeletable(const BaseNode &expr) const; + bool HasNonDeletableExpr(const StmtNode &stmt) const; + bool StmtMustRequired(const StmtNode &stmt, const BB &bb) const; + void DumpStmt(const StmtNode &stmt, const std::string &msg) const; std::vector bbVec; BB &commonEntryBB; diff --git a/src/maple_me/include/hdse.h b/src/maple_me/include/hdse.h index 29c9408c1711417822c4bb0c14634ab96705d05d..55a06334b8944aa11c3aff7037c878a8e88050a1 100644 --- a/src/maple_me/include/hdse.h +++ b/src/maple_me/include/hdse.h @@ -53,10 +53,10 @@ class HDSE { void MarkPhiRequired(VarOrRegPhiNode &mePhiNode); void MarkMuListRequired(MapleMap &); void MarkChiNodeRequired(ChiMeNode &chiNode); - bool ExprNonDeletable(MeExpr &expr); - bool StmtMustRequired(const MeStmt &stmt, const BB &bb); + bool ExprNonDeletable(const MeExpr &expr) const; + bool StmtMustRequired(const MeStmt &stmt, const BB &bb) const; void MarkStmtRequired(MeStmt &stmt); - bool HasNonDeletableExpr(const MeStmt &stmt); + bool HasNonDeletableExpr(const MeStmt &stmt) const; void MarkStmtUseLive(MeStmt &meStmt); void MarkSingleUseLive(MeExpr &meExpr); void MarkControlDependenceLive(BB &bb); @@ -69,8 +69,8 @@ class HDSE { bool IsExprNeeded(const MeExpr &meExpr) const { return exprLive.at(meExpr.GetExprID()); } - void SetExprNeeded(const MeExpr *meExpr) { - exprLive.at(meExpr->GetExprID()) = true; + void SetExprNeeded(const MeExpr &meExpr) { + exprLive.at(meExpr.GetExprID()) = true; } void PropagateLive() { diff --git a/src/maple_me/include/irmap.h b/src/maple_me/include/irmap.h index f91c098d7db650c44d568f2d55ddb62e5c331cf8..c9ad8f5d78e6abc915a981b4a042b26030283a71 100644 --- a/src/maple_me/include/irmap.h +++ b/src/maple_me/include/irmap.h @@ -56,7 +56,7 @@ class IRMap : public AnalysisResult { IvarMeExpr *BuildIvarFromOpMeExpr(OpMeExpr &opMeExpr); IvarMeExpr *BuildLHSIvarFromIassMeStmt(IassignMeStmt &iassignMeStmt); IvarMeExpr *BuildLHSIvar(MeExpr &baseAddr, IassignMeStmt &iassignMeStmt, FieldID fieldID); - RegMeExpr *CreateRegRefMeExpr(MeExpr&); + RegMeExpr *CreateRegRefMeExpr(const MeExpr&); RegMeExpr *CreateRegRefMeExpr(MIRType&); VarMeExpr *CreateVarMeExprVersion(const VarMeExpr&); MeExpr *CreateAddrofMeExpr(OStIdx ostIdx); @@ -68,8 +68,8 @@ class IRMap : public AnalysisResult { RegMeExpr *CreateRegMeExpr(PrimType); RegMeExpr *CreateRegMeExprVersion(const OriginalSt&); RegMeExpr *CreateRegMeExprVersion(const RegMeExpr&); - MeExpr *ReplaceMeExprExpr(MeExpr&, MeExpr&, MeExpr&); - bool ReplaceMeExprStmt(MeStmt&, MeExpr&, MeExpr&); + MeExpr *ReplaceMeExprExpr(MeExpr&, const MeExpr&, MeExpr&); + bool ReplaceMeExprStmt(MeStmt&, const MeExpr&, MeExpr&); MeExpr *GetMeExprByVerID(uint32 verid) const { return vst2MeExprTable[verid]; } @@ -231,7 +231,7 @@ class IRMap : public AnalysisResult { BB *curBB = nullptr; // current maple_me::BB being visited MeBuilder meBuilder; - bool ReplaceMeExprStmtOpnd(uint32, MeStmt&, MeExpr&, MeExpr&); + bool ReplaceMeExprStmtOpnd(uint32, MeStmt&, const MeExpr&, MeExpr&); MeExpr *BuildLHSVar(const VersionSt &vst, DassignMeStmt &defMeStmt); void PutToBucket(uint32, MeExpr&); MeStmt *BuildMeStmtWithNoSSAPart(StmtNode &stmt); @@ -259,7 +259,7 @@ class IRMap : public AnalysisResult { MeStmt *BuildGosubMeStmt(StmtNode &stmt, AccessSSANodes &ssaPart); MeStmt *BuildThrowMeStmt(StmtNode &stmt, AccessSSANodes &ssaPart); MeStmt *BuildSyncMeStmt(StmtNode &stmt, AccessSSANodes &ssaPart); - MeExpr *ReplaceMeExprExpr(MeExpr &origExpr, MeExpr &newExpr, size_t opndsSize, MeExpr &meExpr, MeExpr &repExpr); + MeExpr *ReplaceMeExprExpr(MeExpr &origExpr, MeExpr &newExpr, size_t opndsSize, const MeExpr &meExpr, MeExpr &repExpr); }; } // namespace maple #endif // MAPLE_ME_INCLUDE_IRMAP_H diff --git a/src/maple_me/include/me_abco.h b/src/maple_me/include/me_abco.h index 12b998c3520c2252e401a48d66836a6418e4f53c..86b99635352462d25259c9acb520540965d9cd14 100644 --- a/src/maple_me/include/me_abco.h +++ b/src/maple_me/include/me_abco.h @@ -256,19 +256,19 @@ class MeABC { Dominance *GetDominace() { return dom; - }; + } MemPool *GetMemPool() { return memPool; - }; + } MapleAllocator &GetAllocator() { return allocator; - }; + } - MeIRMap *GetIRMap() { + const MeIRMap *GetIRMap() const { return irMap; - }; + } MeFunction *meFunc; Dominance *dom; diff --git a/src/maple_me/include/me_analyze_rc.h b/src/maple_me/include/me_analyze_rc.h index 60b19260df7488122cd0dbe0b5b964b3c0e07499..76075bd813b681d3d03d8709f0697739c2fafef6 100644 --- a/src/maple_me/include/me_analyze_rc.h +++ b/src/maple_me/include/me_analyze_rc.h @@ -70,15 +70,15 @@ class AnalyzeRC { void RemoveUnneededCleanups(); void RenameUses(MeStmt &meStmt); RCItem *FindOrCreateRCItem(const OriginalSt &ost); - OriginalSt *GetOriginalSt(const MeExpr &refLHS); + OriginalSt *GetOriginalSt(const MeExpr &refLHS) const; VarMeExpr *GetZeroVersionVarMeExpr(const VarMeExpr &var); - bool NeedIncref(const MeStmt &stmt); + bool NeedIncref(const MeStmt &stmt) const; UnaryMeStmt *CreateIncrefZeroVersion(const OriginalSt &ost); DassignMeStmt *CreateDassignInit(OriginalSt &ost, BB &bb); void TraverseStmt(BB &bb); - bool NeedDecRef(RCItem &rcItem, MeExpr &expr); - bool NeedDecRef(IvarMeExpr &ivar); - bool NeedDecRef(const VarMeExpr &var); + bool NeedDecRef(RCItem &rcItem, MeExpr &expr) const; + bool NeedDecRef(IvarMeExpr &ivar) const; + bool NeedDecRef(const VarMeExpr &var) const; friend class MeDoAnalyzeRC; MeFunction &func; diff --git a/src/maple_me/include/me_bypath_eh.h b/src/maple_me/include/me_bypath_eh.h index 4b7683fc18305b945e39eca336b4240f5429897f..e799c6a5e514f09cd6ad07c56d6d990f4b158a1b 100644 --- a/src/maple_me/include/me_bypath_eh.h +++ b/src/maple_me/include/me_bypath_eh.h @@ -23,18 +23,19 @@ namespace maple { class MeDoBypathEH : public MeFuncPhase { public: - MeDoBypathEH(MePhaseID id) : MeFuncPhase(id) {} + explicit MeDoBypathEH(MePhaseID id) : MeFuncPhase(id) {} ~MeDoBypathEH() = default; AnalysisResult *Run(MeFunction *func, MeFuncResultMgr *m, ModuleResultMgr *mrm) override; std::string PhaseName() const override { return "bypatheh"; } + private: bool DoBypathException(BB *tryBB, BB *catchBB, const Klass *catchClass, const StIdx &stIdx, - const KlassHierarchy *kh, MeFunction *func, const StmtNode *syncExitStmt); - StmtNode *IsSyncExit(BB *syncBB, MeFunction *func, LabelIdx secondLabel); - void BypathException(MeFunction *func, const KlassHierarchy *kh); + const KlassHierarchy &kh, MeFunction &func, const StmtNode *syncExitStmt) const; + StmtNode *IsSyncExit(BB &syncBB, MeFunction &func, LabelIdx secondLabel) const; + void BypathException(MeFunction &func, const KlassHierarchy &kh) const; }; } // namespace maple #endif diff --git a/src/maple_me/include/me_cond_based.h b/src/maple_me/include/me_cond_based.h index 36045f2a5fcc02630cd3c337b203bc312b7eb7a2..f0da8e875dff1c5b4dd87e305ba54d3e1b5fe63b 100644 --- a/src/maple_me/include/me_cond_based.h +++ b/src/maple_me/include/me_cond_based.h @@ -25,19 +25,19 @@ class MeCondBased { MeCondBased(MeFunction *func, Dominance *dom) : func(func), dominance(dom) {} ~MeCondBased() = default; - bool NullValueFromTestCond(const VarMeExpr&, const BB&, bool); - bool IsNotNullValue(const VarMeExpr&, const UnaryMeStmt&, const BB*); + bool NullValueFromTestCond(const VarMeExpr&, const BB&, bool) const; + bool IsNotNullValue(const VarMeExpr&, const UnaryMeStmt&, const BB&) const; const MeFunction *GetFunc() const { return func; } private: - bool NullValueFromOneTestCond(const VarMeExpr&, const BB&, const BB&, bool); - bool PointerWasDereferencedBefore(const VarMeExpr&, const UnaryMeStmt&, const BB*); - bool PointerWasDereferencedRightAfter(const VarMeExpr&, const UnaryMeStmt&); - bool IsIreadWithTheBase(const VarMeExpr&, const MeExpr&); - bool StmtHasDereferencedBase(const MeStmt&, const VarMeExpr&); + bool NullValueFromOneTestCond(const VarMeExpr&, const BB&, const BB&, bool) const; + bool PointerWasDereferencedBefore(const VarMeExpr&, const UnaryMeStmt&, const BB&) const; + bool PointerWasDereferencedRightAfter(const VarMeExpr&, const UnaryMeStmt&) const; + bool IsIreadWithTheBase(const VarMeExpr&, const MeExpr&) const; + bool StmtHasDereferencedBase(const MeStmt&, const VarMeExpr&) const; MeFunction *func; Dominance *dominance; diff --git a/src/maple_me/include/me_cond_based_npc.h b/src/maple_me/include/me_cond_based_npc.h index b7a7c46f63f2896a9c3b124d66bb711df5cb4588..ea2acbbbae7723448568d00c2af663d977511c05 100644 --- a/src/maple_me/include/me_cond_based_npc.h +++ b/src/maple_me/include/me_cond_based_npc.h @@ -22,7 +22,7 @@ class CondBasedNPC : public MeCondBased { CondBasedNPC(MeFunction *func, Dominance *dom) : MeCondBased(func, dom) {} ~CondBasedNPC() = default; - void DoCondBasedNPC(); + void DoCondBasedNPC() const; }; class MeDoCondBasedNPC : public MeFuncPhase { diff --git a/src/maple_me/include/me_critical_edge.h b/src/maple_me/include/me_critical_edge.h index 815602b4edcfc7b2703d2aa7b6ec7feeceb3cc69..03edfd995d1bc212fed75c2fff30b43c58ac62fd 100644 --- a/src/maple_me/include/me_critical_edge.h +++ b/src/maple_me/include/me_critical_edge.h @@ -32,7 +32,7 @@ class MeDoSplitCEdge : public MeFuncPhase { } private: - void BreakCriticalEdge(MeFunction &func, BB &pred, BB &succ); + void BreakCriticalEdge(MeFunction &func, BB &pred, BB &succ) const; }; } // namespace maple #endif // MAPLE_ME_INCLUDE_MECRITICALEDGE_H diff --git a/src/maple_me/include/me_delegate_rc.h b/src/maple_me/include/me_delegate_rc.h index e18408c83fda1cf4de46b1dfd44f95a8e54e8913..e7e955e04c215b2bcf41fd93642608eefe535346 100644 --- a/src/maple_me/include/me_delegate_rc.h +++ b/src/maple_me/include/me_delegate_rc.h @@ -17,6 +17,7 @@ #include "me_function.h" #include "me_phase.h" #include "me_irmap.h" + namespace maple { class DelegateRC { public: @@ -41,23 +42,23 @@ class DelegateRC { void CleanUpDeadLocalRefVar(const std::set &liveLocalrefvars); private: - bool IsCopiedOrDerefedOp(const Opcode op) const; + bool IsCopiedOrDerefedOp(Opcode op) const; void CollectVstCantDecrefEarly(MeExpr &opnd0, MeExpr &opnd1); - void CollectUseCounts(const MeExpr &x); - void FindAndDecrUseCount(VarMeExpr *rhsVar, MeExpr *x, int32 &remainingUses); - bool MayThrowException(MeStmt &stmt); - bool ContainAllTheUses(VarMeExpr *rhsVar, const MeStmt &fromStmt, const MeStmt *toStmt); - RegMeExpr *RHSTempDelegated(MeExpr *rhs, MeStmt &useStmt); - bool FinalRefNoRC(const MeExpr &x); + void CollectUseCounts(const MeExpr &expr); + void FindAndDecrUseCount(const VarMeExpr &rhsVar, const MeExpr &expr, int32 &remainingUses) const; + bool MayThrowException(const MeStmt &stmt) const; + bool ContainAllTheUses(VarMeExpr &rhsVar, const MeStmt &fromStmt, const MeStmt &toStmt) const; + RegMeExpr *RHSTempDelegated(MeExpr &rhs, MeStmt &useStmt); + bool FinalRefNoRC(const MeExpr &expr) const; void SetCantDelegate(const MapleMap &meVarPhiList); void SaveDerefedOrCopiedVst(const MeExpr *expr); void CollectDerefedOrCopied(const MeStmt &stmt); - void CollectDerefedOrCopied(const MeExpr &x); - void CollectUsesInfo(const MeExpr &x); - bool CanOmitRC4LHSVar(const MeStmt &stmt, bool &onlyWithDecref); + void CollectDerefedOrCopied(const MeExpr &expr); + void CollectUsesInfo(const MeExpr &expr); + bool CanOmitRC4LHSVar(const MeStmt &stmt, bool &onlyWithDecref) const; void DelegateHandleNoRCStmt(MeStmt &stmt, bool addDecref); void DelegateRCTemp(MeStmt &stmt); - void RenameDelegatedRefVarUses(MeStmt &meStmt, MeExpr *meExpr); + void RenameDelegatedRefVarUses(MeStmt &meStmt, MeExpr &meExpr); MeFunction &func; IRMap &irMap; diff --git a/src/maple_me/include/me_dse.h b/src/maple_me/include/me_dse.h index 6efd7ed45d30cb3ac09e29aa8ddebd94a5a02102..34f6a9663e133fec56865b9e5eb2d7a8b625e287 100644 --- a/src/maple_me/include/me_dse.h +++ b/src/maple_me/include/me_dse.h @@ -42,7 +42,7 @@ class MeDSE : public DSE { class MeDoDSE : public MeFuncPhase { public: - MeDoDSE(MePhaseID id) : MeFuncPhase(id) {} + explicit MeDoDSE(MePhaseID id) : MeFuncPhase(id) {} virtual ~MeDoDSE() = default; AnalysisResult *Run(MeFunction *ir, MeFuncResultMgr *m, ModuleResultMgr *mrm) override; diff --git a/src/maple_me/include/me_function.h b/src/maple_me/include/me_function.h index 334c7b118a68aa292bd11fdd47b51d8e0260b803..fa00528986da7fc0b456c6cad4b37b1882c7caac 100644 --- a/src/maple_me/include/me_function.h +++ b/src/maple_me/include/me_function.h @@ -174,7 +174,7 @@ class MeFunction : public FuncEmit { sccTopologicalVec(alloc.Adapter()), sccOfBB(GetAllBBs().size(), nullptr, alloc.Adapter()), backEdges(alloc.Adapter()), - fileName(fileName) {} + fileName(fileName, memPool) {} ~MeFunction() override = default; @@ -374,7 +374,7 @@ class MeFunction : public FuncEmit { return *valid_rbegin(); } - MIRModule &GetMIRModule() { + MIRModule &GetMIRModule() const { return mirModule; } @@ -490,7 +490,7 @@ class MeFunction : public FuncEmit { MapleVector sccOfBB; MapleSet> backEdges; /* input */ - std::string fileName; + MapleString fileName; uint32 regNum = 0; // count virtual registers uint32 hints = 0; bool hasEH = false; /* current has try statement */ diff --git a/src/maple_me/include/me_hdse.h b/src/maple_me/include/me_hdse.h index 2552246cb2a952c63e113f94478abaad3f07632f..447bb6afb44562434b9516f82d4801aff9566b29 100644 --- a/src/maple_me/include/me_hdse.h +++ b/src/maple_me/include/me_hdse.h @@ -21,6 +21,7 @@ #include "me_option.h" #include "me_dominance.h" #include "hdse.h" + namespace maple { class MeHDSE : public HDSE { public: diff --git a/src/maple_me/include/me_inequality_graph.h b/src/maple_me/include/me_inequality_graph.h index ee8839c4d3618504f1dff043c36993d165199bb4..b9b437125bbf81950e58deb3bba17660d8faccd5 100644 --- a/src/maple_me/include/me_inequality_graph.h +++ b/src/maple_me/include/me_inequality_graph.h @@ -74,9 +74,11 @@ class InequalEdge { InequalEdge(int v, EdgeType t) : edgeType(t), isVarValue(false), pairEdge(nullptr) { value.constValue = v; } + InequalEdge(MeExpr &expr, bool positive, EdgeType t) : edgeType(t), isVarValue(true), pairEdge(nullptr) { value.varValue = new VarValue(expr, positive); } + InequalEdge(InequalEdge &edge, InequalEdge &nextEdge) : edgeType(edge.GetEdgeType()), isVarValue(false), @@ -87,6 +89,7 @@ class InequalEdge { value.constValue = edge.value.constValue - nextEdge.GetConstValue(); } } + ~InequalEdge() { if (isVarValue) { delete(value.varValue); @@ -319,13 +322,14 @@ class InequalityGraph { void AddEdge(ESSABaseNode &from, ESSABaseNode &to, MeExpr &value, bool positive, EdgeType type); void ConnectTrivalEdge(); void DumpDotFile(IRMap &irMap, DumpType dumpType) const; - ESSABaseNode &GetNode(MeExpr &meExpr); + ESSABaseNode &GetNode(const MeExpr &meExpr); ESSABaseNode &GetNode(int32 value); - bool HasNode(MeExpr &meExpr) const; + bool HasNode(const MeExpr &meExpr) const; int GetValidID() { ++nodeCount; return nodeCount; } + private: std::string GetColor(EdgeType type) const; bool HasNode(int value) const; @@ -349,11 +353,11 @@ class ABCD { explicit ABCD(InequalityGraph &graph) : inequalityGraph(&graph), recursiveCount(0) {} ~ABCD() = default; - bool DemandProve(MeExpr &arrayNode, MeExpr &idx); + bool DemandProve(const MeExpr &arrayNode, const MeExpr &idx); private: - using meet_function = ProveResult (*)(ProveResult, ProveResult); - static ProveResult max(ProveResult res1, ProveResult res2) { + using MeetFunction = ProveResult (*)(ProveResult, ProveResult); + static ProveResult Max(ProveResult res1, ProveResult res2) { if (res1 == kTrue || res2 == kTrue) { return kTrue; } @@ -362,7 +366,7 @@ class ABCD { } return kFalse; } - static ProveResult min(ProveResult res1, ProveResult res2) { + static ProveResult Min(ProveResult res1, ProveResult res2) { if (res1 == kFalse || res2 == kFalse) { return kFalse; } @@ -371,9 +375,9 @@ class ABCD { } return kReduced; } - bool DemandProve(ESSABaseNode &aNode, ESSABaseNode &bNode, EdgeType eType); + bool DemandProve(ESSABaseNode &firstNode, ESSABaseNode &secondNode, EdgeType edgeType); ProveResult Prove(ESSABaseNode &a, ESSABaseNode &b, InequalEdge &e); - ProveResult UpdateCacheResult(ESSABaseNode &a, ESSABaseNode &b, InequalEdge &e, meet_function meet); + ProveResult UpdateCacheResult(ESSABaseNode &a, ESSABaseNode &b, InequalEdge &e, MeetFunction meet); void PrintTracing(); InequalityGraph *inequalityGraph; std::map active; diff --git a/src/maple_me/include/me_ir.h b/src/maple_me/include/me_ir.h index c99036a2d6b7c09a0cf71c967834eeaddde4406b..aa13c90ddc27202f82bcf2c604b4417cdac127ac 100644 --- a/src/maple_me/include/me_ir.h +++ b/src/maple_me/include/me_ir.h @@ -110,7 +110,7 @@ class MeExpr { this->numOpnds = static_cast(numOpnds); } - virtual void Dump(IRMap*, int32 indent = 0) const { + virtual void Dump(const IRMap*, int32 indent = 0) const { (void)indent; } @@ -205,7 +205,7 @@ class VarMeExpr final : public MeExpr { ~VarMeExpr() = default; - void Dump(IRMap*, int32 indent = 0) const override; + void Dump(const IRMap*, int32 indent = 0) const override; bool IsUseSameSymbol(const MeExpr&) const override; BaseNode &EmitExpr(SSATab&) override; bool IsValidVerIdx(const SSATab &ssaTab) const; @@ -304,6 +304,10 @@ class VarMeExpr final : public MeExpr { return *def.defPhi; } + const MeVarPhiNode &GetDefPhi() const { + return *def.defPhi; + } + void SetDefPhi(MeVarPhiNode &defPhi) { def.defPhi = &defPhi; } @@ -312,6 +316,10 @@ class VarMeExpr final : public MeExpr { return *def.defChi; } + const ChiMeNode &GetDefChi() const { + return *def.defChi; + } + void SetDefChi(ChiMeNode &defChi) { def.defChi = &defChi; } @@ -320,6 +328,10 @@ class VarMeExpr final : public MeExpr { return *def.defMustDef; } + const MustDefMeNode &GetDefMustDef() const { + return *def.defMustDef; + } + void SetDefMustDef(MustDefMeNode &defMustDef) { def.defMustDef = &defMustDef; } @@ -370,7 +382,7 @@ class MeVarPhiNode { } bool IsPureLocal(const SSATab &ssaTab, const MIRFunction &mirFunc); - void Dump(IRMap *irMap) const; + void Dump(const IRMap *irMap) const; VarMeExpr *GetOpnd(size_t idx) const { ASSERT(idx < opnds.size(), "out of range in MeVarPhiNode::GetOpnd"); @@ -402,6 +414,10 @@ class MeVarPhiNode { return defBB; } + const BB *GetDefBB() const { + return defBB; + } + VarMeExpr *GetLHS() { return lhs; } @@ -438,7 +454,7 @@ class RegMeExpr : public MeExpr { ~RegMeExpr() = default; - void Dump(IRMap*, int32 indent = 0) const override; + void Dump(const IRMap*, int32 indent = 0) const override; BaseNode &EmitExpr(SSATab&) override; void SetDefByStmt(MeStmt &defStmt) override { defBy = kDefByStmt; @@ -449,7 +465,7 @@ class RegMeExpr : public MeExpr { return defBy == kDefByPhi; } - MeRegPhiNode *GetMeRegPhiDef() { + MeRegPhiNode *GetMeRegPhiDef() const { return IsDefByPhi() ? def.defPhi : nullptr; } @@ -495,10 +511,18 @@ class RegMeExpr : public MeExpr { return *def.defPhi; } + const MeRegPhiNode &GetDefPhi() const { + return *def.defPhi; + } + MustDefMeNode &GetDefMustDef() { return *def.defMustDef; } + const MustDefMeNode &GetDefMustDef() const { + return *def.defMustDef; + } + void SetDefStmt(MeStmt *defStmtVal) { def.defStmt = defStmtVal; } @@ -546,7 +570,7 @@ class MeRegPhiNode { reg.SetDefPhi(*this); } - void Dump(IRMap *irMap) const; + void Dump(const IRMap *irMap) const; RegMeExpr *GetLHS() { return lhs; @@ -598,7 +622,7 @@ class ConstMeExpr : public MeExpr { ConstMeExpr(int32 exprID, MIRConst *constValParam) : MeExpr(exprID, kMeOpConst), constVal(constValParam) {} ~ConstMeExpr() = default; - void Dump(IRMap*, int32 indent = 0) const override; + void Dump(const IRMap*, int32 indent = 0) const override; BaseNode &EmitExpr(SSATab &) override; bool GeZero() const; bool GtZero() const; @@ -643,7 +667,7 @@ class ConststrMeExpr : public MeExpr { ~ConststrMeExpr() = default; - void Dump(IRMap*, int32 indent = 0) const override; + void Dump(const IRMap*, int32 indent = 0) const override; BaseNode &EmitExpr(SSATab&) override; MeExpr *GetIdenticalExpr(MeExpr &expr) const override; @@ -665,7 +689,7 @@ class Conststr16MeExpr : public MeExpr { Conststr16MeExpr(int32 exprID, U16StrIdx idx) : MeExpr(exprID, kMeOpConststr16), strIdx(idx) {} ~Conststr16MeExpr() = default; - void Dump(IRMap*, int32 indent = 0) const override; + void Dump(const IRMap*, int32 indent = 0) const override; BaseNode &EmitExpr(SSATab&) override; MeExpr *GetIdenticalExpr(MeExpr &expr) const override; @@ -687,7 +711,7 @@ class SizeoftypeMeExpr : public MeExpr { SizeoftypeMeExpr(int32 exprid, TyIdx idx) : MeExpr(exprid, kMeOpSizeoftype), tyIdx(idx) {} ~SizeoftypeMeExpr() = default; - void Dump(IRMap*, int32 indent = 0) const override; + void Dump(const IRMap*, int32 indent = 0) const override; BaseNode &EmitExpr(SSATab&) override; MeExpr *GetIdenticalExpr(MeExpr &expr) const override; @@ -710,7 +734,7 @@ class FieldsDistMeExpr : public MeExpr { : MeExpr(exprid, kMeOpFieldsDist), tyIdx(idx), fieldID1(f1), fieldID2(f2) {} ~FieldsDistMeExpr() = default; - void Dump(IRMap*, int32 indent = 0) const override; + void Dump(const IRMap*, int32 indent = 0) const override; BaseNode &EmitExpr(SSATab&) override; MeExpr *GetIdenticalExpr(MeExpr &expr) const override; @@ -745,7 +769,7 @@ class AddrofMeExpr : public MeExpr { ~AddrofMeExpr() = default; - void Dump(IRMap*, int32 indent = 0) const override; + void Dump(const IRMap*, int32 indent = 0) const override; bool IsUseSameSymbol(const MeExpr&) const override; BaseNode &EmitExpr(SSATab&) override; MeExpr *GetIdenticalExpr(MeExpr &expr) const override; @@ -778,11 +802,11 @@ class AddroffuncMeExpr : public MeExpr { ~AddroffuncMeExpr() = default; - void Dump(IRMap*, int32 indent = 0) const override; + void Dump(const IRMap*, int32 indent = 0) const override; BaseNode &EmitExpr(SSATab&) override; MeExpr *GetIdenticalExpr(MeExpr &expr) const override; - PUIdx GetPuIdx() { + PUIdx GetPuIdx() const { return puIdx; } @@ -801,7 +825,7 @@ class GcmallocMeExpr : public MeExpr { ~GcmallocMeExpr() = default; - void Dump(IRMap*, int32 indent = 0) const; + void Dump(const IRMap*, int32 indent = 0) const; BaseNode &EmitExpr(SSATab&); TyIdx GetTyIdx() const { @@ -840,7 +864,7 @@ class OpMeExpr : public MeExpr { bool IsIdentical(const OpMeExpr &meexpr) const; bool IsAllOpndsIdentical(const OpMeExpr &meExpr) const; bool IsCompareIdentical(const OpMeExpr &meExpr) const; - void Dump(IRMap*, int32 indent = 0) const override; + void Dump(const IRMap*, int32 indent = 0) const override; bool IsUseSameSymbol(const MeExpr&) const override; MeExpr *GetIdenticalExpr(MeExpr &expr) const override; BaseNode &EmitExpr(SSATab&) override; @@ -938,7 +962,7 @@ class IvarMeExpr : public MeExpr { ~IvarMeExpr() = default; - void Dump(IRMap*, int32 indent = 0) const override; + void Dump(const IRMap*, int32 indent = 0) const override; BaseNode &EmitExpr(SSATab&) override; bool IsVolatile(const SSATab&) const override { return IsVolatile(); @@ -998,7 +1022,7 @@ class IvarMeExpr : public MeExpr { fieldID = fieldIDVal; } - bool GetMaybeNull() { + bool GetMaybeNull() const { return maybeNull; } @@ -1037,7 +1061,7 @@ class NaryMeExpr : public MeExpr { NaryMeExpr(MapleAllocator *alloc, int32 expID, TyIdx tyIdx, MIRIntrinsicID intrinID, bool bCheck) : MeExpr(expID, kMeOpNary), tyIdx(tyIdx), intrinsic(intrinID), opnds(alloc->Adapter()), boundCheck(bCheck) {} - NaryMeExpr(MapleAllocator *alloc, int32 expID, NaryMeExpr &meExpr) + NaryMeExpr(MapleAllocator *alloc, int32 expID, const NaryMeExpr &meExpr) : MeExpr(expID, kMeOpNary), tyIdx(meExpr.tyIdx), intrinsic(meExpr.intrinsic), @@ -1051,7 +1075,7 @@ class NaryMeExpr : public MeExpr { ~NaryMeExpr() = default; - void Dump(IRMap*, int32 indent = 0) const override; + void Dump(const IRMap*, int32 indent = 0) const override; bool IsIdentical(NaryMeExpr&) const; bool IsUseSameSymbol(const MeExpr&) const override; BaseNode &EmitExpr(SSATab&) override; @@ -1136,7 +1160,7 @@ class MeStmt { isLive = value; } - virtual void Dump(IRMap*) const; + virtual void Dump(const IRMap*) const; MeStmt *GetNextMeStmt() const; virtual size_t NumMeStmtOpnds() const { return 0; @@ -1199,7 +1223,7 @@ class MeStmt { isLive = meStmt.isLive; } - bool IsTheSameWorkcand(MeStmt&) const; + bool IsTheSameWorkcand(const MeStmt&) const; virtual bool NeedDecref() const { return false; } @@ -1354,7 +1378,7 @@ class ChiMeNode { lhs = value; } - void Dump(IRMap *irMap) const; + void Dump(const IRMap *irMap) const; MeStmt *GetBase() const { return base; @@ -1451,7 +1475,7 @@ class MustDefMeNode { ~MustDefMeNode() = default; - void Dump(IRMap*) const; + void Dump(const IRMap*) const; private: MeExpr *lhs; // could be var or register, can we make this private? @@ -1498,7 +1522,7 @@ class PiassignMeStmt : public MeStmt { return isToken; } - void Dump(IRMap*) const; + void Dump(const IRMap*) const; private: VarMeExpr *rhs = nullptr; @@ -1517,7 +1541,7 @@ class DassignMeStmt : public MeStmt { : MeStmt(OP_dassign), chiList(std::less(), alloc->Adapter()) {} - DassignMeStmt(MapleAllocator *alloc, DassignMeStmt *dass) + DassignMeStmt(MapleAllocator *alloc, const DassignMeStmt *dass) : MeStmt(dass->GetOp()), rhs(dass->rhs), lhs(dass->GetVarLHS()), @@ -1597,7 +1621,7 @@ class DassignMeStmt : public MeStmt { wasMayDassign = value; } - void Dump(IRMap*) const; + void Dump(const IRMap*) const; MeExpr *GetLHS() const { return lhs; } @@ -1666,7 +1690,7 @@ class RegassignMeStmt : public MeStmt { rhs = val; } - void Dump(IRMap*) const; + void Dump(const IRMap*) const; bool NeedIncref() const { return needIncref; } @@ -1775,7 +1799,7 @@ class MaydassignMeStmt : public MeStmt { fieldID = fieldIDVal; } - void Dump(IRMap*) const; + void Dump(const IRMap*) const; MeExpr *GetLHS() const { return chiList.begin()->second->GetLHS(); } @@ -1886,7 +1910,7 @@ class IassignMeStmt : public MeStmt { needIncref = false; } - void Dump(IRMap*) const; + void Dump(const IRMap*) const; MeExpr *GetLHS() const { return lhsVar; } @@ -1924,7 +1948,7 @@ class NaryMeStmt : public MeStmt { NaryMeStmt(MapleAllocator *alloc, Opcode op) : MeStmt(op), opnds(alloc->Adapter()) {} - NaryMeStmt(MapleAllocator *alloc, NaryMeStmt *nstmt) : MeStmt(nstmt->GetOp()), opnds(alloc->Adapter()) { + NaryMeStmt(MapleAllocator *alloc, const NaryMeStmt *nstmt) : MeStmt(nstmt->GetOp()), opnds(alloc->Adapter()) { for (MeExpr *o : nstmt->opnds) { opnds.push_back(o); } @@ -1973,8 +1997,8 @@ class NaryMeStmt : public MeStmt { opnds.insert(begin, expr); } - void DumpOpnds(IRMap*) const; - void Dump(IRMap*) const; + void DumpOpnds(const IRMap*) const; + void Dump(const IRMap*) const; virtual MapleMap *GetMuList() { return nullptr; } @@ -2014,7 +2038,7 @@ class AssignedPart { virtual ~AssignedPart() = default; - void DumpAssignedPart(IRMap *irMap) const; + void DumpAssignedPart(const IRMap *irMap) const; VarMeExpr *GetAssignedPartLHSRef(SSATab &ssaTab, bool excludeLocalRefVar); protected: @@ -2036,7 +2060,7 @@ class CallMeStmt : public NaryMeStmt, public MuChiMePart, public AssignedPart { CallMeStmt(MapleAllocator *alloc, Opcode op) : NaryMeStmt(alloc, op), MuChiMePart(alloc), AssignedPart(alloc) {} - CallMeStmt(MapleAllocator *alloc, CallMeStmt *cstmt) + CallMeStmt(MapleAllocator *alloc, const CallMeStmt *cstmt) : NaryMeStmt(alloc, cstmt), MuChiMePart(alloc), AssignedPart(cstmt->mustDefList), @@ -2056,7 +2080,7 @@ class CallMeStmt : public NaryMeStmt, public MuChiMePart, public AssignedPart { return stmtID; } - void Dump(IRMap*) const; + void Dump(const IRMap*) const; MapleMap *GetMuList() { return &muList; } @@ -2154,7 +2178,7 @@ class IcallMeStmt : public NaryMeStmt, public MuChiMePart, public AssignedPart { IcallMeStmt(MapleAllocator *alloc, Opcode op) : NaryMeStmt(alloc, op), MuChiMePart(alloc), AssignedPart(alloc) {} - IcallMeStmt(MapleAllocator *alloc, IcallMeStmt *cstmt) + IcallMeStmt(MapleAllocator *alloc, const IcallMeStmt *cstmt) : NaryMeStmt(alloc, cstmt), MuChiMePart(alloc), AssignedPart(cstmt->mustDefList), @@ -2163,7 +2187,7 @@ class IcallMeStmt : public NaryMeStmt, public MuChiMePart, public AssignedPart { virtual ~IcallMeStmt() = default; - void Dump(IRMap*) const; + void Dump(const IRMap*) const; MapleMap *GetMuList() { return &muList; } @@ -2250,7 +2274,7 @@ class IntrinsiccallMeStmt : public NaryMeStmt, public MuChiMePart, public Assign intrinsic(id), tyIdx(tyid) {} - IntrinsiccallMeStmt(MapleAllocator *alloc, IntrinsiccallMeStmt *intrn) + IntrinsiccallMeStmt(MapleAllocator *alloc, const IntrinsiccallMeStmt *intrn) : NaryMeStmt(alloc, intrn), MuChiMePart(alloc), AssignedPart(intrn->mustDefList), @@ -2260,7 +2284,7 @@ class IntrinsiccallMeStmt : public NaryMeStmt, public MuChiMePart, public Assign virtual ~IntrinsiccallMeStmt() = default; - void Dump(IRMap*) const; + void Dump(const IRMap*) const; MapleMap *GetMuList() { return &muList; } @@ -2352,7 +2376,7 @@ class RetMeStmt : public NaryMeStmt { ~RetMeStmt() = default; - void Dump(IRMap*) const; + void Dump(const IRMap*) const; MapleMap *GetMuList() { return &muList; } @@ -2368,7 +2392,7 @@ class UnaryMeStmt : public MeStmt { explicit UnaryMeStmt(Opcode o) : MeStmt(o) {} - explicit UnaryMeStmt(UnaryMeStmt *umestmt) : MeStmt(umestmt->GetOp()), opnd(umestmt->opnd) {} + explicit UnaryMeStmt(const UnaryMeStmt *umestmt) : MeStmt(umestmt->GetOp()), opnd(umestmt->opnd) {} virtual ~UnaryMeStmt() = default; @@ -2392,7 +2416,7 @@ class UnaryMeStmt : public MeStmt { opnd = val; } - void Dump(IRMap*) const; + void Dump(const IRMap*) const; StmtNode &EmitStmt(SSATab &ssaTab); @@ -2435,7 +2459,7 @@ class CondGotoMeStmt : public UnaryMeStmt { offset = currOffset; } - void Dump(IRMap*) const; + void Dump(const IRMap*) const; StmtNode &EmitStmt(SSATab &ssaTab); private: @@ -2517,7 +2541,7 @@ class SwitchMeStmt : public UnaryMeStmt { return switchTable; } - void Dump(IRMap*) const; + void Dump(const IRMap*) const; StmtNode &EmitStmt(SSATab &ssatab); private: @@ -2565,7 +2589,7 @@ class GosubMeStmt : public WithMuMeStmt { ~GosubMeStmt() = default; - void Dump(IRMap*) const; + void Dump(const IRMap*) const; StmtNode &EmitStmt(SSATab &ssatab); private: @@ -2598,7 +2622,7 @@ class ThrowMeStmt : public WithMuMeStmt { opnd = val; } - void Dump(IRMap*) const; + void Dump(const IRMap*) const; StmtNode &EmitStmt(SSATab &ssaTab); private: @@ -2611,7 +2635,7 @@ class SyncMeStmt : public NaryMeStmt, public MuChiMePart { ~SyncMeStmt() = default; - void Dump(IRMap*) const; + void Dump(const IRMap*) const; MapleMap *GetMuList() { return &muList; } @@ -2669,7 +2693,7 @@ class AssertMeStmt : public MeStmt { return opnds[i]; } - void Dump(IRMap*) const override; + void Dump(const IRMap*) const override; StmtNode &EmitStmt(SSATab &ssaTab) override; private: @@ -2686,8 +2710,8 @@ class AssertMeStmt : public MeStmt { }; MapleMap *GenericGetChiListFromVarMeExpr(VarMeExpr &expr); -void DumpMuList(IRMap *irMap, const MapleMap &muList); -void DumpChiList(IRMap *irMap, const MapleMap &chiList); +void DumpMuList(const IRMap *irMap, const MapleMap &muList); +void DumpChiList(const IRMap *irMap, const MapleMap &chiList); class DumpOptions { public: static bool GetSimpleDump() { diff --git a/src/maple_me/include/me_loop_analysis.h b/src/maple_me/include/me_loop_analysis.h index 2bf8f52a9df72d3521d5ea94acb22485c1210f17..83e30becb85892582742732e148372f662737bd4 100644 --- a/src/maple_me/include/me_loop_analysis.h +++ b/src/maple_me/include/me_loop_analysis.h @@ -39,7 +39,7 @@ struct LoopDesc { // IdentifyLoop records all the loops in a MeFunction. class IdentifyLoops : public AnalysisResult { public: - explicit IdentifyLoops(MemPool *memPool, MeFunction *mf, Dominance *dm) + IdentifyLoops(MemPool *memPool, MeFunction *mf, Dominance *dm) : AnalysisResult(memPool), meLoopMemPool(memPool), meLoopAlloc(memPool), @@ -53,15 +53,17 @@ class IdentifyLoops : public AnalysisResult { const MapleVector &GetMeLoops() const { return meLoops; } - void SetMeLoop(size_t i, LoopDesc *desc) { - meLoops[i] = desc; + + void SetMeLoop(size_t i, LoopDesc &desc) { + meLoops[i] = &desc; } - LoopDesc *CreateLoopDesc(BB *hd, BB *tail); - void SetLoopParent4BB(const BB *bb, LoopDesc *loopDesc); + LoopDesc *CreateLoopDesc(BB &hd, BB &tail); + void SetLoopParent4BB(const BB &bb, LoopDesc &loopDesc); void ProcessBB(BB *bb); void MarkBB(); void Dump(); + private: MemPool *meLoopMemPool; MapleAllocator meLoopAlloc; diff --git a/src/maple_me/include/me_loop_canon.h b/src/maple_me/include/me_loop_canon.h index 7a9fe6a07c8852b2a9ac8e8b8ecba7dcd11a574b..0183b7792ad195409d572031764ea83792330006 100644 --- a/src/maple_me/include/me_loop_canon.h +++ b/src/maple_me/include/me_loop_canon.h @@ -21,7 +21,7 @@ namespace maple { // convert loop to do-while format class MeDoLoopCanon : public MeFuncPhase { public: - MeDoLoopCanon(MePhaseID id) : MeFuncPhase(id) {} + explicit MeDoLoopCanon(MePhaseID id) : MeFuncPhase(id) {} ~MeDoLoopCanon() = default; @@ -32,8 +32,8 @@ class MeDoLoopCanon : public MeFuncPhase { private: using Key = std::pair; - void Convert(MeFunction *func, BB *bb, BB *pred, MapleMap &swapSuccs); - bool NeedConvert(BB *bb, BB *pred, MapleAllocator &alloc, MapleMap &swapSuccs); + void Convert(MeFunction &func, BB &bb, BB &pred, MapleMap &swapSuccs); + bool NeedConvert(BB &bb, BB &pred, MapleAllocator &alloc, MapleMap &swapSuccs) const; }; } // namespace maple #endif // MAPLE_ME_INCLUDE_MELOOPCANON_H diff --git a/src/maple_me/include/me_lower_globals.h b/src/maple_me/include/me_lower_globals.h index 35ecf1923b80072b70cbcb405ec31b5c80723862..6582619a2fa9b6a5286881aa67d4fa8efa190e90 100644 --- a/src/maple_me/include/me_lower_globals.h +++ b/src/maple_me/include/me_lower_globals.h @@ -32,7 +32,7 @@ class MeLowerGlobals { MeFunction *func; IRMap *irMap; SSATab *ssaTable; - void LowerGlobalDreads(MeStmt &stmt, MeExpr *x); + void LowerGlobalDreads(MeStmt &stmt, MeExpr &expr); }; } // namespace maple #endif // MAPLE_ME_INCLUDE_MELOWERGLOBALS_H diff --git a/src/maple_me/include/me_may2dassign.h b/src/maple_me/include/me_may2dassign.h index 793ff62b6c8471f2634bd39d397282286c31ebfe..765da6349063b0d066d8266d96e2e7ea4badfea6 100644 --- a/src/maple_me/include/me_may2dassign.h +++ b/src/maple_me/include/me_may2dassign.h @@ -21,7 +21,7 @@ namespace maple { class May2Dassign { public: - May2Dassign(MeFunction *f) : func(f), irMap(f->GetIRMap()), ssaTab(f->GetMeSSATab()) {} + explicit May2Dassign(MeFunction *f) : func(f), irMap(f->GetIRMap()), ssaTab(f->GetMeSSATab()) {} ~May2Dassign() = default; void DoIt(); @@ -34,7 +34,7 @@ class May2Dassign { class MeDoMay2Dassign : public MeFuncPhase { public: - MeDoMay2Dassign(MePhaseID id) : MeFuncPhase(id) {} + explicit MeDoMay2Dassign(MePhaseID id) : MeFuncPhase(id) {} virtual ~MeDoMay2Dassign() = default; AnalysisResult *Run(MeFunction *func, MeFuncResultMgr *m, ModuleResultMgr *mrm) override; diff --git a/src/maple_me/include/me_prop.h b/src/maple_me/include/me_prop.h index ff381119fc186ff56ae84fda1bdfd11fc3e548f8..0a4e8f7e23998791e14c0165972f9210b4bd3947 100644 --- a/src/maple_me/include/me_prop.h +++ b/src/maple_me/include/me_prop.h @@ -24,8 +24,8 @@ class MeProp : public Prop { public: MeProp(MeIRMap &irMap, Dominance &dom, MemPool &memPool, const PropConfig &config) : Prop(irMap, dom, memPool, std::vector(irMap.GetFunc().GetAllBBs().begin(), - irMap.GetFunc().GetAllBBs().end()), - *irMap.GetFunc().GetCommonEntryBB(), config) {} + irMap.GetFunc().GetAllBBs().end()), + *irMap.GetFunc().GetCommonEntryBB(), config) {} virtual ~MeProp() = default; }; diff --git a/src/maple_me/include/me_rc_lowering.h b/src/maple_me/include/me_rc_lowering.h index 6a58eae885f524576b3912362bc4a1939c1119d1..dda8b11a59dcd701978f45b840c8a3668507eac9 100644 --- a/src/maple_me/include/me_rc_lowering.h +++ b/src/maple_me/include/me_rc_lowering.h @@ -48,10 +48,10 @@ class RCLowering { void CreateCleanupIntrinsics(); void HandleArguments(); void CompactRC(BB &bb); - void CompactIncAndDec(MeStmt &incStmt, MeStmt &decStmt); - void CompactIncAndDecReset(MeStmt &incStmt, MeStmt &resetStmt); - void ReplaceDecResetWithDec(MeStmt &prevStmt, MeStmt &stmt); - void CompactAdjacentDecReset(MeStmt &prevStmt, MeStmt &stmt); + void CompactIncAndDec(const MeStmt &incStmt, const MeStmt &decStmt); + void CompactIncAndDecReset(const MeStmt &incStmt, const MeStmt &resetStmt); + void ReplaceDecResetWithDec(MeStmt &prevStmt, const MeStmt &stmt); + void CompactAdjacentDecReset(const MeStmt &prevStmt, const MeStmt &stmt); // create new symbol from name and return its ost OriginalSt *RetrieveOSt(const std::string &name, bool isLocalrefvar) const; // create new symbol from temp name and return its VarMeExpr @@ -65,13 +65,13 @@ class RCLowering { MIRIntrinsicID PrepareVolatileCall(const MeStmt &stmt, MIRIntrinsicID index = INTRN_UNDEFINED); IntrinsiccallMeStmt *CreateRCIntrinsic(MIRIntrinsicID intrnID, const MeStmt &stmt, std::vector &opnds, bool assigned = false); - MeExpr *HandleIncRefAndDecRefStmt(MeStmt &stmt); + MeExpr *HandleIncRefAndDecRefStmt(const MeStmt &stmt); void InitializedObjectFields(MeStmt &stmt); bool IsInitialized(IvarMeExpr &ivar); void PreprocessAssignMeStmt(MeStmt &stmt); void HandleAssignMeStmtRHS(MeStmt &stmt); void HandleAssignMeStmtRegLHS(MeStmt &stmt); - void HandleAssignToGlobalVar(MeStmt &stmt); + void HandleAssignToGlobalVar(const MeStmt &stmt); void HandleAssignToLocalVar(MeStmt &stmt, MeExpr *pendingDec); void HandleAssignMeStmtVarLHS(MeStmt &stmt, MeExpr *pendingDec); void HandleAssignMeStmtIvarLHS(MeStmt &stmt); @@ -89,6 +89,8 @@ class RCLowering { void HandleReturnStmt(); void HandleAssignMeStmt(MeStmt &stmt, MeExpr *pendingDec); MIRIntrinsicID SelectWriteBarrier(const MeStmt &stmt); + MIRType *GetArrayNodeType(const VarMeExpr &var); + void CheckArrayStore(const IntrinsiccallMeStmt &writeRefCall); MeFunction &func; MIRModule &mirModule; IRMap &irMap; diff --git a/src/maple_me/include/me_ssa_devirtual.h b/src/maple_me/include/me_ssa_devirtual.h index 463d5ce97021b7dac0d0648f13b44ac335abd3bd..b38b2d6222e61da8a35b717bff9eca4ec8b769f0 100644 --- a/src/maple_me/include/me_ssa_devirtual.h +++ b/src/maple_me/include/me_ssa_devirtual.h @@ -21,18 +21,18 @@ namespace maple { class MeSSADevirtual : public SSADevirtual { public: - MeSSADevirtual(MemPool *memPool, MIRModule *mod, MeFunction *func, IRMap *irMap, KlassHierarchy *kh, Dominance *dom, - Clone *clone) - : SSADevirtual(memPool, mod, irMap, kh, dom, func->GetAllBBs().size(), clone), func(func) {} + MeSSADevirtual(MemPool &memPool, MIRModule &mod, MeFunction &func, IRMap &irMap, KlassHierarchy &kh, Dominance &dom, + Clone &clone) + : SSADevirtual(memPool, mod, irMap, kh, dom, func.GetAllBBs().size(), clone), func(&func) {} ~MeSSADevirtual() = default; protected: - BB *GetBB(BBId id) override { + BB *GetBB(BBId id) const override { return func->GetAllBBs().at(id); } - MIRFunction *GetMIRFunction() override { + MIRFunction *GetMIRFunction() const override { return func->GetMirFunc(); } diff --git a/src/maple_me/include/me_ssa_epre.h b/src/maple_me/include/me_ssa_epre.h index ed40ad3974514c91d61ff89640b514f498577e81..5419c4c63dd96295167b03ba9f871ce06bb88984 100644 --- a/src/maple_me/include/me_ssa_epre.h +++ b/src/maple_me/include/me_ssa_epre.h @@ -26,16 +26,16 @@ class MeSSAEPre : public SSAEPre { public: // a symbol is a candidate for ssaupdate if its ostidx key exists in the map; // the mapped set gives bbs where dassign's are inserted by ssa_epre for the symbol - explicit MeSSAEPre(MeFunction *func, IRMap &map, Dominance &dom, KlassHierarchy &kh, MemPool &memPool, MemPool &mp2, + explicit MeSSAEPre(MeFunction &func, IRMap &map, Dominance &dom, KlassHierarchy &kh, MemPool &memPool, MemPool &mp2, uint32 limit, bool includeRef, bool epreLocalRefVar, bool lhsIvar) : SSAEPre(map, dom, memPool, mp2, kExprPre, limit, includeRef, lhsIvar), candsForSSAUpdate(std::less(), ssaPreAllocator.Adapter()), - func(func), + func(&func), epreLocalRefVar(epreLocalRefVar), klassHierarchy(kh) {} virtual ~MeSSAEPre() = default; - void GetIterDomFrontier(BB &bb, MapleSet &dfSet, std::vector &visitedMap) override; + void GetIterDomFrontier(const BB &bb, MapleSet &dfSet, std::vector &visitedMap) const override; bool ScreenPhiBB(BBId) const override { return true; } @@ -52,8 +52,8 @@ class MeSSAEPre : public SSAEPre { private: void BuildWorkList() override; - bool IsThreadObjField(const IvarMeExpr &expr) override; - BB *GetBB(BBId id) override { + bool IsThreadObjField(const IvarMeExpr &expr) const override; + BB *GetBB(BBId id) const override { return func->GetBBFromID(id); } @@ -61,21 +61,21 @@ class MeSSAEPre : public SSAEPre { return func->GetMirFunc()->GetPuidx(); } - bool CfgHasDoWhile() override { + bool CfgHasDoWhile() const override { return func->GetTheCfg()->GetHasDoWhile(); } - bool EpreLocalRefVar() override { + bool EpreLocalRefVar() const override { return epreLocalRefVar; } - void EnterCandsForSSAUpdate(OStIdx ostIdx, BB *bb) override { + void EnterCandsForSSAUpdate(OStIdx ostIdx, const BB &bb) override { if (candsForSSAUpdate.find(ostIdx) == candsForSSAUpdate.end()) { MapleSet *bbSet = ssaPreMemPool->New>(std::less(), ssaPreAllocator.Adapter()); - bbSet->insert(bb->GetBBId()); + bbSet->insert(bb.GetBBId()); candsForSSAUpdate[ostIdx] = bbSet; } else { - candsForSSAUpdate[ostIdx]->insert(bb->GetBBId()); + candsForSSAUpdate[ostIdx]->insert(bb.GetBBId()); } } }; diff --git a/src/maple_me/include/me_ssa_lpre.h b/src/maple_me/include/me_ssa_lpre.h index 9b67eeaf7feb07f72fb3a6970b35b7849f5da0dc..480439ca989e9c75c857662fa4974c2fcfdd837b 100644 --- a/src/maple_me/include/me_ssa_lpre.h +++ b/src/maple_me/include/me_ssa_lpre.h @@ -22,46 +22,46 @@ namespace maple { constexpr size_t kDoLpreBBsLimit = 0x7fffff; class MeSSALPre : public SSAPre { public: - MeSSALPre(MeFunction *f, MeIRMap &hMap, Dominance &dom, MemPool &memPool, MemPool &mp2, PreKind kind, uint32 limit) + MeSSALPre(MeFunction &f, MeIRMap &hMap, Dominance &dom, MemPool &memPool, MemPool &mp2, PreKind kind, uint32 limit) : SSAPre(hMap, dom, memPool, mp2, kind, limit), irMap(&hMap), - func(f), + func(&f), assignedFormals(ssaPreAllocator.Adapter()), loopHeadBBs(ssaPreAllocator.Adapter()) {} virtual ~MeSSALPre() = default; - void FindLoopHeadBBs(IdentifyLoops *identLoops); + void FindLoopHeadBBs(const IdentifyLoops &identLoops); private: - void GenerateSaveRealOcc(MeRealOcc*) override; - void GenerateReloadRealOcc(MeRealOcc*) override; - MeExpr *PhiOpndFromRes(MeRealOcc*, size_t) override; - void GetIterDomFrontier(BB &bb, MapleSet &dfSet, std::vector &visitedMap) override; + void GenerateSaveRealOcc(MeRealOcc&) override; + void GenerateReloadRealOcc(MeRealOcc&) override; + MeExpr *PhiOpndFromRes(MeRealOcc&, size_t) const override; + void GetIterDomFrontier(const BB &bb, MapleSet &dfSet, std::vector &visitedMap) const override; void ComputeVarAndDfPhis() override; bool ScreenPhiBB(BBId) const override { return true; } - void CollectVarForMeExpr(MeExpr *meExpr, std::vector &varVec) override { - if (meExpr->GetMeOp() == kMeOpAddrof || meExpr->GetMeOp() == kMeOpAddroffunc) { + void CollectVarForMeExpr(MeExpr &meExpr, std::vector &varVec) const override { + if (meExpr.GetMeOp() == kMeOpAddrof || meExpr.GetMeOp() == kMeOpAddroffunc) { return; } - varVec.push_back(meExpr); + varVec.push_back(&meExpr); } - void CollectVarForCand(MeRealOcc *realOcc, std::vector &varVec) override { - if (realOcc->GetMeExpr()->GetMeOp() == kMeOpAddrof || realOcc->GetMeExpr()->GetMeOp() == kMeOpAddroffunc) { + void CollectVarForCand(MeRealOcc &realOcc, std::vector &varVec) const override { + if (realOcc.GetMeExpr()->GetMeOp() == kMeOpAddrof || realOcc.GetMeExpr()->GetMeOp() == kMeOpAddroffunc) { return; } - varVec.push_back(realOcc->GetMeExpr()); + varVec.push_back(realOcc.GetMeExpr()); } - void BuildEntryLHSOcc4Formals() override; - void BuildWorkListLHSOcc(MeStmt *meStmt, int32 seqStmt) override; + void BuildEntryLHSOcc4Formals() const override; + void BuildWorkListLHSOcc(MeStmt &meStmt, int32 seqStmt) override; void CreateMembarOccAtCatch(BB &bb) override; - void BuildWorkListExpr(MeStmt*, int32, MeExpr*, bool, MeExpr*, bool isRootExpr) override; + void BuildWorkListExpr(MeStmt&, int32, MeExpr&, bool, MeExpr*, bool isRootExpr) override; void BuildWorkList() override; - BB *GetBB(BBId id) override { + BB *GetBB(BBId id) const override { return func->GetBBFromID(id); } diff --git a/src/maple_me/include/me_ssa_update.h b/src/maple_me/include/me_ssa_update.h index 22207fea9edc03b2be0c0560c45a055873396232..7379d40373962d7d8e61d1ecde9899d4ae4170ea 100644 --- a/src/maple_me/include/me_ssa_update.h +++ b/src/maple_me/include/me_ssa_update.h @@ -1,5 +1,5 @@ /* - * Copyright (c) [2019] Huawei Technologies Co.,Ltd.All rights reserved. + * Copyright (c) [2019-2020] Huawei Technologies Co.,Ltd.All rights reserved. * * OpenArkCompiler is licensed under the Mulan PSL v1. * You can use this software according to the terms and conditions of the Mulan PSL v1. @@ -38,7 +38,7 @@ class MeSSAUpdate { void Run(); private: - void GetIterDomFrontier(const BB &bb, MapleSet &dfSet, std::vector &visitedMap); + void GetIterDomFrontier(const BB &bb, MapleSet &dfSet, std::vector &visitedMap) const; void InsertPhis(); void RenamePhi(const BB &bb); MeExpr *RenameExpr(MeExpr &meExpr, bool &changed); diff --git a/src/maple_me/include/me_ssu_pre.h b/src/maple_me/include/me_ssu_pre.h index a9bff37707b159394cf1c76879f41e3d157c41c7..0ed421699e911d6a8630be863d22da9912a86e06 100644 --- a/src/maple_me/include/me_ssu_pre.h +++ b/src/maple_me/include/me_ssu_pre.h @@ -35,8 +35,8 @@ class SOcc { virtual ~SOcc() = default; - virtual void Dump() = 0; - bool IsPostDominate(Dominance *dom, SOcc *occ) { + virtual void Dump() const = 0; + bool IsPostDominate(Dominance *dom, const SOcc *occ) const { CHECK_NULL_FATAL(occ); CHECK_NULL_FATAL(dom); return dom->PostDominate(*mirBB, *occ->mirBB); @@ -66,17 +66,18 @@ class SOcc { return mirBB; } - void SetBB(BB *currMirBB) { - this->mirBB = currMirBB; + void SetBB(BB &currMirBB) { + this->mirBB = &currMirBB; } SOcc *GetUse() const { return use; } - void SetUse(SOcc *currUse) { - this->use = currUse; + void SetUse(SOcc &currUse) { + this->use = &currUse; } + private: SOccType occTy; uint32 classId; @@ -88,14 +89,14 @@ class SRealOcc : public SOcc { public: SRealOcc() : SOcc(kSOccReal, nullptr), meStmt(nullptr), vMeExpr(nullptr), realFromDef(false), redundant(true) {} - SRealOcc(MeStmt *s) - : SOcc(kSOccReal, s->GetBB()), meStmt(s), vMeExpr(nullptr), realFromDef(false), redundant(true) {} - SRealOcc(MeStmt *s, VarMeExpr *v) - : SOcc(kSOccReal, s->GetBB()), meStmt(s), vMeExpr(v), realFromDef(false), redundant(true) {} - SRealOcc(BB *bb, VarMeExpr *v) - : SOcc(kSOccReal, bb), meStmt(nullptr), vMeExpr(v), realFromDef(false), redundant(true) {} + explicit SRealOcc(MeStmt &s) + : SOcc(kSOccReal, s.GetBB()), meStmt(&s), vMeExpr(nullptr), realFromDef(false), redundant(true) {} + SRealOcc(MeStmt &s, VarMeExpr &v) + : SOcc(kSOccReal, s.GetBB()), meStmt(&s), vMeExpr(&v), realFromDef(false), redundant(true) {} + SRealOcc(BB &bb, VarMeExpr &v) + : SOcc(kSOccReal, &bb), meStmt(nullptr), vMeExpr(&v), realFromDef(false), redundant(true) {} virtual ~SRealOcc() = default; - void Dump() { + void Dump() const { LogInfo::MapleLogger() << "RealOcc at bb" << GetBB()->GetBBId(); if (realFromDef) { LogInfo::MapleLogger() << "(from-def)"; @@ -103,11 +104,11 @@ class SRealOcc : public SOcc { LogInfo::MapleLogger() << " classId" << GetClassId(); } - MeStmt *GetStmt() { + MeStmt *GetStmt() const { return meStmt; } - VarMeExpr *GetVar() { + VarMeExpr *GetVar() const { return vMeExpr; } @@ -119,13 +120,14 @@ class SRealOcc : public SOcc { this->realFromDef = real; } - bool GetRedundant() { + bool GetRedundant() const { return redundant; } void SetRedundant(bool isRedundant) { this->redundant = isRedundant; } + private: MeStmt *meStmt; // the stmt of this real occurrence; null for formal at entry VarMeExpr *vMeExpr; // the varmeexpr of this real occurrence @@ -137,10 +139,11 @@ class SLambdaOcc; class SLambdaResOcc : public SOcc { public: - SLambdaResOcc(BB *bb) : SOcc(kSOccLambdaRes, bb), useLambdaOcc(nullptr), hasRealUse(false), insertHere(false) {} + explicit SLambdaResOcc(BB &bb) + : SOcc(kSOccLambdaRes, &bb), useLambdaOcc(nullptr), hasRealUse(false), insertHere(false) {} virtual ~SLambdaResOcc() = default; - void Dump() { + void Dump() const { LogInfo::MapleLogger() << "LambdaResOcc at bb" << GetBB()->GetBBId() << " classId" << GetClassId(); } @@ -148,8 +151,8 @@ class SLambdaResOcc : public SOcc { return useLambdaOcc; } - void SetUseLambdaOcc(SLambdaOcc *currUseLambdaOcc) { - this->useLambdaOcc = currUseLambdaOcc; + void SetUseLambdaOcc(SLambdaOcc &currUseLambdaOcc) { + this->useLambdaOcc = &currUseLambdaOcc; } bool GetHasRealUse() const { @@ -167,6 +170,7 @@ class SLambdaResOcc : public SOcc { void SetInsertHere(bool currInsertHere) { this->insertHere = currInsertHere; } + private: SLambdaOcc *useLambdaOcc; // its rhs use bool hasRealUse; @@ -175,15 +179,15 @@ class SLambdaResOcc : public SOcc { class SLambdaOcc : public SOcc { public: - SLambdaOcc(BB *bb, MapleAllocator *alloc) - : SOcc(kSOccLambda, bb), isUpsafe(true), isCanBeAnt(true), isEarlier(true), lambdaRes(alloc->Adapter()) {} + SLambdaOcc(BB &bb, MapleAllocator &alloc) + : SOcc(kSOccLambda, &bb), isUpsafe(true), isCanBeAnt(true), isEarlier(true), lambdaRes(alloc.Adapter()) {} virtual ~SLambdaOcc() = default; bool WillBeAnt() const { return isCanBeAnt && !isEarlier; } - void Dump() { + void Dump() const { LogInfo::MapleLogger() << "LambdaOcc at bb" << GetBB()->GetBBId() << " classId" << GetClassId() << " Lambda["; for (size_t i = 0; i < lambdaRes.size(); i++) { lambdaRes[i]->Dump(); @@ -221,6 +225,7 @@ class SLambdaOcc : public SOcc { MapleVector &GetLambdaRes() { return lambdaRes; } + private: bool isUpsafe; bool isCanBeAnt; @@ -230,27 +235,27 @@ class SLambdaOcc : public SOcc { class SEntryOcc : public SOcc { public: - explicit SEntryOcc(BB *bb) : SOcc(kSOccEntry, bb) {} + explicit SEntryOcc(BB &bb) : SOcc(kSOccEntry, &bb) {} virtual ~SEntryOcc() = default; - void Dump() { + void Dump() const { LogInfo::MapleLogger() << "EntryOcc at bb" << GetBB()->GetBBId(); } }; class SUseOcc : public SOcc { public: - explicit SUseOcc(BB *bb) : SOcc(kSOccUse, bb) {} + explicit SUseOcc(BB &bb) : SOcc(kSOccUse, &bb) {} virtual ~SUseOcc() = default; - void Dump() { + void Dump() const { LogInfo::MapleLogger() << "UseOcc at bb" << GetBB()->GetBBId(); } }; class SPhiOcc : public SOcc { public: - SPhiOcc(BB *bb, MeVarPhiNode *p, VarMeExpr *v) : SOcc(kSOccPhi, bb), phi(p), vMeExpr(v) {}; + SPhiOcc(BB &bb, MeVarPhiNode &p, VarMeExpr &v) : SOcc(kSOccPhi, &bb), phi(&p), vMeExpr(&v) {}; virtual ~SPhiOcc() = default; @@ -270,9 +275,10 @@ class SPhiOcc : public SOcc { return vMeExpr; } - void Dump() { + void Dump() const { LogInfo::MapleLogger() << "PhiOcc at bb" << GetBB()->GetBBId(); } + private: MeVarPhiNode *phi; // the phinode of this real occurrence; VarMeExpr *vMeExpr; // the varmeexpr of this real occurrence @@ -280,11 +286,11 @@ class SPhiOcc : public SOcc { class SpreWorkCand { public: - SpreWorkCand(MapleAllocator *alloc, const OriginalSt *ost) + SpreWorkCand(MapleAllocator &alloc, const OriginalSt &ost) : next(nullptr), - theOst(ost), + theOst(&ost), theVar(nullptr), - realOccs(alloc->Adapter()), + realOccs(alloc.Adapter()), hasStoreOcc(false), hasCriticalEdge(false) {} @@ -302,8 +308,8 @@ class SpreWorkCand { return theVar; } - void SetTheVar(VarMeExpr *var) { - this->theVar = var; + void SetTheVar(VarMeExpr &var) { + this->theVar = &var; } MapleVector &GetRealOccs() { @@ -343,15 +349,16 @@ class MeSSUPre { kSecondDecrefPre, kSubsumePre } preKind; - MeSSUPre(MeFunction *f, Dominance *dom, MemPool *memPool, PreKind kind, bool enabledDebug) + + MeSSUPre(MeFunction &f, Dominance &dom, MemPool &memPool, PreKind kind, bool enabledDebug) : preKind(kind), - func(f), - ssaTab(f->GetMeSSATab()), - irMap(f->GetIRMap()), - mirModule(&f->GetMeSSATab()->GetModule()), - dom(dom), - spreMp(memPool), - spreAllocator(memPool), + func(&f), + ssaTab(f.GetMeSSATab()), + irMap(f.GetIRMap()), + mirModule(&f.GetMeSSATab()->GetModule()), + dom(&dom), + spreMp(&memPool), + spreAllocator(&memPool), workCandMap(std::less(), spreAllocator.Adapter()), workCand(nullptr), lambdaDfns(std::less(), spreAllocator.Adapter()), @@ -394,24 +401,24 @@ class MeSSUPre { // step 5 methods void Finalize(); // step 4 methods - void ResetCanBeAnt(SLambdaOcc *lambda); - void ComputeCanBeAnt(); - void ResetEarlier(SLambdaOcc *lambda); - void ComputeEarlier(); - void ResetCanBeFullyAnt(SLambdaOcc *lambda); - void ComputeCanBeFullyAnt(); + void ResetCanBeAnt(SLambdaOcc &lambda) const; + void ComputeCanBeAnt() const; + void ResetEarlier(SLambdaOcc &lambda) const; + void ComputeEarlier() const; + void ResetCanBeFullyAnt(SLambdaOcc &lambda) const; + void ComputeCanBeFullyAnt() const; // step 3 methods - void ResetUpsafe(SLambdaResOcc *lambdaRes); - void ComputeUpsafe(); + void ResetUpsafe(const SLambdaResOcc &lambdaRes) const; + void ComputeUpsafe() const; // step 2 methods void Rename(); // step 1 methods - void GetIterPdomFrontier(const BB *bb, MapleSet *pdfSet, std::vector &visitedMap); + void GetIterPdomFrontier(const BB &bb, MapleSet &pdfSet, std::vector &visitedMap); void FormLambdas(); void FormLambdaRes(); void CreateSortedOccs(); // step 0 methods - void CreateEntryOcc(BB *bb) { + void CreateEntryOcc(BB &bb) { SEntryOcc *entryOcc = spreMp->New(bb); entryOccs.push_back(entryOcc); } diff --git a/src/maple_me/include/me_stmt_pre.h b/src/maple_me/include/me_stmt_pre.h index 04fec9015c90eaf14b323a8bb28ec661068e6f1b..14550afa2a6080f56cf83beaefc5c477fbf2794e 100644 --- a/src/maple_me/include/me_stmt_pre.h +++ b/src/maple_me/include/me_stmt_pre.h @@ -32,7 +32,7 @@ class MeStmtPre : public SSAEPre { useOccurMap(std::less(), ssaPreAllocator.Adapter()) {} virtual ~MeStmtPre() = default; - void GetIterDomFrontier(BB &bb, MapleSet &dfSet, std::vector &visitedMap) override; + void GetIterDomFrontier(const BB &bb, MapleSet &dfSet, std::vector &visitedMap) const override; bool ScreenPhiBB(BBId) const override { return true; } @@ -54,29 +54,29 @@ class MeStmtPre : public SSAEPre { void Finalize1() override; void Finalize2() override {}; // fully available (replaces downsafety, canbeavail and later under SSAFRE) - void ResetFullyAvail(MePhiOcc *occ); + void ResetFullyAvail(MePhiOcc &occ); void ComputeFullyAvail(); // rename phase - bool AllVarsSameVersion(MeRealOcc *realOcc1, MeRealOcc *realOcc2) override; - bool AllVarsSameVersionStmtFre(MeRealOcc *topOcc, MeRealOcc *curOcc) const; - void CollectVarForMeStmt(MeStmt *meStmt, MeExpr *meExpr, std::vector &varVec); - void CollectVarForCand(MeRealOcc *realOcc, std::vector &varVec) override; - MeStmt *CopyMeStmt(MeStmt &meStmt) override; - MeStmt *PhiOpndFromRes4Stmt(MeRealOcc *realZ, size_t j, MeExpr *&lhsVar); + bool AllVarsSameVersion(const MeRealOcc &realOcc1, const MeRealOcc &realOcc2) const override; + bool AllVarsSameVersionStmtFre(MeRealOcc &topOcc, MeRealOcc &curOcc) const; + void CollectVarForMeStmt(const MeStmt &meStmt, MeExpr *meExpr, std::vector &varVec) const; + void CollectVarForCand(MeRealOcc &realOcc, std::vector &varVec) const override; + MeStmt *CopyMeStmt(const MeStmt &meStmt) const override; + MeStmt *PhiOpndFromRes4Stmt(MeRealOcc &realZ, size_t j, MeExpr *&lhsVar) const; void Rename1StmtFre(); void Rename2() override; // phi insertion phase void ComputeVarAndDfPhis() override; void CreateSortedOccs() override; - void ConstructUseOccurMapExpr(uint32 bbDfn, MeExpr *meExpr); + void ConstructUseOccurMapExpr(uint32 bbDfn, const MeExpr &meExpr); void ConstructUseOccurMap() override; // build useOccurMap for dassign candidates PreStmtWorkCand *CreateStmtRealOcc(MeStmt &meStmt, int seqStmt); void VersionStackChiListUpdate(const MapleMap &chiList); void BuildWorkListBB(BB *bb) override; void BuildWorkList() override; - void RemoveUnnecessaryDassign(DassignMeStmt *dssMeStmt); + void RemoveUnnecessaryDassign(DassignMeStmt &dssMeStmt); void DoSSAFRE() override; - BB *GetBB(BBId id) override { + BB *GetBB(BBId id) const override { return func->GetBBFromID(id); } @@ -87,7 +87,7 @@ class MeStmtPre : public SSAEPre { class MeDoStmtPre : public MeFuncPhase { public: - MeDoStmtPre(MePhaseID id) : MeFuncPhase(id) {} + explicit MeDoStmtPre(MePhaseID id) : MeFuncPhase(id) {} virtual ~MeDoStmtPre() = default; AnalysisResult *Run(MeFunction *func, MeFuncResultMgr *m, ModuleResultMgr *mrm) override; diff --git a/src/maple_me/include/me_store_pre.h b/src/maple_me/include/me_store_pre.h index 78e2f2bac9aec94e339cd63c01a6456a24c11fef..967c53ea83240f0bb4c2050e976e0f05755214c7 100644 --- a/src/maple_me/include/me_store_pre.h +++ b/src/maple_me/include/me_store_pre.h @@ -16,17 +16,18 @@ #define MAPLE_ME_INCLUDE_MESTOREPRE_H #include "me_ssu_pre.h" #include "me_alias_class.h" + namespace maple { class MeStorePre : public MeSSUPre { public: - MeStorePre(MeFunction *f, Dominance *dom, AliasClass *ac, MemPool *memPool, bool enabledDebug) - : MeSSUPre(f, dom, memPool, kStorePre, enabledDebug), aliasClass(ac), curTemp(nullptr), + MeStorePre(MeFunction &f, Dominance &dom, AliasClass &ac, MemPool &memPool, bool enabledDebug) + : MeSSUPre(f, dom, memPool, kStorePre, enabledDebug), aliasClass(&ac), curTemp(nullptr), bbCurTempMap(spreAllocator.Adapter()) {} virtual ~MeStorePre() = default; private: - inline bool IsJavaLang() { + inline bool IsJavaLang() const { return mirModule->IsJavaModule(); } AliasClass *aliasClass; @@ -35,14 +36,14 @@ class MeStorePre : public MeSSUPre { MapleUnorderedMap bbCurTempMap; // map bb to curTemp version // step 6 methods void CheckCreateCurTemp(); - RegMeExpr *EnsureRHSInCurTemp(BB *bb); + RegMeExpr *EnsureRHSInCurTemp(BB &bb); void CodeMotion(); // step 0 methods - void CreateRealOcc(OStIdx ostIdx, MeStmt *meStmt); - void CreateUseOcc(OStIdx ostIdx, BB *bb); - void CreateSpreUseOccsThruAliasing(const OriginalSt *muOst, BB *bb); - void FindAndCreateSpreUseOccs(MeExpr *meExpr, BB *bb); - void CreateSpreUseOccsForAll(BB *bb); + void CreateRealOcc(OStIdx ostIdx, MeStmt &meStmt); + void CreateUseOcc(OStIdx ostIdx, BB &bb) const; + void CreateSpreUseOccsThruAliasing(const OriginalSt &muOst, BB &bb) const; + void FindAndCreateSpreUseOccs(const MeExpr &meExpr, BB &bb) const; + void CreateSpreUseOccsForAll(BB &bb) const; void BuildWorkListBB(BB *bb); void PerCandInit() { curTemp = nullptr; diff --git a/src/maple_me/include/occur.h b/src/maple_me/include/occur.h index ccfb644be1cd2a09fc9ed1f26a6d9b9fd42ff427..f589be93b089f0e10bc21b28753bd2a8e6771262 100644 --- a/src/maple_me/include/occur.h +++ b/src/maple_me/include/occur.h @@ -18,6 +18,7 @@ #include "me_function.h" #include "irmap.h" const int kWorkCandHashLength = 229; + namespace maple { enum OccType { kOccUndef, @@ -35,11 +36,11 @@ class MePhiOcc; class MeOccur { public: MeOccur(OccType ty, int cId, MeOccur *df) : occTy(ty), classID(cId), mirBB(nullptr), def(df) {} - MeOccur(OccType ty, int cId, BB *bb, MeOccur *df) : occTy(ty), classID(cId), mirBB(bb), def(df) {} + MeOccur(OccType ty, int cId, BB &bb, MeOccur *df) : occTy(ty), classID(cId), mirBB(&bb), def(df) {} virtual ~MeOccur() = default; - virtual void Dump(IRMap&); + virtual void Dump(const IRMap&) const; void DumpOccur(IRMap&); - bool IsDominate(Dominance *dom, MeOccur*); + bool IsDominate(Dominance &dom, MeOccur&); const BB *GetBB() const { return mirBB; } @@ -80,6 +81,7 @@ class MeOccur { def = define; } MeExpr *GetSavedExpr(); + private: OccType occTy; // kinds of occ int classID; // class id @@ -106,7 +108,7 @@ class MeRealOcc : public MeOccur { } ~MeRealOcc() = default; - void Dump(IRMap&); + void Dump(const IRMap&) const; const MeStmt *GetMeStmt() const { return meStmt; } @@ -194,6 +196,7 @@ class MeRealOcc : public MeOccur { void SetIsFormalAtEntry(bool isFormal) { isFormalAtEntry = isFormal; } + private: MeStmt *meStmt; // the stmt that has this occ MeExpr *meExpr; // the expr it's corresponding to @@ -208,11 +211,11 @@ class MeRealOcc : public MeOccur { class MeInsertedOcc : public MeOccur { public: - MeInsertedOcc(MeExpr *expr, MeStmt *stmt, BB *bb) + MeInsertedOcc(MeExpr *expr, MeStmt *stmt, BB &bb) : MeOccur(kOccInserted, 0, bb, nullptr), meExpr(expr), meStmt(stmt), savedExpr(nullptr) {} ~MeInsertedOcc() = default; - void Dump(IRMap&); + void Dump(const IRMap&) const; const MeStmt *GetMeStmt() const { return meStmt; } @@ -252,6 +255,7 @@ class MeInsertedOcc : public MeOccur { void SetSavedExpr(MeExpr &expr) { savedExpr = &expr; } + private: MeExpr *meExpr; MeStmt *meStmt; @@ -260,7 +264,7 @@ class MeInsertedOcc : public MeOccur { class MePhiOpndOcc : public MeOccur { public: - MePhiOpndOcc(BB *bb) + explicit MePhiOpndOcc(BB &bb) : MeOccur(kOccPhiopnd, 0, bb, nullptr), isProcessed(false), hasRealUse(false), @@ -271,8 +275,8 @@ class MePhiOpndOcc : public MeOccur { } ~MePhiOpndOcc() = default; - bool IsOkToInsert(); - void Dump(IRMap&); + bool IsOkToInsert() const; + void Dump(const IRMap&) const; bool IsProcessed() const { return isProcessed; } @@ -340,6 +344,7 @@ class MePhiOpndOcc : public MeOccur { void SetCurrentMeStmt(MeStmt &stmt) { currentExpr.meStmt = &stmt; } + private: bool isProcessed; bool hasRealUse; @@ -354,15 +359,15 @@ class MePhiOpndOcc : public MeOccur { class MePhiOcc : public MeOccur { public: - MePhiOcc(BB *bb, MapleAllocator *alloc) + MePhiOcc(BB &bb, MapleAllocator &alloc) : MeOccur(kOccPhiocc, 0, bb, nullptr), - isDownSafe(!bb->GetAttributes(kBBAttrIsCatch)), + isDownSafe(!bb.GetAttributes(kBBAttrIsCatch)), speculativeDownSafe(false), isCanBeAvail(true), isLater(true), isExtraneous(false), isRemoved(false), - phiOpnds(alloc->Adapter()), + phiOpnds(alloc.Adapter()), regPhi(nullptr), varPhi(nullptr) {} @@ -464,8 +469,9 @@ class MePhiOcc : public MeOccur { void SetVarPhi(MeVarPhiNode &phi) { varPhi = φ } - bool IsOpndDefByRealOrInserted(); - void Dump(IRMap&); + + bool IsOpndDefByRealOrInserted() const; + void Dump(const IRMap&) const; private: bool isDownSafe; // default is true bool speculativeDownSafe; // is downsafe due to speculation @@ -481,10 +487,10 @@ class MePhiOcc : public MeOccur { // each singly linked list repersents each bucket in workCandHashTable class PreWorkCand { public: - PreWorkCand(MapleAllocator *alloc, int32 idx, MeExpr *meExpr, PUIdx pIdx) + PreWorkCand(MapleAllocator &alloc, int32 idx, MeExpr *meExpr, PUIdx pIdx) : next(nullptr), index(idx), - realOccs(alloc->Adapter()), + realOccs(alloc.Adapter()), theMeExpr(meExpr), puIdx(pIdx), hasLocalOpnd(false), @@ -494,10 +500,10 @@ class PreWorkCand { } virtual ~PreWorkCand() = default; - void Dump(IRMap *irMap) { - irMap->GetSSATab().GetModule().GetOut() << "========index: " << index << " has the following occ\n"; + void Dump(const IRMap &irMap) const { + irMap.GetSSATab().GetModule().GetOut() << "========index: " << index << " has the following occ\n"; for (MeOccur *occ : realOccs) { - occ->Dump(*irMap); + occ->Dump(irMap); } } @@ -510,14 +516,14 @@ class PreWorkCand { } } - void AddRealOccSorted(Dominance &dom, MeRealOcc &occ, PUIdx pIdx); + void AddRealOccSorted(const Dominance &dom, MeRealOcc &occ, PUIdx pIdx); PrimType GetPrimType() const { PrimType pTyp = theMeExpr->GetPrimType(); CHECK_FATAL(pTyp != kPtyInvalid, "invalid primtype"); return pTyp; } - static uint32 ComputeWorkCandHashIndex(MeExpr &meExpr); + static uint32 ComputeWorkCandHashIndex(const MeExpr &meExpr); virtual void DumpCand(IRMap &irMap) { theMeExpr->Dump(&irMap); } @@ -615,6 +621,7 @@ class PreWorkCand { static void SetWorkCandAt(size_t idx, PreWorkCand &workCand) { workCandHashTable[idx] = &workCand; } + private: PreWorkCand *next; int32 index; @@ -633,11 +640,11 @@ class PreWorkCand { class PreStmtWorkCand : public PreWorkCand { public: - PreStmtWorkCand(MapleAllocator *alloc, int32 idx, MeStmt *meStmt, PUIdx pIdx) - : PreWorkCand(alloc, idx, nullptr, pIdx), theMeStmt(meStmt), lhsIsFinal(false) {} + PreStmtWorkCand(MapleAllocator &alloc, int32 idx, MeStmt &meStmt, PUIdx pIdx) + : PreWorkCand(alloc, idx, nullptr, pIdx), theMeStmt(&meStmt), lhsIsFinal(false) {} virtual ~PreStmtWorkCand() = default; - static uint32 ComputeStmtWorkCandHashIndex(MeStmt &stmt); + static uint32 ComputeStmtWorkCandHashIndex(const MeStmt &stmt); void DumpCand(IRMap &irMap) { theMeStmt->Dump(&irMap); } @@ -661,6 +668,7 @@ class PreStmtWorkCand : public PreWorkCand { void SetLHSIsFinal(bool isFinal) { lhsIsFinal = isFinal; } + private: MeStmt *theMeStmt; // the statement of this workcand bool lhsIsFinal; // used only if candidate is an assignment diff --git a/src/maple_me/include/preg_renamer.h b/src/maple_me/include/preg_renamer.h index a50de0a8addfc02d8d3352cf6e451594f9b0465e..78f600a984e9049985934a5e2e8b0e5392e6f598 100644 --- a/src/maple_me/include/preg_renamer.h +++ b/src/maple_me/include/preg_renamer.h @@ -20,13 +20,13 @@ namespace maple { class PregRenamer { public: - PregRenamer(MemPool *memPool, MeFunction *f, MeIRMap *irMap, bool enabledDebug) - : alloc(memPool), func(f), irMap(irMap), enabledDebug(enabledDebug) {} + PregRenamer(MemPool &memPool, MeFunction &f, MeIRMap &irMap, bool enabledDebug) + : alloc(&memPool), func(&f), irMap(&irMap), enabledDebug(enabledDebug) {} virtual ~PregRenamer() = default; - void RunSelf(); + void RunSelf() const; private: - void EnqueDefUses(std::list &qu, RegMeExpr *node, std::set &curVisited); + void EnqueDefUses(std::list &qu, RegMeExpr *node, std::set &curVisited) const; MapleAllocator alloc; MeFunction *func; MeIRMap *irMap; diff --git a/src/maple_me/include/prop.h b/src/maple_me/include/prop.h index 9fa41df0f5d46ea919e298337ef821095865795b..3c62c09a9641df5c66e018082e031134a2c3f841 100644 --- a/src/maple_me/include/prop.h +++ b/src/maple_me/include/prop.h @@ -43,7 +43,7 @@ class Prop { protected: Dominance &dom; - virtual void UpdateCurFunction(BB&) { + virtual void UpdateCurFunction(BB&) const { } virtual bool LocalToDifferentPU(StIdx, const BB&) const { @@ -61,15 +61,15 @@ class Prop { const std::vector> &vstLiveStack) const; bool IvarIsFinalField(const IvarMeExpr &ivarMeExpr) const; bool Propagatable(const MeExpr &expr, const BB &fromBB, bool atParm) const; - MeExpr &PropVar(VarMeExpr &varmeExpr, bool atParm, bool checkPhi); - MeExpr &PropReg(RegMeExpr ®meExpr, bool atParm); - MeExpr &PropIvar(IvarMeExpr &ivarMeExpr); + MeExpr &PropVar(VarMeExpr &varmeExpr, bool atParm, bool checkPhi) const; + MeExpr &PropReg(RegMeExpr ®meExpr, bool atParm) const; + MeExpr &PropIvar(IvarMeExpr &ivarMeExpr) const; MeExpr &PropMeExpr(MeExpr &meExpr, bool &isproped, bool atParm); - MeExpr *SimplifyMeExpr(OpMeExpr &opMeExpr); - MeExpr *SimplifyCvtMeExpr(const OpMeExpr &opMeExpr); - MeExpr *SimplifyCompareMeExpr(OpMeExpr &opMeExpr); + MeExpr *SimplifyMeExpr(OpMeExpr &opMeExpr) const; + MeExpr *SimplifyCvtMeExpr(const OpMeExpr &opMeExpr) const; + MeExpr *SimplifyCompareMeExpr(OpMeExpr &opMeExpr) const; MeExpr *SimplifyCompareSelectConstMeExpr(const OpMeExpr &opMeExpr, const MeExpr &opMeOpnd0, MeExpr &opnd1, - MeExpr &opnd01, MeExpr &opnd02); + MeExpr &opnd01, MeExpr &opnd02) const; IRMap &irMap; SSATab &ssaTab; diff --git a/src/maple_me/include/ssa_devirtual.h b/src/maple_me/include/ssa_devirtual.h index b07732e7b1a7ff7d18777b504116cd034531b324..6b1ca93657b5c342efa96df8b150b315edb22034 100644 --- a/src/maple_me/include/ssa_devirtual.h +++ b/src/maple_me/include/ssa_devirtual.h @@ -25,15 +25,15 @@ namespace maple { class SSADevirtual { public: static bool debug; - SSADevirtual(MemPool *memPool, MIRModule *currMod, IRMap *irMap, KlassHierarchy *currKh, - Dominance *currDom, size_t bbVecSize, Clone *currClone) - : devirtualAlloc(memPool), - mod(currMod), - irMap(irMap), - kh(currKh), - dom(currDom), + SSADevirtual(MemPool &memPool, MIRModule &currMod, IRMap &irMap, KlassHierarchy &currKh, + Dominance &currDom, size_t bbVecSize, Clone &currClone) + : devirtualAlloc(&memPool), + mod(&currMod), + irMap(&irMap), + kh(&currKh), + dom(&currDom), bbVisited(bbVecSize, false, devirtualAlloc.Adapter()), - clone(currClone), + clone(&currClone), retTy(kNotSeen), inferredRetTyIdx(0), totalVirtualCalls(0), @@ -44,27 +44,27 @@ class SSADevirtual { virtual ~SSADevirtual() = default; - void Perform(BB *entryBB); + void Perform(BB &entryBB); protected: - virtual MIRFunction *GetMIRFunction() { + virtual MIRFunction *GetMIRFunction() const { return nullptr; } - virtual BB *GetBB(BBId id) = 0; + virtual BB *GetBB(BBId id) const = 0; void TraversalBB(BB*); - void TraversalMeStmt(MeStmt *Stmt); - void VisitVarPhiNode(MeVarPhiNode*); - void VisitMeExpr(MeExpr*); - void PropVarInferredType(VarMeExpr*); - void PropIvarInferredType(IvarMeExpr*); - void ReturnTyIdxInferring(const RetMeStmt*); - bool NeedNullCheck(MeExpr*) const; - void InsertNullCheck(CallMeStmt*, MeExpr*); - bool DevirtualizeCall(CallMeStmt*); - void SSADevirtualize(CallNode *stmt); - void ReplaceCall(CallMeStmt*, MIRFunction*); - TyIdx GetInferredTyIdx(MeExpr *expr); + void TraversalMeStmt(MeStmt &Stmt); + void VisitVarPhiNode(MeVarPhiNode&) const; + void VisitMeExpr(MeExpr*) const; + void PropVarInferredType(VarMeExpr&) const; + void PropIvarInferredType(IvarMeExpr&) const; + void ReturnTyIdxInferring(const RetMeStmt&); + bool NeedNullCheck(const MeExpr&) const; + void InsertNullCheck(const CallMeStmt&, MeExpr&) const; + bool DevirtualizeCall(CallMeStmt&); + void SSADevirtualize(CallNode &stmt); + void ReplaceCall(CallMeStmt&, const MIRFunction&); + TyIdx GetInferredTyIdx(MeExpr &expr) const; private: MapleAllocator devirtualAlloc; diff --git a/src/maple_me/include/ssa_epre.h b/src/maple_me/include/ssa_epre.h index a5c5c0e7f26ba177168db5a4a6fb0e4272c2d644..237df61aee7db70a99bf40089227817ee0140805 100644 --- a/src/maple_me/include/ssa_epre.h +++ b/src/maple_me/include/ssa_epre.h @@ -26,28 +26,29 @@ class SSAEPre : public SSAPre { virtual ~SSAEPre() = default; private: - bool epreIncludeRef; - bool enableLHSIvar; - void GenerateSaveLHSRealocc(MeRealOcc *realOcc, MeExpr *regOrVar); - void GenerateSaveRealOcc(MeRealOcc *realOcc); - void GenerateReloadRealOcc(MeRealOcc *realOcc); - MeExpr *PhiOpndFromRes(MeRealOcc *realZ, size_t j); + void GenerateSaveLHSRealocc(MeRealOcc &realOcc, MeExpr ®OrVar); + void GenerateSaveRealOcc(MeRealOcc &realOcc); + void GenerateReloadRealOcc(MeRealOcc &realOcc); + MeExpr *PhiOpndFromRes(MeRealOcc &realZ, size_t j) const; void ComputeVarAndDfPhis(); - void BuildWorkListExpr(MeStmt *meStmt, int32 seqStmt, MeExpr*, bool isReBuild, MeExpr *tempVar, bool isRootExpr); - void BuildWorkListIvarLHSOcc(MeStmt *meStmt, int32 seqStmt, bool isReBuild, MeExpr *tempVar); - void CollectVarForMeExpr(MeExpr *meExpr, std::vector &varVec); - void CollectVarForCand(MeRealOcc *realOcc, std::vector &varVec); - bool LeafIsVolatile(MeExpr *x) { - VarMeExpr *v = safe_cast(x); + void BuildWorkListExpr(MeStmt &meStmt, int32 seqStmt, MeExpr&, bool isReBuild, MeExpr *tempVar, bool isRootExpr); + void BuildWorkListIvarLHSOcc(MeStmt &meStmt, int32 seqStmt, bool isReBuild, MeExpr *tempVar); + void CollectVarForMeExpr(MeExpr &meExpr, std::vector &varVec) const ; + void CollectVarForCand(MeRealOcc &realOcc, std::vector &varVec) const; + bool LeafIsVolatile(const MeExpr *x) const { + const VarMeExpr *v = safe_cast(x); return v != nullptr && v->IsVolatile(irMap->GetSSATab()); } - virtual bool IsThreadObjField(const IvarMeExpr &expr) { + virtual bool IsThreadObjField(const IvarMeExpr &expr) const { return false; } - virtual bool CfgHasDoWhile() { + virtual bool CfgHasDoWhile() const { return false; } + + bool epreIncludeRef; + bool enableLHSIvar; }; } // namespace maple #endif // MAPLE_ME_INCLUDE_SSAEPRE_H diff --git a/src/maple_me/include/ssa_mir_nodes.h b/src/maple_me/include/ssa_mir_nodes.h index 8f2239883ffa0a393a21f1208471200981224e74..3939e5c83cb416fbcf7c3bdee7b9997cd7f7da15 100644 --- a/src/maple_me/include/ssa_mir_nodes.h +++ b/src/maple_me/include/ssa_mir_nodes.h @@ -552,7 +552,7 @@ class RegreadSSANode : public SSANode { RegreadNode *regreadNode; }; -void GenericSSAPrint(MIRModule &mod, const StmtNode &stmtNode, int32 indent, StmtsSSAPart &stmtsSSAPart); +void GenericSSAPrint(const MIRModule &mod, const StmtNode &stmtNode, int32 indent, StmtsSSAPart &stmtsSSAPart); MapleMap *SSAGenericGetMayDefsFromVersionSt(const VersionSt &sym, StmtsSSAPart &stmtsSSAPart); bool HasMayUseOpnd(const BaseNode &baseNode, SSATab &func); } // namespace maple diff --git a/src/maple_me/include/ssa_pre.h b/src/maple_me/include/ssa_pre.h index 4080cea4bbde3814f75c026fde90c7c080bf85e3..b9cc744bfb28a635101726841aa324880d8e0c73 100644 --- a/src/maple_me/include/ssa_pre.h +++ b/src/maple_me/include/ssa_pre.h @@ -53,29 +53,29 @@ class SSAPre { virtual ~SSAPre() = default; void ApplySSAPRE(); - bool DefVarDominateOcc(MeExpr *meExpr, MeOccur *meOcc); - virtual void CollectVarForMeExpr(MeExpr *meExpr, std::vector &varVec) = 0; - virtual void CollectVarForCand(MeRealOcc *realOcc, std::vector &varVec) = 0; + bool DefVarDominateOcc(const MeExpr *meExpr, const MeOccur &meOcc) const; + virtual void CollectVarForMeExpr(MeExpr &meExpr, std::vector &varVec) const = 0; + virtual void CollectVarForCand(MeRealOcc &realOcc, std::vector &varVec) const = 0; const MapleVector &GetRealOccList() const { return workCand->GetRealOccs(); } - virtual MeExpr *CopyMeExpr(MeExpr &expr); - virtual MeStmt *CopyMeStmt(MeStmt &meStmt); - virtual IassignMeStmt *CopyIassignMeStmt(const IassignMeStmt &iaStmt); + virtual MeExpr *CopyMeExpr(const MeExpr &expr) const; + virtual MeStmt *CopyMeStmt(const MeStmt &meStmt) const; + virtual IassignMeStmt *CopyIassignMeStmt(const IassignMeStmt &iaStmt) const; void IncTreeid() { // Incremented by 2 for each tree; purpose is to avoid processing a node the third time inside a tree curTreeId += 2; } - virtual void DumpWorkList(); - virtual void DumpWorkListWrap(); + virtual void DumpWorkList() const; + virtual void DumpWorkListWrap() const; GStrIdx NewTempStrIdx(); - virtual BB *GetBB(BBId id) = 0; + virtual BB *GetBB(BBId id) const = 0; virtual PUIdx GetPUIdx() const = 0; - virtual void SetCurFunction(PUIdx) {} + virtual void SetCurFunction(PUIdx) const {} - virtual void GetIterDomFrontier(BB &bb, MapleSet &dfSet, std::vector &visitedMap) = 0; + virtual void GetIterDomFrontier(const BB &bb, MapleSet &dfSet, std::vector &visitedMap) const = 0; void SetSpillAtCatch(bool status) { spillAtCatch = status; } @@ -129,87 +129,50 @@ class SSAPre { } protected: - IRMap *irMap; - SSATab *ssaTab; - MIRModule *mirModule; - Dominance *dom; - MemPool *ssaPreMemPool; - MapleAllocator ssaPreAllocator; - MemPool *perCandMemPool; - MapleAllocator perCandAllocator; - MapleVector workList; - PreWorkCand *workCand = nullptr; // the current PreWorkCand - PreKind preKind; - - uint32 curTreeId = 0; // based on number of rooted trees processed in collecting - // PRE work candidates; incremented by 2 for each tree; - // purpose is to avoid processing a node the third time - // inside a tree (which is a DAG) - // the following 3 lists are all maintained in order of dt_preorder - MapleVector allOccs; // cleared at start of each workcand - MapleVector phiOccs; // cleared at start of each workcand - MapleVector exitOccs; // this is shared by all workcands - uint32 preLimit; // set by command-line option to limit the number of candidates optimized (for debugging purpose) - // step 1 phi insertion data structures - // following are set of BBs in terms of their dfn's; index into - // dominance->pdt_preorder to get their bbid's - MapleSet dfPhiDfns; // phis inserted due to dominance frontiers - MapleSet varPhiDfns; // phis inserted due to the var operands - // step 2 renaming data structures - uint32 classCount = 0; // count class created during renaming - MapleSet rename2Set; // set created by rename1 for use rename2; value - // is index into workCand->realOccs - // step 6 codemotion data structures - MeExpr *curTemp = nullptr; // the created temp for current workCand - VarMeExpr *curLocalRefVar = nullptr; // the created localrefvar for ref-type iread - MapleMap temp2LocalRefVarMap; - int32 reBuiltOccIndex = -1; // stores the size of worklist every time when try to add new worklist, update before - // each code motion - uint32 strIdxCount = 0; // ssapre will create a lot of temp variables if using var to store redundances, start from 0 // step 6 codemotion methods - MeExpr *CreateNewCurTemp(MeExpr *meExpr); + MeExpr *CreateNewCurTemp(const MeExpr &meExpr); VarMeExpr *CreateNewCurLocalRefVar(); - virtual void GenerateSaveRealOcc(MeRealOcc *realOcc) = 0; - virtual void GenerateReloadRealOcc(MeRealOcc *realOcc) = 0; - void GenerateSaveInsertedOcc(MeInsertedOcc *insertedOcc); - void GenerateSavePhiOcc(MePhiOcc *phiOcc); + virtual void GenerateSaveRealOcc(MeRealOcc &realOcc) = 0; + virtual void GenerateReloadRealOcc(MeRealOcc &realOcc) = 0; + void GenerateSaveInsertedOcc(MeInsertedOcc &insertedOcc); + void GenerateSavePhiOcc(MePhiOcc &phiOcc); void UpdateInsertedPhiOccOpnd(); virtual void CodeMotion(); // step 5 Finalize methods virtual void Finalize1(); - void SetSave(MeOccur *defX); - void SetReplacement(MePhiOcc *occ, MeOccur *repDef); + void SetSave(MeOccur &defX); + void SetReplacement(MePhiOcc &occ, MeOccur *repDef); virtual void Finalize2(); // step 4 willbevail methods - void ComputeCanBeAvail(); - void ResetCanBeAvail(MePhiOcc *occ); - void ComputeLater(); - void ResetLater(MePhiOcc *occ); + void ComputeCanBeAvail() const; + void ResetCanBeAvail(MePhiOcc &occ) const; + void ComputeLater() const; + void ResetLater(MePhiOcc *occ) const; // step 3 downsafety methods - void ResetDS(MePhiOpndOcc *phiOpnd); - void ComputeDS(); + void ResetDS(MePhiOpndOcc &phiOpnd) const; + void ComputeDS() const; // step 2 renaming methods - virtual bool AllVarsSameVersion(MeRealOcc *realOcc1, MeRealOcc *realOcc2) { - return realOcc1->GetMeExpr() == realOcc2->GetMeExpr(); + virtual bool AllVarsSameVersion(const MeRealOcc &realOcc1, const MeRealOcc &realOcc2) const { + return realOcc1.GetMeExpr() == realOcc2.GetMeExpr(); } void Rename1(); - MeExpr *GetReplaceMeExpr(MeExpr *opnd, const BB *ePhiBB, size_t j); - virtual MeExpr *PhiOpndFromRes(MeRealOcc *realOcc, size_t i) = 0; + MeExpr *GetReplaceMeExpr(const MeExpr &opnd, const BB &ePhiBB, size_t j) const; + virtual MeExpr *PhiOpndFromRes(MeRealOcc &realOcc, size_t i) const = 0; virtual void Rename2(); // step 1 phi insertion methods - void SetVarPhis(MeExpr *meExpr); + void SetVarPhis(const MeExpr &meExpr); virtual void ComputeVarAndDfPhis() = 0; virtual void CreateSortedOccs(); // phi insertion methods end virtual void BuildWorkList() = 0; - virtual void BuildEntryLHSOcc4Formals() {} + virtual void BuildEntryLHSOcc4Formals() const {} - virtual void BuildWorkListLHSOcc(MeStmt*, int32) {} + virtual void BuildWorkListLHSOcc(MeStmt&, int32) {} - virtual void BuildWorkListIvarLHSOcc(MeStmt*, int32, bool, MeExpr*) {} + virtual void BuildWorkListIvarLHSOcc(MeStmt&, int32, bool, MeExpr*) {} - virtual void BuildWorkListExpr(MeStmt *meStmt, int32 seqStmt, MeExpr *meExpr, bool isRebuilt, MeExpr *tempVar, + virtual void BuildWorkListExpr(MeStmt &meStmt, int32 seqStmt, MeExpr &meExpr, bool isRebuilt, MeExpr *tempVar, bool isRootExpr) = 0; virtual void BuildWorkListStmt(MeStmt* meStmt, uint32 seqStmt, bool isRebuilt, MeExpr *tempVar = nullptr); virtual void BuildWorkListBB(BB *bb); @@ -217,32 +180,71 @@ class SSAPre { void CreateMembarOcc(MeStmt &meStmt, int seqStmt); virtual void CreateMembarOccAtCatch(BB &bb); - void CreateExitOcc(BB *bb) { + void CreateExitOcc(BB &bb) { MeOccur *exitOcc = ssaPreMemPool->New(kOccExit, 0, bb, nullptr); exitOccs.push_back(exitOcc); } - bool CheckIfAnyLocalOpnd(MeExpr *meExpr); + bool CheckIfAnyLocalOpnd(const MeExpr &meExpr) const; MeRealOcc *CreateRealOcc(MeStmt &meStmt, int32 seqStmt, MeExpr &meExpr, bool isRebuilt, bool isLHS = false); virtual bool ScreenPhiBB(BBId bbId) const = 0; - virtual bool EpreLocalRefVar() { + virtual bool EpreLocalRefVar() const { return false; } - virtual void EnterCandsForSSAUpdate(OStIdx, BB*) {} + virtual void EnterCandsForSSAUpdate(OStIdx, const BB&) {} virtual bool IsLoopHeadBB(BBId) const { return false; } + IRMap *irMap; + SSATab *ssaTab; + MIRModule *mirModule; + Dominance *dom; + MemPool *ssaPreMemPool; + MapleAllocator ssaPreAllocator; + MemPool *perCandMemPool; + MapleAllocator perCandAllocator; + MapleVector workList; + PreWorkCand *workCand = nullptr; // the current PreWorkCand + PreKind preKind; + + uint32 curTreeId = 0; // based on number of rooted trees processed in collecting + // PRE work candidates; incremented by 2 for each tree; + // purpose is to avoid processing a node the third time + // inside a tree (which is a DAG) + // the following 3 lists are all maintained in order of dt_preorder + MapleVector allOccs; // cleared at start of each workcand + MapleVector phiOccs; // cleared at start of each workcand + MapleVector exitOccs; // this is shared by all workcands + uint32 preLimit; // set by command-line option to limit the number of candidates optimized (for debugging purpose) + // step 1 phi insertion data structures + // following are set of BBs in terms of their dfn's; index into + // dominance->pdt_preorder to get their bbid's + MapleSet dfPhiDfns; // phis inserted due to dominance frontiers + MapleSet varPhiDfns; // phis inserted due to the var operands + // step 2 renaming data structures + uint32 classCount = 0; // count class created during renaming + MapleSet rename2Set; // set created by rename1 for use rename2; value + // is index into workCand->realOccs + // step 6 codemotion data structures + MeExpr *curTemp = nullptr; // the created temp for current workCand + VarMeExpr *curLocalRefVar = nullptr; // the created localrefvar for ref-type iread + MapleMap temp2LocalRefVarMap; + int32 reBuiltOccIndex = -1; // stores the size of worklist every time when try to add new worklist, update before + // each code motion + uint32 strIdxCount = 0; // ssapre will create a lot of temp variables if using var to store redundances, start from 0 + private: + virtual void DoSSAFRE() {}; + bool enableDebug = false; bool rcLoweringEnabled = false; bool regReadAtReturn = false; bool spillAtCatch = false; bool placementRCEnabled = false; bool addedNewLocalRefVars = false; - virtual void DoSSAFRE() {}; }; } // namespace maple #endif // MAPLE_ME_INCLUDE_SSAPRE_H diff --git a/src/maple_me/include/ver_symbol.h b/src/maple_me/include/ver_symbol.h index f71514f23f09ff88907fb474e3951fd25e1b0055..5d2d92d38ec44f33a1b70fd6c8faa4c9915ba971 100644 --- a/src/maple_me/include/ver_symbol.h +++ b/src/maple_me/include/ver_symbol.h @@ -1,5 +1,5 @@ /* - * Copyright (c) [2019] Huawei Technologies Co.,Ltd.All rights reserved. + * Copyright (c) [2019-2020] Huawei Technologies Co.,Ltd.All rights reserved. * * OpenArkCompiler is licensed under the Mulan PSL v1. * You can use this software according to the terms and conditions of the Mulan PSL v1. @@ -214,7 +214,7 @@ class VersionStTable { return vstAlloc; } - void Dump(MIRModule *mod) const; + void Dump(const MIRModule *mod) const; private: MapleAllocator vstAlloc; // this stores versionStVector diff --git a/src/maple_me/src/bb.cpp b/src/maple_me/src/bb.cpp index 8a26c3e8e5cef10c59f3f8f94e1e57c76b600732..70aab5c5b61465098db873a981faf0f56f91a4e3 100644 --- a/src/maple_me/src/bb.cpp +++ b/src/maple_me/src/bb.cpp @@ -43,7 +43,7 @@ std::string BB::StrAttribute() const { return "NYI"; } -void BB::DumpBBAttribute(MIRModule *mod) const { +void BB::DumpBBAttribute(const MIRModule *mod) const { if (GetAttributes(kBBAttrIsEntry)) { mod->GetOut() << " Entry "; } @@ -287,7 +287,7 @@ MeStmt *BB::GetLastMe() { return &meStmtList.back(); } -void BB::RemoveMeStmt(MeStmt *meStmt) { +void BB::RemoveMeStmt(const MeStmt *meStmt) { CHECK_FATAL(meStmt != nullptr, "null ptr check"); meStmtList.erase(meStmt); } @@ -332,18 +332,18 @@ void BB::InsertMeStmtLastBr(MeStmt *inStmt) { } } -void BB::ReplaceMeStmt(MeStmt *stmt, MeStmt *newStmt) { +void BB::ReplaceMeStmt(const MeStmt *stmt, MeStmt *newStmt) { InsertMeStmtBefore(stmt, newStmt); RemoveMeStmt(stmt); } -void BB::DumpMeBB(IRMap &irMap) { +void BB::DumpMeBB(const IRMap &irMap) { for (MeStmt &meStmt : GetMeStmts()) { meStmt.Dump(&irMap); } } -void BB::DumpMeVarPiList(IRMap *irMap) { +void BB::DumpMeVarPiList(const IRMap *irMap) { if (meVarPiList.empty()) { return; } @@ -358,7 +358,7 @@ void BB::DumpMeVarPiList(IRMap *irMap) { std::cout << "<<<<<<<<<<<<<< PI Node End >>>>>>>>>>>>>>>>>>>>\n"; } -void BB::DumpMeVarPhiList(IRMap *irMap) { +void BB::DumpMeVarPhiList(const IRMap *irMap) { int count = 0; for (const auto &phi : meVarPhiList) { phi.second->Dump(irMap); @@ -370,7 +370,7 @@ void BB::DumpMeVarPhiList(IRMap *irMap) { } } -void BB::DumpMeRegPhiList(IRMap *irMap) { +void BB::DumpMeRegPhiList(const IRMap *irMap) { for (const auto &phi : meRegPhiList) { phi.second->Dump(irMap); } diff --git a/src/maple_me/src/dominance.cpp b/src/maple_me/src/dominance.cpp index d52a5cebbaadfa56740781f7f278b70608048029..e3cd899b8f787ed3ea4033ee359f875cb3868817 100644 --- a/src/maple_me/src/dominance.cpp +++ b/src/maple_me/src/dominance.cpp @@ -308,14 +308,14 @@ void Dominance::ComputePdtDfn() { } // true if b1 postdominates b2 -bool Dominance::PostDominate(const BB &bb1, BB &bb2) { +bool Dominance::PostDominate(const BB &bb1, const BB &bb2) { if (&bb1 == &bb2) { return true; } if (pdoms[bb2.GetBBId()] == nullptr) { return false; } - BB *impdom = &bb2; + const BB *impdom = &bb2; do { if (impdom == nullptr) { return false; diff --git a/src/maple_me/src/dse.cpp b/src/maple_me/src/dse.cpp index 59d5dc714d912663d011d5ef4b3ef577600467fd..8caa9052e5a8de4ee35a8fc3afdebfa5eb1f48a1 100644 --- a/src/maple_me/src/dse.cpp +++ b/src/maple_me/src/dse.cpp @@ -30,11 +30,11 @@ // Put all operands and mayUse nodes of the needed stmt into worklist. // 3. For the nodes in worklist mark the def stmt as needed just as step 2 and // pop the node from the worklist. -// 4. Repeat step 3 untile the worklist is empty. +// 4. Repeat step 3 until the worklist is empty. namespace maple { using namespace utils; -bool DSE::ExprNonDeletable(const BaseNode &expr) { +bool DSE::ExprNonDeletable(const BaseNode &expr) const { if (kOpcodeInfo.HasSideEffect(expr.GetOpCode())) { return true; } @@ -74,7 +74,7 @@ bool DSE::ExprNonDeletable(const BaseNode &expr) { return false; } -bool DSE::HasNonDeletableExpr(const StmtNode &stmt) { +bool DSE::HasNonDeletableExpr(const StmtNode &stmt) const { Opcode op = stmt.GetOpCode(); switch (op) { @@ -103,7 +103,7 @@ bool DSE::HasNonDeletableExpr(const StmtNode &stmt) { } } -bool DSE::StmtMustRequired(const StmtNode &stmt, BB &bb) { +bool DSE::StmtMustRequired(const StmtNode &stmt, const BB &bb) const { Opcode op = stmt.GetOpCode(); // special opcode stmt cannot be eliminated if (IsStmtMustRequire(op)) { @@ -115,14 +115,10 @@ bool DSE::StmtMustRequired(const StmtNode &stmt, BB &bb) { return true; } - if (HasNonDeletableExpr(stmt)) { - return true; - } - - return false; + return HasNonDeletableExpr(stmt); } -void DSE::DumpStmt(const StmtNode &stmt, const std::string &msg) { +void DSE::DumpStmt(const StmtNode &stmt, const std::string &msg) const { if (enableDebug) { LogInfo::MapleLogger() << msg; stmt.Dump(); diff --git a/src/maple_me/src/hdse.cpp b/src/maple_me/src/hdse.cpp index 4d2feebcd3d3e6ad5d23b08afd533a25678c1dc2..303051d10924c4a9915f6cb7b9fda12495a96d76 100644 --- a/src/maple_me/src/hdse.cpp +++ b/src/maple_me/src/hdse.cpp @@ -32,7 +32,7 @@ // Put all operands and mayUse nodes of the needed stmt into worklist. // 3. For the nodes in worklist mark the def stmt as needed just as step 2 and // pop the node from the worklist. -// 4. Repeat step 3 untile the worklist is empty. +// 4. Repeat step 3 until the worklist is empty. namespace maple { using namespace utils; @@ -178,21 +178,21 @@ void HDSE::PropagateUseLive(MeExpr &meExpr) { } } -bool HDSE::ExprNonDeletable(MeExpr &meExpr) { +bool HDSE::ExprNonDeletable(const MeExpr &meExpr) const { if (kOpcodeInfo.HasSideEffect(meExpr.GetOp())) { return true; } switch (meExpr.GetMeOp()) { case kMeOpReg: { - auto ®MeExpr = static_cast(meExpr); + auto ®MeExpr = static_cast(meExpr); return (regMeExpr.GetRegIdx() == -kSregThrownval); } case kMeOpVar: { - auto &varMeExpr = static_cast(meExpr); + auto &varMeExpr = static_cast(meExpr); return varMeExpr.IsVolatile(ssaTab); } case kMeOpIvar: { - auto &opIvar = static_cast(meExpr); + auto &opIvar = static_cast(meExpr); return opIvar.IsVolatile() || ExprNonDeletable(*opIvar.GetBase()); } case kMeOpOp: { @@ -202,7 +202,7 @@ bool HDSE::ExprNonDeletable(MeExpr &meExpr) { break; } case kMeOpNary: { - auto &opNary = static_cast(meExpr); + auto &opNary = static_cast(meExpr); if (meExpr.GetOp() == OP_intrinsicop) { IntrinDesc *intrinDesc = &IntrinDesc::intrinTable[opNary.GetIntrinsic()]; return (!intrinDesc->HasNoSideEffect()); @@ -220,7 +220,7 @@ bool HDSE::ExprNonDeletable(MeExpr &meExpr) { return false; } -bool HDSE::HasNonDeletableExpr(const MeStmt &meStmt) { +bool HDSE::HasNonDeletableExpr(const MeStmt &meStmt) const { Opcode op = meStmt.GetOp(); switch (op) { case OP_dassign: { @@ -304,7 +304,7 @@ void HDSE::MarkSingleUseLive(MeExpr &meExpr) { if (IsExprNeeded(meExpr)) { return; } - SetExprNeeded(&meExpr); + SetExprNeeded(meExpr); MeExprOp meOp = meExpr.GetMeOp(); switch (meOp) { case kMeOpVar: @@ -364,7 +364,7 @@ void HDSE::MarkStmtRequired(MeStmt &meStmt) { MarkControlDependenceLive(*meStmt.GetBB()); } -bool HDSE::StmtMustRequired(const MeStmt &meStmt, const BB &bb) { +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) { diff --git a/src/maple_me/src/irmap.cpp b/src/maple_me/src/irmap.cpp index 09c3783e10d7c4b7be3132cce8c0bd81830cba33..bef42a220a5d9f9f268af97fac9439412a8a5b58 100644 --- a/src/maple_me/src/irmap.cpp +++ b/src/maple_me/src/irmap.cpp @@ -237,18 +237,18 @@ RegMeExpr *IRMap::CreateRegRefMeExpr(MIRType &mirType) { return regReadExpr; } -RegMeExpr *IRMap::CreateRegRefMeExpr(MeExpr &meExpr) { +RegMeExpr *IRMap::CreateRegRefMeExpr(const MeExpr &meExpr) { MIRType *mirType = nullptr; switch (meExpr.GetMeOp()) { case kMeOpVar: { - auto &varMeExpr = static_cast(meExpr); + auto &varMeExpr = static_cast(meExpr); const OriginalSt *ost = ssaTab.GetOriginalStFromID(varMeExpr.GetOStIdx()); ASSERT(ost->GetTyIdx() != 0u, "expect ost->tyIdx to be initialized"); mirType = GlobalTables::GetTypeTable().GetTypeFromTyIdx(ost->GetTyIdx()); break; } case kMeOpIvar: { - auto &ivarMeExpr = static_cast(meExpr); + auto &ivarMeExpr = static_cast(meExpr); MIRType *ptrMirType = GlobalTables::GetTypeTable().GetTypeFromTyIdx(ivarMeExpr.GetTyIdx()); ASSERT(ptrMirType->GetKind() == kTypePointer, "must be point type for ivar"); auto *realMirType = static_cast(ptrMirType); @@ -266,7 +266,7 @@ RegMeExpr *IRMap::CreateRegRefMeExpr(MeExpr &meExpr) { } case kMeOpOp: if (meExpr.GetOp() == OP_retype) { - auto &opMeExpr = static_cast(meExpr); + auto &opMeExpr = static_cast(meExpr); ASSERT(opMeExpr.GetTyIdx() != 0u, "expect opMeExpr.tyIdx to be initialized"); mirType = GlobalTables::GetTypeTable().GetTypeFromTyIdx(opMeExpr.GetTyIdx()); break; @@ -680,7 +680,8 @@ MeExpr *IRMap::HashMeExpr(MeExpr &meExpr) { return resultExpr; } -MeExpr *IRMap::ReplaceMeExprExpr(MeExpr &origExpr, MeExpr &newExpr, size_t opndsSize, MeExpr &meExpr, MeExpr &repExpr) { +MeExpr *IRMap::ReplaceMeExprExpr(MeExpr &origExpr, MeExpr &newExpr, size_t opndsSize, + const MeExpr &meExpr, MeExpr &repExpr) { bool needRehash = false; for (size_t i = 0; i < opndsSize; ++i) { @@ -705,7 +706,7 @@ MeExpr *IRMap::ReplaceMeExprExpr(MeExpr &origExpr, MeExpr &newExpr, size_t opnds // replace meExpr with repexpr. meExpr must be a kid of origexpr // return repexpr's parent if replaced, otherwise return nullptr -MeExpr *IRMap::ReplaceMeExprExpr(MeExpr &origExpr, MeExpr &meExpr, MeExpr &repExpr) { +MeExpr *IRMap::ReplaceMeExprExpr(MeExpr &origExpr, const MeExpr &meExpr, MeExpr &repExpr) { if (origExpr.IsLeaf()) { return &origExpr; } @@ -742,7 +743,7 @@ MeExpr *IRMap::ReplaceMeExprExpr(MeExpr &origExpr, MeExpr &meExpr, MeExpr &repEx } } -bool IRMap::ReplaceMeExprStmtOpnd(uint32 opndID, MeStmt &meStmt, MeExpr &meExpr, MeExpr &repExpr) { +bool IRMap::ReplaceMeExprStmtOpnd(uint32 opndID, MeStmt &meStmt, const MeExpr &meExpr, MeExpr &repExpr) { MeExpr *opnd = meStmt.GetOpnd(opndID); if (opnd == &meExpr) { @@ -757,7 +758,7 @@ bool IRMap::ReplaceMeExprStmtOpnd(uint32 opndID, MeStmt &meStmt, MeExpr &meExpr, } // replace meExpr in meStmt with repexpr -bool IRMap::ReplaceMeExprStmt(MeStmt &meStmt, MeExpr &meExpr, MeExpr &repexpr) { +bool IRMap::ReplaceMeExprStmt(MeStmt &meStmt, const MeExpr &meExpr, MeExpr &repexpr) { bool isReplaced = false; Opcode op = meStmt.GetOp(); diff --git a/src/maple_me/src/me_abco.cpp b/src/maple_me/src/me_abco.cpp index 4c67fb1509aef12cafd68ab88c726da568ad11b9..dd6ac35af853492e83b41efaff5cb82d7b619bae 100644 --- a/src/maple_me/src/me_abco.cpp +++ b/src/maple_me/src/me_abco.cpp @@ -225,6 +225,7 @@ void MeABC::InsertPhiNodes() { for (size_t i = 0; i < newDefPoints.size(); ++i) { DefPoint *newDefStmt = newDefPoints[i]; BB *newDefBB = newDefStmt->GetBB(); + CHECK_NULL_FATAL(newDefBB); VarMeExpr *rhs = newDefStmt->GetRHS(); if (newDefStmt->IsPiStmt()) { BB *genByBB = newDefStmt->GetGeneratedByBB(); @@ -240,7 +241,6 @@ void MeABC::InsertPhiNodes() { oldDefBB = meFunc->GetCommonEntryBB(); CHECK_FATAL(rhs->IsZeroVersion(irMap->GetSSATab()), "must be"); } - CHECK_NULL_FATAL(newDefBB); CHECK_NULL_FATAL(oldDefBB); MapleSet &dfs = dom->GetDomFrontier(newDefBB->GetBBId()); for (auto bbID : dfs) { @@ -1226,6 +1226,19 @@ MeExpr *MeABC::ReplaceArrayExpr(MeExpr &rhs, MeExpr &naryMeExpr, MeStmt *ivarStm MeExpr *newNaryMeExpr = irMap->HashMeExpr(tmpNaryMeExpr); return newNaryMeExpr; } + if (rhs.GetMeOp() == kMeOpOp) { + auto &oldOpMeExpr = static_cast(rhs); + OpMeExpr newMeExpr(oldOpMeExpr, kInvalidExprID); + for (size_t i = 0; i < kOperandNumTernary; i++) { + if (oldOpMeExpr.GetOpnd(i) == nullptr) { + continue; + } + MeExpr *newOpnd = ReplaceArrayExpr(*(oldOpMeExpr.GetOpnd(i)), naryMeExpr, ivarStmt); + newMeExpr.SetOpnd(i, newOpnd); + } + MeExpr *newOpMeExpr = irMap->HashMeExpr(newMeExpr); + return newOpMeExpr; + } CHECK_FATAL(rhs.GetMeOp() == kMeOpIvar, "must be"); MeExpr *newBase = ReplaceArrayExpr(*static_cast(rhs).GetBase(), naryMeExpr, ivarStmt); CHECK_NULL_FATAL(newBase); @@ -1255,7 +1268,6 @@ bool MeABC::CleanABCInStmt(MeStmt &meStmt, NaryMeExpr &naryMeExpr) { break; } case OP_iassign: { - CHECK_FATAL(meStmt.GetRHS()->IsLeaf(), "must be"); MeExpr *lhs = static_cast(&meStmt)->GetLHSVal(); MeExpr *newLHS = ReplaceArrayExpr(*lhs, naryMeExpr, &meStmt); replaced = lhs != newLHS; diff --git a/src/maple_me/src/me_analyze_rc.cpp b/src/maple_me/src/me_analyze_rc.cpp index 7406b2ef96599dee856d982d867c502ec6125c24..bd959b69480e01d3e957628e8f1c29e94e50cb03 100644 --- a/src/maple_me/src/me_analyze_rc.cpp +++ b/src/maple_me/src/me_analyze_rc.cpp @@ -102,7 +102,7 @@ RCItem *AnalyzeRC::FindOrCreateRCItem(const OriginalSt &ost) { return rcItem; } -OriginalSt *AnalyzeRC::GetOriginalSt(const MeExpr &refLHS) { +OriginalSt *AnalyzeRC::GetOriginalSt(const MeExpr &refLHS) const { if (refLHS.GetMeOp() == kMeOpVar) { auto &varMeExpr = static_cast(refLHS); return ssaTab.GetSymbolOriginalStFromID(varMeExpr.GetOStIdx()); @@ -127,7 +127,7 @@ VarMeExpr *AnalyzeRC::GetZeroVersionVarMeExpr(const VarMeExpr &var) { // if it is callassigned, the incref has already been done in the callee; // if rhs is gcmalloc/gcmallocjarray, the refcount is already 1; // if rhs is neither dread or iread, it cannot be a pointer, so incref not needed -bool AnalyzeRC::NeedIncref(const MeStmt &stmt) { +bool AnalyzeRC::NeedIncref(const MeStmt &stmt) const { if (kOpcodeInfo.IsCallAssigned(stmt.GetOp())) { return false; } @@ -328,7 +328,7 @@ void AnalyzeRC::OptimizeRC() { } } -bool AnalyzeRC::NeedDecRef(RCItem &rcItem, MeExpr &expr) { +bool AnalyzeRC::NeedDecRef(RCItem &rcItem, MeExpr &expr) const { CHECK_FATAL((rcItem.nonLocal || rcItem.noAlias), "OptimizeRC: local pointers cannot have alias"); // see if the decref can be optimized away if (rcItem.nonLocal) { @@ -346,7 +346,7 @@ bool AnalyzeRC::NeedDecRef(RCItem &rcItem, MeExpr &expr) { return NeedDecRef(varMeExpr); } -bool AnalyzeRC::NeedDecRef(IvarMeExpr &ivar) { +bool AnalyzeRC::NeedDecRef(IvarMeExpr &ivar) const { auto *base = ivar.GetBase(); if (base->GetMeOp() != kMeOpVar) { return true; @@ -371,7 +371,7 @@ bool AnalyzeRC::NeedDecRef(IvarMeExpr &ivar) { return ivar.GetMu()->GetVstIdx() != ost->GetZeroVersionIndex() && ivar.GetMu()->GetDefBy() != kDefByNo; } -bool AnalyzeRC::NeedDecRef(const VarMeExpr &var) { +bool AnalyzeRC::NeedDecRef(const VarMeExpr &var) const { OriginalSt *ost = GetOriginalSt(var); return var.GetVstIdx() != ost->GetZeroVersionIndex() && var.GetDefBy() != kDefByNo; } diff --git a/src/maple_me/src/me_bypath_eh.cpp b/src/maple_me/src/me_bypath_eh.cpp index 24efe1c31edf8e41049d692594b0d7c1f57d30ba..0733891e8b7742d528a36ad20ba7d2dc92b17526 100644 --- a/src/maple_me/src/me_bypath_eh.cpp +++ b/src/maple_me/src/me_bypath_eh.cpp @@ -21,7 +21,7 @@ namespace maple { bool MeDoBypathEH::DoBypathException(BB *tryBB, BB *catchBB, const Klass *catchClass, const StIdx &stIdx, - const KlassHierarchy *kh, MeFunction *func, const StmtNode *syncExitStmt) { + const KlassHierarchy &kh, MeFunction &func, const StmtNode *syncExitStmt) const { std::vector tryBBV; std::set tryBBS; tryBBV.push_back(tryBB); @@ -40,11 +40,11 @@ bool MeDoBypathEH::DoBypathException(BB *tryBB, BB *catchBB, const Klass *catchC if (node->Opnd(0)->GetOpCode() == OP_dread) { auto *dread = static_cast(node->Opnd(0)); StIdx ehObjIdx = dread->GetStIdx(); - const MIRSymbol *ehObjSymbol = func->GetMirFunc()->GetLocalOrGlobalSymbol(ehObjIdx); + const MIRSymbol *ehObjSymbol = func.GetMirFunc()->GetLocalOrGlobalSymbol(ehObjIdx); MIRType *pType = GlobalTables::GetTypeTable().GetTypeFromTyIdx(ehObjSymbol->GetTyIdx()); CHECK_FATAL(pType->GetKind() == kTypePointer, "must be pointer"); TyIdx pTypeIdx = (static_cast(pType))->GetPointedType()->GetTypeIndex(); - throwClass = kh->GetKlassFromTyIdx(pTypeIdx); + throwClass = kh.GetKlassFromTyIdx(pTypeIdx); rhExpr = dread; } else if (node->Opnd(0)->GetOpCode() == OP_iread) { auto *iread = static_cast(node->Opnd(0)); @@ -56,21 +56,21 @@ bool MeDoBypathEH::DoBypathException(BB *tryBB, BB *catchBB, const Klass *catchC pType = GlobalTables::GetTypeTable().GetTypeFromTyIdx(structType->GetFieldTyIdx(iread->GetFieldID())); CHECK_FATAL(pType->GetKind() == kTypePointer, "must be pointer"); pTypeIdx = (static_cast(pType))->GetPointedType()->GetTypeIndex(); - throwClass = kh->GetKlassFromTyIdx(pTypeIdx); + throwClass = kh.GetKlassFromTyIdx(pTypeIdx); rhExpr = iread; } else { CHECK_FATAL(false, "Can't be here!"); } - if (!kh->IsSuperKlass(catchClass, throwClass)) { + if (!kh.IsSuperKlass(catchClass, throwClass)) { continue; } - MIRBuilder *mirBuilder = func->GetMIRModule().GetMIRBuilder(); + MIRBuilder *mirBuilder = func.GetMIRModule().GetMIRBuilder(); DassignNode *copyStmt = mirBuilder->CreateStmtDassign(stIdx, 0, rhExpr); bb->InsertStmtBefore(stmt, copyStmt); GotoNode *gotoNode = mirBuilder->CreateStmtGoto(OP_goto, catchBB->GetBBLabel()); bb->ReplaceStmt(stmt, gotoNode); if (syncExitStmt != nullptr) { - bb->InsertStmtBefore(gotoNode, syncExitStmt->CloneTree(func->GetMIRModule().GetCurFuncCodeMPAllocator())); + bb->InsertStmtBefore(gotoNode, syncExitStmt->CloneTree(func.GetMIRModule().GetCurFuncCodeMPAllocator())); } transformed = true; bb->GetSucc().insert(bb->GetSucc().begin(), catchBB); @@ -80,7 +80,7 @@ bool MeDoBypathEH::DoBypathException(BB *tryBB, BB *catchBB, const Klass *catchC // Add fall through bb if (bb->GetKind() == kBBFallthru && !bb->GetAttributes(kBBAttrIsTryEnd)) { bool findBB = false; - for (BB *bbTmp : func->GetAllBBs()) { + for (BB *bbTmp : func.GetAllBBs()) { if (findBB && bbTmp != nullptr) { if (bbTmp == catchBB || bbTmp->IsEmpty() || bbTmp->GetFirst().GetOpCode() == OP_try || bbTmp->GetAttributes(kBBAttrIsCatch)) { @@ -118,10 +118,10 @@ bool MeDoBypathEH::DoBypathException(BB *tryBB, BB *catchBB, const Klass *catchC return transformed; } -StmtNode *MeDoBypathEH::IsSyncExit(BB *syncBB, MeFunction *func, LabelIdx secondLabel) { +StmtNode *MeDoBypathEH::IsSyncExit(BB &syncBB, MeFunction &func, LabelIdx secondLabel) const { StmtNode *syncExitStmt = nullptr; - StmtNode *stmt = syncBB->GetFirst().GetNext(); - for (; stmt != nullptr && stmt != syncBB->GetLast().GetNext(); stmt = stmt->GetNext()) { + StmtNode *stmt = syncBB.GetFirst().GetNext(); + for (; stmt != nullptr && stmt != syncBB.GetLast().GetNext(); stmt = stmt->GetNext()) { if (stmt->GetOpCode() != OP_comment) { break; } @@ -135,13 +135,13 @@ StmtNode *MeDoBypathEH::IsSyncExit(BB *syncBB, MeFunction *func, LabelIdx second if (regreadNode->GetRegIdx() != -kSregThrownval) { return nullptr; } - for (stmt = stmt->GetNext(); stmt != nullptr && stmt != syncBB->GetLast().GetNext(); stmt = stmt->GetNext()) { + for (stmt = stmt->GetNext(); stmt != nullptr && stmt != syncBB.GetLast().GetNext(); stmt = stmt->GetNext()) { if (stmt->GetOpCode() == OP_comment) { continue; } if (stmt->GetOpCode() == OP_syncexit) { syncExitStmt = stmt; - if (stmt != &syncBB->GetLast()) { + if (stmt != &syncBB.GetLast()) { return nullptr; } } else { @@ -149,11 +149,11 @@ StmtNode *MeDoBypathEH::IsSyncExit(BB *syncBB, MeFunction *func, LabelIdx second } } - BB *prevBB = syncBB; + BB *prevBB = &syncBB; while (true) { BB *bbTmp = nullptr; - for (size_t i = prevBB->GetBBId() + 1; i < func->GetAllBBs().size(); i++) { - bbTmp = func->GetAllBBs()[i]; + for (size_t i = prevBB->GetBBId() + 1; i < func.GetAllBBs().size(); ++i) { + bbTmp = func.GetAllBBs()[i]; if (bbTmp != nullptr) { break; } @@ -196,13 +196,13 @@ StmtNode *MeDoBypathEH::IsSyncExit(BB *syncBB, MeFunction *func, LabelIdx second return syncExitStmt; } -void MeDoBypathEH::BypathException(MeFunction *func, const KlassHierarchy *kh) { +void MeDoBypathEH::BypathException(MeFunction &func, const KlassHierarchy &kh) const { // Condition check: - // 1. There is only one catch statement, and the catch can handle the thrown exception + // 1. There is only one catch statement, and the catch can handle the thrown exception auto labelIdx = static_cast(-1); // Some new bb will be created, so use visited std::set visited; - for (BB *bb : func->GetAllBBs()) { + for (BB *bb : func.GetAllBBs()) { if (bb == nullptr) { continue; } @@ -222,7 +222,7 @@ void MeDoBypathEH::BypathException(MeFunction *func, const KlassHierarchy *kh) { labelIdx = tryNode->GetOffset(0); } else if (tryNode->GetOffsetsCount() == 2) { // Deal with sync BB *catchBB = nullptr; - for (BB *bbInner : func->GetAllBBs()) { + for (BB *bbInner : func.GetAllBBs()) { if (bbInner == nullptr) { continue; } @@ -241,7 +241,7 @@ void MeDoBypathEH::BypathException(MeFunction *func, const KlassHierarchy *kh) { ASSERT(type->GetKind() == kTypePointer, "Must be pointer"); auto *pType = static_cast(type); if (pType->GetPointedTyIdx() == PTY_void) { - syncExitStmt = IsSyncExit(catchBB, func, tryNode->GetOffset(1)); + syncExitStmt = IsSyncExit(*catchBB, func, tryNode->GetOffset(1)); if (syncExitStmt != nullptr) { labelIdx = tryNode->GetOffset(1); } @@ -253,7 +253,7 @@ void MeDoBypathEH::BypathException(MeFunction *func, const KlassHierarchy *kh) { continue; } // Find catch label, and create a new bb - for (BB *bbInner : func->GetAllBBs()) { + for (BB *bbInner : func.GetAllBBs()) { if (bbInner == nullptr || bbInner->GetBBLabel() != labelIdx) { continue; } @@ -268,9 +268,9 @@ void MeDoBypathEH::BypathException(MeFunction *func, const KlassHierarchy *kh) { auto *pType = static_cast(type); Klass *catchClass = nullptr; if (pType->GetPointedTyIdx() == PTY_void) { - catchClass = kh->GetKlassFromName(NameMangler::kJavaLangExceptionStr); + catchClass = kh.GetKlassFromName(NameMangler::kJavaLangExceptionStr); } else { - catchClass = kh->GetKlassFromTyIdx(pType->GetPointedTyIdx()); + catchClass = kh.GetKlassFromTyIdx(pType->GetPointedTyIdx()); } if (stmtInner.GetNext() == nullptr || stmtInner.GetNext()->GetOpCode() != OP_dassign) { labelIdx = static_cast(-1); @@ -284,18 +284,18 @@ void MeDoBypathEH::BypathException(MeFunction *func, const KlassHierarchy *kh) { } // Insert goto label GStrIdx labelStrIdx = GlobalTables::GetStrTable().GetOrCreateStrIdxFromName("bypatheh" + - func->GetMirFunc()->GetLabelName(bbInner->GetBBLabel())); + func.GetMirFunc()->GetLabelName(bbInner->GetBBLabel())); BB *newBB = nullptr; bool hasCreated = false; - auto it = func->GetMirFunc()->GetLabelTab()->GetStrIdxToLabelIdxMap().find(labelStrIdx); - if (it == func->GetMirFunc()->GetLabelTab()->GetStrIdxToLabelIdxMap().end()) { - LabelIdx labIdx = func->GetMirFunc()->GetLabelTab()->AddLabel(labelStrIdx); - newBB = func->NewBasicBlock(); - func->SetLabelBBAt(labIdx, newBB); + auto it = func.GetMirFunc()->GetLabelTab()->GetStrIdxToLabelIdxMap().find(labelStrIdx); + if (it == func.GetMirFunc()->GetLabelTab()->GetStrIdxToLabelIdxMap().end()) { + LabelIdx labIdx = func.GetMirFunc()->GetLabelTab()->AddLabel(labelStrIdx); + newBB = func.NewBasicBlock(); + func.SetLabelBBAt(labIdx, newBB); newBB->SetBBLabel(labIdx); } else { hasCreated = true; - for (BB *newBBIter : func->GetAllBBs()) { + for (BB *newBBIter : func.GetAllBBs()) { if (newBBIter == nullptr) { continue; } @@ -307,18 +307,18 @@ void MeDoBypathEH::BypathException(MeFunction *func, const KlassHierarchy *kh) { } if (DoBypathException(bb, newBB, catchClass, dassignNode->GetStIdx(), kh, func, syncExitStmt)) { if (!hasCreated) { - ASSERT(newBB == func->GetLastBB(), "newBB should be the last one"); - func->GetAllBBs().pop_back(); - newBB = &func->SplitBB(*bbInner, *stmtInner.GetNext(), newBB); + ASSERT(newBB == func.GetLastBB(), "newBB should be the last one"); + func.GetAllBBs().pop_back(); + newBB = &func.SplitBB(*bbInner, *stmtInner.GetNext(), newBB); } } else { if (!hasCreated) { - func->GetAllBBs().pop_back(); - func->DecNextBBId(); - func->GetMirFunc()->GetLabelTab()->GetLabelTable().pop_back(); - func->EraseLabelBBAt( - func->GetMirFunc()->GetLabelTab()->GetStrIdxToLabelIdxMap().at(labelStrIdx)); - func->GetMirFunc()->GetLabelTab()->EraseStrIdxToLabelIdxElem(labelStrIdx); + func.GetAllBBs().pop_back(); + func.DecNextBBId(); + func.GetMirFunc()->GetLabelTab()->GetLabelTable().pop_back(); + func.EraseLabelBBAt( + func.GetMirFunc()->GetLabelTab()->GetStrIdxToLabelIdxMap().at(labelStrIdx)); + func.GetMirFunc()->GetLabelTab()->EraseStrIdxToLabelIdxElem(labelStrIdx); } } labelIdx = static_cast(-1); @@ -331,7 +331,7 @@ void MeDoBypathEH::BypathException(MeFunction *func, const KlassHierarchy *kh) { AnalysisResult *MeDoBypathEH::Run(MeFunction *func, MeFuncResultMgr*, ModuleResultMgr *mrm) { auto *kh = static_cast(mrm->GetAnalysisResult(MoPhase_CHA, &func->GetMIRModule())); CHECK_NULL_FATAL(kh); - BypathException(func, kh); + BypathException(*func, *kh); return nullptr; } } // namespace maple diff --git a/src/maple_me/src/me_cond_based_opt.cpp b/src/maple_me/src/me_cond_based_opt.cpp index 1c6ad7dd77721976e0a13298282ed30f002f1bb2..e347d4fe6936cbca43e47d8a14dad4e095a5e1eb 100644 --- a/src/maple_me/src/me_cond_based_opt.cpp +++ b/src/maple_me/src/me_cond_based_opt.cpp @@ -36,8 +36,9 @@ namespace maple { // check if varmeexpr is under the condition varmeexpr == 0 when expectedEq0 is true, // or varmeexpr != 0 if expectedEq0 is false -bool MeCondBased::NullValueFromOneTestCond(const VarMeExpr &varMeExpr, const BB &cdBB, const BB &bb, bool expectedEq0) { - auto &meStmts = cdBB.GetMeStmts(); +bool MeCondBased::NullValueFromOneTestCond(const VarMeExpr &varMeExpr, const BB &cdBB, + const BB &bb, bool expectedEq0) const { + const auto &meStmts = cdBB.GetMeStmts(); if (meStmts.empty()) { return false; } @@ -80,7 +81,7 @@ bool MeCondBased::NullValueFromOneTestCond(const VarMeExpr &varMeExpr, const BB return isJumptoBB ? ((isTrueBr && !isEq) || (!isTrueBr && isEq)) : ((isTrueBr && isEq) || (!isTrueBr && !isEq)); } -bool MeCondBased::NullValueFromTestCond(const VarMeExpr &varMeExpr, const BB &bb, bool expectedEq0) { +bool MeCondBased::NullValueFromTestCond(const VarMeExpr &varMeExpr, const BB &bb, bool expectedEq0) const { MapleSet *pdomFrt = &dominance->GetPdomFrontierItem(bb.GetBBId()); size_t bbSize = dominance->GetBBVecSize(); std::vector visitedMap(bbSize, false); @@ -100,9 +101,9 @@ bool MeCondBased::NullValueFromTestCond(const VarMeExpr &varMeExpr, const BB &bb return provenNull; } -bool MeCondBased::IsIreadWithTheBase(const VarMeExpr &var, const MeExpr &meExpr) { +bool MeCondBased::IsIreadWithTheBase(const VarMeExpr &var, const MeExpr &meExpr) const { if (meExpr.GetOp() == OP_iread) { - auto &ivarMeExpr = static_cast(meExpr); + const auto &ivarMeExpr = static_cast(meExpr); if (ivarMeExpr.GetBase()->GetExprID() == var.GetExprID()) { return true; } @@ -115,15 +116,15 @@ bool MeCondBased::IsIreadWithTheBase(const VarMeExpr &var, const MeExpr &meExpr) return false; } -bool MeCondBased::StmtHasDereferencedBase(const MeStmt &stmt, const VarMeExpr &var) { +bool MeCondBased::StmtHasDereferencedBase(const MeStmt &stmt, const VarMeExpr &var) const { if (stmt.GetOp() == OP_iassign) { - auto &iassStmt = static_cast(stmt); + const auto &iassStmt = static_cast(stmt); if (iassStmt.GetLHSVal()->GetBase()->GetExprID() == var.GetExprID()) { return true; } } if (stmt.GetOp() == OP_syncenter || stmt.GetOp() == OP_syncexit) { - auto &syncMeStmt = static_cast(stmt); + const auto &syncMeStmt = static_cast(stmt); const MapleVector &opnds = syncMeStmt.GetOpnds(); for (auto it = opnds.begin(); it != opnds.end(); ++it) { if ((*it)->GetExprID() == var.GetExprID()) { @@ -140,7 +141,8 @@ bool MeCondBased::StmtHasDereferencedBase(const MeStmt &stmt, const VarMeExpr &v return false; } -bool MeCondBased::PointerWasDereferencedBefore(const VarMeExpr &var, const UnaryMeStmt &assertMeStmt, const BB *bb) { +bool MeCondBased::PointerWasDereferencedBefore(const VarMeExpr &var, const UnaryMeStmt &assertMeStmt, + const BB &bb) const { // If var is defined in the function, let BBx be the BB that defines var. // If var is not defined, then let BBx be the function entry BB. // Let BBy be the current BB that contains the assertnonnull. @@ -151,16 +153,16 @@ bool MeCondBased::PointerWasDereferencedBefore(const VarMeExpr &var, const Unary if (bbx == nullptr) { return false; } - CHECK_FATAL(dominance->Dominate(*bbx, *bb), "bbx should dominate bb at this point"); + CHECK_FATAL(dominance->Dominate(*bbx, bb), "bbx should dominate bb at this point"); for (MeStmt *stmt = assertMeStmt.GetPrev(); stmt != nullptr; stmt = stmt->GetPrev()) { if (StmtHasDereferencedBase(*stmt, var)) { return true; } } - if (bbx == bb) { + if (bbx == &bb) { return false; } - BB *itBB = dominance->GetDom(bb->GetBBId()); + BB *itBB = dominance->GetDom(bb.GetBBId()); while (itBB != bbx) { // check if there is an iread or iassign in itbb whose base is var auto &meStmts = itBB->GetMeStmts(); @@ -180,7 +182,7 @@ bool MeCondBased::PointerWasDereferencedBefore(const VarMeExpr &var, const Unary return false; } -bool MeCondBased::PointerWasDereferencedRightAfter(const VarMeExpr &var, const UnaryMeStmt &assertMeStmt) { +bool MeCondBased::PointerWasDereferencedRightAfter(const VarMeExpr &var, const UnaryMeStmt &assertMeStmt) const { // assertnonnull(var) // t = iread(var, 0) // we can safely delete assertnonnull(var) @@ -194,7 +196,7 @@ bool MeCondBased::PointerWasDereferencedRightAfter(const VarMeExpr &var, const U return (nextMeStmt != nullptr) && StmtHasDereferencedBase(*nextMeStmt, var); } -bool MeCondBased::IsNotNullValue(const VarMeExpr &varMeExpr, const UnaryMeStmt &assertMeStmt, const BB *bb) { +bool MeCondBased::IsNotNullValue(const VarMeExpr &varMeExpr, const UnaryMeStmt &assertMeStmt, const BB &bb) const { const OriginalSt *varOst = func->GetMeSSATab()->GetSymbolOriginalStFromID(varMeExpr.GetOStIdx()); if (varOst->IsFormal() && varOst->GetMIRSymbol()->GetName() == kStrThisPointer) { return true; @@ -218,7 +220,7 @@ bool MeCondBased::IsNotNullValue(const VarMeExpr &varMeExpr, const UnaryMeStmt & return PointerWasDereferencedRightAfter(varMeExpr, assertMeStmt); } -void CondBasedNPC::DoCondBasedNPC() { +void CondBasedNPC::DoCondBasedNPC() const { auto eIt = GetFunc()->valid_end(); for (auto bIt = GetFunc()->valid_begin(); bIt != eIt; ++bIt) { auto *bb = *bIt; @@ -231,7 +233,7 @@ void CondBasedNPC::DoCondBasedNPC() { continue; } auto *varMeExpr = static_cast(assertMeStmt.GetOpnd()); - if (NullValueFromTestCond(*varMeExpr, *bb, false) || IsNotNullValue(*varMeExpr, assertMeStmt, bb)) { + if (NullValueFromTestCond(*varMeExpr, *bb, false) || IsNotNullValue(*varMeExpr, assertMeStmt, *bb)) { bb->RemoveMeStmt(&stmt); } } diff --git a/src/maple_me/src/me_critical_edge.cpp b/src/maple_me/src/me_critical_edge.cpp index 08e02510b1652b53c4f3496daf734408f9b7c663..98cbbd7f9cd06c6429a5ffeb9a373dc842f0ad8b 100644 --- a/src/maple_me/src/me_critical_edge.cpp +++ b/src/maple_me/src/me_critical_edge.cpp @@ -33,7 +33,7 @@ // The bblayout phase will determine the final layout order of the bbs. namespace maple { -void MeDoSplitCEdge::BreakCriticalEdge(MeFunction &func, BB &pred, BB &succ) { +void MeDoSplitCEdge::BreakCriticalEdge(MeFunction &func, BB &pred, BB &succ) const { if (DEBUGFUNC(&func)) { LogInfo::MapleLogger() << "******before break : critical edge : BB" << pred.GetBBId() << " -> BB" << succ.GetBBId() << "\n"; diff --git a/src/maple_me/src/me_delegate_rc.cpp b/src/maple_me/src/me_delegate_rc.cpp index 442c0e7be30c673364f676c2c23b750e1787d04d..c5abad9f715efc241d892fa14c6b7d2a02a4fa73 100644 --- a/src/maple_me/src/me_delegate_rc.cpp +++ b/src/maple_me/src/me_delegate_rc.cpp @@ -107,7 +107,7 @@ void DelegateRC::SaveDerefedOrCopiedVst(const MeExpr *expr) { } } -bool DelegateRC::IsCopiedOrDerefedOp(const Opcode op) const { +bool DelegateRC::IsCopiedOrDerefedOp(Opcode op) const { return op == OP_dassign || op == OP_maydassign || op == OP_regassign || op == OP_syncenter || op == OP_syncexit || op == OP_throw || op == OP_return || op == OP_iassign || // cause var copied kOpcodeInfo.IsCall(op); // callstmt need considering parameter @@ -124,11 +124,11 @@ void DelegateRC::CollectDerefedOrCopied(const MeStmt &stmt) { } } -void DelegateRC::CollectDerefedOrCopied(const MeExpr &x) { - Opcode op = x.GetOp(); +void DelegateRC::CollectDerefedOrCopied(const MeExpr &expr) { + Opcode op = expr.GetOp(); if (op == OP_iaddrof || op == OP_add) { - for (size_t i = 0; i < x.GetNumOpnds(); ++i) { - SaveDerefedOrCopiedVst(x.GetOpnd(i)); + for (size_t i = 0; i < expr.GetNumOpnds(); ++i) { + SaveDerefedOrCopiedVst(expr.GetOpnd(i)); } return; } @@ -137,8 +137,8 @@ void DelegateRC::CollectDerefedOrCopied(const MeExpr &x) { // in some cases, we have cvt from int to ref // dassign %Reg0_I 0 (cvt i32 ref (dread ref %Reg0_XXXX)) // cvt ref i32 (dread i32 %Reg0_I) - if (x.GetPrimType() == PTY_ref && x.GetOpnd(0)->GetMeOp() == kMeOpVar) { - auto *baseVar = static_cast(x.GetOpnd(0)); + if (expr.GetPrimType() == PTY_ref && expr.GetOpnd(0)->GetMeOp() == kMeOpVar) { + auto *baseVar = static_cast(expr.GetOpnd(0)); verStDerefedCopied[baseVar->GetVstIdx()] = true; // collect the def of basevar if (baseVar->GetDefBy() == kDefByStmt) { @@ -162,15 +162,15 @@ void DelegateRC::CollectDerefedOrCopied(const MeExpr &x) { } if (op == OP_array || - (op == OP_intrinsicop && static_cast(x).GetIntrinsic() == INTRN_JAVA_ARRAY_LENGTH) || - (op == OP_intrinsicopwithtype && static_cast(x).GetIntrinsic() == INTRN_JAVA_INSTANCE_OF)) { - CHECK_FATAL(x.GetNumOpnds() != 0, "container check"); - SaveDerefedOrCopiedVst(x.GetOpnd(0)); + (op == OP_intrinsicop && static_cast(expr).GetIntrinsic() == INTRN_JAVA_ARRAY_LENGTH) || + (op == OP_intrinsicopwithtype && static_cast(expr).GetIntrinsic() == INTRN_JAVA_INSTANCE_OF)) { + CHECK_FATAL(expr.GetNumOpnds() != 0, "container check"); + SaveDerefedOrCopiedVst(expr.GetOpnd(0)); return; } - if (x.GetMeOp() == kMeOpIvar) { - SaveDerefedOrCopiedVst(x.GetOpnd(0)); + if (expr.GetMeOp() == kMeOpIvar) { + SaveDerefedOrCopiedVst(expr.GetOpnd(0)); } } @@ -196,43 +196,43 @@ void DelegateRC::CollectVstCantDecrefEarly(MeExpr &opnd0, MeExpr &opnd1) { } } -void DelegateRC::CollectUseCounts(const MeExpr &x) { - if (x.GetMeOp() == kMeOpVar) { - const auto &varMeExpr = static_cast(x); +void DelegateRC::CollectUseCounts(const MeExpr &expr) { + if (expr.GetMeOp() == kMeOpVar) { + const auto &varMeExpr = static_cast(expr); ASSERT(varMeExpr.GetVstIdx() < verStUseCounts.size(), "CollectUsesInfo: vstIdx out of bounds"); verStUseCounts[varMeExpr.GetVstIdx()]++; } } -void DelegateRC::CollectUsesInfo(const MeExpr &x) { - for (size_t i = 0; i < x.GetNumOpnds(); ++i) { - CollectUsesInfo(*x.GetOpnd(i)); +void DelegateRC::CollectUsesInfo(const MeExpr &expr) { + for (size_t i = 0; i < expr.GetNumOpnds(); ++i) { + CollectUsesInfo(*expr.GetOpnd(i)); } - if ((x.GetOp() == OP_eq || x.GetOp() == OP_ne) && static_cast(x).GetOpndType() == PTY_ref) { - CollectVstCantDecrefEarly(*x.GetOpnd(0), *x.GetOpnd(1)); + if ((expr.GetOp() == OP_eq || expr.GetOp() == OP_ne) && static_cast(expr).GetOpndType() == PTY_ref) { + CollectVstCantDecrefEarly(*expr.GetOpnd(0), *expr.GetOpnd(1)); } - CollectDerefedOrCopied(x); - CollectUseCounts(x); + CollectDerefedOrCopied(expr); + CollectUseCounts(expr); } // traverse expression x; at each occurrence of rhsvar in x, decrement // remaining_uses -void DelegateRC::FindAndDecrUseCount(VarMeExpr *rhsVar, MeExpr *x, int32 &remainingUses) { - for (size_t i = 0; i < x->GetNumOpnds(); ++i) { - FindAndDecrUseCount(rhsVar, x->GetOpnd(i), remainingUses); +void DelegateRC::FindAndDecrUseCount(const VarMeExpr &rhsVar, const MeExpr &expr, int32 &remainingUses) const { + for (size_t i = 0; i < expr.GetNumOpnds(); ++i) { + FindAndDecrUseCount(rhsVar, *expr.GetOpnd(i), remainingUses); } - if (x == rhsVar) { - remainingUses--; + if (&expr == &rhsVar) { + --remainingUses; } } -bool DelegateRC::MayThrowException(MeStmt &stmt) { +bool DelegateRC::MayThrowException(const MeStmt &stmt) const { if (CheckOp(stmt, OP_maydassign) || CheckOp(stmt, OP_throw)) { return true; } if (CheckOp(stmt, OP_dassign)) { - auto &dass = static_cast(stmt); + const auto &dass = static_cast(stmt); const MeExpr *rhs = dass.GetRHS(); CHECK_NULL_FATAL(rhs); return dass.GetWasMayDassign() || rhs->GetOp() == OP_gcmalloc || rhs->GetOp() == OP_gcmallocjarray; @@ -243,12 +243,12 @@ bool DelegateRC::MayThrowException(MeStmt &stmt) { } if (IsIntrinsic(stmt)) { - auto &intrn = static_cast(stmt); + const auto &intrn = static_cast(stmt); return canThrowIntrinsicsList.find(intrn.GetIntrinsic()) != canThrowIntrinsicsList.end(); } if (kOpcodeInfo.IsCall(stmt.GetOp())) { - auto &callStmt = static_cast(stmt); + const auto &callStmt = static_cast(stmt); MIRFunction *callee = GlobalTables::GetFunctionTable().GetFunctionFromPuidx(callStmt.GetPUIdx()); return (!callee->GetFuncAttrs().GetAttr(FUNCATTR_nothrow_exception)) || (!MeOption::ignoreIPA && !callee->IsNoThrowException()); @@ -261,9 +261,9 @@ bool DelegateRC::MayThrowException(MeStmt &stmt) { // rhsvar, so it can be assumed that tostmt does not contain any use; this check // make use of verStUseCounts in its determination. In addition, if it comes // across any stmt that can raise exception, also return false. -bool DelegateRC::ContainAllTheUses(VarMeExpr *rhsVar, const MeStmt &fromStmt, const MeStmt *toStmt) { - int32 remainingUses = static_cast(verStUseCounts[rhsVar->GetVstIdx()]) - 1; - for (MeStmt *cur = fromStmt.GetPrev(); cur != toStmt; cur = cur->GetPrev()) { +bool DelegateRC::ContainAllTheUses(VarMeExpr &rhsVar, const MeStmt &fromStmt, const MeStmt &toStmt) const { + int32 remainingUses = static_cast(verStUseCounts[rhsVar.GetVstIdx()]) - 1; + for (MeStmt *cur = fromStmt.GetPrev(); cur != &toStmt; cur = cur->GetPrev()) { // do not count decref operands if (IsVarDecRefStmt(*cur)) { continue; @@ -275,7 +275,7 @@ bool DelegateRC::ContainAllTheUses(VarMeExpr *rhsVar, const MeStmt &fromStmt, co continue; } for (size_t i = 0; i < cur->NumMeStmtOpnds(); ++i) { - FindAndDecrUseCount(rhsVar, cur->GetOpnd(i), remainingUses); + FindAndDecrUseCount(rhsVar, *cur->GetOpnd(i), remainingUses); } } CHECK_FATAL(remainingUses >= 0, "ContainAllTheUses: inconsistent use count"); @@ -283,29 +283,29 @@ bool DelegateRC::ContainAllTheUses(VarMeExpr *rhsVar, const MeStmt &fromStmt, co } // return the RegMeExpr node to replace the original temp; nullptr if not successful -RegMeExpr *DelegateRC::RHSTempDelegated(MeExpr *rhs, MeStmt &useStmt) { - if (rhs->GetMeOp() != kMeOpVar) { +RegMeExpr *DelegateRC::RHSTempDelegated(MeExpr &rhs, MeStmt &useStmt) { + if (rhs.GetMeOp() != kMeOpVar) { return nullptr; } - auto *rhsVar = static_cast(rhs); - if (verStCantDelegate[rhsVar->GetVstIdx()]) { + auto &rhsVar = static_cast(rhs); + if (verStCantDelegate[rhsVar.GetVstIdx()]) { return nullptr; } - if (refVar2RegMap.find(rhsVar) != refVar2RegMap.end()) { + if (refVar2RegMap.find(&rhsVar) != refVar2RegMap.end()) { return nullptr; // already delegated by another assignment } - const OriginalSt *ost = ssaTab.GetOriginalStFromID(rhsVar->GetOStIdx()); + const OriginalSt *ost = ssaTab.GetOriginalStFromID(rhsVar.GetOStIdx()); if (ost->IsFormal() || ost->GetMIRSymbol()->IsGlobal()) { return nullptr; } - if (rhsVar->GetDefBy() == kDefByMustDef) { - MustDefMeNode &mustDef = rhsVar->GetDefMustDef(); - ASSERT(mustDef.GetLHS() == rhsVar, "DelegateRCTemp: inconsistent mustdef"); + if (rhsVar.GetDefBy() == kDefByMustDef) { + MustDefMeNode &mustDef = rhsVar.GetDefMustDef(); + ASSERT(mustDef.GetLHS() == &rhsVar, "DelegateRCTemp: inconsistent mustdef"); MeStmt *callStmt = mustDef.GetBase(); if (callStmt->GetBB() != useStmt.GetBB()) { return nullptr; } - if (!ContainAllTheUses(rhsVar, useStmt, callStmt)) { + if (!ContainAllTheUses(rhsVar, useStmt, *callStmt)) { return nullptr; } if (enabledDebug) { @@ -314,42 +314,42 @@ RegMeExpr *DelegateRC::RHSTempDelegated(MeExpr *rhs, MeStmt &useStmt) { callStmt->Dump(func.GetIRMap()); } // replace temp by a new preg - rhsVar->SetDefBy(kDefByNo); + rhsVar.SetDefBy(kDefByNo); RegMeExpr *curReg = nullptr; if (ost->GetMIRSymbol()->GetType()->GetPrimType() == PTY_ptr) { curReg = irMap.CreateRegMeExpr(PTY_ptr); } else { - curReg = irMap.CreateRegRefMeExpr(*rhsVar); + curReg = irMap.CreateRegRefMeExpr(rhsVar); } - refVar2RegMap[rhsVar] = curReg; // record this replacement + refVar2RegMap[&rhsVar] = curReg; // record this replacement mustDef.UpdateLHS(*curReg); if (enabledDebug) { LogInfo::MapleLogger() << "with stmt :\n" << '\n'; mustDef.GetBase()->Dump(func.GetIRMap()); } return curReg; - } else if (rhsVar->GetDefBy() == kDefByStmt) { - MeStmt *defStmt = rhsVar->GetDefStmt(); + } else if (rhsVar.GetDefBy() == kDefByStmt) { + MeStmt *defStmt = rhsVar.GetDefStmt(); if (defStmt->GetBB() != useStmt.GetBB()) { return nullptr; } - if (!ContainAllTheUses(rhsVar, useStmt, defStmt)) { + if (!ContainAllTheUses(rhsVar, useStmt, *defStmt)) { return nullptr; } MeExpr *rhsExpr = defStmt->GetRHS(); bool defStmtNeedIncref = defStmt->NeedIncref(); CHECK_FATAL(defStmt->GetOp() == OP_dassign || defStmt->GetOp() == OP_maydassign, "DelegateRCTemp: unexpected stmt op for kDefByStmt"); - ASSERT(defStmt->GetVarLHS() == rhsVar, "DelegateRCTemp: inconsistent def by dassign"); + ASSERT(defStmt->GetVarLHS() == &rhsVar, "DelegateRCTemp: inconsistent def by dassign"); if (enabledDebug) { LogInfo::MapleLogger() << "delegaterc of form A for func " << func.GetName() << '\n'; LogInfo::MapleLogger() << "\nreplace stmt :\n" << '\n'; defStmt->Dump(func.GetIRMap()); } // replace temp by a new preg - rhsVar->SetDefBy(kDefByNo); - RegMeExpr *curReg = irMap.CreateRegRefMeExpr(*rhsVar); - refVar2RegMap[rhsVar] = curReg; // record this replacement + rhsVar.SetDefBy(kDefByNo); + RegMeExpr *curReg = irMap.CreateRegRefMeExpr(rhsVar); + refVar2RegMap[&rhsVar] = curReg; // record this replacement // create new regassign statement MeStmt *regass = irMap.CreateRegassignMeStmt(*curReg, *rhsExpr, *defStmt->GetBB()); curReg->SetDefByStmt(*regass); @@ -393,7 +393,7 @@ void DelegateRC::DelegateRCTemp(MeStmt &stmt) { } MeExpr *rhs = stmt.GetRHS(); CHECK_FATAL(rhs != nullptr, "null rhs check"); - RegMeExpr *curReg = RHSTempDelegated(rhs, stmt); + RegMeExpr *curReg = RHSTempDelegated(*rhs, stmt); if (curReg != nullptr) { rhs = curReg; stmt.DisableNeedIncref(); @@ -408,7 +408,7 @@ void DelegateRC::DelegateRCTemp(MeStmt &stmt) { CHECK_FATAL(lhsVar != nullptr, "null lhs check"); MeExpr *rhs = stmt.GetRHS(); CHECK_FATAL(rhs != nullptr, "null rhs check"); - RegMeExpr *curReg = RHSTempDelegated(rhs, stmt); + RegMeExpr *curReg = RHSTempDelegated(*rhs, stmt); if (curReg != nullptr) { rhs = curReg; stmt.DisableNeedIncref(); @@ -428,8 +428,8 @@ void DelegateRC::DelegateRCTemp(MeStmt &stmt) { auto *val = static_cast(ret); if (val->GetDefBy() == kDefByMustDef) { MeStmt *defStmt = val->GetDefMustDef().GetBase(); - if (retStmt.GetBB() == defStmt->GetBB() && ContainAllTheUses(val, stmt, defStmt)) { - RegMeExpr *curReg = RHSTempDelegated(ret, stmt); + if (retStmt.GetBB() == defStmt->GetBB() && ContainAllTheUses(*val, stmt, *defStmt)) { + RegMeExpr *curReg = RHSTempDelegated(*ret, stmt); if (curReg != nullptr) { retStmt.SetOpnd(0, curReg); } @@ -446,8 +446,8 @@ void DelegateRC::DelegateRCTemp(MeStmt &stmt) { if (rhs->IsGcmalloc() || (rhs->GetMeOp() == kMeOpIvar && !static_cast(rhs)->IsFinal()) || (rhs->GetMeOp() == kMeOpVar && !ost->IsFinal() && ost->GetMIRSymbol()->IsGlobal()) || (rhs->GetOp() == OP_regread && static_cast(rhs)->GetRegIdx() == -kSregThrownval)) { - if (retStmt.GetBB() == defStmt->GetBB() && ContainAllTheUses(val, stmt, defStmt)) { - RegMeExpr *curReg = RHSTempDelegated(ret, stmt); + if (retStmt.GetBB() == defStmt->GetBB() && ContainAllTheUses(*val, stmt, *defStmt)) { + RegMeExpr *curReg = RHSTempDelegated(*ret, stmt); if (curReg != nullptr) { retStmt.SetOpnd(0, curReg); // Convert following cases: @@ -473,17 +473,17 @@ void DelegateRC::DelegateRCTemp(MeStmt &stmt) { } } -bool DelegateRC::FinalRefNoRC(const MeExpr &x) { - if (x.GetMeOp() == kMeOpVar) { - const auto &theVar = static_cast(x); +bool DelegateRC::FinalRefNoRC(const MeExpr &expr) const { + if (expr.GetMeOp() == kMeOpVar) { + const auto &theVar = static_cast(expr); const OriginalSt *ost = ssaTab.GetSymbolOriginalStFromID(theVar.GetOStIdx()); return ost->IsFinal() && ost->GetMIRSymbol()->IsGlobal(); - } else if (x.GetMeOp() == kMeOpIvar) { + } else if (expr.GetMeOp() == kMeOpIvar) { if (func.GetMirFunc()->IsConstructor() || func.GetMirFunc()->IsStatic() || func.GetMirFunc()->GetFormalCount() == 0) { return false; } - const auto &ivar = static_cast(x); + const auto &ivar = static_cast(expr); MIRType *ty = GlobalTables::GetTypeTable().GetTypeFromTyIdx(ivar.GetTyIdx()); ASSERT(ty->GetKind() == kTypePointer, "FinalRefNoRC: pointer type expected"); MIRType *pointedTy = static_cast(ty)->GetPointedType(); @@ -508,7 +508,7 @@ bool DelegateRC::FinalRefNoRC(const MeExpr &x) { // return true if it is OK to omit reference counting for the LHS variable; if // returning true, only_with_decref specifies whether a decref needs inserted -bool DelegateRC::CanOmitRC4LHSVar(const MeStmt &stmt, bool &onlyWithDecref) { +bool DelegateRC::CanOmitRC4LHSVar(const MeStmt &stmt, bool &onlyWithDecref) const { onlyWithDecref = false; switch (stmt.GetOp()) { case OP_dassign: @@ -638,16 +638,15 @@ void DelegateRC::DelegateHandleNoRCStmt(MeStmt &stmt, bool addDecref) { } } -void DelegateRC::RenameDelegatedRefVarUses(MeStmt &meStmt, MeExpr *meExpr) { - CHECK_NULL_FATAL(meExpr); - for (size_t i = 0; i < meExpr->GetNumOpnds(); ++i) { - RenameDelegatedRefVarUses(meStmt, meExpr->GetOpnd(i)); +void DelegateRC::RenameDelegatedRefVarUses(MeStmt &meStmt, MeExpr &meExpr) { + for (size_t i = 0; i < meExpr.GetNumOpnds(); ++i) { + RenameDelegatedRefVarUses(meStmt, *meExpr.GetOpnd(i)); } - if (meExpr->GetMeOp() == kMeOpVar) { - auto *varMeExpr = static_cast(meExpr); - auto it = refVar2RegMap.find(varMeExpr); + if (meExpr.GetMeOp() == kMeOpVar) { + auto &varMeExpr = static_cast(meExpr); + auto it = refVar2RegMap.find(&varMeExpr); if (it != refVar2RegMap.end()) { - irMap.ReplaceMeExprStmt(meStmt, *varMeExpr, *it->second); + irMap.ReplaceMeExprStmt(meStmt, varMeExpr, *it->second); } } } @@ -705,7 +704,7 @@ std::set DelegateRC::RenameAndGetLiveLocalRefVar() { } for (size_t i = 0; i < stmt.NumMeStmtOpnds(); ++i) { CHECK_FATAL(stmt.GetOpnd(i) != nullptr, "null mestmtopnd check"); - RenameDelegatedRefVarUses(stmt, stmt.GetOpnd(i)); + RenameDelegatedRefVarUses(stmt, *stmt.GetOpnd(i)); } // for live_localrefvars if (CheckOp(stmt, OP_dassign) || CheckOp(stmt, OP_maydassign)) { diff --git a/src/maple_me/src/me_inequality_graph.cpp b/src/maple_me/src/me_inequality_graph.cpp index a230ce2fc1dde700ed6e5117182ae2e14e9f8f41..7f272513c80f0354ec2bc53010364beaf1345554 100644 --- a/src/maple_me/src/me_inequality_graph.cpp +++ b/src/maple_me/src/me_inequality_graph.cpp @@ -120,12 +120,12 @@ namespace maple { from.InsertEdges(std::move(edge)); } - bool InequalityGraph::HasNode(MeExpr &meExpr) const { - return (varNodes.find(meExpr.GetExprID()) == varNodes.end()) ? false : true; + bool InequalityGraph::HasNode(const MeExpr &meExpr) const { + return varNodes.find(meExpr.GetExprID()) != varNodes.end(); } bool InequalityGraph::HasNode(int32 value) const { - return (constNodes.find(value) == constNodes.end()) ? false : true; + return constNodes.find(value) != constNodes.end(); } void InequalityGraph::ConnectTrivalEdge() { @@ -149,7 +149,7 @@ namespace maple { } } - ESSABaseNode &InequalityGraph::GetNode(MeExpr &meExpr) { + ESSABaseNode &InequalityGraph::GetNode(const MeExpr &meExpr) { CHECK_FATAL(HasNode(meExpr), "node is not created"); return *varNodes[meExpr.GetExprID()]; } @@ -320,14 +320,14 @@ namespace maple { fileBuf.close(); } - bool ABCD::DemandProve(MeExpr &arrayNode, MeExpr &idx) { + bool ABCD::DemandProve(const MeExpr &arrayNode, const MeExpr &idx) { ESSABaseNode &aNode = inequalityGraph->GetNode(arrayNode); ESSABaseNode *idxNode = nullptr; if (idx.GetMeOp() == kMeOpVar) { idxNode = &(inequalityGraph->GetNode(idx)); } else { CHECK_FATAL(idx.GetMeOp() == kMeOpConst, "must be"); - idxNode = &(inequalityGraph->GetNode(static_cast(idx).GetIntValue())); + idxNode = &(inequalityGraph->GetNode(static_cast(idx).GetIntValue())); } ESSABaseNode &zNode = inequalityGraph->GetNode(0); bool upperResult = ABCD::DemandProve(aNode, *idxNode, kUpper); @@ -335,10 +335,11 @@ namespace maple { return upperResult && lowerResult; } - bool ABCD::DemandProve(ESSABaseNode &aNode, ESSABaseNode &bNode, EdgeType eType) { - std::unique_ptr e = std::make_unique(eType == kUpper ? kUpperBound : kLowerBound, eType); + bool ABCD::DemandProve(ESSABaseNode &firstNode, ESSABaseNode &secondNode, EdgeType edgeType) { + std::unique_ptr e = + std::make_unique(edgeType == kUpper ? kUpperBound : kLowerBound, edgeType); active.clear(); - ProveResult res = Prove(aNode, bNode, *e.get()); + ProveResult res = Prove(firstNode, secondNode, *e.get()); return res == kTrue; } @@ -392,21 +393,21 @@ namespace maple { } active[&bNode] = &edge; - ProveResult res = bNode.GetKind() == kPhiNode ? UpdateCacheResult(aNode, bNode, edge, min) - : UpdateCacheResult(aNode, bNode, edge, max); + ProveResult res = bNode.GetKind() == kPhiNode ? UpdateCacheResult(aNode, bNode, edge, Min) + : UpdateCacheResult(aNode, bNode, edge, Max); active.erase(&bNode); tracing.pop_back(); return res; } - ProveResult ABCD::UpdateCacheResult(ESSABaseNode &aNode, ESSABaseNode &bNode, InequalEdge &edge, meet_function meet) { - ProveResult res = meet == min ? kReduced : kFalse; - if (meet == min) { + ProveResult ABCD::UpdateCacheResult(ESSABaseNode &aNode, ESSABaseNode &bNode, InequalEdge &edge, MeetFunction meet) { + ProveResult res = meet == Min ? kReduced : kFalse; + if (meet == Min) { CHECK_FATAL(bNode.GetKind() == kPhiNode, "must be"); auto& bPhiNode = static_cast(bNode); auto constEdgeMap = (edge.GetEdgeType() == kUpper) ? bPhiNode.GetInPhiEdgeMap() : bPhiNode.GetOutPhiEdgeMap(); for (auto iter = constEdgeMap.begin(); iter != constEdgeMap.end(); ++iter) { - if (((res == kTrue) && (meet == max)) || ((res == kFalse) && (meet == min))) { + if (((res == kTrue) && (meet == Max)) || ((res == kFalse) && (meet == Min))) { break; } InequalEdge *in = iter->second; @@ -433,7 +434,7 @@ namespace maple { if (in->GetPairEdge()) { in->GetPairEdge()->SetEdgeTypeInValid(); } - res = max(res, Prove(aNode, *(iter->first), nextEdge)); + res = Max(res, Prove(aNode, *(iter->first), nextEdge)); if (in->GetPairEdge()) { in->GetPairEdge()->SetEdgeTypeValid(); } diff --git a/src/maple_me/src/me_ir.cpp b/src/maple_me/src/me_ir.cpp index 793b45e4d9fbb5791b8d628f7e02316db15a646a..7d61832692ddde89a8db9e50779b6de5e06e72c7 100644 --- a/src/maple_me/src/me_ir.cpp +++ b/src/maple_me/src/me_ir.cpp @@ -691,7 +691,7 @@ MeExpr *AddroffuncMeExpr::GetIdenticalExpr(MeExpr &expr) const { return nullptr; } -void MeVarPhiNode::Dump(IRMap *irMap) const { +void MeVarPhiNode::Dump(const IRMap *irMap) const { if (isPiAdded) { LogInfo::MapleLogger() << "PI_ADD VAR:"; } @@ -712,7 +712,7 @@ void MeVarPhiNode::Dump(IRMap *irMap) const { LogInfo::MapleLogger() << '\n'; } -void MeRegPhiNode::Dump(IRMap *irMap) const { +void MeRegPhiNode::Dump(const IRMap *irMap) const { LogInfo::MapleLogger() << "REGVAR: " << lhs->GetRegIdx(); LogInfo::MapleLogger() << "(%" << irMap->GetMIRModule().CurFunction() @@ -731,7 +731,7 @@ void MeRegPhiNode::Dump(IRMap *irMap) const { LogInfo::MapleLogger() << "}" << '\n'; } -void VarMeExpr::Dump(IRMap *irMap, int32) const { +void VarMeExpr::Dump(const IRMap *irMap, int32) const { LogInfo::MapleLogger() << "VAR "; irMap->GetSSATab().GetOriginalStFromID(ostIdx)->Dump(); LogInfo::MapleLogger() << " (field)" << fieldID; @@ -741,7 +741,7 @@ void VarMeExpr::Dump(IRMap *irMap, int32) const { } } -void RegMeExpr::Dump(IRMap *irMap, int32) const { +void RegMeExpr::Dump(const IRMap *irMap, int32) const { LogInfo::MapleLogger() << "REGINDX:" << regIdx; LogInfo::MapleLogger() << " %" @@ -749,13 +749,13 @@ void RegMeExpr::Dump(IRMap *irMap, int32) const { LogInfo::MapleLogger() << " mx" << GetExprID(); } -void AddroffuncMeExpr::Dump(IRMap*, int32) const { +void AddroffuncMeExpr::Dump(const IRMap*, int32) const { LogInfo::MapleLogger() << "ADDROFFUNC:"; LogInfo::MapleLogger() << GlobalTables::GetFunctionTable().GetFunctionFromPuidx(puIdx)->GetName(); LogInfo::MapleLogger() << " mx" << GetExprID(); } -void GcmallocMeExpr::Dump(IRMap*, int32) const { +void GcmallocMeExpr::Dump(const IRMap*, int32) const { LogInfo::MapleLogger() << kOpcodeInfo.GetTableItemAt(GetOp()).name << " " << GetPrimTypeName(GetPrimType()); LogInfo::MapleLogger() << " "; GlobalTables::GetTypeTable().GetTypeFromTyIdx(tyIdx)->Dump(0); @@ -763,28 +763,28 @@ void GcmallocMeExpr::Dump(IRMap*, int32) const { LogInfo::MapleLogger() << " "; } -void ConstMeExpr::Dump(IRMap*, int32) const { +void ConstMeExpr::Dump(const IRMap*, int32) const { LogInfo::MapleLogger() << "CONST"; LogInfo::MapleLogger() << " "; constVal->Dump(); LogInfo::MapleLogger() << " mx" << GetExprID(); } -void ConststrMeExpr::Dump(IRMap*, int32) const { +void ConststrMeExpr::Dump(const IRMap*, int32) const { LogInfo::MapleLogger() << "CONSTSTR"; LogInfo::MapleLogger() << " "; LogInfo::MapleLogger() << strIdx; LogInfo::MapleLogger() << " mx" << GetExprID(); } -void Conststr16MeExpr::Dump(IRMap*, int32) const { +void Conststr16MeExpr::Dump(const IRMap*, int32) const { LogInfo::MapleLogger() << "CONSTSTR16"; LogInfo::MapleLogger() << " "; LogInfo::MapleLogger() << strIdx; LogInfo::MapleLogger() << " mx" << GetExprID(); } -void SizeoftypeMeExpr::Dump(IRMap*, int32) const { +void SizeoftypeMeExpr::Dump(const IRMap*, int32) const { LogInfo::MapleLogger() << kOpcodeInfo.GetTableItemAt(GetOp()).name << " " << GetPrimTypeName(GetPrimType()); LogInfo::MapleLogger() << " TYIDX:" << tyIdx; MIRType *mirType = GlobalTables::GetTypeTable().GetTypeFromTyIdx(tyIdx); @@ -792,7 +792,7 @@ void SizeoftypeMeExpr::Dump(IRMap*, int32) const { LogInfo::MapleLogger() << " mx" << GetExprID(); } -void FieldsDistMeExpr::Dump(IRMap*, int32) const { +void FieldsDistMeExpr::Dump(const IRMap*, int32) const { LogInfo::MapleLogger() << kOpcodeInfo.GetTableItemAt(GetOp()).name << " " << GetPrimTypeName(GetPrimType()); LogInfo::MapleLogger() << " TYIDX:" << tyIdx; MIRType *mirType = GlobalTables::GetTypeTable().GetTypeFromTyIdx(tyIdx); @@ -802,14 +802,14 @@ void FieldsDistMeExpr::Dump(IRMap*, int32) const { LogInfo::MapleLogger() << " mx" << GetExprID(); } -void AddrofMeExpr::Dump(IRMap *irMap, int32) const { +void AddrofMeExpr::Dump(const IRMap *irMap, int32) const { LogInfo::MapleLogger() << "ADDROF:"; irMap->GetSSATab().GetOriginalStFromID(ostIdx)->Dump(); LogInfo::MapleLogger() << " (field)" << fieldID; LogInfo::MapleLogger() << " mx" << GetExprID(); } -void OpMeExpr::Dump(IRMap *irMap, int32 indent) const { +void OpMeExpr::Dump(const IRMap *irMap, int32 indent) const { LogInfo::MapleLogger() << "OP " << kOpcodeInfo.GetTableItemAt(GetOp()).name; LogInfo::MapleLogger() << " mx" << GetExprID(); LogInfo::MapleLogger() << '\n'; @@ -835,7 +835,7 @@ void OpMeExpr::Dump(IRMap *irMap, int32 indent) const { opnds[2]->Dump(irMap, indent + 1); } -void IvarMeExpr::Dump(IRMap *irMap, int32 indent) const { +void IvarMeExpr::Dump(const IRMap *irMap, int32 indent) const { LogInfo::MapleLogger() << "IVAR mx" << GetExprID(); LogInfo::MapleLogger() << " " << GetPrimTypeName(GetPrimType()); LogInfo::MapleLogger() << " TYIDX:" << tyIdx; @@ -854,7 +854,7 @@ void IvarMeExpr::Dump(IRMap *irMap, int32 indent) const { LogInfo::MapleLogger() << "}"; } -void NaryMeExpr::Dump(IRMap *irMap, int32 indent) const { +void NaryMeExpr::Dump(const IRMap *irMap, int32 indent) const { ASSERT(static_cast(GetNumOpnds()) == opnds.size(), "array size error"); if (GetOp() == OP_array) { LogInfo::MapleLogger() << "ARRAY "; @@ -965,7 +965,7 @@ VarMeExpr *AssignedPart::GetAssignedPartLHSRef(SSATab &ssaTab, bool excludeLocal } // default Dump -void MeStmt::Dump(IRMap *irMap) const { +void MeStmt::Dump(const IRMap *irMap) const { if (op == OP_comment) { return; } @@ -981,7 +981,7 @@ MeStmt *MeStmt::GetNextMeStmt() const { return nextMeStmt; } -void PiassignMeStmt::Dump(IRMap *irMap) const { +void PiassignMeStmt::Dump(const IRMap *irMap) const { LogInfo::MapleLogger() << "||MEIR PI|| " << kOpcodeInfo.GetTableItemAt(GetOp()).name << " "; lhs->Dump(irMap); LogInfo::MapleLogger() << '\n'; @@ -991,7 +991,7 @@ void PiassignMeStmt::Dump(IRMap *irMap) const { LogInfo::MapleLogger() << '\n'; } -void DassignMeStmt::Dump(IRMap *irMap) const { +void DassignMeStmt::Dump(const IRMap *irMap) const { LogInfo::MapleLogger() << "||MEIR|| " << kOpcodeInfo.GetTableItemAt(GetOp()).name << " "; lhs->Dump(irMap); LogInfo::MapleLogger() << '\n'; @@ -1008,7 +1008,7 @@ void DassignMeStmt::Dump(IRMap *irMap) const { DumpChiList(irMap, chiList); } -void RegassignMeStmt::Dump(IRMap *irMap) const { +void RegassignMeStmt::Dump(const IRMap *irMap) const { LogInfo::MapleLogger() << "||MEIR|| " << kOpcodeInfo.GetTableItemAt(GetOp()).name << " "; lhs->Dump(irMap); LogInfo::MapleLogger() << '\n'; @@ -1021,7 +1021,7 @@ void RegassignMeStmt::Dump(IRMap *irMap) const { LogInfo::MapleLogger() << '\n'; } -void MaydassignMeStmt::Dump(IRMap *irMap) const { +void MaydassignMeStmt::Dump(const IRMap *irMap) const { LogInfo::MapleLogger() << "||MEIR|| " << kOpcodeInfo.GetTableItemAt(GetOp()).name << '\n'; PrintIndentation(kDefaultPrintIndentNum); LogInfo::MapleLogger() << "rhs = "; @@ -1036,7 +1036,7 @@ void MaydassignMeStmt::Dump(IRMap *irMap) const { DumpChiList(irMap, chiList); } -void ChiMeNode::Dump(IRMap *irMap) const { +void ChiMeNode::Dump(const IRMap *irMap) const { auto *meLHS = static_cast(lhs); auto *meRHS = static_cast(rhs); CHECK_FATAL(meLHS != nullptr, "Node doesn't have lhs?"); @@ -1049,7 +1049,7 @@ void ChiMeNode::Dump(IRMap *irMap) const { LogInfo::MapleLogger() << "mx" << meRHS->GetExprID() << "}"; } -void DumpMuList(IRMap *irMap, const MapleMap &muList) { +void DumpMuList(const IRMap *irMap, const MapleMap &muList) { if (muList.empty()) { return; } @@ -1075,7 +1075,7 @@ void DumpMuList(IRMap *irMap, const MapleMap &muList) { LogInfo::MapleLogger() << " }\n"; } -void DumpChiList(IRMap *irMap, const MapleMap &chiList) { +void DumpChiList(const IRMap *irMap, const MapleMap &chiList) { if (chiList.empty()) { return; } @@ -1097,7 +1097,7 @@ void DumpChiList(IRMap *irMap, const MapleMap &chiList) { LogInfo::MapleLogger() << " }\n"; } -void IassignMeStmt::Dump(IRMap *irMap) const { +void IassignMeStmt::Dump(const IRMap *irMap) const { LogInfo::MapleLogger() << "||MEIR|| " << kOpcodeInfo.GetTableItemAt(GetOp()).name << '\n'; PrintIndentation(kDefaultPrintIndentNum); LogInfo::MapleLogger() << "lhs = "; @@ -1116,7 +1116,7 @@ void IassignMeStmt::Dump(IRMap *irMap) const { DumpChiList(irMap, chiList); } -void NaryMeStmt::DumpOpnds(IRMap *irMap) const { +void NaryMeStmt::DumpOpnds(const IRMap *irMap) const { for (size_t i = 0; i < opnds.size(); ++i) { PrintIndentation(kDefaultPrintIndentNum); LogInfo::MapleLogger() << "opnd[" << i << "] = "; @@ -1125,12 +1125,12 @@ void NaryMeStmt::DumpOpnds(IRMap *irMap) const { } } -void NaryMeStmt::Dump(IRMap *irMap) const { +void NaryMeStmt::Dump(const IRMap *irMap) const { LogInfo::MapleLogger() << "||MEIR|| " << kOpcodeInfo.GetTableItemAt(GetOp()).name << " "; DumpOpnds(irMap); } -void AssignedPart::DumpAssignedPart(IRMap *irMap) const { +void AssignedPart::DumpAssignedPart(const IRMap *irMap) const { LogInfo::MapleLogger() << " assignedpart: {"; for (auto it = mustDefList.begin(); it != mustDefList.end(); ++it) { const MeExpr *lhsVar = (*it).GetLHS(); @@ -1145,7 +1145,7 @@ void AssignedPart::DumpAssignedPart(IRMap *irMap) const { LogInfo::MapleLogger() << "}\n"; } -void CallMeStmt::Dump(IRMap *irMap) const { +void CallMeStmt::Dump(const IRMap *irMap) const { LogInfo::MapleLogger() << "||MEIR|| " << kOpcodeInfo.GetTableItemAt(GetOp()).name << " "; if (tyIdx != 0u) { LogInfo::MapleLogger() << " TYIDX:" << tyIdx; @@ -1161,7 +1161,7 @@ void CallMeStmt::Dump(IRMap *irMap) const { DumpAssignedPart(irMap); } -void IcallMeStmt::Dump(IRMap *irMap) const { +void IcallMeStmt::Dump(const IRMap *irMap) const { LogInfo::MapleLogger() << "||MEIR|| " << kOpcodeInfo.GetTableItemAt(GetOp()).name << " "; LogInfo::MapleLogger() << " TYIDX:" << retTyIdx; DumpOpnds(irMap); @@ -1170,7 +1170,7 @@ void IcallMeStmt::Dump(IRMap *irMap) const { DumpAssignedPart(irMap); } -void IntrinsiccallMeStmt::Dump(IRMap *irMap) const { +void IntrinsiccallMeStmt::Dump(const IRMap *irMap) const { LogInfo::MapleLogger() << "||MEIR|| " << kOpcodeInfo.GetTableItemAt(GetOp()).name << " "; LogInfo::MapleLogger() << "TYIDX:" << tyIdx; MIRType *mirType = GlobalTables::GetTypeTable().GetTypeFromTyIdx(tyIdx); @@ -1184,13 +1184,13 @@ void IntrinsiccallMeStmt::Dump(IRMap *irMap) const { DumpAssignedPart(irMap); } -void RetMeStmt::Dump(IRMap *irMap) const { +void RetMeStmt::Dump(const IRMap *irMap) const { LogInfo::MapleLogger() << "||MEIR|| " << kOpcodeInfo.GetTableItemAt(GetOp()).name << '\n'; DumpOpnds(irMap); DumpMuList(irMap, muList); } -void CondGotoMeStmt::Dump(IRMap *irMap) const { +void CondGotoMeStmt::Dump(const IRMap *irMap) const { LogInfo::MapleLogger() << "||MEIR|| " << kOpcodeInfo.GetTableItemAt(GetOp()).name << '\n'; PrintIndentation(kDefaultPrintIndentNum); LogInfo::MapleLogger() << "cond: "; @@ -1198,7 +1198,7 @@ void CondGotoMeStmt::Dump(IRMap *irMap) const { LogInfo::MapleLogger() << '\n'; } -void UnaryMeStmt::Dump(IRMap *irMap) const { +void UnaryMeStmt::Dump(const IRMap *irMap) const { LogInfo::MapleLogger() << "||MEIR|| " << kOpcodeInfo.GetTableItemAt(GetOp()).name << '\n'; PrintIndentation(kDefaultPrintIndentNum); LogInfo::MapleLogger() << " unaryopnd: "; @@ -1206,7 +1206,7 @@ void UnaryMeStmt::Dump(IRMap *irMap) const { LogInfo::MapleLogger() << '\n'; } -void SwitchMeStmt::Dump(IRMap *irMap) const { +void SwitchMeStmt::Dump(const IRMap *irMap) const { LogInfo::MapleLogger() << "||MEIR|| " << kOpcodeInfo.GetTableItemAt(GetOp()).name << '\n'; PrintIndentation(kDefaultPrintIndentNum); LogInfo::MapleLogger() << "switchOpnd: "; @@ -1214,13 +1214,13 @@ void SwitchMeStmt::Dump(IRMap *irMap) const { LogInfo::MapleLogger() << '\n'; } -void GosubMeStmt::Dump(IRMap *irMap) const { +void GosubMeStmt::Dump(const IRMap *irMap) const { LogInfo::MapleLogger() << "||MEIR|| " << kOpcodeInfo.GetTableItemAt(GetOp()).name << '\n'; DumpMuList(irMap, *GetMuList()); LogInfo::MapleLogger() << '\n'; } -void ThrowMeStmt::Dump(IRMap *irMap) const { +void ThrowMeStmt::Dump(const IRMap *irMap) const { LogInfo::MapleLogger() << "||MEIR|| " << kOpcodeInfo.GetTableItemAt(GetOp()).name << '\n'; PrintIndentation(kDefaultPrintIndentNum); LogInfo::MapleLogger() << "throwopnd: "; @@ -1229,14 +1229,14 @@ void ThrowMeStmt::Dump(IRMap *irMap) const { DumpMuList(irMap, *GetMuList()); } -void SyncMeStmt::Dump(IRMap *irMap) const { +void SyncMeStmt::Dump(const IRMap *irMap) const { LogInfo::MapleLogger() << "||MEIR|| " << kOpcodeInfo.GetTableItemAt(GetOp()).name << '\n'; DumpOpnds(irMap); DumpMuList(irMap, muList); DumpChiList(irMap, chiList); } -bool MeStmt::IsTheSameWorkcand(MeStmt &mestmt) const { +bool MeStmt::IsTheSameWorkcand(const MeStmt &mestmt) const { if (op != mestmt.op) { return false; } @@ -1246,16 +1246,16 @@ bool MeStmt::IsTheSameWorkcand(MeStmt &mestmt) const { } } else if (op == OP_intrinsiccallwithtype) { if (static_cast(this)->GetTyIdx() != - static_cast(mestmt).GetTyIdx()) { + static_cast(mestmt).GetTyIdx()) { return false; } if (static_cast(this)->GetIntrinsic() != - static_cast(mestmt).GetIntrinsic()) { + static_cast(mestmt).GetIntrinsic()) { return false; } } else if (op == OP_callassigned) { auto *thisCass = static_cast(this); - auto &cass = static_cast(mestmt); + auto &cass = static_cast(mestmt); if (thisCass->GetPUIdx() != cass.GetPUIdx()) { return false; } @@ -1280,7 +1280,7 @@ bool MeStmt::IsTheSameWorkcand(MeStmt &mestmt) const { return true; } -void AssertMeStmt::Dump(IRMap *irMap) const { +void AssertMeStmt::Dump(const IRMap *irMap) const { LogInfo::MapleLogger() << "||MEIR|| " << kOpcodeInfo.GetTableItemAt(GetOp()).name << '\n'; PrintIndentation(kDefaultPrintIndentNum); LogInfo::MapleLogger() << "opnd[0] = "; diff --git a/src/maple_me/src/me_loop_analysis.cpp b/src/maple_me/src/me_loop_analysis.cpp index 86bff7118d69baad1fec3d7e1265f5aa339e01c4..ccc3abe8f9d3f71c4d86c0c984e00353b5ba455c 100644 --- a/src/maple_me/src/me_loop_analysis.cpp +++ b/src/maple_me/src/me_loop_analysis.cpp @@ -21,20 +21,20 @@ // always detected before its nested loop(s). The building of the LoopDesc data // structure takes advantage of this ordering. namespace maple { -LoopDesc *IdentifyLoops::CreateLoopDesc(BB *hd, BB *tail) { - LoopDesc *newLoop = meLoopMemPool->New(&meLoopAlloc, hd, tail); +LoopDesc *IdentifyLoops::CreateLoopDesc(BB &hd, BB &tail) { + LoopDesc *newLoop = meLoopMemPool->New(&meLoopAlloc, &hd, &tail); meLoops.push_back(newLoop); return newLoop; } -void IdentifyLoops::SetLoopParent4BB(const BB *bb, LoopDesc *loopDesc) { - if (bbLoopParent[bb->GetBBId()] != nullptr) { - if (loopDesc->parent == nullptr) { - loopDesc->parent = bbLoopParent[bb->GetBBId()]; - loopDesc->nestDepth = loopDesc->parent->nestDepth + 1; +void IdentifyLoops::SetLoopParent4BB(const BB &bb, LoopDesc &loopDesc) { + if (bbLoopParent[bb.GetBBId()] != nullptr) { + if (loopDesc.parent == nullptr) { + loopDesc.parent = bbLoopParent[bb.GetBBId()]; + loopDesc.nestDepth = loopDesc.parent->nestDepth + 1; } } - bbLoopParent[bb->GetBBId()] = loopDesc; + bbLoopParent[bb.GetBBId()] = &loopDesc; } // process each BB in preorder traversal of dominator tree @@ -45,7 +45,7 @@ void IdentifyLoops::ProcessBB(BB *bb) { for (BB *pred : bb->GetPred()) { if (dominance->Dominate(*bb, *pred)) { // create a loop with bb as loop head and pred as loop tail - LoopDesc *loop = CreateLoopDesc(bb, pred); + LoopDesc *loop = CreateLoopDesc(*bb, *pred); std::list bodyList; bodyList.push_back(pred); while (!bodyList.empty()) { @@ -56,13 +56,13 @@ void IdentifyLoops::ProcessBB(BB *bb) { continue; } loop->loopBBs.insert(curr->GetBBId()); - SetLoopParent4BB(curr, loop); + SetLoopParent4BB(*curr, *loop); for (BB *curPred : curr->GetPred()) { bodyList.push_back(curPred); } } loop->loopBBs.insert(bb->GetBBId()); - SetLoopParent4BB(bb, loop); + SetLoopParent4BB(*bb, *loop); } } // recursive call @@ -99,7 +99,7 @@ void IdentifyLoops::MarkBB() { AnalysisResult *MeDoMeLoop::Run(MeFunction *func, MeFuncResultMgr *m, ModuleResultMgr*) { auto *dom = static_cast(m->GetAnalysisResult(MeFuncPhase_DOMINANCE, func)); - ASSERT(dom, "dominance phase has problem"); + ASSERT(dom != nullptr, "dominance phase has problem"); MemPool *meLoopMp = NewMemPool(); IdentifyLoops *identLoops = meLoopMp->New(meLoopMp, func, dom); identLoops->ProcessBB(func->GetCommonEntryBB()); diff --git a/src/maple_me/src/me_loop_canon.cpp b/src/maple_me/src/me_loop_canon.cpp index d67947703acf4e530094024f2ac3772259296743..f90045b98b407d596e1b4b0a5ad6d5fcb840a1ff 100644 --- a/src/maple_me/src/me_loop_canon.cpp +++ b/src/maple_me/src/me_loop_canon.cpp @@ -49,19 +49,17 @@ static bool CompareBackedge(const std::pair &a, const std::pairGetBBId() < (b.first)->GetBBId(); } -bool MeDoLoopCanon::NeedConvert(BB *bb, BB *pred, MapleAllocator &localAlloc, MapleMap &swapSuccs) { - CHECK_FATAL(bb != nullptr, "bb should not be null"); - CHECK_FATAL(pred != nullptr, "pred should not be null"); - bb->SetAttributes(kBBAttrIsInLoop); - pred->SetAttributes(kBBAttrIsInLoop); +bool MeDoLoopCanon::NeedConvert(BB &bb, BB &pred, MapleAllocator &localAlloc, MapleMap &swapSuccs) const { + bb.SetAttributes(kBBAttrIsInLoop); + pred.SetAttributes(kBBAttrIsInLoop); // do not convert do-while loop - if ((bb->GetKind() != kBBCondGoto) || (pred == bb) || bb->GetAttributes(kBBAttrIsTry) || - bb->GetAttributes(kBBAttrIsCatch)) { + if ((bb.GetKind() != kBBCondGoto) || (&pred == &bb) || bb.GetAttributes(kBBAttrIsTry) || + bb.GetAttributes(kBBAttrIsCatch)) { return false; } - ASSERT(bb->GetSucc().size() == 2, "the number of bb's successors must equal 2"); + ASSERT(bb.GetSucc().size() == 2, "the number of bb's successors must equal 2"); // if both succs are equal, return false - if (bb->GetSucc().front() == bb->GetSucc().back()) { + if (bb.GetSucc().front() == bb.GetSucc().back()) { return false; } // check bb's succ both in loop body or not, such as @@ -73,12 +71,12 @@ bool MeDoLoopCanon::NeedConvert(BB *bb, BB *pred, MapleAllocator &localAlloc, Ma // / MapleSet inLoop(std::less(), localAlloc.Adapter()); MapleList bodyList(localAlloc.Adapter()); - bodyList.push_back(pred); + bodyList.push_back(&pred); while (!bodyList.empty()) { BB *curr = bodyList.front(); bodyList.pop_front(); // skip bb and bb is already in loop body(has been dealt with) - if (curr == bb || inLoop.count(curr->GetBBId()) == 1) { + if (curr == &bb || inLoop.count(curr->GetBBId()) == 1) { continue; } inLoop.insert(curr->GetBBId()); @@ -88,25 +86,23 @@ bool MeDoLoopCanon::NeedConvert(BB *bb, BB *pred, MapleAllocator &localAlloc, Ma tmpPred->SetAttributes(kBBAttrIsInLoop); } } - if ((inLoop.count(bb->GetSucc(0)->GetBBId()) == 1) && (inLoop.count(bb->GetSucc(1)->GetBBId()) == 1)) { + if ((inLoop.count(bb.GetSucc(0)->GetBBId()) == 1) && (inLoop.count(bb.GetSucc(1)->GetBBId()) == 1)) { return false; } // other case // fallthru is in loop body, latchBB need swap succs - if (inLoop.count(bb->GetSucc().at(0)->GetBBId()) == 1) { - swapSuccs.insert(make_pair(std::make_pair(bb, pred), true)); + if (inLoop.count(bb.GetSucc().at(0)->GetBBId()) == 1) { + swapSuccs.insert(make_pair(std::make_pair(&bb, &pred), true)); } return true; } -void MeDoLoopCanon::Convert(MeFunction *func, BB *bb, BB *pred, MapleMap &swapSuccs) { - ASSERT(bb != nullptr, "bb should not be null"); - ASSERT(pred != nullptr, "pred should not be null"); +void MeDoLoopCanon::Convert(MeFunction &func, BB &bb, BB &pred, MapleMap &swapSuccs) { // if bb->fallthru is in loopbody, latchBB need convert condgoto and make original target as its fallthru - bool swapSuccOfLatch = (swapSuccs.find(std::make_pair(bb, pred)) != swapSuccs.end()); - if (DEBUGFUNC(func)) { - LogInfo::MapleLogger() << "***loop convert: backedge bb->id_ " << bb->GetBBId() << " pred->id_ " - << pred->GetBBId(); + bool swapSuccOfLatch = (swapSuccs.find(std::make_pair(&bb, &pred)) != swapSuccs.end()); + if (DEBUGFUNC(&func)) { + LogInfo::MapleLogger() << "***loop convert: backedge bb->id_ " << bb.GetBBId() << " pred->id_ " + << pred.GetBBId(); if (swapSuccOfLatch) { LogInfo::MapleLogger() << " need swap succs\n"; } else { @@ -114,38 +110,38 @@ void MeDoLoopCanon::Convert(MeFunction *func, BB *bb, BB *pred, MapleMapNewBasicBlock(); + BB *latchBB = func.NewBasicBlock(); latchBB->SetAttributes(kBBAttrArtificial); // update pred bb - bb->RemoveBBFromPred(pred); - pred->ReplaceSucc(bb, latchBB); // replace pred->succ with latchBB and set pred of latchBB + bb.RemoveBBFromPred(&pred); + pred.ReplaceSucc(&bb, latchBB); // replace pred.succ with latchBB and set pred of latchBB // update pred stmt if needed - if (pred->GetKind() == kBBGoto) { - ASSERT(pred->GetAttributes(kBBAttrIsTry) || pred->GetSucc().size() == 1, "impossible"); - ASSERT(!pred->GetStmtNodes().empty(), "impossible"); - ASSERT(pred->GetStmtNodes().back().GetOpCode() == OP_goto, "impossible"); + if (pred.GetKind() == kBBGoto) { + ASSERT(pred.GetAttributes(kBBAttrIsTry) || pred.GetSucc().size() == 1, "impossible"); + ASSERT(!pred.GetStmtNodes().empty(), "impossible"); + ASSERT(pred.GetStmtNodes().back().GetOpCode() == OP_goto, "impossible"); // delete goto stmt and make pred is fallthru - pred->RemoveLastStmt(); - pred->SetKind(kBBFallthru); - } else if (pred->GetKind() == kBBCondGoto) { + pred.RemoveLastStmt(); + pred.SetKind(kBBFallthru); + } else if (pred.GetKind() == kBBCondGoto) { // if replaced bb is goto target - ASSERT(pred->GetAttributes(kBBAttrIsTry) || pred->GetSucc().size() == 2, + ASSERT(pred.GetAttributes(kBBAttrIsTry) || pred.GetSucc().size() == 2, "pred should have attr kBBAttrIsTry or have 2 successors"); - ASSERT(!pred->GetStmtNodes().empty(), "pred's stmtNodeList should not be empty"); - auto &condGotoStmt = static_cast(pred->GetStmtNodes().back()); - if (latchBB == pred->GetSucc().at(1)) { + ASSERT(!pred.GetStmtNodes().empty(), "pred's stmtNodeList should not be empty"); + auto &condGotoStmt = static_cast(pred.GetStmtNodes().back()); + if (latchBB == pred.GetSucc().at(1)) { // latchBB is the new target - LabelIdx label = func->GetOrCreateBBLabel(*latchBB); + LabelIdx label = func.GetOrCreateBBLabel(*latchBB); condGotoStmt.SetOffset(label); } - } else if (pred->GetKind() == kBBFallthru) { + } else if (pred.GetKind() == kBBFallthru) { // donothing - } else if (pred->GetKind() == kBBSwitch) { - ASSERT(!pred->GetStmtNodes().empty(), ""); - auto &switchStmt = static_cast(pred->GetStmtNodes().back()); - ASSERT(bb->GetBBLabel() != 0, ""); - LabelIdx oldlabIdx = bb->GetBBLabel(); - LabelIdx label = func->GetOrCreateBBLabel(*latchBB); + } else if (pred.GetKind() == kBBSwitch) { + ASSERT(!pred.GetStmtNodes().empty(), "bb is empty"); + auto &switchStmt = static_cast(pred.GetStmtNodes().back()); + ASSERT(bb.GetBBLabel() != 0, "wrong bb label"); + LabelIdx oldlabIdx = bb.GetBBLabel(); + LabelIdx label = func.GetOrCreateBBLabel(*latchBB); if (switchStmt.GetDefaultLabel() == oldlabIdx) { switchStmt.SetDefaultLabel(label); } @@ -159,14 +155,14 @@ void MeDoLoopCanon::Convert(MeFunction *func, BB *bb, BB *pred, MapleMapCloneBasicBlock(*latchBB, *bb); + func.CloneBasicBlock(*latchBB, bb); // clone bb's succ to latchBB - for (BB *succ : bb->GetSucc()) { + for (BB *succ : bb.GetSucc()) { ASSERT(!latchBB->GetAttributes(kBBAttrIsTry) || latchBB->GetSucc().empty(), - "loopcanon TODO: tryblock should insert succ before handler"); + "loopcanon : tryblock should insert succ before handler"); latchBB->AddSuccBB(succ); } - latchBB->SetKind(bb->GetKind()); + latchBB->SetKind(bb.GetKind()); // swap latchBB's succ if needed if (swapSuccOfLatch) { // modify condBr stmt @@ -175,7 +171,7 @@ void MeDoLoopCanon::Convert(MeFunction *func, BB *bb, BB *pred, MapleMapGetSucc(0); - LabelIdx label = func->GetOrCreateBBLabel(*fallthru); + LabelIdx label = func.GetOrCreateBBLabel(*fallthru); condGotoStmt.SetOffset(label); // swap succ BB *tmp = latchBB->GetSucc(0); @@ -228,7 +224,7 @@ AnalysisResult *MeDoLoopCanon::Run(MeFunction *func, MeFuncResultMgr *m, ModuleR ASSERT_NOT_NULL(pred); // bb is reachable from entry && bb dominator pred if (dom->Dominate(*func->GetCommonEntryBB(), *bb) && dom->Dominate(*bb, *pred) && - !pred->GetAttributes(kBBAttrWontExit) && (NeedConvert(bb, pred, localAlloc, swapSuccs))) { + !pred->GetAttributes(kBBAttrWontExit) && (NeedConvert(*bb, *pred, localAlloc, swapSuccs))) { if (DEBUGFUNC(func)) { LogInfo::MapleLogger() << "find backedge " << bb->GetBBId() << " <-- " << pred->GetBBId() << '\n'; } @@ -254,7 +250,11 @@ AnalysisResult *MeDoLoopCanon::Run(MeFunction *func, MeFuncResultMgr *m, ModuleR func->Dump(true); } for (auto it = backEdges.begin(); it != backEdges.end(); ++it) { - Convert(func, (*it).first, (*it).second, swapSuccs); + BB *bb = it->first; + BB *pred = it->second; + ASSERT(bb != nullptr, "bb should not be nullptr"); + ASSERT(pred != nullptr, "pred should not be nullptr"); + Convert(*func, *bb, *pred, swapSuccs); if (DEBUGFUNC(func)) { LogInfo::MapleLogger() << "-----------------Dump mefunction after loop convert-----------\n"; func->Dump(true); diff --git a/src/maple_me/src/me_lower_globals.cpp b/src/maple_me/src/me_lower_globals.cpp index e98cda45af5b36f3264113578a8b1eee5bea58d0..054c952df7a42520761bba3ce99d0f531927fb53 100644 --- a/src/maple_me/src/me_lower_globals.cpp +++ b/src/maple_me/src/me_lower_globals.cpp @@ -27,34 +27,34 @@ // The addroffunc is inserted as the extra first operand and the // call/callassinged is renamed to icall/icallassigned. namespace maple { -void MeLowerGlobals::LowerGlobalDreads(MeStmt &stmt, MeExpr *x) { - switch (x->GetMeOp()) { +void MeLowerGlobals::LowerGlobalDreads(MeStmt &stmt, MeExpr &expr) { + switch (expr.GetMeOp()) { case kMeOpOp: { - auto *meOpExpr = static_cast(x); + auto &meOpExpr = static_cast(expr); for (size_t i = 0; i < kOperandNumTernary; ++i) { - MeExpr *opnd = meOpExpr->GetOpnd(i); + MeExpr *opnd = meOpExpr.GetOpnd(i); if (opnd != nullptr) { - LowerGlobalDreads(stmt, opnd); + LowerGlobalDreads(stmt, *opnd); } } break; } case kMeOpNary: { - auto *naryMeExpr = static_cast(x); - MapleVector &opnds = naryMeExpr->GetOpnds(); + auto &naryMeExpr = static_cast(expr); + MapleVector &opnds = naryMeExpr.GetOpnds(); for (auto it = opnds.begin(); it != opnds.end(); ++it) { - LowerGlobalDreads(stmt, *it); + LowerGlobalDreads(stmt, **it); } break; } case kMeOpIvar: { - auto *ivarMeExpr = static_cast(x); - LowerGlobalDreads(stmt, ivarMeExpr->GetBase()); + auto &ivarMeExpr = static_cast(expr); + LowerGlobalDreads(stmt, *ivarMeExpr.GetBase()); break; } case kMeOpVar: { - auto *varExpr = static_cast(x); - OriginalSt *ost = ssaTable->GetSymbolOriginalStFromID(varExpr->GetOStIdx()); + auto &varExpr = static_cast(expr); + OriginalSt *ost = ssaTable->GetSymbolOriginalStFromID(varExpr.GetOStIdx()); if (ost->IsLocal()) { break; } @@ -64,19 +64,19 @@ void MeLowerGlobals::LowerGlobalDreads(MeStmt &stmt, MeExpr *x) { PUIdx puIdx = func->GetMirFunc()->GetPuidx(); baseOst = ssaTable->FindOrCreateSymbolOriginalSt(*ost->GetMIRSymbol(), puIdx, 0); } - auto *addrofExpr = static_cast(irMap->CreateAddrofMeExpr(*varExpr)); + auto *addrofExpr = static_cast(irMap->CreateAddrofMeExpr(varExpr)); MIRPtrType ptrType(baseOst->GetTyIdx(), PTY_ptr); TyIdx addrTyIdx = GlobalTables::GetTypeTable().GetOrCreateMIRType(&ptrType); - auto *ivarExpr = static_cast(irMap->CreateIvarMeExpr(*varExpr, addrTyIdx, *addrofExpr)); - (void)irMap->ReplaceMeExprStmt(stmt, *varExpr, *ivarExpr); + auto *ivarExpr = static_cast(irMap->CreateIvarMeExpr(varExpr, addrTyIdx, *addrofExpr)); + (void)irMap->ReplaceMeExprStmt(stmt, varExpr, *ivarExpr); break; } case kMeOpAddrof: { - auto *addrofExpr = static_cast(x); - if (addrofExpr->GetFieldID() == 0) { + auto &addrofExpr = static_cast(expr); + if (addrofExpr.GetFieldID() == 0) { break; } - OriginalSt *ost = ssaTable->GetSymbolOriginalStFromID(addrofExpr->GetOstIdx()); + OriginalSt *ost = ssaTable->GetSymbolOriginalStFromID(addrofExpr.GetOstIdx()); if (ost->IsLocal()) { break; } @@ -87,8 +87,8 @@ void MeLowerGlobals::LowerGlobalDreads(MeStmt &stmt, MeExpr *x) { MeExpr *newAddrofExpr = irMap->CreateAddrofMeExprFromSymbol(*ost->GetMIRSymbol(), puIdx); MIRPtrType ptrType(baseOst->GetTyIdx(), PTY_ptr); TyIdx addrTyIdx = GlobalTables::GetTypeTable().GetOrCreateMIRType(&ptrType); - MeExpr *iaddrofExpr = irMap->CreateIaddrofMeExpr(*addrofExpr, addrTyIdx, *newAddrofExpr); - (void)irMap->ReplaceMeExprStmt(stmt, *addrofExpr, *iaddrofExpr); + MeExpr *iaddrofExpr = irMap->CreateIaddrofMeExpr(addrofExpr, addrTyIdx, *newAddrofExpr); + (void)irMap->ReplaceMeExprStmt(stmt, addrofExpr, *iaddrofExpr); break; } default: @@ -102,7 +102,7 @@ void MeLowerGlobals::Run() { auto *bb = *bIt; for (auto &stmt : bb->GetMeStmts()) { for (size_t i = 0; i < stmt.NumMeStmtOpnds(); ++i) { - LowerGlobalDreads(stmt, stmt.GetOpnd(i)); + LowerGlobalDreads(stmt, *stmt.GetOpnd(i)); } if (stmt.GetOp() == OP_dassign) { auto &dass = static_cast(stmt); diff --git a/src/maple_me/src/me_rc_lowering.cpp b/src/maple_me/src/me_rc_lowering.cpp index 89b202af7a9da81076801c0913d4fb7fd1abf39c..6beee9bc69e0144cd81a4e701d8d382158081ca8 100644 --- a/src/maple_me/src/me_rc_lowering.cpp +++ b/src/maple_me/src/me_rc_lowering.cpp @@ -27,7 +27,7 @@ static inline bool CheckOp(const MeStmt *stmt, Opcode op) { return stmt != nullptr && stmt->GetOp() == op; } -static inline void CheckRemove(MeStmt *stmt, Opcode op) { +static inline void CheckRemove(const MeStmt *stmt, Opcode op) { if (CheckOp(stmt, op)) { stmt->GetBB()->RemoveMeStmt(stmt); } @@ -342,7 +342,67 @@ void RCLowering::HandleAssignMeStmtVarLHS(MeStmt &stmt, MeExpr *pendingDec) { assignedPtrSym.insert(lsym); } -void RCLowering::HandleAssignToGlobalVar(MeStmt &stmt) { +MIRType *RCLowering::GetArrayNodeType(const VarMeExpr &var) { + const MIRSymbol *arrayElemSym = ssaTab.GetMIRSymbolFromID(var.GetOStIdx()); + MIRType *baseType = arrayElemSym->GetType(); + MIRType *arrayElemType = nullptr; + if (baseType != nullptr) { + MIRType *stType = GlobalTables::GetTypeTable().GetTypeFromTyIdx( + static_cast(baseType)->GetPointedTyIdx()); + while (kTypeJArray == stType->GetKind()) { + MIRJarrayType *baseType1 = static_cast(stType); + MIRType *elemType = baseType1->GetElemType(); + if (elemType->GetKind() == kTypePointer) { + const TyIdx &index = static_cast(elemType)->GetPointedTyIdx(); + stType = GlobalTables::GetTypeTable().GetTypeFromTyIdx(index); + } else { + stType = elemType; + } + } + arrayElemType = stType; + } + return arrayElemType; +} + +void RCLowering::CheckArrayStore(const IntrinsiccallMeStmt &writeRefCall) { + if (!Options::checkArrayStore) { + return; + } + MIRIntrinsicID intrnID = writeRefCall.GetIntrinsic(); + if (!((INTRN_MCCWriteVolNoInc <= intrnID) && (intrnID <= INTRN_MCCWrite))) { + return; + } + if (writeRefCall.GetOpnd(1)->GetOp() != OP_iaddrof) { + return; + } + OpMeExpr *opExpr = static_cast(writeRefCall.GetOpnd(1)); + if (opExpr->GetOpnd(0)->GetOp() != OP_array) { + return; + } + MeExpr *arrayNode = writeRefCall.GetOpnd(0); + if (arrayNode->GetMeOp() != kMeOpVar) { + return; + } + VarMeExpr *arrayVar = static_cast(arrayNode); + MeExpr *valueNode = writeRefCall.GetOpnd(2); + if (valueNode->GetMeOp() != kMeOpVar) { + return; + } + MIRType *arrayElemType = GetArrayNodeType(*arrayVar); + MIRType *valueRealType = GetArrayNodeType(*(static_cast(valueNode))); + if ((arrayElemType != nullptr) && (arrayElemType->GetKind() == kTypeClass) && + static_cast(arrayElemType)->IsFinal() && + (valueRealType != nullptr) && (valueRealType->GetKind() == kTypeClass) && + static_cast(valueRealType)->IsFinal() && + (valueRealType->GetTypeIndex() == arrayElemType->GetTypeIndex())) { + return; + } + std::vector opnds = { arrayNode, valueNode }; + IntrinsiccallMeStmt *checkStmt = irMap.CreateIntrinsicCallMeStmt(INTRN_MCCCheckArrayStore, opnds); + writeRefCall.GetBB()->InsertMeStmtBefore(&writeRefCall, checkStmt); +} + +void RCLowering::HandleAssignToGlobalVar(const MeStmt &stmt) { MeExpr *lhs = stmt.GetLHS(); CHECK_FATAL(lhs != nullptr, "null ptr check"); MeExpr *rhs = stmt.GetRHS(); @@ -353,6 +413,7 @@ void RCLowering::HandleAssignToGlobalVar(MeStmt &stmt) { std::vector opnds = { irMap.CreateAddrofMeExpr(*lhs), rhs }; IntrinsiccallMeStmt *writeRefCall = CreateRCIntrinsic(SelectWriteBarrier(stmt), stmt, opnds); bb->ReplaceMeStmt(&stmt, writeRefCall); + CheckArrayStore(*writeRefCall); } void RCLowering::HandleAssignToLocalVar(MeStmt &stmt, MeExpr *pendingDec) { @@ -436,6 +497,7 @@ void RCLowering::HandleAssignMeStmtIvarLHS(MeStmt &stmt) { { &lhsInner->GetBase()->GetAddrExprBase(), irMap.CreateAddrofMeExpr(*lhsInner), rhsInner }; IntrinsiccallMeStmt *writeRefCall = CreateRCIntrinsic(intrinsicID, stmt, opnds); stmt.GetBB()->ReplaceMeStmt(&stmt, writeRefCall); + CheckArrayStore(*writeRefCall); } void RCLowering::HandleAssignMeStmt(MeStmt &stmt, MeExpr *pendingDec) { @@ -497,7 +559,7 @@ void RCLowering::RCLower() { } } -MeExpr *RCLowering::HandleIncRefAndDecRefStmt(MeStmt &stmt) { +MeExpr *RCLowering::HandleIncRefAndDecRefStmt(const MeStmt &stmt) { Opcode opCode = stmt.GetOp(); if (opCode == OP_decref) { stmt.GetBB()->RemoveMeStmt(&stmt); @@ -647,6 +709,10 @@ void RCLowering::HandleReturnRegread(RetMeStmt &ret) { cleanup->EraseOpnds(iter); cleanup->PushBackOpnd(retVar); // pin it to end of std::vector cleanup->SetIntrinsic(INTRN_MPL_CLEANUP_LOCALREFVARS_SKIP); + MIRSymbol *sym = ssaTab.GetMIRSymbolFromID(retVar->GetOStIdx()); + if (sym->GetAttr(ATTR_localrefvar)) { + func.GetMirFunc()->InsertMIRSymbol(sym); + } break; } } @@ -857,7 +923,7 @@ void RCLowering::CompactRC(BB &bb) { } } -void RCLowering::CompactIncAndDec(MeStmt &incStmt, MeStmt &decStmt) { +void RCLowering::CompactIncAndDec(const MeStmt &incStmt, const MeStmt &decStmt) { BB *bb = incStmt.GetBB(); CHECK_FATAL(bb != nullptr, "bb nullptr check"); MeExpr *incOpnd = incStmt.GetOpnd(0); @@ -872,7 +938,7 @@ void RCLowering::CompactIncAndDec(MeStmt &incStmt, MeStmt &decStmt) { bb->RemoveMeStmt(&decStmt); } -void RCLowering::CompactIncAndDecReset(MeStmt &incStmt, MeStmt &resetStmt) { +void RCLowering::CompactIncAndDecReset(const MeStmt &incStmt, const MeStmt &resetStmt) { BB *bb = incStmt.GetBB(); CHECK_FATAL(bb != nullptr, "bb nullptr check"); MeExpr *incOpnd = incStmt.GetOpnd(0); @@ -887,7 +953,7 @@ void RCLowering::CompactIncAndDecReset(MeStmt &incStmt, MeStmt &resetStmt) { bb->RemoveMeStmt(&incStmt); } -void RCLowering::ReplaceDecResetWithDec(MeStmt &prevStmt, MeStmt &stmt) { +void RCLowering::ReplaceDecResetWithDec(MeStmt &prevStmt, const MeStmt &stmt) { auto *addrofMeExpr = static_cast(stmt.GetOpnd(0)); ASSERT_NOT_NULL(addrofMeExpr); auto *dass = static_cast(&prevStmt); @@ -902,7 +968,7 @@ void RCLowering::ReplaceDecResetWithDec(MeStmt &prevStmt, MeStmt &stmt) { bb->RemoveMeStmt(&prevStmt); } -void RCLowering::CompactAdjacentDecReset(MeStmt &prevStmt, MeStmt &stmt) { +void RCLowering::CompactAdjacentDecReset(const MeStmt &prevStmt, const MeStmt &stmt) { MeExpr *prevOpnd = prevStmt.GetOpnd(0); MeExpr *curOpnd = stmt.GetOpnd(0); BB *bb = stmt.GetBB(); diff --git a/src/maple_me/src/me_rename2preg.cpp b/src/maple_me/src/me_rename2preg.cpp index 8c98d234ad343fdda70e30a0e6536a2a08ad566d..d151715df391e5b5691b12829e95a31f16192667 100644 --- a/src/maple_me/src/me_rename2preg.cpp +++ b/src/maple_me/src/me_rename2preg.cpp @@ -107,11 +107,11 @@ class CacheProxy final { preg = std::make_unique(irMap); } - OStCache &OSt() { + OStCache &OSt() const { return utils::ToRef(ost); } - PregCache &Preg() { + PregCache &Preg() const { return utils::ToRef(preg); } @@ -173,7 +173,7 @@ class FormalRenaming final { std::vector paramUsed; // if parameter is not used, it's false, otherwise true // if the parameter got promoted, the nth of func->mirfunc->_formal is the nth of reg_formal_vec, otherwise nullptr; - std::vector renamedReg; + std::vector renamedReg; }; class SSARename2Preg { @@ -201,7 +201,7 @@ class SSARename2Preg { for (auto it = func.valid_begin(), eIt = func.valid_end(); it != eIt; ++it) { BB &bb = utils::ToRef(*it); - // rename the phi'ss + // rename the phi's if (enabledDebug) { LogInfo::MapleLogger() << " working on phi part of BB" << bb.GetBBId() << '\n'; } @@ -278,7 +278,7 @@ class SSARename2Preg { } } } else if (auto *naryExpr = safe_cast(expr)) { - MapleVector &opnds = naryExpr->GetOpnds(); + MapleVector &opnds = naryExpr->GetOpnds(); for (auto *opnd : opnds) { Rename2PregExpr(aliasClass, irMap, stmt, utils::ToRef(opnd)); } @@ -289,7 +289,7 @@ class SSARename2Preg { } } - void Rename2PregLeafRHS(const AliasClass &aliasClass, MeIRMap &irMap, MeStmt &stmt, VarMeExpr &varExpr) { + void Rename2PregLeafRHS(const AliasClass &aliasClass, MeIRMap &irMap, MeStmt &stmt, const VarMeExpr &varExpr) { RegMeExpr *regExpr = RenameVar(aliasClass, varExpr); if (regExpr != nullptr) { (void)irMap.ReplaceMeExprStmt(stmt, varExpr, *regExpr); @@ -332,7 +332,7 @@ class SSARename2Preg { // update regphinode operands void UpdateRegPhi(const RegMeExpr &curRegExpr, const MapleVector &phiNodeOpnds, - MeRegPhiNode ®PhiNode) { + MeRegPhiNode ®PhiNode) const { PregCache &pregCache = cacheProxy.Preg(); for (VarMeExpr *phiOpnd : phiNodeOpnds) { const VarMeExpr &varExpr = utils::ToRef(phiOpnd); diff --git a/src/maple_me/src/me_ssa_devirtual.cpp b/src/maple_me/src/me_ssa_devirtual.cpp index 80dd519bee0fe6574fada77277149e39cc10283f..650f27003138419a2afb81cf3ef46e17a0ec559d 100644 --- a/src/maple_me/src/me_ssa_devirtual.cpp +++ b/src/maple_me/src/me_ssa_devirtual.cpp @@ -20,8 +20,8 @@ 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 *hMap = static_cast(frm->GetAnalysisResult(MeFuncPhase_IRMAP, func)); - ASSERT(hMap != nullptr, "hssaMap has problem"); + auto *irMap = static_cast(frm->GetAnalysisResult(MeFuncPhase_IRMAP, 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())); ASSERT(kh != nullptr, "KlassHierarchy has problem"); @@ -29,11 +29,11 @@ AnalysisResult *MeDoSSADevirtual::Run(MeFunction *func, MeFuncResultMgr *frm, Mo if (Options::O2) { clone = static_cast(mrm->GetAnalysisResult(MoPhase_CLONE, &func->GetMIRModule())); } - MeSSADevirtual meSSADevirtual(NewMemPool(), &func->GetMIRModule(), func, hMap, kh, dom, clone); + MeSSADevirtual meSSADevirtual(*NewMemPool(), func->GetMIRModule(), *func, *irMap, *kh, *dom, *clone); if (DEBUGFUNC(func)) { SSADevirtual::debug = true; } - meSSADevirtual.Perform(func->GetCommonEntryBB()); + meSSADevirtual.Perform(*func->GetCommonEntryBB()); if (DEBUGFUNC(func)) { SSADevirtual::debug = false; LogInfo::MapleLogger() << "\n============== After SSA Devirtualization =============" << "\n"; diff --git a/src/maple_me/src/me_ssa_epre.cpp b/src/maple_me/src/me_ssa_epre.cpp index 4ac77fce0b5a4aa35f99f46170112075e63f4687..4f1471b870046c039d5f262a01dde288ef6df0db 100644 --- a/src/maple_me/src/me_ssa_epre.cpp +++ b/src/maple_me/src/me_ssa_epre.cpp @@ -16,11 +16,10 @@ #include "me_dominance.h" #include "me_ssa_update.h" - // accumulate the BBs that are in the iterated dominance frontiers of bb in // the set dfSet, visiting each BB only once namespace maple { -void MeSSAEPre::GetIterDomFrontier(BB &bb, MapleSet &dfSet, std::vector &visitedMap) { +void MeSSAEPre::GetIterDomFrontier(const BB &bb, MapleSet &dfSet, std::vector &visitedMap) const { CHECK_FATAL(bb.GetBBId() < visitedMap.size(), "index out of range in MeSSAEPre::GetIterDomFrontier"); if (visitedMap[bb.GetBBId()]) { return; @@ -41,7 +40,7 @@ void MeSSAEPre::BuildWorkList() { } } -bool MeSSAEPre::IsThreadObjField(const IvarMeExpr &expr) { +bool MeSSAEPre::IsThreadObjField(const IvarMeExpr &expr) const { if (expr.GetFieldID() == 0) { return false; } @@ -76,7 +75,7 @@ AnalysisResult *MeDoSSAEPre::Run(MeFunction *func, MeFuncResultMgr *m, ModuleRes (eprePULimitSpecified && puCount != MeOption::eprePULimit) ? UINT32_MAX : MeOption::epreLimit; MemPool *ssaPreMemPool = NewMemPool(); bool epreIncludeRef = MeOption::epreIncludeRef; - MeSSAEPre ssaPre(func, *irMap, *dom, *kh, *ssaPreMemPool, *NewMemPool(), epreLimitUsed, epreIncludeRef, + MeSSAEPre ssaPre(*func, *irMap, *dom, *kh, *ssaPreMemPool, *NewMemPool(), epreLimitUsed, epreIncludeRef, MeOption::epreLocalRefVar, MeOption::epreLHSIvar); ssaPre.SetSpillAtCatch(MeOption::spillAtCatch); if (eprePULimitSpecified && puCount == MeOption::eprePULimit && epreLimitUsed != UINT32_MAX) { diff --git a/src/maple_me/src/me_ssa_lpre.cpp b/src/maple_me/src/me_ssa_lpre.cpp index e96fc7443baaa3c76c32a481e0463423ad399619..debd6e597342722fab24ec0ace8f67c2e6d04d68 100644 --- a/src/maple_me/src/me_ssa_lpre.cpp +++ b/src/maple_me/src/me_ssa_lpre.cpp @@ -17,22 +17,22 @@ #include "me_lower_globals.h" namespace maple { -void MeSSALPre::GenerateSaveRealOcc(MeRealOcc *realOcc) { +void MeSSALPre::GenerateSaveRealOcc(MeRealOcc &realOcc) { ASSERT(GetPUIdx() == workCand->GetPUIdx() || workCand->GetPUIdx() == 0, "GenerateSaveRealOcc: inconsistent puIdx"); - MeExpr *regOrVar = CreateNewCurTemp(realOcc->GetMeExpr()); + MeExpr *regOrVar = CreateNewCurTemp(*realOcc.GetMeExpr()); CHECK_NULL_FATAL(regOrVar); - if (!realOcc->IsLHS()) { + if (!realOcc.IsLHS()) { // create a new meStmt before realOcc->GetMeStmt() - MeStmt *newMeStmt = irMap->CreateRegassignMeStmt(*regOrVar, *realOcc->GetMeExpr(), *realOcc->GetMeStmt()->GetBB()); + MeStmt *newMeStmt = irMap->CreateRegassignMeStmt(*regOrVar, *realOcc.GetMeExpr(), *realOcc.GetMeStmt()->GetBB()); regOrVar->SetDefByStmt(*newMeStmt); - realOcc->GetMeStmt()->GetBB()->InsertMeStmtBefore(realOcc->GetMeStmt(), newMeStmt); + realOcc.GetMeStmt()->GetBB()->InsertMeStmtBefore(realOcc.GetMeStmt(), newMeStmt); // replace realOcc->GetMeStmt()'s occ with regOrVar - (void)irMap->ReplaceMeExprStmt(*realOcc->GetMeStmt(), *realOcc->GetMeExpr(), *regOrVar); - } else if (realOcc->IsFormalAtEntry()) { + (void)irMap->ReplaceMeExprStmt(*realOcc.GetMeStmt(), *realOcc.GetMeExpr(), *regOrVar); + } else if (realOcc.IsFormalAtEntry()) { // no need generate any code, but change formal declaration to preg CHECK_FATAL(regOrVar->GetMeOp() == kMeOpReg, "formals not promoted to register"); - auto *varMeExpr = static_cast(realOcc->GetMeExpr()); + auto *varMeExpr = static_cast(realOcc.GetMeExpr()); const MIRSymbol *oldFormalSt = ssaTab->GetMIRSymbolFromID(varMeExpr->GetOStIdx()); auto *regFormal = static_cast(regOrVar); MIRSymbol *newFormalSt = mirModule->GetMIRBuilder()->CreatePregFormalSymbol(oldFormalSt->GetTyIdx(), @@ -46,23 +46,23 @@ void MeSSALPre::GenerateSaveRealOcc(MeRealOcc *realOcc) { } } CHECK_FATAL(i < func->GetMirFunc()->GetFormalCount(), "Cannot replace promoted formal"); - } else if (realOcc->GetOpcodeOfMeStmt() == OP_dassign || realOcc->GetOpcodeOfMeStmt() == OP_maydassign) { - VarMeExpr *theLHS = realOcc->GetMeStmt()->GetVarLHS(); - MeExpr *savedRHS = realOcc->GetMeStmt()->GetRHS(); + } else if (realOcc.GetOpcodeOfMeStmt() == OP_dassign || realOcc.GetOpcodeOfMeStmt() == OP_maydassign) { + VarMeExpr *theLHS = realOcc.GetMeStmt()->GetVarLHS(); + MeExpr *savedRHS = realOcc.GetMeStmt()->GetRHS(); CHECK_NULL_FATAL(theLHS); CHECK_NULL_FATAL(savedRHS); - CHECK_NULL_FATAL(realOcc->GetMeStmt()->GetChiList()); - realOcc->GetMeStmt()->GetChiList()->clear(); - SrcPosition savedSrcPos = realOcc->GetMeStmt()->GetSrcPosition(); - BB *savedBB = realOcc->GetMeStmt()->GetBB(); - MeStmt *savedPrev = realOcc->GetMeStmt()->GetPrev(); - MeStmt *savedNext = realOcc->GetMeStmt()->GetNext(); + CHECK_NULL_FATAL(realOcc.GetMeStmt()->GetChiList()); + realOcc.GetMeStmt()->GetChiList()->clear(); + SrcPosition savedSrcPos = realOcc.GetMeStmt()->GetSrcPosition(); + BB *savedBB = realOcc.GetMeStmt()->GetBB(); + MeStmt *savedPrev = realOcc.GetMeStmt()->GetPrev(); + MeStmt *savedNext = realOcc.GetMeStmt()->GetNext(); // change original dassign/maydassign to regassign; // use placement new to modify in place, because other occ nodes are pointing // to this statement in order to get to the rhs expression; // this assume RegassignMeStmt has smaller size then DassignMeStmt and // MaydassignMeStmt - RegassignMeStmt *rass = new (realOcc->GetMeStmt()) RegassignMeStmt(); + RegassignMeStmt *rass = new (realOcc.GetMeStmt()) RegassignMeStmt(); rass->SetLHS(static_cast(regOrVar)); rass->SetRHS(savedRHS); rass->SetSrcPos(savedSrcPos); @@ -73,11 +73,11 @@ void MeSSALPre::GenerateSaveRealOcc(MeRealOcc *realOcc) { // create new dassign for original lhs MeStmt *newDassign = irMap->CreateDassignMeStmt(*theLHS, *regOrVar, *savedBB); theLHS->SetDefByStmt(*newDassign); - savedBB->InsertMeStmtAfter(realOcc->GetMeStmt(), newDassign); + savedBB->InsertMeStmtAfter(realOcc.GetMeStmt(), newDassign); } else { - CHECK_FATAL(kOpcodeInfo.IsCallAssigned(realOcc->GetOpcodeOfMeStmt()), + CHECK_FATAL(kOpcodeInfo.IsCallAssigned(realOcc.GetOpcodeOfMeStmt()), "LHS real occurrence has unrecognized stmt type"); - MapleVector *mustDefList = realOcc->GetMeStmt()->GetMustDefList(); + MapleVector *mustDefList = realOcc.GetMeStmt()->GetMustDefList(); CHECK_NULL_FATAL(mustDefList); CHECK_FATAL(!mustDefList->empty(), "empty mustdef in callassigned stmt"); MustDefMeNode *mustDefMeNode = &mustDefList->front(); @@ -86,20 +86,20 @@ void MeSSALPre::GenerateSaveRealOcc(MeRealOcc *realOcc) { // change mustDef lhs to regOrVar mustDefMeNode->UpdateLHS(*regOrVar); // create new dassign for original lhs - MeStmt *newDassign = irMap->CreateDassignMeStmt(*theLHS, *regOrVar, *realOcc->GetMeStmt()->GetBB()); + MeStmt *newDassign = irMap->CreateDassignMeStmt(*theLHS, *regOrVar, *realOcc.GetMeStmt()->GetBB()); theLHS->SetDefByStmt(*newDassign); - realOcc->GetMeStmt()->GetBB()->InsertMeStmtAfter(realOcc->GetMeStmt(), newDassign); + realOcc.GetMeStmt()->GetBB()->InsertMeStmtAfter(realOcc.GetMeStmt(), newDassign); } else { CHECK_FATAL(false, "GenerateSaveRealOcc: non-reg temp for callassigned LHS occurrence NYI"); } } - realOcc->SetSavedExpr(*regOrVar); + realOcc.SetSavedExpr(*regOrVar); } -void MeSSALPre::GenerateReloadRealOcc(MeRealOcc *realOcc) { - CHECK_FATAL(!realOcc->IsLHS(), "GenerateReloadRealOcc: cannot be LHS occurrence"); +void MeSSALPre::GenerateReloadRealOcc(MeRealOcc &realOcc) { + CHECK_FATAL(!realOcc.IsLHS(), "GenerateReloadRealOcc: cannot be LHS occurrence"); MeExpr *regOrVar = nullptr; - MeOccur *defOcc = realOcc->GetDef(); + MeOccur *defOcc = realOcc.GetDef(); if (defOcc->GetOccType() == kOccReal) { auto *defRealOcc = static_cast(defOcc); regOrVar = defRealOcc->GetSavedExpr(); @@ -115,23 +115,23 @@ void MeSSALPre::GenerateReloadRealOcc(MeRealOcc *realOcc) { } CHECK_NULL_FATAL(regOrVar); // replace realOcc->GetMeStmt()'s occ with regOrVar - (void)irMap->ReplaceMeExprStmt(*realOcc->GetMeStmt(), *realOcc->GetMeExpr(), *regOrVar); + (void)irMap->ReplaceMeExprStmt(*realOcc.GetMeStmt(), *realOcc.GetMeExpr(), *regOrVar); } // the variable in realZ is defined by a phi; replace it by the jth phi opnd -MeExpr *MeSSALPre::PhiOpndFromRes(MeRealOcc *realZ, size_t j) { - MeOccur *defZ = realZ->GetDef(); +MeExpr *MeSSALPre::PhiOpndFromRes(MeRealOcc &realZ, size_t j) const { + MeOccur *defZ = realZ.GetDef(); CHECK_NULL_FATAL(defZ); CHECK_FATAL(defZ->GetOccType() == kOccPhiocc, "must be def by phiocc"); - MeExpr *meExprZ = realZ->GetMeExpr(); + MeExpr *meExprZ = realZ.GetMeExpr(); BB *ePhiBB = static_cast(defZ)->GetBB(); - MeExpr *retVar = GetReplaceMeExpr(meExprZ, ePhiBB, j); + MeExpr *retVar = GetReplaceMeExpr(*meExprZ, *ePhiBB, j); return (retVar != nullptr) ? retVar : meExprZ; } // accumulate the BBs that are in the iterated dominance frontiers of bb in // the set dfSet, visiting each BB only once -void MeSSALPre::GetIterDomFrontier(BB &bb, MapleSet &dfSet, std::vector &visitedMap) { +void MeSSALPre::GetIterDomFrontier(const BB &bb, MapleSet &dfSet, std::vector &visitedMap) const { CHECK_FATAL(bb.GetBBId() < visitedMap.size(), "index out of range in MeSSALPre::GetIterDomFrontier"); if (visitedMap[bb.GetBBId()]) { return; @@ -158,12 +158,12 @@ void MeSSALPre::ComputeVarAndDfPhis() { GetIterDomFrontier(*defBB, dfPhiDfns, visitedMap); MeExpr *meExpr = realOcc->GetMeExpr(); if (meExpr->GetMeOp() == kMeOpVar) { - SetVarPhis(meExpr); + SetVarPhis(*meExpr); } } } -void MeSSALPre::BuildEntryLHSOcc4Formals() { +void MeSSALPre::BuildEntryLHSOcc4Formals() const { if (preKind == kAddrPre) { return; } @@ -190,27 +190,27 @@ void MeSSALPre::BuildEntryLHSOcc4Formals() { occ->SetBB(*func->GetFirstBB()); } -void MeSSALPre::BuildWorkListLHSOcc(MeStmt *meStmt, int32 seqStmt) { +void MeSSALPre::BuildWorkListLHSOcc(MeStmt &meStmt, int32 seqStmt) { if (preKind == kAddrPre) { return; } - if (meStmt->GetOp() == OP_dassign || meStmt->GetOp() == OP_maydassign) { - VarMeExpr *lhs = meStmt->GetVarLHS(); + if (meStmt.GetOp() == OP_dassign || meStmt.GetOp() == OP_maydassign) { + VarMeExpr *lhs = meStmt.GetVarLHS(); CHECK_NULL_FATAL(lhs); const OriginalSt *ost = ssaTab->GetSymbolOriginalStFromID(lhs->GetOStIdx()); if (ost->IsFormal()) { assignedFormals.insert(ost->GetIndex()); } - CHECK_NULL_FATAL(meStmt->GetRHS()); + CHECK_NULL_FATAL(meStmt.GetRHS()); if (ost->IsVolatile()) { return; } if (lhs->GetPrimType() == PTY_agg) { return; } - (void)CreateRealOcc(*meStmt, seqStmt, *lhs, false, true); - } else if (kOpcodeInfo.IsCallAssigned(meStmt->GetOp())) { - MapleVector *mustDefList = meStmt->GetMustDefList(); + (void)CreateRealOcc(meStmt, seqStmt, *lhs, false, true); + } else if (kOpcodeInfo.IsCallAssigned(meStmt.GetOp())) { + MapleVector *mustDefList = meStmt.GetMustDefList(); if (mustDefList->empty()) { return; } @@ -231,7 +231,7 @@ void MeSSALPre::BuildWorkListLHSOcc(MeStmt *meStmt, int32 seqStmt) { if (theLHS->GetPrimType() == PTY_agg) { return; } - (void)CreateRealOcc(*meStmt, seqStmt, *theLHS, false, true); + (void)CreateRealOcc(meStmt, seqStmt, *theLHS, false, true); } } @@ -256,14 +256,14 @@ void MeSSALPre::CreateMembarOccAtCatch(BB &bb) { // only handle the leaf of load, because all other expressions has been done by // previous SSAPre -void MeSSALPre::BuildWorkListExpr(MeStmt *meStmt, int32 seqStmt, MeExpr *meExpr, bool, MeExpr*, bool) { - MeExprOp meOp = meExpr->GetMeOp(); +void MeSSALPre::BuildWorkListExpr(MeStmt &meStmt, int32 seqStmt, MeExpr &meExpr, bool, MeExpr*, bool) { + MeExprOp meOp = meExpr.GetMeOp(); switch (meOp) { case kMeOpVar: { if (preKind != kLoadPre) { break; } - auto *varMeExpr = static_cast(meExpr); + auto *varMeExpr = static_cast(&meExpr); const OriginalSt *ost = ssaTab->GetOriginalStFromID(varMeExpr->GetOStIdx()); if (ost->IsVolatile()) { break; @@ -273,53 +273,53 @@ void MeSSALPre::BuildWorkListExpr(MeStmt *meStmt, int32 seqStmt, MeExpr *meExpr, // not doing because its SSA form is not complete break; } - if (meExpr->GetPrimType() == PTY_agg) { + if (meExpr.GetPrimType() == PTY_agg) { break; } - (void)CreateRealOcc(*meStmt, seqStmt, *meExpr, false); + (void)CreateRealOcc(meStmt, seqStmt, meExpr, false); break; } case kMeOpAddrof: { if (preKind != kAddrPre) { break; } - auto *addrOfMeExpr = static_cast(meExpr); + auto *addrOfMeExpr = static_cast(&meExpr); const OriginalSt *ost = ssaTab->GetOriginalStFromID(addrOfMeExpr->GetOstIdx()); if (ost->IsLocal()) { // skip lpre for stack addresses as they are cheap break; } - (void)CreateRealOcc(*meStmt, seqStmt, *meExpr, false); + (void)CreateRealOcc(meStmt, seqStmt, meExpr, false); break; } case kMeOpAddroffunc: { if (preKind != kAddrPre) { break; } - (void)CreateRealOcc(*meStmt, seqStmt, *meExpr, false); + (void)CreateRealOcc(meStmt, seqStmt, meExpr, false); break; } case kMeOpOp: { - auto *meOpExpr = static_cast(meExpr); + auto *meOpExpr = static_cast(&meExpr); for (size_t i = 0; i < kOperandNumTernary; ++i) { MeExpr *opnd = meOpExpr->GetOpnd(i); if (opnd != nullptr) { - BuildWorkListExpr(meStmt, seqStmt, opnd, false, nullptr, false); + BuildWorkListExpr(meStmt, seqStmt, *opnd, false, nullptr, false); } } break; } case kMeOpNary: { - auto *naryMeExpr = static_cast(meExpr); + auto *naryMeExpr = static_cast(&meExpr); MapleVector &opnds = naryMeExpr->GetOpnds(); for (auto it = opnds.begin(); it != opnds.end(); ++it) { MeExpr *opnd = *it; - BuildWorkListExpr(meStmt, seqStmt, opnd, false, nullptr, false); + BuildWorkListExpr(meStmt, seqStmt, *opnd, false, nullptr, false); } break; } case kMeOpIvar: { - auto *ivarMeExpr = static_cast(meExpr); - BuildWorkListExpr(meStmt, seqStmt, ivarMeExpr->GetBase(), false, nullptr, false); + auto *ivarMeExpr = static_cast(&meExpr); + BuildWorkListExpr(meStmt, seqStmt, *ivarMeExpr->GetBase(), false, nullptr, false); break; } default: @@ -340,8 +340,8 @@ void MeSSALPre::BuildWorkList() { } } -void MeSSALPre::FindLoopHeadBBs(IdentifyLoops *identLoops) { - for (LoopDesc *mapleLoop : identLoops->GetMeLoops()) { +void MeSSALPre::FindLoopHeadBBs(const IdentifyLoops &identLoops) { + for (LoopDesc *mapleLoop : identLoops.GetMeLoops()) { if (mapleLoop->head != nullptr) { loopHeadBBs.insert(mapleLoop->head->GetBBId()); } @@ -364,7 +364,7 @@ AnalysisResult *MeDoSSALPre::Run(MeFunction *irFunc, MeFuncResultMgr *funcMgr, M uint32 lpreLimitUsed = (lprePULimitSpecified && puCount != MeOption::lprePULimit) ? UINT32_MAX : MeOption::lpreLimit; { - MeSSALPre ssaLpre(irFunc, *irMap, *dom, *NewMemPool(), *NewMemPool(), kLoadPre, lpreLimitUsed); + MeSSALPre ssaLpre(*irFunc, *irMap, *dom, *NewMemPool(), *NewMemPool(), kLoadPre, lpreLimitUsed); ssaLpre.SetRcLoweringOn(MeOption::rcLowering); ssaLpre.SetRegReadAtReturn(MeOption::regreadAtReturn); ssaLpre.SetSpillAtCatch(MeOption::spillAtCatch); @@ -376,7 +376,7 @@ AnalysisResult *MeDoSSALPre::Run(MeFunction *irFunc, MeFuncResultMgr *funcMgr, M ssaLpre.SetSSAPreDebug(true); } if (MeOption::lpreSpeculate && !irFunc->HasException()) { - ssaLpre.FindLoopHeadBBs(identLoops); + ssaLpre.FindLoopHeadBBs(*identLoops); } ssaLpre.ApplySSAPRE(); if (DEBUGFUNC(irFunc)) { @@ -387,13 +387,13 @@ AnalysisResult *MeDoSSALPre::Run(MeFunction *irFunc, MeFuncResultMgr *funcMgr, M MeLowerGlobals lowerGlobals(irFunc, irFunc->GetMeSSATab()); lowerGlobals.Run(); { - MeSSALPre ssaLpre(irFunc, *irMap, *dom, *NewMemPool(), *NewMemPool(), kAddrPre, lpreLimitUsed); + MeSSALPre ssaLpre(*irFunc, *irMap, *dom, *NewMemPool(), *NewMemPool(), kAddrPre, lpreLimitUsed); ssaLpre.SetSpillAtCatch(MeOption::spillAtCatch); if (DEBUGFUNC(irFunc)) { ssaLpre.SetSSAPreDebug(true); } if (MeOption::lpreSpeculate && !irFunc->HasException()) { - ssaLpre.FindLoopHeadBBs(identLoops); + ssaLpre.FindLoopHeadBBs(*identLoops); } ssaLpre.ApplySSAPRE(); if (DEBUGFUNC(irFunc)) { diff --git a/src/maple_me/src/me_ssa_update.cpp b/src/maple_me/src/me_ssa_update.cpp index 8c479c6d04fbb4e7abf8dec523901354d95f3100..2845e99e78cf98481195d863cfd9a942c2d7355e 100644 --- a/src/maple_me/src/me_ssa_update.cpp +++ b/src/maple_me/src/me_ssa_update.cpp @@ -23,7 +23,7 @@ namespace maple { // accumulate the BBs that are in the iterated dominance frontiers of bb in // the set dfSet, visiting each BB only once -void MeSSAUpdate::GetIterDomFrontier(const BB &bb, MapleSet &dfSet, std::vector &visitedMap) { +void MeSSAUpdate::GetIterDomFrontier(const BB &bb, MapleSet &dfSet, std::vector &visitedMap) const { CHECK_FATAL(bb.GetBBId() < visitedMap.size(), "index out of range in MeSSAUpdate::GetIterDomFrontier"); if (visitedMap[bb.GetBBId()]) { return; diff --git a/src/maple_me/src/me_ssu_pre.cpp b/src/maple_me/src/me_ssu_pre.cpp index 23a7a385d52cebbbfa995c5143322ad419997dfb..2e2124f183b7adbe41462bc841f232608a424d8d 100644 --- a/src/maple_me/src/me_ssu_pre.cpp +++ b/src/maple_me/src/me_ssu_pre.cpp @@ -69,7 +69,7 @@ void MeSSUPre::Finalize() { } lambdaResOcc->SetInsertHere(true); } else { - lambdaResOcc->SetUse(anticipatedDefVec[classId]); + lambdaResOcc->SetUse(*anticipatedDefVec[classId]); } } break; @@ -80,6 +80,7 @@ void MeSSUPre::Finalize() { break; default: ASSERT(false, "Finalize: unexpected occ type"); + break; } } if (enabledDebug) { @@ -103,20 +104,19 @@ void MeSSUPre::Finalize() { } // ================ Step 4: WillBeAnt Computation ================ -void MeSSUPre::ResetCanBeFullyAnt(SLambdaOcc *lambda) { - CHECK_NULL_FATAL(lambda); - lambda->SetIsCanBeAnt(false); +void MeSSUPre::ResetCanBeFullyAnt(SLambdaOcc &lambda) const { + lambda.SetIsCanBeAnt(false); for (SLambdaOcc *lambdaOcc : lambdaOccs) { for (SLambdaResOcc *lambdaResOcc : lambdaOcc->GetLambdaRes()) { - if (lambdaResOcc->GetUse() && lambdaResOcc->GetUse() == lambda && + if (lambdaResOcc->GetUse() != nullptr && lambdaResOcc->GetUse() == &lambda && !lambdaResOcc->GetHasRealUse() && lambdaOcc->GetIsCanBeAnt()) { - ResetCanBeFullyAnt(lambdaOcc); + ResetCanBeFullyAnt(*lambdaOcc); } } } } -void MeSSUPre::ComputeCanBeFullyAnt() { +void MeSSUPre::ComputeCanBeFullyAnt() const { for (SLambdaOcc *lambdaOcc : lambdaOccs) { bool existNullUse = false; for (SLambdaResOcc *lambdaResOcc : lambdaOcc->GetLambdaRes()) { @@ -126,27 +126,26 @@ void MeSSUPre::ComputeCanBeFullyAnt() { } } if (existNullUse) { - ResetCanBeFullyAnt(lambdaOcc); + ResetCanBeFullyAnt(*lambdaOcc); } } } -void MeSSUPre::ResetCanBeAnt(SLambdaOcc *lambda) { - CHECK_NULL_FATAL(lambda); - lambda->SetIsCanBeAnt(false); +void MeSSUPre::ResetCanBeAnt(SLambdaOcc &lambda) const { + lambda.SetIsCanBeAnt(false); // the following loop finds lambda's defs and reset them for (SLambdaOcc *lambdaOcc : lambdaOccs) { for (SLambdaResOcc *lambdaResOcc : lambdaOcc->GetLambdaRes()) { - if (lambdaResOcc->GetUse() != nullptr && lambdaResOcc->GetUse() == lambda) { + if (lambdaResOcc->GetUse() != nullptr && lambdaResOcc->GetUse() == &lambda) { if (!lambdaResOcc->GetHasRealUse() && !lambdaOcc->GetIsUpsafe() && lambdaOcc->GetIsCanBeAnt()) { - ResetCanBeAnt(lambdaOcc); + ResetCanBeAnt(*lambdaOcc); } } } } } -void MeSSUPre::ComputeCanBeAnt() { +void MeSSUPre::ComputeCanBeAnt() const { for (SLambdaOcc *lambdaOcc : lambdaOccs) { if (!lambdaOcc->GetIsUpsafe() && lambdaOcc->GetIsCanBeAnt()) { bool existNullUse = false; @@ -157,28 +156,27 @@ void MeSSUPre::ComputeCanBeAnt() { } } if (existNullUse) { - ResetCanBeAnt(lambdaOcc); + ResetCanBeAnt(*lambdaOcc); } } } } -void MeSSUPre::ResetEarlier(SLambdaOcc *lambda) { - CHECK_NULL_FATAL(lambda); - lambda->SetIsEarlier(false); +void MeSSUPre::ResetEarlier(SLambdaOcc &lambda) const { + lambda.SetIsEarlier(false); // the following loop finds lambda's defs and reset them for (SLambdaOcc *lambdaOcc : lambdaOccs) { for (SLambdaResOcc *lambdaResOcc : lambdaOcc->GetLambdaRes()) { - if (lambdaResOcc->GetUse() != nullptr && lambdaResOcc->GetUse() == lambda) { + if (lambdaResOcc->GetUse() != nullptr && lambdaResOcc->GetUse() == &lambda) { if (lambdaOcc->GetIsEarlier()) { - ResetEarlier(lambdaOcc); + ResetEarlier(*lambdaOcc); } } } } } -void MeSSUPre::ComputeEarlier() { +void MeSSUPre::ComputeEarlier() const { for (SLambdaOcc *lambdaOcc : lambdaOccs) { lambdaOcc->SetIsEarlier(lambdaOcc->GetIsCanBeAnt()); } @@ -192,7 +190,7 @@ void MeSSUPre::ComputeEarlier() { } } if (existNonNullUse) { - ResetEarlier(lambdaOcc); + ResetEarlier(*lambdaOcc); } } } @@ -215,12 +213,11 @@ void MeSSUPre::ComputeEarlier() { } // ================ Step 3: Upsafe Computation ================ -void MeSSUPre::ResetUpsafe(SLambdaResOcc *lambdaRes) { - CHECK_NULL_FATAL(lambdaRes); - if (lambdaRes->GetHasRealUse()) { +void MeSSUPre::ResetUpsafe(const SLambdaResOcc &lambdaRes) const { + if (lambdaRes.GetHasRealUse()) { return; } - SOcc *useOcc = lambdaRes->GetUse(); + SOcc *useOcc = lambdaRes.GetUse(); if (useOcc == nullptr || useOcc->GetOccTy() != kSOccLambda) { return; } @@ -230,16 +227,16 @@ void MeSSUPre::ResetUpsafe(SLambdaResOcc *lambdaRes) { } useLambdaOcc->SetIsUpsafe(false); for (SLambdaResOcc *lambdaResOcc : useLambdaOcc->GetLambdaRes()) { - ResetUpsafe(lambdaResOcc); + ResetUpsafe(*lambdaResOcc); } } -void MeSSUPre::ComputeUpsafe() { +void MeSSUPre::ComputeUpsafe() const { for (SLambdaOcc *lambdaOcc : lambdaOccs) { if (!lambdaOcc->GetIsUpsafe()) { // propagate not-upsafe forward along def-use edges for (SLambdaResOcc *lambdaResOcc : lambdaOcc->GetLambdaRes()) { - ResetUpsafe(lambdaResOcc); + ResetUpsafe(*lambdaResOcc); } } } @@ -338,7 +335,7 @@ void MeSSUPre::Rename() { } ASSERT(topOcc->GetOccTy() == kSOccLambda || topOcc->GetOccTy() == kSOccReal, "Rename: unexpected top-of-stack occ"); - occ->SetUse(topOcc); + occ->SetUse(*topOcc); occ->SetClassId(topOcc->GetClassId()); if (topOcc->GetOccTy() == kSOccReal) { static_cast(occ)->SetHasRealUse(true); @@ -349,6 +346,7 @@ void MeSSUPre::Rename() { break; default: ASSERT(false, "Rename: unexpected type of occurrence"); + break; } } if (enabledDebug) { @@ -361,22 +359,20 @@ void MeSSUPre::Rename() { } // ================ Step 1: insert lambdas ================ -void MeSSUPre::GetIterPdomFrontier(const BB *bb, MapleSet *pdfSet, std::vector &visitedMap) { - CHECK_NULL_FATAL(bb); - CHECK_FATAL(bb->GetBBId() < visitedMap.size(), "index out of range in MeSSUPre::GetIterPdomFrontier"); - if (visitedMap[bb->GetBBId()]) { +void MeSSUPre::GetIterPdomFrontier(const BB &bb, MapleSet &pdfSet, std::vector &visitedMap) { + CHECK_FATAL(bb.GetBBId() < visitedMap.size(), "index out of range in MeSSUPre::GetIterPdomFrontier"); + if (visitedMap[bb.GetBBId()]) { return; } CHECK_FATAL(!visitedMap.empty(), "visitedMap in MeSSUPre::GetIterPdomFrontier is empty"); - visitedMap[bb->GetBBId()] = true; - CHECK_NULL_FATAL(pdfSet); - for (BBId frontierBBId : dom->GetPdomFrontierItem(bb->GetBBId())) { - pdfSet->insert(dom->GetPdtDfnItem(frontierBBId)); + visitedMap[bb.GetBBId()] = true; + for (BBId frontierBBId : dom->GetPdomFrontierItem(bb.GetBBId())) { + pdfSet.insert(dom->GetPdtDfnItem(frontierBBId)); } CHECK_NULL_FATAL(func); - for (BBId frontierBBId : dom->GetPdomFrontierItem(bb->GetBBId())) { + for (BBId frontierBBId : dom->GetPdomFrontierItem(bb.GetBBId())) { BB *frontierBB = func->GetAllBBs().at(frontierBBId); - GetIterPdomFrontier(frontierBB, pdfSet, visitedMap); + GetIterPdomFrontier(*frontierBB, pdfSet, visitedMap); } } @@ -387,7 +383,7 @@ void MeSSUPre::FormLambdas() { std::vector visitedMap(func->NumBBs(), false); CHECK_NULL_FATAL(workCand); for (SOcc *occ : workCand->GetRealOccs()) { - GetIterPdomFrontier(occ->GetBB(), &lambdaDfns, visitedMap); + GetIterPdomFrontier(*occ->GetBB(), lambdaDfns, visitedMap); } } @@ -422,11 +418,11 @@ void MeSSUPre::CreateSortedOccs() { SLambdaOcc *nextLambdaOcc = nullptr; if (lambdaDfnIt != lambdaDfns.end()) { nextLambdaOcc = - spreMp->New(func->GetAllBBs().at(dom->GetPdtPreOrderItem(*lambdaDfnIt)), &spreAllocator); + spreMp->New(*func->GetAllBBs().at(dom->GetPdtPreOrderItem(*lambdaDfnIt)), spreAllocator); } SLambdaResOcc *nextLambdaResOcc = nullptr; if (lambdaResDfnIt != lambdaResDfns.end()) { - nextLambdaResOcc = spreMp->New(func->GetAllBBs().at(dom->GetPdtPreOrderItem(*lambdaResDfnIt))); + nextLambdaResOcc = spreMp->New(*func->GetAllBBs().at(dom->GetPdtPreOrderItem(*lambdaResDfnIt))); auto it = bb2lambdaResMap.find(dom->GetPdtPreOrderItem(*lambdaResDfnIt)); if (it == bb2lambdaResMap.end()) { std::forward_list newlist = { nextLambdaResOcc }; @@ -483,7 +479,7 @@ void MeSSUPre::CreateSortedOccs() { ++lambdaDfnIt; if (lambdaDfnIt != lambdaDfns.end()) { nextLambdaOcc = - spreMp->New(func->GetAllBBs().at(dom->GetPdtPreOrderItem(*lambdaDfnIt)), &spreAllocator); + spreMp->New(*func->GetAllBBs().at(dom->GetPdtPreOrderItem(*lambdaDfnIt)), spreAllocator); } else { nextLambdaOcc = nullptr; } @@ -493,7 +489,7 @@ void MeSSUPre::CreateSortedOccs() { ++lambdaResDfnIt; if (lambdaResDfnIt != lambdaResDfns.end()) { nextLambdaResOcc = - spreMp->New(func->GetAllBBs().at(dom->GetPdtPreOrderItem(*lambdaResDfnIt))); + spreMp->New(*func->GetAllBBs().at(dom->GetPdtPreOrderItem(*lambdaResDfnIt))); CHECK_NULL_FATAL(dom); auto it = bb2lambdaResMap.find(dom->GetPdtPreOrderItem(*lambdaResDfnIt)); if (it == bb2lambdaResMap.end()) { @@ -508,6 +504,7 @@ void MeSSUPre::CreateSortedOccs() { break; default: ASSERT(false, "CreateSortedOccs: unexpected occTy"); + break; } } } while (pickedOcc != nullptr); @@ -516,7 +513,7 @@ void MeSSUPre::CreateSortedOccs() { for (BB *succ : lambdaOcc->GetBB()->GetSucc()) { SLambdaResOcc *lambdaResOcc = bb2lambdaResMap[succ->GetBBId()].front(); lambdaOcc->GetLambdaRes().push_back(lambdaResOcc); - lambdaResOcc->SetUseLambdaOcc(lambdaOcc); + lambdaResOcc->SetUseLambdaOcc(*lambdaOcc); bb2lambdaResMap[succ->GetBBId()].pop_front(); } } @@ -570,7 +567,7 @@ void MeSSUPre::ApplySSUPre() { } // #5 Finalize Finalize(); - // #6 Code Mmotion + // #6 Code Motion CHECK_NULL_FATAL(workCand); if (!workCand->GetHasCriticalEdge()) { CodeMotion(); diff --git a/src/maple_me/src/me_stmt_fre.cpp b/src/maple_me/src/me_stmt_fre.cpp index 5c1bd24898a56a85a804d293ae4e2546344bd294..d8af9ff561b2358173ae3c0bde538ecf39e48157 100644 --- a/src/maple_me/src/me_stmt_fre.cpp +++ b/src/maple_me/src/me_stmt_fre.cpp @@ -15,16 +15,16 @@ #include "me_stmt_pre.h" namespace maple { -void MeStmtPre::ResetFullyAvail(MePhiOcc *occ) { - occ->SetIsCanBeAvail(false); +void MeStmtPre::ResetFullyAvail(MePhiOcc &occ) { + occ.SetIsCanBeAvail(false); // reset those phiocc nodes that have oc as one of its operands for (auto it = phiOccs.begin(); it != phiOccs.end(); ++it) { MePhiOcc *phiOcc = *it; for (MePhiOpndOcc *phiOpnd : phiOcc->GetPhiOpnds()) { - if (phiOpnd->GetDef() != nullptr && phiOpnd->GetDef() == occ) { + if (phiOpnd->GetDef() != nullptr && phiOpnd->GetDef() == &occ) { // phiOpnd is a use of occ if (!phiOpnd->HasRealUse()) { - ResetCanBeAvail(phiOcc); + ResetCanBeAvail(*phiOcc); } } } @@ -44,23 +44,23 @@ void MeStmtPre::ComputeFullyAvail() { } } if (existNullDef) { - ResetFullyAvail(phiOcc); + ResetFullyAvail(*phiOcc); } } } -bool MeStmtPre::AllVarsSameVersionStmtFre(MeRealOcc *topOcc, MeRealOcc *curOcc) const { - ASSERT(topOcc->GetOpcodeOfMeStmt() == OP_dassign || topOcc->GetOpcodeOfMeStmt() == OP_callassigned, +bool MeStmtPre::AllVarsSameVersionStmtFre(MeRealOcc &topOcc, MeRealOcc &curOcc) const { + ASSERT(topOcc.GetOpcodeOfMeStmt() == OP_dassign || topOcc.GetOpcodeOfMeStmt() == OP_callassigned, "AllVarsSameVersionStmtFre: only dassign or callassigned is handled"); - if (topOcc->GetMeStmt()->NumMeStmtOpnds() != curOcc->GetMeStmt()->NumMeStmtOpnds()) { + if (topOcc.GetMeStmt()->NumMeStmtOpnds() != curOcc.GetMeStmt()->NumMeStmtOpnds()) { return false; } - for (size_t i = 0; i < topOcc->GetMeStmt()->NumMeStmtOpnds(); ++i) { - if (topOcc->GetMeStmt()->GetOpnd(i) != curOcc->GetMeStmt()->GetOpnd(i)) { + for (size_t i = 0; i < topOcc.GetMeStmt()->NumMeStmtOpnds(); ++i) { + if (topOcc.GetMeStmt()->GetOpnd(i) != curOcc.GetMeStmt()->GetOpnd(i)) { return false; } } - return topOcc->GetMeStmt()->GetVarLHS() == curOcc->GetMeExpr(); + return topOcc.GetMeStmt()->GetVarLHS() == curOcc.GetMeExpr(); } void MeStmtPre::Rename1StmtFre() { @@ -69,7 +69,7 @@ void MeStmtPre::Rename1StmtFre() { classCount = 1; // iterate the occurrence according to its preorder dominator tree for (MeOccur *occ : allOccs) { - while (!occStack.empty() && !occStack.top()->IsDominate(dom, occ)) { + while (!occStack.empty() && !occStack.top()->IsDominate(*dom, *occ)) { occStack.pop(); } switch (occ->GetOccType()) { @@ -89,7 +89,7 @@ void MeStmtPre::Rename1StmtFre() { auto *realOcc = static_cast(occ); if (topOccur->GetOccType() == kOccReal) { auto *realTopOccur = static_cast(topOccur); - if (AllVarsSameVersionStmtFre(realTopOccur, realOcc)) { + if (AllVarsSameVersionStmtFre(*realTopOccur, *realOcc)) { // all corresponding variables are the same realOcc->SetClassID(realTopOccur->GetClassID()); realOcc->SetDef(realTopOccur); @@ -101,11 +101,11 @@ void MeStmtPre::Rename1StmtFre() { } else { // top of stack is a PHI occurrence std::vector varVec; - CollectVarForCand(realOcc, varVec); + CollectVarForCand(*realOcc, varVec); bool isAllDom = true; for (auto varIt = varVec.begin(); varIt != varVec.end(); ++varIt) { MeExpr *varMeExpr = *varIt; - if (!DefVarDominateOcc(varMeExpr, topOccur)) { + if (!DefVarDominateOcc(varMeExpr, *topOccur)) { isAllDom = false; } } @@ -150,12 +150,13 @@ void MeStmtPre::Rename1StmtFre() { break; default: ASSERT(false, "should not be here"); + break; } } if (GetSSAPreDebug()) { PreWorkCand *curCand = workCand; mirModule->GetOut() << "======== ssafre candidate " << curCand->GetIndex() << - " after rename1StmtFre ===================\n"; + " after rename1StmtFre ===================\n"; for (MeOccur *occ : allOccs) { occ->Dump(*irMap); mirModule->GetOut() << "\n"; @@ -232,6 +233,7 @@ void MeStmtPre::DoSSAFRE() { break; default: ASSERT(false, "should not be here"); + break; } if (hasInsertion) { break; diff --git a/src/maple_me/src/me_stmt_pre.cpp b/src/maple_me/src/me_stmt_pre.cpp index 8bd47b14bf7930675c12b8f5db66db8c30bd1587..286526aa3a9e62392da6217c2642d8ca93354953 100644 --- a/src/maple_me/src/me_stmt_pre.cpp +++ b/src/maple_me/src/me_stmt_pre.cpp @@ -25,7 +25,7 @@ // the set dfset, visiting each BB only once namespace maple { -void MeStmtPre::GetIterDomFrontier(BB &bb, MapleSet &dfSet, std::vector &visitedMap) { +void MeStmtPre::GetIterDomFrontier(const BB &bb, MapleSet &dfSet, std::vector &visitedMap) const { CHECK_FATAL(bb.GetBBId() < visitedMap.size(), "index out of range in MeStmtPre::GetIterDomFrontier"); if (visitedMap[bb.GetBBId()]) { return; @@ -44,7 +44,7 @@ void MeStmtPre::CodeMotion() { case kOccReal: { auto *realOcc = static_cast(occ); if (realOcc->IsSave()) { - CHECK_FATAL(realOcc->IsReload() == false, "should be false"); + CHECK_FATAL(!realOcc->IsReload(), "should be false"); } else if (realOcc->IsReload()) { realOcc->GetBB()->RemoveMeStmt(realOcc->GetMeStmt()); if (realOcc->GetOpcodeOfMeStmt() == OP_dassign) { @@ -140,6 +140,7 @@ void MeStmtPre::CodeMotion() { break; default: ASSERT(false, "should not be here"); + break; } } } @@ -161,7 +162,7 @@ void MeStmtPre::Finalize1() { case kOccReal: { MeOccur *availDef = availDefVec[classId]; auto *realOcc = static_cast(occ); - if (availDef == nullptr || !availDef->IsDominate(dom, occ)) { + if (availDef == nullptr || !availDef->IsDominate(*dom, *occ)) { realOcc->SetIsReload(false); availDefVec[classId] = realOcc; } else { @@ -190,7 +191,7 @@ void MeStmtPre::Finalize1() { MeStmt *insertedStmt = phiOpnd->GetCurrentMeStmt(); ASSERT(insertedStmt != nullptr, "NYI"); MeInsertedOcc *insertedOcc = - perCandMemPool->New(static_cast(nullptr), insertedStmt, phiOpnd->GetBB()); + perCandMemPool->New(static_cast(nullptr), insertedStmt, *phiOpnd->GetBB()); insertedOcc->SetClassID(classCount++); phiOpnd->SetDef(insertedOcc); phiOpnd->SetClassID(insertedOcc->GetClassID()); @@ -237,16 +238,16 @@ void MeStmtPre::Finalize1() { } } -bool MeStmtPre::AllVarsSameVersion(MeRealOcc *realOcc1, MeRealOcc *realOcc2) { - MeStmt *stmt1 = realOcc1->GetMeStmt(); +bool MeStmtPre::AllVarsSameVersion(const MeRealOcc &realOcc1, const MeRealOcc &realOcc2) const { + const MeStmt *stmt1 = realOcc1.GetMeStmt(); Opcode op = stmt1->GetOp(); if (op == OP_intrinsiccallwithtype) { return true; } - if ((op == OP_dassign || op == OP_callassigned) && realOcc1->GetMeExpr() != realOcc2->GetMeExpr()) { + if ((op == OP_dassign || op == OP_callassigned) && realOcc1.GetMeExpr() != realOcc2.GetMeExpr()) { return false; } - MeStmt *stmt2 = realOcc2->GetMeStmt(); + const MeStmt *stmt2 = realOcc2.GetMeStmt(); for (size_t i = 0; i < stmt1->NumMeStmtOpnds(); ++i) { if (stmt1->GetOpnd(i) != stmt2->GetOpnd(i)) { return false; @@ -257,17 +258,17 @@ bool MeStmtPre::AllVarsSameVersion(MeRealOcc *realOcc1, MeRealOcc *realOcc2) { // collect meExpr's variables and put them into varvec; // varvec can only store RegMeExpr and VarMeExpr -void MeStmtPre::CollectVarForMeStmt(MeStmt *meStmt, MeExpr *meExpr, std::vector &varVec) { - switch (meStmt->GetOp()) { +void MeStmtPre::CollectVarForMeStmt(const MeStmt &meStmt, MeExpr *meExpr, std::vector &varVec) const { + switch (meStmt.GetOp()) { case OP_assertnonnull: { - auto *unaryStmt = static_cast(meStmt); + auto *unaryStmt = static_cast(&meStmt); if (unaryStmt->GetOpnd()->GetMeOp() == kMeOpVar || unaryStmt->GetOpnd()->GetMeOp() == kMeOpReg) { varVec.push_back(unaryStmt->GetOpnd()); } break; } case OP_dassign: { - auto *dassMeStmt = static_cast(meStmt); + auto *dassMeStmt = static_cast(&meStmt); if (dassMeStmt->GetRHS()->GetMeOp() == kMeOpVar || dassMeStmt->GetRHS()->GetMeOp() == kMeOpReg) { varVec.push_back(dassMeStmt->GetRHS()); } @@ -280,7 +281,7 @@ void MeStmtPre::CollectVarForMeStmt(MeStmt *meStmt, MeExpr *meExpr, std::vector< case OP_intrinsiccallwithtype: case OP_intrinsiccall: case OP_callassigned: { - auto *nStmt = static_cast(meStmt); + auto *nStmt = static_cast(&meStmt); for (size_t i = 0; i < nStmt->NumMeStmtOpnds(); ++i) if (nStmt->GetOpnd(i)->GetMeOp() == kMeOpVar || nStmt->GetOpnd(i)->GetMeOp() == kMeOpReg) { varVec.push_back(nStmt->GetOpnd(i)); @@ -296,30 +297,30 @@ void MeStmtPre::CollectVarForMeStmt(MeStmt *meStmt, MeExpr *meExpr, std::vector< } } -void MeStmtPre::CollectVarForCand(MeRealOcc *realOcc, std::vector &varVec) { - CollectVarForMeStmt(realOcc->GetMeStmt(), realOcc->GetMeExpr(), varVec); +void MeStmtPre::CollectVarForCand(MeRealOcc &realOcc, std::vector &varVec) const { + CollectVarForMeStmt(*realOcc.GetMeStmt(), realOcc.GetMeExpr(), varVec); } -MeStmt *MeStmtPre::CopyMeStmt(MeStmt &meStmt) { +MeStmt *MeStmtPre::CopyMeStmt(const MeStmt &meStmt) const { switch (meStmt.GetOp()) { case OP_assertnonnull: { - auto *unaryStmt = static_cast(&meStmt); + auto *unaryStmt = static_cast(&meStmt); UnaryMeStmt *newUnaryStmt = irMap->New(unaryStmt); return newUnaryStmt; } case OP_dassign: { - auto *dass = static_cast(&meStmt); + auto *dass = static_cast(&meStmt); DassignMeStmt *newDass = irMap->New(&irMap->GetIRMapAlloc(), dass); return newDass; } case OP_intrinsiccall: case OP_intrinsiccallwithtype: { - auto *intrnStmt = static_cast(&meStmt); + auto *intrnStmt = static_cast(&meStmt); IntrinsiccallMeStmt *newIntrnStmt = irMap->NewInPool(intrnStmt); return newIntrnStmt; } case OP_callassigned: { - auto *callAss = static_cast(&meStmt); + auto *callAss = static_cast(&meStmt); CallMeStmt *newCallAss = irMap->NewInPool(callAss); return newCallAss; } @@ -330,18 +331,18 @@ MeStmt *MeStmtPre::CopyMeStmt(MeStmt &meStmt) { // for each variable in realz that is defined by a phi, replace it by the jth // phi opnd; the tagged lhs is returned in the reference parameter lhsvar -MeStmt *MeStmtPre::PhiOpndFromRes4Stmt(MeRealOcc *realZ, size_t j, MeExpr *&lhsVar) { - MeOccur *defZ = realZ->GetDef(); - CHECK_FATAL(defZ, "must be def by phiocc"); +MeStmt *MeStmtPre::PhiOpndFromRes4Stmt(MeRealOcc &realZ, size_t j, MeExpr *&lhsVar) const { + MeOccur *defZ = realZ.GetDef(); + CHECK_FATAL(defZ != nullptr, "must be def by phiocc"); CHECK_FATAL(defZ->GetOccType() == kOccPhiocc, "must be def by phiocc"); - MeStmt *stmtQ = CopyMeStmt(utils::ToRef(realZ->GetMeStmt())); - lhsVar = realZ->GetMeExpr(); + MeStmt *stmtQ = CopyMeStmt(utils::ToRef(realZ.GetMeStmt())); + lhsVar = realZ.GetMeExpr(); BB *phiBB = defZ->GetBB(); CHECK_FATAL(stmtQ != nullptr, "nullptr check"); switch (stmtQ->GetOp()) { case OP_assertnonnull: { auto *unaryStmtQ = static_cast(stmtQ); - MeExpr *retOpnd = GetReplaceMeExpr(unaryStmtQ->GetOpnd(), phiBB, j); + MeExpr *retOpnd = GetReplaceMeExpr(*unaryStmtQ->GetOpnd(), *phiBB, j); if (retOpnd != nullptr) { unaryStmtQ->SetMeStmtOpndValue(retOpnd); } @@ -349,7 +350,7 @@ MeStmt *MeStmtPre::PhiOpndFromRes4Stmt(MeRealOcc *realZ, size_t j, MeExpr *&lhsV } case OP_dassign: { auto *dassQ = static_cast(stmtQ); - MeExpr *retOpnd = GetReplaceMeExpr(dassQ->GetRHS(), phiBB, j); + MeExpr *retOpnd = GetReplaceMeExpr(*dassQ->GetRHS(), *phiBB, j); if (retOpnd != nullptr) { dassQ->SetRHS(retOpnd); } @@ -360,7 +361,7 @@ MeStmt *MeStmtPre::PhiOpndFromRes4Stmt(MeRealOcc *realZ, size_t j, MeExpr *&lhsV case OP_callassigned: { auto *nStmtQ = static_cast(stmtQ); for (size_t i = 0; i < nStmtQ->NumMeStmtOpnds(); ++i) { - MeExpr *retOpnd = GetReplaceMeExpr(nStmtQ->GetOpnd(i), phiBB, j); + MeExpr *retOpnd = GetReplaceMeExpr(*nStmtQ->GetOpnd(i), *phiBB, j); if (retOpnd != nullptr) { nStmtQ->SetOpnd(i, retOpnd); } @@ -369,9 +370,10 @@ MeStmt *MeStmtPre::PhiOpndFromRes4Stmt(MeRealOcc *realZ, size_t j, MeExpr *&lhsV } default: ASSERT(false, "MeStmtPre::PhiOpndFromRes4Stmt: NYI"); + break; } - if ((stmtQ->GetOp() == OP_dassign || stmtQ->GetOp() == OP_callassigned) && realZ->GetMeExpr() != nullptr) { - MeExpr *retOpnd = GetReplaceMeExpr(realZ->GetMeExpr(), phiBB, j); + if ((stmtQ->GetOp() == OP_dassign || stmtQ->GetOp() == OP_callassigned) && realZ.GetMeExpr() != nullptr) { + MeExpr *retOpnd = GetReplaceMeExpr(*realZ.GetMeExpr(), *phiBB, j); if (retOpnd != nullptr) { lhsVar = retOpnd; } @@ -395,7 +397,7 @@ void MeStmtPre::Rename2() { if (!phiOccOpnd->IsProcessed()) { phiOccOpnd->SetIsProcessed(true); MeExpr *varY = nullptr; - MeStmt *stmtY = PhiOpndFromRes4Stmt(realOcc, i, varY); + MeStmt *stmtY = PhiOpndFromRes4Stmt(*realOcc, i, varY); stmtY->SetBB(phiOccOpnd->GetBB()); phiOccOpnd->SetCurrentMeStmt(*stmtY); // stmtY might be inserted at the end of the block MeOccur *defX = phiOccOpnd->GetDef(); @@ -406,8 +408,8 @@ void MeStmtPre::Rename2() { auto *realDefX = static_cast(defX); std::vector varVecX; std::vector varVecY; - CollectVarForCand(realDefX, varVecX); - CollectVarForMeStmt(stmtY, varY, varVecY); + CollectVarForCand(*realDefX, varVecX); + CollectVarForMeStmt(*stmtY, varY, varVecY); CHECK_FATAL(varVecX.size() == varVecY.size(), "vector size should be the same"); bool hasSameVersion = true; size_t checkLimit = varVecY.size(); @@ -428,7 +430,7 @@ void MeStmtPre::Rename2() { } else if (defX->GetOccType() == kOccPhiocc) { std::vector varVecY; bool allDom = true; - CollectVarForMeStmt(stmtY, varY, varVecY); + CollectVarForMeStmt(*stmtY, varY, varVecY); size_t checkLimit = varVecY.size(); if (varY != nullptr) { if (varVecY[checkLimit - 1] == stmtY->GetVarLHS()) { @@ -436,7 +438,7 @@ void MeStmtPre::Rename2() { } } for (size_t k = 0; k < checkLimit; ++k) { - if (!DefVarDominateOcc(varVecY[k], defX)) { + if (!DefVarDominateOcc(varVecY[k], *defX)) { allDom = false; } } @@ -492,13 +494,13 @@ void MeStmtPre::ComputeVarAndDfPhis() { switch (stmt->GetOp()) { case OP_assertnonnull: { auto *unaryStmt = static_cast(stmt); - SetVarPhis(unaryStmt->GetOpnd()); + SetVarPhis(*unaryStmt->GetOpnd()); break; } case OP_dassign: { auto *dassMeStmt = static_cast(stmt); - SetVarPhis(dassMeStmt->GetRHS()); - SetVarPhis(realOcc->GetMeExpr()); + SetVarPhis(*dassMeStmt->GetRHS()); + SetVarPhis(*realOcc->GetMeExpr()); break; } case OP_intrinsiccall: @@ -506,10 +508,10 @@ void MeStmtPre::ComputeVarAndDfPhis() { case OP_callassigned: { auto *nStmt = static_cast(stmt); for (size_t i = 0; i < nStmt->NumMeStmtOpnds(); ++i) { - SetVarPhis(nStmt->GetOpnd(i)); + SetVarPhis(*nStmt->GetOpnd(i)); } if (realOcc->GetMeExpr() != nullptr) { - SetVarPhis(realOcc->GetMeExpr()); + SetVarPhis(*realOcc->GetMeExpr()); } break; } @@ -562,8 +564,7 @@ void MeStmtPre::CreateSortedOccs() { auto useDfnIt = useDfns->begin(); MeOccur *nextUseOcc = nullptr; if (useDfnIt != useDfns->end()) { - CHECK_NULL_FATAL(GetBB(dom->GetDtPreOrderItem(*useDfnIt))); - nextUseOcc = perCandMemPool->New(kOccUse, 0, GetBB(dom->GetDtPreOrderItem(*useDfnIt)), nullptr); + nextUseOcc = perCandMemPool->New(kOccUse, 0, *GetBB(dom->GetDtPreOrderItem(*useDfnIt)), nullptr); } MeRealOcc *nextRealOcc = nullptr; if (realOccIt != workCand->GetRealOccs().end()) { @@ -575,12 +576,11 @@ void MeStmtPre::CreateSortedOccs() { } MePhiOcc *nextPhiOcc = nullptr; if (phiDfnIt != dfPhiDfns.end()) { - CHECK_NULL_FATAL(GetBB(dom->GetDtPreOrderItem(*phiDfnIt))); - nextPhiOcc = perCandMemPool->New(GetBB(dom->GetDtPreOrderItem(*phiDfnIt)), &perCandAllocator); + nextPhiOcc = perCandMemPool->New(*GetBB(dom->GetDtPreOrderItem(*phiDfnIt)), perCandAllocator); } MePhiOpndOcc *nextPhiOpndOcc = nullptr; if (phiOpndDfnIt != phiOpndDfns.end()) { - nextPhiOpndOcc = perCandMemPool->New(GetBB(dom->GetDtPreOrderItem(*phiOpndDfnIt))); + nextPhiOpndOcc = perCandMemPool->New(*GetBB(dom->GetDtPreOrderItem(*phiOpndDfnIt))); std::unordered_map>::iterator it = bb2PhiOpndMap.find(dom->GetDtPreOrderItem(*phiOpndDfnIt)); if (it == bb2PhiOpndMap.end()) { @@ -624,7 +624,7 @@ void MeStmtPre::CreateSortedOccs() { ++useDfnIt; if (useDfnIt != useDfns->end()) { CHECK_NULL_FATAL(GetBB(dom->GetDtPreOrderItem(*useDfnIt))); - nextUseOcc = perCandMemPool->New(kOccUse, 0, GetBB(dom->GetDtPreOrderItem(*useDfnIt)), nullptr); + nextUseOcc = perCandMemPool->New(kOccUse, 0, *GetBB(dom->GetDtPreOrderItem(*useDfnIt)), nullptr); } else { nextUseOcc = nullptr; } @@ -653,9 +653,7 @@ void MeStmtPre::CreateSortedOccs() { phiOccs.push_back(static_cast(pickedOcc)); ++phiDfnIt; if (phiDfnIt != dfPhiDfns.end()) { - CHECK_FATAL(GetBB(dom->GetDtPreOrderItem(*phiDfnIt)) != nullptr, - "GetBB return null in SSAPre::CreateSortedOccs"); - nextPhiOcc = perCandMemPool->New(GetBB(dom->GetDtPreOrderItem(*phiDfnIt)), &perCandAllocator); + nextPhiOcc = perCandMemPool->New(*GetBB(dom->GetDtPreOrderItem(*phiDfnIt)), perCandAllocator); } else { nextPhiOcc = nullptr; } @@ -663,7 +661,7 @@ void MeStmtPre::CreateSortedOccs() { case kOccPhiopnd: ++phiOpndDfnIt; if (phiOpndDfnIt != phiOpndDfns.end()) { - nextPhiOpndOcc = perCandMemPool->New(GetBB(dom->GetDtPreOrderItem(*phiOpndDfnIt))); + nextPhiOpndOcc = perCandMemPool->New(*GetBB(dom->GetDtPreOrderItem(*phiOpndDfnIt))); std::unordered_map>::iterator it = bb2PhiOpndMap.find(dom->GetDtPreOrderItem(*phiOpndDfnIt)); if (it == bb2PhiOpndMap.end()) { @@ -705,9 +703,9 @@ void MeStmtPre::CreateSortedOccs() { } } -void MeStmtPre::ConstructUseOccurMapExpr(uint32 bbDfn, MeExpr *meExpr) { - if (meExpr->GetMeOp() == kMeOpVar) { - OStIdx ostIdx = static_cast(meExpr)->GetOStIdx(); +void MeStmtPre::ConstructUseOccurMapExpr(uint32 bbDfn, const MeExpr &meExpr) { + if (meExpr.GetMeOp() == kMeOpVar) { + OStIdx ostIdx = static_cast(&meExpr)->GetOStIdx(); MapleMap*>::iterator mapIt; mapIt = useOccurMap.find(ostIdx); if (mapIt == useOccurMap.end()) { @@ -717,8 +715,8 @@ void MeStmtPre::ConstructUseOccurMapExpr(uint32 bbDfn, MeExpr *meExpr) { bbDfnSet->insert(bbDfn); return; } - for (uint8 i = 0; i < meExpr->GetNumOpnds(); ++i) { - ConstructUseOccurMapExpr(bbDfn, meExpr->GetOpnd(i)); + for (uint8 i = 0; i < meExpr.GetNumOpnds(); ++i) { + ConstructUseOccurMapExpr(bbDfn, *meExpr.GetOpnd(i)); } } @@ -747,7 +745,7 @@ void MeStmtPre::ConstructUseOccurMap() { BB *bb = func->GetAllBBs().at(preOrderDt[i]); for (auto &stmt : bb->GetMeStmts()) { for (size_t j = 0; j < stmt.NumMeStmtOpnds(); ++j) { - ConstructUseOccurMapExpr(i, stmt.GetOpnd(j)); + ConstructUseOccurMapExpr(i, *stmt.GetOpnd(j)); } } } @@ -776,7 +774,7 @@ PreStmtWorkCand *MeStmtPre::CreateStmtRealOcc(MeStmt &meStmt, int seqStmt) { return wkCand; } // workCand not yet created; create a new one and add to workList - wkCand = ssaPreMemPool->New(&ssaPreAllocator, workList.size(), &meStmt, GetPUIdx()); + wkCand = ssaPreMemPool->New(ssaPreAllocator, workList.size(), meStmt, GetPUIdx()); wkCand->SetHasLocalOpnd(true); // dummy workList.push_back(wkCand); wkCand->AddRealOccAsLast(*newOcc, GetPUIdx()); @@ -801,7 +799,7 @@ void MeStmtPre::VersionStackChiListUpdate(const MapleMap &ch static bool NoPriorUseInBB(const VarMeExpr *lhsVar, MeStmt *defStmt) { for (MeStmt *stmt = defStmt->GetPrev(); stmt != nullptr; stmt = stmt->GetPrev()) { for (size_t i = 0; i < stmt->NumMeStmtOpnds(); ++i) { - CHECK_FATAL(stmt->GetOpnd(i), "null ptr check"); + CHECK_FATAL(stmt->GetOpnd(i) != nullptr, "null ptr check"); if (stmt->GetOpnd(i)->SymAppears(lhsVar->GetOStIdx())) { return false; } @@ -947,7 +945,7 @@ void MeStmtPre::BuildWorkListBB(BB *bb) { (void)CreateStmtRealOcc(stmt, seqStmt); } } else if (dassMeStmt.GetLHS()->IsUseSameSymbol(*dassMeStmt.GetRHS())) { - RemoveUnnecessaryDassign(&dassMeStmt); + RemoveUnnecessaryDassign(dassMeStmt); } // update version stacks MapleStack *pStack = versionStackVec.at(dassMeStmt.GetVarLHS()->GetOStIdx()); @@ -1008,7 +1006,7 @@ void MeStmtPre::BuildWorkListBB(BB *bb) { } } if (bb->GetAttributes(kBBAttrIsExit) || bb->GetAttributes(kBBAttrWontExit)) { - CreateExitOcc(bb); + CreateExitOcc(*bb); } // recurse on child BBs in dominator tree const MapleSet &domChildren = dom->GetDomChildren(bb->GetBBId()); @@ -1044,10 +1042,10 @@ void MeStmtPre::BuildWorkList() { BuildWorkListBB(func->GetCommonEntryBB()); } -void MeStmtPre::RemoveUnnecessaryDassign(DassignMeStmt *dssMeStmt) { - BB *bb = dssMeStmt->GetBB(); - bb->RemoveMeStmt(dssMeStmt); - OStIdx ostIdx = dssMeStmt->GetVarLHS()->GetOStIdx(); +void MeStmtPre::RemoveUnnecessaryDassign(DassignMeStmt &dssMeStmt) { + BB *bb = dssMeStmt.GetBB(); + bb->RemoveMeStmt(&dssMeStmt); + OStIdx ostIdx = dssMeStmt.GetVarLHS()->GetOStIdx(); MapleSet *bbSet = nullptr; if (candsForSSAUpdate.find(ostIdx) == candsForSSAUpdate.end()) { bbSet = ssaPreMemPool->New>(std::less(), ssaPreAllocator.Adapter()); diff --git a/src/maple_me/src/me_store_pre.cpp b/src/maple_me/src/me_store_pre.cpp index 9007c1bcf4d893ed54f427d9c8bf390d81e52494..72cb2091e692d9c759683c91f95ecdd0d1121ee2 100644 --- a/src/maple_me/src/me_store_pre.cpp +++ b/src/maple_me/src/me_store_pre.cpp @@ -36,15 +36,15 @@ void MeStorePre::CheckCreateCurTemp() { // bbCurTempMap maps bb to cur_temp_version and is used to avoid re-processing // each bb. The return value is the curTemp version that contains the RHS value // at the entry to bb; -RegMeExpr *MeStorePre::EnsureRHSInCurTemp(BB *bb) { - CHECK_FATAL(bb != func->GetCommonEntryBB(), "EnsureRHSInCurTemp: cannot find earlier definition"); +RegMeExpr *MeStorePre::EnsureRHSInCurTemp(BB &bb) { + CHECK_FATAL(&bb != func->GetCommonEntryBB(), "EnsureRHSInCurTemp: cannot find earlier definition"); // see if processed before - auto mapIt = bbCurTempMap.find(bb); + auto mapIt = bbCurTempMap.find(&bb); if (mapIt != bbCurTempMap.end()) { return mapIt->second; } // traverse statements - auto &meStmts = bb->GetMeStmts(); + auto &meStmts = bb.GetMeStmts(); for (auto itStmt = meStmts.rbegin(); itStmt != meStmts.rend(); ++itStmt) { if (itStmt->GetOp() == OP_dassign) { auto *dass = static_cast(to_ptr(itStmt)); @@ -52,7 +52,7 @@ RegMeExpr *MeStorePre::EnsureRHSInCurTemp(BB *bb) { continue; } if (enabledDebug) { - LogInfo::MapleLogger() << "EnsureRHSInCurTemp: found dassign at BB" << bb->GetBBId() << '\n'; + LogInfo::MapleLogger() << "EnsureRHSInCurTemp: found dassign at BB" << bb.GetBBId() << '\n'; } if (dass->GetRHS()->GetMeOp() == kMeOpReg && static_cast(dass->GetRHS())->GetOstIdx() == curTemp->GetOstIdx()) { @@ -60,13 +60,13 @@ RegMeExpr *MeStorePre::EnsureRHSInCurTemp(BB *bb) { } // create and insert regassign before dass RegMeExpr *lhsReg = irMap->CreateRegMeExprVersion(*curTemp); - RegassignMeStmt *rass = irMap->CreateRegassignMeStmt(*lhsReg, *dass->GetRHS(), *bb); + RegassignMeStmt *rass = irMap->CreateRegassignMeStmt(*lhsReg, *dass->GetRHS(), bb); rass->SetSrcPos(itStmt->GetSrcPosition()); lhsReg->SetDefByStmt(*rass); - bb->InsertMeStmtBefore(dass, rass); + bb.InsertMeStmtBefore(dass, rass); // change dass's rhs to lhsReg dass->SetRHS(lhsReg); - bbCurTempMap[bb] = lhsReg; + bbCurTempMap[&bb] = lhsReg; return lhsReg; } else if (kOpcodeInfo.IsCallAssigned(itStmt->GetOp())) { MapleVector *mustDefList = itStmt->GetMustDefList(); @@ -81,51 +81,51 @@ RegMeExpr *MeStorePre::EnsureRHSInCurTemp(BB *bb) { continue; } if (enabledDebug) { - LogInfo::MapleLogger() << "EnsureRHSInCurTemp: found callassigned at BB" << bb->GetBBId() << '\n'; + LogInfo::MapleLogger() << "EnsureRHSInCurTemp: found callassigned at BB" << bb.GetBBId() << '\n'; } // change mustDefList RegMeExpr *lhsReg = irMap->CreateRegMeExprVersion(*curTemp); mustDefList->front().UpdateLHS(*lhsReg); // create dassign - DassignMeStmt *dass = irMap->CreateDassignMeStmt(*lhsVar, *lhsReg, *bb); + DassignMeStmt *dass = irMap->CreateDassignMeStmt(*lhsVar, *lhsReg, bb); dass->SetSrcPos(itStmt->GetSrcPosition()); lhsVar->SetDefByStmt(*dass); - bb->InsertMeStmtAfter(to_ptr(itStmt), dass); - bbCurTempMap[bb] = lhsReg; + bb.InsertMeStmtAfter(to_ptr(itStmt), dass); + bbCurTempMap[&bb] = lhsReg; return lhsReg; } } } // check if there is def by phi - auto phiIt = bb->GetMevarPhiList().find(workCand->GetOst()->GetIndex()); - if (phiIt != bb->GetMevarPhiList().end()) { + auto phiIt = bb.GetMevarPhiList().find(workCand->GetOst()->GetIndex()); + if (phiIt != bb.GetMevarPhiList().end()) { if (enabledDebug) { - LogInfo::MapleLogger() << "EnsureRHSInCurTemp: found def-by-phi at BB" << bb->GetBBId() << '\n'; + LogInfo::MapleLogger() << "EnsureRHSInCurTemp: found def-by-phi at BB" << bb.GetBBId() << '\n'; } RegMeExpr *lhsReg = irMap->CreateRegMeExprVersion(*curTemp); - bbCurTempMap[bb] = lhsReg; + bbCurTempMap[&bb] = lhsReg; // form a new phi for the temp MeRegPhiNode *regPhi = irMap->NewInPool(); regPhi->SetLHS(lhsReg); - regPhi->SetDefBB(bb); + regPhi->SetDefBB(&bb); // call recursively for each varPhi operands - for (BB *pred : bb->GetPred()) { - RegMeExpr *regPhiOpnd = EnsureRHSInCurTemp(pred); + for (BB *pred : bb.GetPred()) { + RegMeExpr *regPhiOpnd = EnsureRHSInCurTemp(*pred); CHECK_NULL_FATAL(regPhiOpnd); regPhi->GetOpnds().push_back(regPhiOpnd); regPhiOpnd->GetPhiUseSet().insert(regPhi); } // insert the regPhi - bb->GetMeRegPhiList().insert(std::make_pair(lhsReg->GetOstIdx(), regPhi)); + bb.GetMeRegPhiList().insert(std::make_pair(lhsReg->GetOstIdx(), regPhi)); return lhsReg; } // continue at immediate dominator if (enabledDebug) { - LogInfo::MapleLogger() << "EnsureRHSInCurTemp: cannot find def at BB" << bb->GetBBId() << '\n'; + LogInfo::MapleLogger() << "EnsureRHSInCurTemp: cannot find def at BB" << bb.GetBBId() << '\n'; } - RegMeExpr *savedCurTemp = EnsureRHSInCurTemp(dom->GetDom(bb->GetBBId())); + RegMeExpr *savedCurTemp = EnsureRHSInCurTemp(*dom->GetDom(bb.GetBBId())); CHECK_NULL_FATAL(savedCurTemp); - bbCurTempMap[bb] = savedCurTemp; + bbCurTempMap[&bb] = savedCurTemp; return savedCurTemp; } @@ -143,7 +143,7 @@ void MeStorePre::CodeMotion() { BB *insertBB = lambdaResOcc->GetBB(); CheckCreateCurTemp(); CHECK_FATAL(insertBB->GetPred().size() == 1, "CodeMotion: encountered critical edge"); - RegMeExpr *rhsReg = EnsureRHSInCurTemp(insertBB->GetPred(0)); + RegMeExpr *rhsReg = EnsureRHSInCurTemp(*insertBB->GetPred(0)); DassignMeStmt *newDass = irMap->CreateDassignMeStmt(*lhsVar, *rhsReg, *insertBB); lhsVar->SetDefByStmt(*newDass); // insert at earliest point in BB, but after statements required to be @@ -190,32 +190,31 @@ void MeStorePre::CodeMotion() { // ================ Step 0: collect occurrences ================ // create a new real occurrence for the store of meStmt of symbol oidx -void MeStorePre::CreateRealOcc(OStIdx ostIdx, MeStmt *meStmt) { - ASSERT_NOT_NULL(meStmt); +void MeStorePre::CreateRealOcc(OStIdx ostIdx, MeStmt &meStmt) { SpreWorkCand *wkCand = nullptr; auto mapIt = workCandMap.find(ostIdx); if (mapIt != workCandMap.end()) { wkCand = mapIt->second; } else { const OriginalSt *ost = ssaTab->GetSymbolOriginalStFromID(ostIdx); - wkCand = spreMp->New(&spreAllocator, ost); + wkCand = spreMp->New(spreAllocator, *ost); workCandMap[ostIdx] = wkCand; // if it is local symbol, insert artificial real occ at common_exit_bb if (ost->IsLocal()) { SRealOcc *artOcc = spreMp->New(); - artOcc->SetBB(func->GetCommonExitBB()); + artOcc->SetBB(*func->GetCommonExitBB()); wkCand->GetRealOccs().push_back(artOcc); } } if (wkCand->GetTheVar() == nullptr) { - if (meStmt->GetOp() == OP_dassign) { - wkCand->SetTheVar(static_cast(meStmt)->GetVarLHS()); + if (meStmt.GetOp() == OP_dassign) { + wkCand->SetTheVar(*static_cast(&meStmt)->GetVarLHS()); } else { - ASSERT(kOpcodeInfo.IsCallAssigned(meStmt->GetOp()), "CreateRealOcc: callassign expected"); - MapleVector *mustDefList = meStmt->GetMustDefList(); + ASSERT(kOpcodeInfo.IsCallAssigned(meStmt.GetOp()), "CreateRealOcc: callassign expected"); + MapleVector *mustDefList = meStmt.GetMustDefList(); CHECK_FATAL(mustDefList != nullptr, "CreateRealOcc: mustDefList cannot be empty"); CHECK_FATAL(!mustDefList->empty(), "CreateRealOcc: mustDefList cannot be empty"); - wkCand->SetTheVar(static_cast(mustDefList->front().GetLHS())); + wkCand->SetTheVar(*static_cast(mustDefList->front().GetLHS())); } } SRealOcc *newOcc = spreMp->New(meStmt); @@ -224,7 +223,7 @@ void MeStorePre::CreateRealOcc(OStIdx ostIdx, MeStmt *meStmt) { } // create a new use occurrence for symbol oidx in given bb -void MeStorePre::CreateUseOcc(OStIdx ostIdx, BB *bb) { +void MeStorePre::CreateUseOcc(OStIdx ostIdx, BB &bb) const { SpreWorkCand *wkcand = nullptr; auto mapIt = workCandMap.find(ostIdx); if (mapIt == workCandMap.end()) { @@ -233,7 +232,7 @@ void MeStorePre::CreateUseOcc(OStIdx ostIdx, BB *bb) { wkcand = mapIt->second; CHECK_FATAL(!wkcand->GetRealOccs().empty(), "empty container check"); SOcc *lastOcc = wkcand->GetRealOccs().back(); - if (lastOcc->GetOccTy() == kSOccUse && lastOcc->GetBB() == bb) { + if (lastOcc->GetOccTy() == kSOccUse && lastOcc->GetBB() == &bb) { return; // no need to push consecutive use occurrences at same BB } SUseOcc *newOcc = spreMp->New(bb); @@ -241,12 +240,11 @@ void MeStorePre::CreateUseOcc(OStIdx ostIdx, BB *bb) { } // create use occurs for all the symbols that alias with muost -void MeStorePre::CreateSpreUseOccsThruAliasing(const OriginalSt *muOst, BB *bb) { - ASSERT_NOT_NULL(muOst); - if (muOst->GetIndex() >= aliasClass->GetAliasElemCount()) { +void MeStorePre::CreateSpreUseOccsThruAliasing(const OriginalSt &muOst, BB &bb) const { + if (muOst.GetIndex() >= aliasClass->GetAliasElemCount()) { return; } - AliasElem *ae = aliasClass->FindAliasElem(*muOst); + AliasElem *ae = aliasClass->FindAliasElem(muOst); if (ae->GetClassSet() == nullptr) { return; } @@ -259,39 +257,37 @@ void MeStorePre::CreateSpreUseOccsThruAliasing(const OriginalSt *muOst, BB *bb) } } -void MeStorePre::FindAndCreateSpreUseOccs(MeExpr *meExpr, BB *bb) { - ASSERT_NOT_NULL(meExpr); - ASSERT_NOT_NULL(bb); - if (meExpr->GetMeOp() == kMeOpVar) { - auto *var = static_cast(meExpr); +void MeStorePre::FindAndCreateSpreUseOccs(const MeExpr &meExpr, BB &bb) const { + if (meExpr.GetMeOp() == kMeOpVar) { + auto *var = static_cast(&meExpr); const OriginalSt *ost = ssaTab->GetOriginalStFromID(var->GetOStIdx()); if (!ost->IsVolatile()) { CreateUseOcc(var->GetOStIdx(), bb); } return; } - for (uint8 i = 0; i < meExpr->GetNumOpnds(); i++) { - FindAndCreateSpreUseOccs(meExpr->GetOpnd(i), bb); + for (uint8 i = 0; i < meExpr.GetNumOpnds(); i++) { + FindAndCreateSpreUseOccs(*meExpr.GetOpnd(i), bb); } if (IsJavaLang()) { return; } - if (meExpr->GetMeOp() == kMeOpIvar) { - auto *ivarMeExpr = static_cast(meExpr); + if (meExpr.GetMeOp() == kMeOpIvar) { + auto *ivarMeExpr = static_cast(&meExpr); if (ivarMeExpr->GetMu() != nullptr) { - CreateSpreUseOccsThruAliasing(ssaTab->GetOriginalStFromID(ivarMeExpr->GetMu()->GetOStIdx()), bb); + CreateSpreUseOccsThruAliasing(*ssaTab->GetOriginalStFromID(ivarMeExpr->GetMu()->GetOStIdx()), bb); } } } -void MeStorePre::CreateSpreUseOccsForAll(BB *bb) { +void MeStorePre::CreateSpreUseOccsForAll(BB &bb) const { // go thru all workcands and insert a use occurrence for each of them for (std::pair wkCandPair : workCandMap) { SpreWorkCand *wkCand = wkCandPair.second; CHECK_NULL_FATAL(wkCand); CHECK_FATAL(!wkCand->GetRealOccs().empty(), "container empty check"); SOcc *lastOcc = wkCand->GetRealOccs().back(); - if (lastOcc->GetOccTy() == kSOccUse && lastOcc->GetBB() == bb) { + if (lastOcc->GetOccTy() == kSOccUse && lastOcc->GetBB() == &bb) { continue; // no need to push consecutive use occurrences at same BB } SUseOcc *newOcc = spreMp->New(bb); @@ -326,13 +322,12 @@ void MeStorePre::BuildWorkListBB(BB *bb) { if (lhsOstIdx != 0u) { const OriginalSt *ost = ssaTab->GetOriginalStFromID(lhsOstIdx); if (!ost->IsVolatile()) { - CreateRealOcc(lhsOstIdx, to_ptr(stmt)); + CreateRealOcc(lhsOstIdx, *to_ptr(stmt)); } } // look for use occurrence of stores for (size_t i = 0; i < stmt->NumMeStmtOpnds(); i++) { - CHECK_NULL_FATAL(stmt->GetOpnd(i)); - FindAndCreateSpreUseOccs(stmt->GetOpnd(i), stmt->GetBB()); + FindAndCreateSpreUseOccs(*stmt->GetOpnd(i), *stmt->GetBB()); } if (!IsJavaLang()) { // go thru mu list @@ -340,16 +335,16 @@ void MeStorePre::BuildWorkListBB(BB *bb) { if (naryMeStmt != nullptr) { CHECK_NULL_FATAL(naryMeStmt->GetMuList()); for (std::pair muPair : *(naryMeStmt->GetMuList())) { - CreateSpreUseOccsThruAliasing(ssaTab->GetOriginalStFromID(muPair.second->GetOStIdx()), bb); + CreateSpreUseOccsThruAliasing(*ssaTab->GetOriginalStFromID(muPair.second->GetOStIdx()), *bb); } } } } if (bb->GetAttributes(kBBAttrIsCatch)) { - CreateSpreUseOccsForAll(bb); + CreateSpreUseOccsForAll(*bb); } if (bb->GetAttributes(kBBAttrIsEntry)) { - CreateEntryOcc(bb); + CreateEntryOcc(*bb); } // recurse on child BBs in post-dominator tree for (BBId bbId : dom->GetPdomChildrenItem(bb->GetBBId())) { @@ -364,7 +359,7 @@ AnalysisResult *MeDoStorePre::Run(MeFunction *func, MeFuncResultMgr *m, ModuleRe ASSERT(aliasClass != nullptr, "aliasClass phase has problem"); auto *meIrMap = static_cast(m->GetAnalysisResult(MeFuncPhase_IRMAP, func)); CHECK_FATAL(meIrMap != nullptr, "irmap phase has problem"); - MeStorePre storePre(func, dom, aliasClass, NewMemPool(), DEBUGFUNC(func)); + MeStorePre storePre(*func, *dom, *aliasClass, *NewMemPool(), DEBUGFUNC(func)); storePre.ApplySSUPre(); if (DEBUGFUNC(func)) { func->Dump(false); diff --git a/src/maple_me/src/occur.cpp b/src/maple_me/src/occur.cpp index 2cceb78595ed648cf5e91f354214d5692b1af7a3..d6b9b57dc1640ac411ed45e6d49822a1b3904099 100644 --- a/src/maple_me/src/occur.cpp +++ b/src/maple_me/src/occur.cpp @@ -47,38 +47,39 @@ void MeOccur::DumpOccur(IRMap &irMap) { } // return if this occur dominate occ -bool MeOccur::IsDominate(Dominance *dom, MeOccur *occ) { +bool MeOccur::IsDominate(Dominance &dom, MeOccur &occ) { switch (occTy) { case kOccReal: { - switch (occ->GetOccType()) { + switch (occ.GetOccType()) { case kOccReal: { - if (mirBB == occ->GetBB()) { + if (mirBB == occ.GetBB()) { auto *thisRealOcc = static_cast(this); - auto *domOcc = static_cast(occ); + auto *domOcc = static_cast(&occ); return thisRealOcc->GetSequence() <= domOcc->GetSequence(); } - return dom->Dominate(*mirBB, *occ->GetBB()); + return dom.Dominate(*mirBB, *occ.GetBB()); } case kOccPhiocc: { - if (mirBB == occ->GetBB()) { + if (mirBB == occ.GetBB()) { return false; } - return dom->Dominate(*mirBB, *occ->GetBB()); + return dom.Dominate(*mirBB, *occ.GetBB()); } case kOccPhiopnd: case kOccExit: case kOccMembar: case kOccUse: - return dom->Dominate(*mirBB, *occ->GetBB()); + return dom.Dominate(*mirBB, *occ.GetBB()); default: ASSERT(false, "should not be here"); + break; } break; } case kOccPhiocc: case kOccMembar: case kOccUse: - return dom->Dominate(*mirBB, *occ->GetBB()); + return dom.Dominate(*mirBB, *occ.GetBB()); default: ASSERT(false, "should not be here"); return false; @@ -110,20 +111,20 @@ MeExpr *MeOccur::GetSavedExpr() { // return true if either: // operand is nullptr (def is null), or // hasRealUse is false and defined by a PHI not will be avail -bool MePhiOpndOcc::IsOkToInsert() { +bool MePhiOpndOcc::IsOkToInsert() const { if (GetDef() == nullptr) { return true; } if (!hasRealUse) { - MeOccur *defOcc = GetDef(); - if (defOcc->GetOccType() == kOccPhiocc && !static_cast(defOcc)->IsWillBeAvail()) { + const MeOccur *defOcc = GetDef(); + if (defOcc->GetOccType() == kOccPhiocc && !static_cast(defOcc)->IsWillBeAvail()) { return true; } } return false; } -bool MePhiOcc::IsOpndDefByRealOrInserted() { +bool MePhiOcc::IsOpndDefByRealOrInserted() const { for (MePhiOpndOcc *phiOpnd : phiOpnds) { MeOccur *defOcc = phiOpnd->GetDef(); if (defOcc->GetOccType() == kOccReal || defOcc->GetOccType() == kOccInserted) { @@ -133,7 +134,7 @@ bool MePhiOcc::IsOpndDefByRealOrInserted() { return false; } -void MeOccur::Dump(IRMap &irMap) { +void MeOccur::Dump(const IRMap &irMap) const { MIRModule *mod = &irMap.GetSSATab().GetModule(); if (occTy == kOccExit) { mod->GetOut() << "ExitOcc at bb" << GetBB()->GetBBId(); @@ -144,7 +145,7 @@ void MeOccur::Dump(IRMap &irMap) { } } -void MeRealOcc::Dump(IRMap &irMap) { +void MeRealOcc::Dump(const IRMap &irMap) const { MIRModule *mod = &irMap.GetSSATab().GetModule(); if (GetOccType() == kOccReal) { if (!isLHS) { @@ -168,7 +169,7 @@ void MeRealOcc::Dump(IRMap &irMap) { } } -void MePhiOcc::Dump(IRMap &irMap) { +void MePhiOcc::Dump(const IRMap &irMap) const { MIRModule *mod = &irMap.GetSSATab().GetModule(); mod->GetOut() << "PhiOcc "; mod->GetOut() << "PHI("; @@ -183,7 +184,7 @@ void MePhiOcc::Dump(IRMap &irMap) { mod->GetOut() << " at bb" << GetBB()->GetBBId() << " classID " << GetClassID(); } -void MePhiOpndOcc::Dump(IRMap &irMap) { +void MePhiOpndOcc::Dump(const IRMap &irMap) const { MIRModule *mod = &irMap.GetSSATab().GetModule(); mod->GetOut() << "PhiOpndOcc at bb" << GetBB()->GetBBId() << " classID " << GetClassID(); if (hasRealUse) { @@ -191,14 +192,14 @@ void MePhiOpndOcc::Dump(IRMap &irMap) { } } -void MeInsertedOcc::Dump(IRMap &irMap) { +void MeInsertedOcc::Dump(const IRMap &irMap) const { MIRModule *mod = &irMap.GetSSATab().GetModule(); mod->GetOut() << "InsertedOcc at bb" << GetBB()->GetBBId() << " classID " << GetClassID(); } // compute bucket index for the work candidate in workCandHashTable -uint32 PreWorkCand::ComputeWorkCandHashIndex(MeExpr &meExpr) { - uint32 hIdx = 0; +uint32 PreWorkCand::ComputeWorkCandHashIndex(const MeExpr &meExpr) { + uint32 hashIdx = 0; MeExprOp meOp = meExpr.GetMeOp(); switch (meOp) { case kMeOpAddrof: @@ -209,50 +210,50 @@ uint32 PreWorkCand::ComputeWorkCandHashIndex(MeExpr &meExpr) { case kMeOpConststr16: case kMeOpSizeoftype: case kMeOpFieldsDist: - hIdx = (static_cast(meExpr.GetExprID())) << kOffsetMeExprID; + hashIdx = (static_cast(meExpr.GetExprID())) << kOffsetMeExprID; break; case kMeOpVar: { - auto &varMeExpr = static_cast(meExpr); - hIdx = static_cast(varMeExpr.GetOStIdx()) << kOffsetVarMeExprOstIdx; + auto &varMeExpr = static_cast(meExpr); + hashIdx = static_cast(varMeExpr.GetOStIdx()) << kOffsetVarMeExprOstIdx; break; } case kMeOpReg: { - auto ®MeExpr = static_cast(meExpr); - hIdx = (static_cast(static_cast(regMeExpr.GetRegIdx()))) << kOffsetRegMeExprRegIdx; + auto ®MeExpr = static_cast(meExpr); + hashIdx = (static_cast(static_cast(regMeExpr.GetRegIdx()))) << kOffsetRegMeExprRegIdx; break; } case kMeOpIvar: { - auto &iVar = static_cast(meExpr); - hIdx = ComputeWorkCandHashIndex(*iVar.GetBase()) + + auto &iVar = static_cast(meExpr); + hashIdx = ComputeWorkCandHashIndex(*iVar.GetBase()) + (static_cast(iVar.GetTyIdx()) << kOffsetIvarMeExprTyIdx) + iVar.GetFieldID(); break; } case kMeOpOp: { - hIdx = static_cast(meExpr.GetOp()); + hashIdx = static_cast(meExpr.GetOp()); for (size_t idx = 0; idx < kOperandNumTernary; ++idx) { MeExpr *opnd = meExpr.GetOpnd(idx); if (opnd == nullptr) { break; } - hIdx += ComputeWorkCandHashIndex(*opnd) << kOffsetOpMeExprOpnd; + hashIdx += ComputeWorkCandHashIndex(*opnd) << kOffsetOpMeExprOpnd; } break; } case kMeOpNary: { - hIdx = static_cast(meExpr.GetOp()); + hashIdx = static_cast(meExpr.GetOp()); for (uint8 i = 0; i < meExpr.GetNumOpnds(); ++i) { - hIdx += ComputeWorkCandHashIndex(*meExpr.GetOpnd(i)) << kOffsetNaryMeExprOpnd; + hashIdx += ComputeWorkCandHashIndex(*meExpr.GetOpnd(i)) << kOffsetNaryMeExprOpnd; } break; } default: CHECK_FATAL(false, "MeOP NIY"); } - return hIdx % kWorkCandHashLength; + return hashIdx % kWorkCandHashLength; } // insert occ as realOccs[pos] after shifting the vector elements further down -void PreWorkCand::InsertRealOccAt(MeRealOcc &occ, MapleVector::iterator it, PUIdx pIdx) { +void PreWorkCand::InsertRealOccAt(MeRealOcc &occ, const MapleVector::iterator it, PUIdx pIdx) { ASSERT(pIdx != 0, "puIdx of realocc cannot be 0"); if (pIdx != puIdx) { ASSERT(!hasLocalOpnd, "candidate with local opnd cannot have real occurrences in more than one PU"); @@ -263,7 +264,7 @@ void PreWorkCand::InsertRealOccAt(MeRealOcc &occ, MapleVector::itera } // insert occ in realOccs maintaining sorted order according to dt_preorder -void PreWorkCand::AddRealOccSorted(Dominance &dom, MeRealOcc &occ, PUIdx pIdx) { +void PreWorkCand::AddRealOccSorted(const Dominance &dom, MeRealOcc &occ, PUIdx pIdx) { ASSERT(!realOccs.empty(), "AddRealOccSorted: realOccs is empty"); uint32 occDfn = dom.GetDtDfnItem(occ.GetBB()->GetBBId()); // check the end of realOccs first because inserting at end is most frequent @@ -311,7 +312,7 @@ void PreWorkCand::AddRealOccSorted(Dominance &dom, MeRealOcc &occ, PUIdx pIdx) { } // compute bucket index for the work candidate in workCandHashTable -uint32 PreStmtWorkCand::ComputeStmtWorkCandHashIndex(MeStmt &stmt) { +uint32 PreStmtWorkCand::ComputeStmtWorkCandHashIndex(const MeStmt &stmt) { uint32 hIdx = (static_cast(stmt.GetOp())) << kOffsetMeStmtOpcode; switch (stmt.GetOp()) { case OP_assertnonnull: { @@ -328,7 +329,7 @@ uint32 PreStmtWorkCand::ComputeStmtWorkCandHashIndex(MeStmt &stmt) { } case OP_intrinsiccall: case OP_intrinsiccallwithtype: { - auto &intrnStmt = static_cast(stmt); + auto &intrnStmt = static_cast(stmt); hIdx += (static_cast(intrnStmt.GetIntrinsic())) << kOffsetIntrinsicCallMeStmtIntrinsic; if (stmt.GetOp() == OP_intrinsiccallwithtype) { hIdx += static_cast(intrnStmt.GetTyIdx()) << 1; @@ -339,14 +340,14 @@ uint32 PreStmtWorkCand::ComputeStmtWorkCandHashIndex(MeStmt &stmt) { break; } case OP_callassigned: { - auto &callAss = static_cast(stmt); + auto &callAss = static_cast(stmt); hIdx += callAss.GetPUIdx(); for (size_t i = 0; i < callAss.NumMeStmtOpnds(); ++i) { hIdx += ComputeWorkCandHashIndex(*callAss.GetOpnd(i)) << kOffsetNaryMeStmtOpnd; } - if (!callAss.GetMustDefList()->empty()) { - MeExpr *lhs = callAss.GetMustDefList()->front().GetLHS(); - auto *lhsVar = static_cast(lhs); + if (!callAss.GetMustDefList().empty()) { + const MeExpr *lhs = callAss.GetMustDefList().front().GetLHS(); + auto *lhsVar = static_cast(lhs); hIdx += static_cast(lhsVar->GetOStIdx()) << 1; } break; diff --git a/src/maple_me/src/preg_renamer.cpp b/src/maple_me/src/preg_renamer.cpp index f25342a945b6f3ed1700ebd0a4108458c86e58cb..ef55dd8a9ed2de10447c3a2104f83c8cbc548559 100644 --- a/src/maple_me/src/preg_renamer.cpp +++ b/src/maple_me/src/preg_renamer.cpp @@ -16,8 +16,9 @@ #include "alias_class.h" #include "mir_builder.h" #include "me_irmap.h" + namespace maple { -void PregRenamer::EnqueDefUses(std::list &qu, RegMeExpr *node, std::set &curVisited) { +void PregRenamer::EnqueDefUses(std::list &qu, RegMeExpr *node, std::set &curVisited) const { // get its define if (node->GetDefBy() == kDefByPhi) { MeRegPhiNode &defPhi = node->GetDefPhi(); @@ -48,7 +49,7 @@ void PregRenamer::EnqueDefUses(std::list &qu, RegMeExpr *node, std:: } } -void PregRenamer::RunSelf() { +void PregRenamer::RunSelf() const { // BFS the graph of register phi node; std::set curVisited; const MapleVector ®MeExprTable = irMap->GetRegMeExprTable(); @@ -101,7 +102,7 @@ void PregRenamer::RunSelf() { ++renameCount; if (enabledDebug) { LogInfo::MapleLogger() << "%" << - pregTab->PregFromPregIdx(static_cast(regMeExpr->GetRegIdx()))->GetPregNo(); + pregTab->PregFromPregIdx(static_cast(regMeExpr->GetRegIdx()))->GetPregNo(); LogInfo::MapleLogger() << " renamed to %" << pregTab->PregFromPregIdx(newPregIdx)->GetPregNo() << '\n'; } // reneme all the register @@ -117,8 +118,7 @@ void PregRenamer::RunSelf() { AnalysisResult *MeDoPregRename::Run(MeFunction *func, MeFuncResultMgr *m, ModuleResultMgr*) { auto *irMap = static_cast(m->GetAnalysisResult(MeFuncPhase_IRMAP, func)); - CHECK_NULL_FATAL(irMap); - PregRenamer pregRenamer(NewMemPool(), func, irMap, DEBUGFUNC(func)); + PregRenamer pregRenamer(*NewMemPool(), *func, *irMap, DEBUGFUNC(func)); pregRenamer.RunSelf(); if (DEBUGFUNC(func)) { LogInfo::MapleLogger() << "------------after pregrename:-------------------\n"; diff --git a/src/maple_me/src/prop.cpp b/src/maple_me/src/prop.cpp index 0860d0ab6b2d5cd140779979b93febf04b1560f3..847dcedb807b151fa3cc0a1f1540cf6f5a545a64 100644 --- a/src/maple_me/src/prop.cpp +++ b/src/maple_me/src/prop.cpp @@ -57,7 +57,7 @@ Prop::Prop(IRMap &irMap, Dominance &dom, MemPool &memPool, std::vector &&bb } } -MeExpr *Prop::SimplifyCvtMeExpr(const OpMeExpr &opMeExpr) { +MeExpr *Prop::SimplifyCvtMeExpr(const OpMeExpr &opMeExpr) const { MeExpr *opnd0 = opMeExpr.GetOpnd(0); @@ -79,7 +79,7 @@ MeExpr *Prop::SimplifyCvtMeExpr(const OpMeExpr &opMeExpr) { } MeExpr *Prop::SimplifyCompareSelectConstMeExpr(const OpMeExpr &opMeExpr, const MeExpr &opMeOpnd0, MeExpr &opnd1, - MeExpr &opnd01, MeExpr &opnd02) { + MeExpr &opnd01, MeExpr &opnd02) const { // b, c and compare operand are all constant auto *constOpnd1 = static_cast(opnd1).GetConstVal(); auto *constOpnd01 = static_cast(opnd01).GetConstVal(); @@ -118,7 +118,7 @@ MeExpr *Prop::SimplifyCompareSelectConstMeExpr(const OpMeExpr &opMeExpr, const M return irMap.HashMeExpr(newopMeExpr); } -MeExpr *Prop::SimplifyCompareMeExpr(OpMeExpr &opMeExpr) { +MeExpr *Prop::SimplifyCompareMeExpr(OpMeExpr &opMeExpr) const { MeExpr *opnd0 = opMeExpr.GetOpnd(0); MeExpr *opnd1 = opMeExpr.GetOpnd(1); @@ -161,7 +161,7 @@ MeExpr *Prop::SimplifyCompareMeExpr(OpMeExpr &opMeExpr) { return nullptr; } -MeExpr *Prop::SimplifyMeExpr(OpMeExpr &opMeExpr) { +MeExpr *Prop::SimplifyMeExpr(OpMeExpr &opMeExpr) const { Opcode opcode = opMeExpr.GetOp(); if (kOpcodeInfo.IsCompare(opcode)) { return SimplifyCompareMeExpr(opMeExpr); @@ -350,7 +350,7 @@ bool Prop::Propagatable(const MeExpr &expr, const BB &fromBB, bool atParm) const } // return varMeExpr itself if no propagation opportunity -MeExpr &Prop::PropVar(VarMeExpr &varMeExpr, bool atParm, bool checkPhi) { +MeExpr &Prop::PropVar(VarMeExpr &varMeExpr, bool atParm, bool checkPhi) const { const MIRSymbol *st = ssaTab.GetMIRSymbolFromID(varMeExpr.GetOStIdx()); if (st->IsInstrumented() || varMeExpr.IsVolatile(ssaTab)) { return varMeExpr; @@ -394,7 +394,7 @@ MeExpr &Prop::PropVar(VarMeExpr &varMeExpr, bool atParm, bool checkPhi) { return varMeExpr; } -MeExpr &Prop::PropReg(RegMeExpr ®MeExpr, bool atParm) { +MeExpr &Prop::PropReg(RegMeExpr ®MeExpr, bool atParm) const { if (regMeExpr.GetDefBy() == kDefByStmt) { RegassignMeStmt *defStmt = static_cast(regMeExpr.GetDefStmt()); MeExpr &rhs = utils::ToRef(defStmt->GetRHS()); @@ -405,7 +405,7 @@ MeExpr &Prop::PropReg(RegMeExpr ®MeExpr, bool atParm) { return regMeExpr; } -MeExpr &Prop::PropIvar(IvarMeExpr &ivarMeExpr) { +MeExpr &Prop::PropIvar(IvarMeExpr &ivarMeExpr) const { IassignMeStmt *defStmt = ivarMeExpr.GetDefStmt(); if (defStmt == nullptr || ivarMeExpr.IsVolatile()) { return ivarMeExpr; diff --git a/src/maple_me/src/ssa_devirtual.cpp b/src/maple_me/src/ssa_devirtual.cpp index a6f957acd29d6fee3785fd026fe367052d0b385e..4e560d4fa3c99cae1b081a8166c49eb43c03d334 100644 --- a/src/maple_me/src/ssa_devirtual.cpp +++ b/src/maple_me/src/ssa_devirtual.cpp @@ -24,15 +24,15 @@ namespace maple { bool SSADevirtual::debug = false; -static bool MaybeNull(MeExpr *expr) { - if (expr->GetMeOp() == kMeOpVar) { - return static_cast(expr)->GetMaybeNull(); +static bool MaybeNull(const MeExpr &expr) { + if (expr.GetMeOp() == kMeOpVar) { + return static_cast(&expr)->GetMaybeNull(); } - if (expr->GetMeOp() == kMeOpIvar) { - return static_cast(expr)->GetMaybeNull(); + if (expr.GetMeOp() == kMeOpIvar) { + return static_cast(&expr)->GetMaybeNull(); } - if (expr->GetOp() == OP_retype) { - MeExpr *retypeRHS = (static_cast(expr))->GetOpnd(0); + if (expr.GetOp() == OP_retype) { + MeExpr *retypeRHS = (static_cast(&expr))->GetOpnd(0); if (retypeRHS->GetMeOp() == kMeOpVar) { return static_cast(retypeRHS)->GetMaybeNull(); } @@ -49,9 +49,9 @@ static bool IsFinalMethod(const MIRFunction *mirFunc) { return (classType != nullptr && (mirFunc->IsFinal() || classType->IsFinal())); } -TyIdx SSADevirtual::GetInferredTyIdx(MeExpr *expr) { - if (expr->GetMeOp() == kMeOpVar) { - auto *varMeExpr = static_cast(expr); +TyIdx SSADevirtual::GetInferredTyIdx(MeExpr &expr) const { + if (expr.GetMeOp() == kMeOpVar) { + auto *varMeExpr = static_cast(&expr); if (varMeExpr->GetInferredTyIdx() == 0u) { // If varMeExpr->inferredTyIdx has not been set, we can double check // if it is coming from a static final field @@ -72,11 +72,11 @@ TyIdx SSADevirtual::GetInferredTyIdx(MeExpr *expr) { } return varMeExpr->GetInferredTyIdx(); } - if (expr->GetMeOp() == kMeOpIvar) { - return static_cast(expr)->GetInferredTyIdx(); + if (expr.GetMeOp() == kMeOpIvar) { + return static_cast(&expr)->GetInferredTyIdx(); } - if (expr->GetOp() == OP_retype) { - MeExpr *retypeRHS = (static_cast(expr))->GetOpnd(0); + if (expr.GetOp() == OP_retype) { + MeExpr *retypeRHS = (static_cast(&expr))->GetOpnd(0); if (retypeRHS->GetMeOp() == kMeOpVar) { return static_cast(retypeRHS)->GetInferredTyIdx(); } @@ -84,53 +84,53 @@ TyIdx SSADevirtual::GetInferredTyIdx(MeExpr *expr) { return TyIdx(0); } -void SSADevirtual::ReplaceCall(CallMeStmt *callStmt, MIRFunction *targetFunc) { +void SSADevirtual::ReplaceCall(CallMeStmt &callStmt, const MIRFunction &targetFunc) { if (SSADevirtual::debug) { - MIRFunction &mirFunc = callStmt->GetTargetFunction(); - LogInfo::MapleLogger() << "[SSA-DEVIRT] " << kOpcodeInfo.GetTableItemAt(callStmt->GetOp()).name << " " << + MIRFunction &mirFunc = callStmt.GetTargetFunction(); + LogInfo::MapleLogger() << "[SSA-DEVIRT] " << kOpcodeInfo.GetTableItemAt(callStmt.GetOp()).name << " " << NameMangler::DecodeName(mirFunc.GetName()); } - if (callStmt->GetOp() == OP_virtualicall || callStmt->GetOp() == OP_virtualicallassigned || - callStmt->GetOp() == OP_interfaceicall || callStmt->GetOp() == OP_interfaceicallassigned) { + if (callStmt.GetOp() == OP_virtualicall || callStmt.GetOp() == OP_virtualicallassigned || + callStmt.GetOp() == OP_interfaceicall || callStmt.GetOp() == OP_interfaceicallassigned) { // delete 1st argument - callStmt->EraseOpnds(callStmt->GetOpnds().begin()); + callStmt.EraseOpnds(callStmt.GetOpnds().begin()); } - MeExpr *receiver = callStmt->GetOpnd(0); - if (NeedNullCheck(receiver)) { - InsertNullCheck(callStmt, receiver); + MeExpr *receiver = callStmt.GetOpnd(0); + if (NeedNullCheck(*receiver)) { + InsertNullCheck(callStmt, *receiver); ++nullCheckCount; } // Set the actuall callee puIdx - callStmt->SetPUIdx(targetFunc->GetPuidx()); - if (callStmt->GetOp() == OP_virtualcall || callStmt->GetOp() == OP_virtualicall) { - callStmt->SetOp(OP_call); + callStmt.SetPUIdx(targetFunc.GetPuidx()); + if (callStmt.GetOp() == OP_virtualcall || callStmt.GetOp() == OP_virtualicall) { + callStmt.SetOp(OP_call); ++optedVirtualCalls; - } else if (callStmt->GetOp() == OP_virtualcallassigned || callStmt->GetOp() == OP_virtualicallassigned) { - callStmt->SetOp(OP_callassigned); + } else if (callStmt.GetOp() == OP_virtualcallassigned || callStmt.GetOp() == OP_virtualicallassigned) { + callStmt.SetOp(OP_callassigned); ++optedVirtualCalls; - } else if (callStmt->GetOp() == OP_interfacecall || callStmt->GetOp() == OP_interfaceicall) { - callStmt->SetOp(OP_call); + } else if (callStmt.GetOp() == OP_interfacecall || callStmt.GetOp() == OP_interfaceicall) { + callStmt.SetOp(OP_call); ++optedInterfaceCalls; - } else if (callStmt->GetOp() == OP_interfacecallassigned || callStmt->GetOp() == OP_interfaceicallassigned) { - callStmt->SetOp(OP_callassigned); + } else if (callStmt.GetOp() == OP_interfacecallassigned || callStmt.GetOp() == OP_interfaceicallassigned) { + callStmt.SetOp(OP_callassigned); ++optedInterfaceCalls; } - if (clone != nullptr && OP_callassigned == callStmt->GetOp()) { - clone->UpdateReturnVoidIfPossible(callStmt, targetFunc); + if (clone != nullptr && OP_callassigned == callStmt.GetOp()) { + clone->UpdateReturnVoidIfPossible(&callStmt, &targetFunc); } if (SSADevirtual::debug) { - LogInfo::MapleLogger() << "\t -> \t" << kOpcodeInfo.GetTableItemAt(callStmt->GetOp()).name << " " << - NameMangler::DecodeName(targetFunc->GetName()); - if (NeedNullCheck(receiver)) { + LogInfo::MapleLogger() << "\t -> \t" << kOpcodeInfo.GetTableItemAt(callStmt.GetOp()).name << " " << + NameMangler::DecodeName(targetFunc.GetName()); + if (NeedNullCheck(*receiver)) { LogInfo::MapleLogger() << " with null-check "; } - LogInfo::MapleLogger() << "\t at " << mod->GetFileNameFromFileNum(callStmt->GetSrcPosition().FileNum()) << ":" << - callStmt->GetSrcPosition().LineNum() << '\n'; + LogInfo::MapleLogger() << "\t at " << mod->GetFileNameFromFileNum(callStmt.GetSrcPosition().FileNum()) << ":" << + callStmt.GetSrcPosition().LineNum() << '\n'; } } -bool SSADevirtual::DevirtualizeCall(CallMeStmt *callStmt) { - switch (callStmt->GetOp()) { +bool SSADevirtual::DevirtualizeCall(CallMeStmt &callStmt) { + switch (callStmt.GetOp()) { case OP_interfacecall: case OP_interfaceicall: case OP_interfacecallassigned: @@ -141,17 +141,17 @@ bool SSADevirtual::DevirtualizeCall(CallMeStmt *callStmt) { case OP_virtualcallassigned: case OP_virtualicallassigned: { totalVirtualCalls++; // actually the number of interfacecalls + virtualcalls - const MapleVector &parms = callStmt->GetOpnds(); + const MapleVector &parms = callStmt.GetOpnds(); if (parms.empty() || parms[0] == nullptr) { break; } MeExpr *thisParm = parms[0]; - if (callStmt->GetOp() == OP_interfaceicall || callStmt->GetOp() == OP_interfaceicallassigned || - callStmt->GetOp() == OP_virtualicall || callStmt->GetOp() == OP_virtualicallassigned) { + if (callStmt.GetOp() == OP_interfaceicall || callStmt.GetOp() == OP_interfaceicallassigned || + callStmt.GetOp() == OP_virtualicall || callStmt.GetOp() == OP_virtualicallassigned) { thisParm = parms[1]; } - TyIdx receiverInferredTyIdx = GetInferredTyIdx(thisParm); - MIRFunction &mirFunc = callStmt->GetTargetFunction(); + TyIdx receiverInferredTyIdx = GetInferredTyIdx(*thisParm); + MIRFunction &mirFunc = callStmt.GetTargetFunction(); if (thisParm->GetPrimType() == PTY_ref && receiverInferredTyIdx != 0u) { Klass *inferredKlass = kh->GetKlassFromTyIdx(receiverInferredTyIdx); if (inferredKlass == nullptr) { @@ -169,7 +169,7 @@ bool SSADevirtual::DevirtualizeCall(CallMeStmt *callStmt) { if (thisParm->GetMeOp() != kMeOpVar && thisParm->GetMeOp() != kMeOpIvar) { break; } - ReplaceCall(callStmt, inferredFunction); + ReplaceCall(callStmt, *inferredFunction); return true; } else if (IsFinalMethod(&mirFunc)) { GStrIdx uniqFuncNameStrIdx = mirFunc.GetNameStrIdx(); @@ -178,10 +178,9 @@ bool SSADevirtual::DevirtualizeCall(CallMeStmt *callStmt) { ASSERT(uniqFuncSym != nullptr, "The real callee %s has not been seen in any imported .mplt file", mirFunc.GetName().c_str()); MIRFunction *uniqFunc = uniqFuncSym->GetFunction(); - ASSERT(uniqFunc != nullptr, "Invalid function replacement in devirtualization"); ASSERT(mirFunc.GetBaseFuncNameWithType() == uniqFunc->GetBaseFuncNameWithType(), "Invalid function replacement in devirtualization"); - ReplaceCall(callStmt, uniqFunc); + ReplaceCall(callStmt, *uniqFunc); return true; } else { if (thisParm->GetMeOp() == kMeOpVar) { @@ -211,7 +210,7 @@ bool SSADevirtual::DevirtualizeCall(CallMeStmt *callStmt) { LogInfo::MapleLogger() << "Devirutalize based on set of inferred types: In " << GetMIRFunction()->GetName() << "; Devirtualize: " << mirFunc.GetName() << '\n'; } - ReplaceCall(callStmt, inferredFunction); + ReplaceCall(callStmt, *inferredFunction); return true; } } @@ -225,59 +224,59 @@ bool SSADevirtual::DevirtualizeCall(CallMeStmt *callStmt) { return false; } -bool SSADevirtual::NeedNullCheck(MeExpr *receiver) const { +bool SSADevirtual::NeedNullCheck(const MeExpr &receiver) const { return MaybeNull(receiver); } // Java requires to throw Null-Pointer-Execption if the receiver of // the virtualcall is null. We insert an eval(iread recevier, 0) // statment perform the null-check. -void SSADevirtual::InsertNullCheck(CallMeStmt *callStmt, MeExpr *receiver) { +void SSADevirtual::InsertNullCheck(const CallMeStmt &callStmt, MeExpr &receiver) const { UnaryMeStmt *nullCheck = irMap->New(OP_assertnonnull); - nullCheck->SetBB(callStmt->GetBB()); - nullCheck->SetSrcPos(callStmt->GetSrcPosition()); - nullCheck->SetMeStmtOpndValue(receiver); - callStmt->GetBB()->InsertMeStmtBefore(callStmt, nullCheck); + nullCheck->SetBB(callStmt.GetBB()); + nullCheck->SetSrcPos(callStmt.GetSrcPosition()); + nullCheck->SetMeStmtOpndValue(&receiver); + callStmt.GetBB()->InsertMeStmtBefore(&callStmt, nullCheck); } -void SSADevirtual::PropVarInferredType(VarMeExpr *VarMeExpr) { - if (VarMeExpr->GetInferredTyIdx() != 0u) { +void SSADevirtual::PropVarInferredType(VarMeExpr &VarMeExpr) const { + if (VarMeExpr.GetInferredTyIdx() != 0u) { return; } - if (VarMeExpr->GetDefBy() == kDefByStmt) { - DassignMeStmt &defStmt = utils::ToRef(safe_cast(VarMeExpr->GetDefStmt())); + if (VarMeExpr.GetDefBy() == kDefByStmt) { + DassignMeStmt &defStmt = utils::ToRef(safe_cast(VarMeExpr.GetDefStmt())); MeExpr *rhs = defStmt.GetRHS(); if (rhs->GetOp() == OP_gcmalloc) { - VarMeExpr->SetInferredTyIdx(static_cast(rhs)->GetTyIdx()); - VarMeExpr->SetMaybeNull(false); + VarMeExpr.SetInferredTyIdx(static_cast(rhs)->GetTyIdx()); + VarMeExpr.SetMaybeNull(false); if (SSADevirtual::debug) { - MIRType *type = GlobalTables::GetTypeTable().GetTypeFromTyIdx(VarMeExpr->GetInferredTyIdx()); - LogInfo::MapleLogger() << "[SSA-DEVIRT] [TYPE-INFERRING] mx" << VarMeExpr->GetExprID() << " "; + MIRType *type = GlobalTables::GetTypeTable().GetTypeFromTyIdx(VarMeExpr.GetInferredTyIdx()); + LogInfo::MapleLogger() << "[SSA-DEVIRT] [TYPE-INFERRING] mx" << VarMeExpr.GetExprID() << " "; type->Dump(0, false); LogInfo::MapleLogger() << '\n'; } } else { - TyIdx tyIdx = GetInferredTyIdx(rhs); - VarMeExpr->SetMaybeNull(MaybeNull(rhs)); + TyIdx tyIdx = GetInferredTyIdx(*rhs); + VarMeExpr.SetMaybeNull(MaybeNull(*rhs)); if (tyIdx != 0u) { - VarMeExpr->SetInferredTyIdx(tyIdx); + VarMeExpr.SetInferredTyIdx(tyIdx); if (SSADevirtual::debug) { - MIRType *type = GlobalTables::GetTypeTable().GetTypeFromTyIdx(VarMeExpr->GetInferredTyIdx()); - LogInfo::MapleLogger() << "[SSA-DEVIRT] [TYPE-INFERRING] mx" << VarMeExpr->GetExprID() << " "; + MIRType *type = GlobalTables::GetTypeTable().GetTypeFromTyIdx(VarMeExpr.GetInferredTyIdx()); + LogInfo::MapleLogger() << "[SSA-DEVIRT] [TYPE-INFERRING] mx" << VarMeExpr.GetExprID() << " "; type->Dump(0, false); LogInfo::MapleLogger() << '\n'; } } } - if (VarMeExpr->GetInferredTyIdx() != 0u) { + if (VarMeExpr.GetInferredTyIdx() != 0u) { OriginalSt *ost = irMap->GetSSATab().GetOriginalStFromID(defStmt.GetVarLHS()->GetOStIdx()); MIRSymbol *mirSym = ost->GetMIRSymbol(); if (mirSym->IsStatic() && mirSym->IsFinal()) { // static final field can store and propagate inferred typeinfo if (mirSym->GetInferredTyIdx() == kInitTyIdx) { // mirSym->_inferred_tyIdx has not been set before - mirSym->SetInferredTyIdx(VarMeExpr->GetInferredTyIdx()); - } else if (mirSym->GetInferredTyIdx() != VarMeExpr->GetInferredTyIdx()) { + mirSym->SetInferredTyIdx(VarMeExpr.GetInferredTyIdx()); + } else if (mirSym->GetInferredTyIdx() != VarMeExpr.GetInferredTyIdx()) { // If mirSym->_inferred_tyIdx has been set before, it means we have // seen a divergence on control flow. Set to NONE if not all // branches reach the same conclusion. @@ -285,40 +284,40 @@ void SSADevirtual::PropVarInferredType(VarMeExpr *VarMeExpr) { } } } - } else if (VarMeExpr->GetDefBy() == kDefByPhi) { + } else if (VarMeExpr.GetDefBy() == kDefByPhi) { if (SSADevirtual::debug) { LogInfo::MapleLogger() << "[SSA-DEVIRT] [TYPE-INFERRING] " << "Def by phi " << '\n'; } } } -void SSADevirtual::PropIvarInferredType(IvarMeExpr *ivar) { - if (ivar->GetInferredTyIdx() != 0u) { +void SSADevirtual::PropIvarInferredType(IvarMeExpr &ivar) const { + if (ivar.GetInferredTyIdx() != 0u) { return; } - IassignMeStmt *defStmt = ivar->GetDefStmt(); + IassignMeStmt *defStmt = ivar.GetDefStmt(); if (defStmt == nullptr) { return; } MeExpr *rhs = defStmt->GetRHS(); CHECK_NULL_FATAL(rhs); if (rhs->GetOp() == OP_gcmalloc) { - ivar->GetInferredTyIdx() = static_cast(rhs)->GetTyIdx(); - ivar->SetMaybeNull(false); + ivar.GetInferredTyIdx() = static_cast(rhs)->GetTyIdx(); + ivar.SetMaybeNull(false); if (SSADevirtual::debug) { - MIRType *type = GlobalTables::GetTypeTable().GetTypeFromTyIdx(ivar->GetInferredTyIdx()); - LogInfo::MapleLogger() << "[SSA-DEVIRT] [TYPE-INFERRING] mx" << ivar->GetExprID() << " "; + MIRType *type = GlobalTables::GetTypeTable().GetTypeFromTyIdx(ivar.GetInferredTyIdx()); + LogInfo::MapleLogger() << "[SSA-DEVIRT] [TYPE-INFERRING] mx" << ivar.GetExprID() << " "; type->Dump(0, false); LogInfo::MapleLogger() << '\n'; } } else { - TyIdx tyIdx = GetInferredTyIdx(rhs); - ivar->SetMaybeNull(MaybeNull(rhs)); + TyIdx tyIdx = GetInferredTyIdx(*rhs); + ivar.SetMaybeNull(MaybeNull(*rhs)); if (tyIdx != 0u) { - ivar->SetInferredTyidx(tyIdx); + ivar.SetInferredTyidx(tyIdx); if (SSADevirtual::debug) { - MIRType *type = GlobalTables::GetTypeTable().GetTypeFromTyIdx(ivar->GetInferredTyIdx()); - LogInfo::MapleLogger() << "[SSA-DEVIRT] [TYPE-INFERRING] mx" << ivar->GetExprID() << " "; + MIRType *type = GlobalTables::GetTypeTable().GetTypeFromTyIdx(ivar.GetInferredTyIdx()); + LogInfo::MapleLogger() << "[SSA-DEVIRT] [TYPE-INFERRING] mx" << ivar.GetExprID() << " "; type->Dump(0, false); LogInfo::MapleLogger() << '\n'; } @@ -326,13 +325,13 @@ void SSADevirtual::PropIvarInferredType(IvarMeExpr *ivar) { } } -void SSADevirtual::VisitVarPhiNode(MeVarPhiNode *varPhi) { - MapleVector opnds = varPhi->GetOpnds(); - auto *lhs = varPhi->GetLHS(); +void SSADevirtual::VisitVarPhiNode(MeVarPhiNode &varPhi) const { + MapleVector opnds = varPhi.GetOpnds(); + auto *lhs = varPhi.GetLHS(); const MapleVector &inferredTypeCandidates = lhs->GetInferredTypeCandidates(); for (size_t i = 0; i < opnds.size(); ++i) { VarMeExpr *opnd = opnds[i]; - PropVarInferredType(opnd); + PropVarInferredType(*opnd); if (opnd->GetInferredTyIdx() != 0u) { size_t j = 0; for (; j < inferredTypeCandidates.size(); j++) { @@ -350,7 +349,7 @@ void SSADevirtual::VisitVarPhiNode(MeVarPhiNode *varPhi) { } } -void SSADevirtual::VisitMeExpr(MeExpr *meExpr) { +void SSADevirtual::VisitMeExpr(MeExpr *meExpr) const { if (meExpr == nullptr) { return; } @@ -358,14 +357,14 @@ void SSADevirtual::VisitMeExpr(MeExpr *meExpr) { switch (meOp) { case kMeOpVar: { auto *varExpr = static_cast(meExpr); - PropVarInferredType(varExpr); + PropVarInferredType(*varExpr); break; } case kMeOpReg: break; case kMeOpIvar: { auto *iVar = static_cast(meExpr); - PropIvarInferredType(iVar); + PropIvarInferredType(*iVar); break; } case kMeOpOp: { @@ -397,12 +396,12 @@ void SSADevirtual::VisitMeExpr(MeExpr *meExpr) { } } -void SSADevirtual::ReturnTyIdxInferring(const RetMeStmt *retMeStmt) { - const MapleVector &opnds = retMeStmt->GetOpnds(); +void SSADevirtual::ReturnTyIdxInferring(const RetMeStmt &retMeStmt) { + const MapleVector &opnds = retMeStmt.GetOpnds(); CHECK_FATAL(opnds.size() <= 1, "Assume at most one return value for now"); for (size_t i = 0; i < opnds.size(); ++i) { MeExpr *opnd = opnds[i]; - TyIdx tyIdx = GetInferredTyIdx(opnd); + TyIdx tyIdx = GetInferredTyIdx(*opnd); if (retTy == kNotSeen) { // seen the first return stmt retTy = kSeen; @@ -417,32 +416,32 @@ void SSADevirtual::ReturnTyIdxInferring(const RetMeStmt *retMeStmt) { } } -void SSADevirtual::TraversalMeStmt(MeStmt *meStmt) { - Opcode op = meStmt->GetOp(); +void SSADevirtual::TraversalMeStmt(MeStmt &meStmt) { + Opcode op = meStmt.GetOp(); switch (op) { case OP_dassign: { - auto *varMeStmt = static_cast(meStmt); + auto *varMeStmt = static_cast(&meStmt); VisitMeExpr(varMeStmt->GetRHS()); break; } case OP_regassign: { - auto *regMeStmt = static_cast(meStmt); + auto *regMeStmt = static_cast(&meStmt); VisitMeExpr(regMeStmt->GetRHS()); break; } case OP_maydassign: { - auto *maydStmt = static_cast(meStmt); + auto *maydStmt = static_cast(&meStmt); VisitMeExpr(maydStmt->GetRHS()); break; } case OP_iassign: { - auto *ivarStmt = static_cast(meStmt); + auto *ivarStmt = static_cast(&meStmt); VisitMeExpr(ivarStmt->GetRHS()); break; } case OP_syncenter: case OP_syncexit: { - auto *syncMeStmt = static_cast(meStmt); + auto *syncMeStmt = static_cast(&meStmt); const MapleVector &opnds = syncMeStmt->GetOpnds(); for (size_t i = 0; i < opnds.size(); ++i) { MeExpr *opnd = opnds[i]; @@ -451,14 +450,14 @@ void SSADevirtual::TraversalMeStmt(MeStmt *meStmt) { break; } case OP_throw: { - auto *thrMeStmt = static_cast(meStmt); + auto *thrMeStmt = static_cast(&meStmt); VisitMeExpr(thrMeStmt->GetOpnd()); break; } case OP_assertnonnull: case OP_eval: case OP_free: { - auto *umeStmt = static_cast(meStmt); + auto *umeStmt = static_cast(&meStmt); VisitMeExpr(umeStmt->GetOpnd()); break; } @@ -478,13 +477,13 @@ void SSADevirtual::TraversalMeStmt(MeStmt *meStmt) { case OP_interfaceicallassigned: case OP_customcallassigned: case OP_polymorphiccallassigned: { - auto *callMeStmt = static_cast(meStmt); + auto *callMeStmt = static_cast(&meStmt); const MapleVector &opnds = callMeStmt->GetOpnds(); for (size_t i = 0; i < opnds.size(); ++i) { MeExpr *opnd = opnds[i]; VisitMeExpr(opnd); } - (void)DevirtualizeCall(callMeStmt); + (void)DevirtualizeCall(*callMeStmt); if (clone != nullptr && OP_callassigned == callMeStmt->GetOp()) { MIRFunction &targetFunc = callMeStmt->GetTargetFunction(); clone->UpdateReturnVoidIfPossible(callMeStmt, &targetFunc); @@ -493,7 +492,7 @@ void SSADevirtual::TraversalMeStmt(MeStmt *meStmt) { } case OP_icall: case OP_icallassigned: { - auto *icallMeStmt = static_cast(meStmt); + auto *icallMeStmt = static_cast(&meStmt); const MapleVector &opnds = icallMeStmt->GetOpnds(); for (size_t i = 0; i < opnds.size(); ++i) { MeExpr *opnd = opnds[i]; @@ -507,7 +506,7 @@ void SSADevirtual::TraversalMeStmt(MeStmt *meStmt) { case OP_intrinsiccallwithtypeassigned: case OP_intrinsiccallassigned: case OP_xintrinsiccallassigned: { - auto *intrinCallStmt = static_cast(meStmt); + auto *intrinCallStmt = static_cast(&meStmt); const MapleVector &opnds = intrinCallStmt->GetOpnds(); for (size_t i = 0; i < opnds.size(); ++i) { MeExpr *opnd = opnds[i]; @@ -517,28 +516,28 @@ void SSADevirtual::TraversalMeStmt(MeStmt *meStmt) { } case OP_brtrue: case OP_brfalse: { - auto *condGotoStmt = static_cast(meStmt); + auto *condGotoStmt = static_cast(&meStmt); VisitMeExpr(condGotoStmt->GetOpnd()); break; } case OP_switch: { - auto *switchStmt = static_cast(meStmt); + auto *switchStmt = static_cast(&meStmt); VisitMeExpr(switchStmt->GetOpnd()); break; } case OP_return: { - auto *retMeStmt = static_cast(meStmt); + auto *retMeStmt = static_cast(&meStmt); const MapleVector &opnds = retMeStmt->GetOpnds(); for (size_t i = 0; i < opnds.size(); ++i) { MeExpr *opnd = opnds[i]; VisitMeExpr(opnd); } - ReturnTyIdxInferring(retMeStmt); + ReturnTyIdxInferring(*retMeStmt); break; } case OP_assertlt: case OP_assertge: { - auto *assMeStmt = static_cast(meStmt); + auto *assMeStmt = static_cast(&meStmt); VisitMeExpr(assMeStmt->GetOpnd(0)); VisitMeExpr(assMeStmt->GetOpnd(1)); break; @@ -562,10 +561,10 @@ void SSADevirtual::TraversalMeStmt(MeStmt *meStmt) { default: CHECK_FATAL(false, "unexpected stmt in ssadevirt or NYI"); } - if (meStmt->GetOp() != OP_callassigned) { + if (meStmt.GetOp() != OP_callassigned) { return; } - MapleVector *mustDefList = meStmt->GetMustDefList(); + MapleVector *mustDefList = meStmt.GetMustDefList(); if (mustDefList->empty()) { return; } @@ -574,7 +573,7 @@ void SSADevirtual::TraversalMeStmt(MeStmt *meStmt) { return; } auto *lhsVar = static_cast(meLHS); - auto *callMeStmt = static_cast(meStmt); + auto *callMeStmt = static_cast(&meStmt); MIRFunction &called = callMeStmt->GetTargetFunction(); if (called.GetInferredReturnTyIdx() != 0u) { lhsVar->SetInferredTyIdx(called.GetInferredReturnTyIdx()); @@ -599,20 +598,20 @@ void SSADevirtual::TraversalBB(BB *bb) { MapleMap &meVarPhiList = bb->GetMevarPhiList(); for (auto it = meVarPhiList.begin(); it != meVarPhiList.end(); ++it) { MeVarPhiNode *phiMeNode = it->second; - VisitVarPhiNode(phiMeNode); + VisitVarPhiNode(*phiMeNode); } // traversal reg phi nodes (NYI) // traversal on stmt for (auto &meStmt : bb->GetMeStmts()) { - TraversalMeStmt(&meStmt); + TraversalMeStmt(meStmt); } } -void SSADevirtual::Perform(BB *entryBB) { +void SSADevirtual::Perform(BB &entryBB) { // Pre-order traverse the cominance tree, so that each def is traversed // before its use std::queue bbList; - bbList.push(entryBB); + bbList.push(&entryBB); while (!bbList.empty()) { BB *bb = bbList.front(); bbList.pop(); diff --git a/src/maple_me/src/ssa_epre.cpp b/src/maple_me/src/ssa_epre.cpp index b54acbc99726466a8f1e48018b8cc76e3993963f..20b745052807f1df09d3454410996787845f8db7 100644 --- a/src/maple_me/src/ssa_epre.cpp +++ b/src/maple_me/src/ssa_epre.cpp @@ -13,10 +13,15 @@ * See the Mulan PSL v1 for more details. */ #include "ssa_epre.h" + +namespace { + constexpr maple::uint32 kMeOpOpNum = 3; +} + namespace maple { -void SSAEPre::GenerateSaveLHSRealocc(MeRealOcc *realOcc, MeExpr *regOrVar) { - CHECK_FATAL(realOcc->GetOpcodeOfMeStmt() == OP_iassign, "GenerateSaveLHSReal: only iassign expected"); - auto *iass = static_cast(realOcc->GetMeStmt()); +void SSAEPre::GenerateSaveLHSRealocc(MeRealOcc &realOcc, MeExpr ®OrVar) { + CHECK_FATAL(realOcc.GetOpcodeOfMeStmt() == OP_iassign, "GenerateSaveLHSReal: only iassign expected"); + auto *iass = static_cast(realOcc.GetMeStmt()); IvarMeExpr *theLHS = iass->GetLHSVal(); MeExpr *savedRHS = iass->GetRHS(); TyIdx savedTyIdx = iass->GetTyIdx(); @@ -28,23 +33,23 @@ void SSAEPre::GenerateSaveLHSRealocc(MeRealOcc *realOcc, MeExpr *regOrVar) { MeStmt *savedNext = iass->GetNext(); RegassignMeStmt *rass = nullptr; if (!workCand->NeedLocalRefVar() || GetPlacementRCOn()) { - CHECK_FATAL(regOrVar->GetMeOp() == kMeOpReg, "GenerateSaveLHSRealocc: EPRE temp must b e preg here"); + CHECK_FATAL(regOrVar.GetMeOp() == kMeOpReg, "GenerateSaveLHSRealocc: EPRE temp must b e preg here"); // change original iassign to regassign; // use placement new to modify in place, because other occ nodes are pointing // to this statement in order to get to the rhs expression; // this assumes RegassignMeStmt has smaller size then IassignMeStmt rass = new (iass) RegassignMeStmt(); - rass->SetLHS(static_cast(regOrVar)); + rass->SetLHS(static_cast(®OrVar)); rass->SetRHS(savedRHS); rass->SetSrcPos(savedSrcPos); rass->SetBB(savedBB); rass->SetPrev(savedPrev); rass->SetNext(savedNext); - regOrVar->SetDefByStmt(*rass); + regOrVar.SetDefByStmt(*rass); } else { // regOrVar is kMeOpReg and localRefVar is kMeOpVar VarMeExpr *localRefVar = CreateNewCurLocalRefVar(); - temp2LocalRefVarMap[static_cast(regOrVar)] = localRefVar; + temp2LocalRefVarMap[static_cast(®OrVar)] = localRefVar; // generate localRefVar = saved_rhs by changing original iassign to dassign; // use placement new to modify in place, because other occ nodes are pointing // to this statement in order to get to the rhs expression; @@ -57,13 +62,13 @@ void SSAEPre::GenerateSaveLHSRealocc(MeRealOcc *realOcc, MeExpr *regOrVar) { dass->SetPrev(savedPrev); dass->SetNext(savedNext); localRefVar->SetDefByStmt(*dass); - rass = irMap->CreateRegassignMeStmt(*regOrVar, *localRefVar, *savedBB); - regOrVar->SetDefByStmt(*rass); + rass = irMap->CreateRegassignMeStmt(regOrVar, *localRefVar, *savedBB); + regOrVar.SetDefByStmt(*rass); savedBB->InsertMeStmtAfter(dass, rass); - EnterCandsForSSAUpdate(localRefVar->GetOStIdx(), savedBB); + EnterCandsForSSAUpdate(localRefVar->GetOStIdx(), *savedBB); } // create new iassign for original lhs - IassignMeStmt *newIass = irMap->NewInPool(savedTyIdx, theLHS, regOrVar, &savedChiList); + IassignMeStmt *newIass = irMap->NewInPool(savedTyIdx, theLHS, ®OrVar, &savedChiList); theLHS->SetDefStmt(newIass); newIass->SetBB(savedBB); savedBB->InsertMeStmtAfter(rass, newIass); @@ -72,59 +77,59 @@ void SSAEPre::GenerateSaveLHSRealocc(MeRealOcc *realOcc, MeExpr *regOrVar) { ChiMeNode *chi = it->second; chi->SetBase(newIass); } - realOcc->SetSavedExpr(*regOrVar); + realOcc.SetSavedExpr(regOrVar); } -void SSAEPre::GenerateSaveRealOcc(MeRealOcc *realOcc) { +void SSAEPre::GenerateSaveRealOcc(MeRealOcc &realOcc) { ASSERT(GetPUIdx() == workCand->GetPUIdx() || workCand->GetPUIdx() == 0, "GenerateSaveRealOcc: inconsistent puIdx"); - MeExpr *regOrVar = CreateNewCurTemp(realOcc->GetMeExpr()); - if (realOcc->IsLHS()) { - GenerateSaveLHSRealocc(realOcc, regOrVar); + MeExpr *regOrVar = CreateNewCurTemp(*realOcc.GetMeExpr()); + if (realOcc.IsLHS()) { + GenerateSaveLHSRealocc(realOcc, *regOrVar); return; } // create a new meStmt before realOcc->GetMeStmt() MeStmt *newMeStmt = nullptr; bool isRHSOfDassign = false; - if (workCand->NeedLocalRefVar() && (realOcc->GetOpcodeOfMeStmt() == OP_dassign) && - (realOcc->GetMeStmt()->GetOpnd(0) == realOcc->GetMeExpr())) { + if (workCand->NeedLocalRefVar() && (realOcc.GetOpcodeOfMeStmt() == OP_dassign) && + (realOcc.GetMeStmt()->GetOpnd(0) == realOcc.GetMeExpr())) { isRHSOfDassign = true; // setting flag so delegaterc will skip - static_cast(realOcc->GetMeStmt())->GetVarLHS()->SetNoDelegateRC(1); + static_cast(realOcc.GetMeStmt())->GetVarLHS()->SetNoDelegateRC(1); } if (!workCand->NeedLocalRefVar() || isRHSOfDassign || GetPlacementRCOn()) { if (regOrVar->GetMeOp() == kMeOpReg) { - newMeStmt = irMap->CreateRegassignMeStmt(*regOrVar, *realOcc->GetMeExpr(), *realOcc->GetMeStmt()->GetBB()); + newMeStmt = irMap->CreateRegassignMeStmt(*regOrVar, *realOcc.GetMeExpr(), *realOcc.GetMeStmt()->GetBB()); } else { - newMeStmt = irMap->CreateDassignMeStmt(*regOrVar, *realOcc->GetMeExpr(), *realOcc->GetMeStmt()->GetBB()); + newMeStmt = irMap->CreateDassignMeStmt(*regOrVar, *realOcc.GetMeExpr(), *realOcc.GetMeStmt()->GetBB()); } regOrVar->SetDefByStmt(*newMeStmt); - realOcc->GetMeStmt()->GetBB()->InsertMeStmtBefore(realOcc->GetMeStmt(), newMeStmt); + realOcc.GetMeStmt()->GetBB()->InsertMeStmtBefore(realOcc.GetMeStmt(), newMeStmt); } else { // regOrVar is MeOp_reg and localRefVar is kMeOpVar VarMeExpr *localRefVar = CreateNewCurLocalRefVar(); temp2LocalRefVarMap[static_cast(regOrVar)] = localRefVar; - newMeStmt = irMap->CreateDassignMeStmt(*localRefVar, *realOcc->GetMeExpr(), *realOcc->GetMeStmt()->GetBB()); + newMeStmt = irMap->CreateDassignMeStmt(*localRefVar, *realOcc.GetMeExpr(), *realOcc.GetMeStmt()->GetBB()); localRefVar->SetDefByStmt(*newMeStmt); - realOcc->GetMeStmt()->GetBB()->InsertMeStmtBefore(realOcc->GetMeStmt(), newMeStmt); - newMeStmt = irMap->CreateRegassignMeStmt(*regOrVar, *localRefVar, *realOcc->GetMeStmt()->GetBB()); + realOcc.GetMeStmt()->GetBB()->InsertMeStmtBefore(realOcc.GetMeStmt(), newMeStmt); + newMeStmt = irMap->CreateRegassignMeStmt(*regOrVar, *localRefVar, *realOcc.GetMeStmt()->GetBB()); regOrVar->SetDefByStmt(*newMeStmt); - realOcc->GetMeStmt()->GetBB()->InsertMeStmtBefore(realOcc->GetMeStmt(), newMeStmt); - EnterCandsForSSAUpdate(localRefVar->GetOStIdx(), realOcc->GetMeStmt()->GetBB()); + realOcc.GetMeStmt()->GetBB()->InsertMeStmtBefore(realOcc.GetMeStmt(), newMeStmt); + EnterCandsForSSAUpdate(localRefVar->GetOStIdx(), *realOcc.GetMeStmt()->GetBB()); } // replace realOcc->GetMeStmt()'s occ with regOrVar - bool isReplaced = irMap->ReplaceMeExprStmt(*realOcc->GetMeStmt(), *realOcc->GetMeExpr(), *regOrVar); + bool isReplaced = irMap->ReplaceMeExprStmt(*realOcc.GetMeStmt(), *realOcc.GetMeExpr(), *regOrVar); // rebuild worklist if (isReplaced) { - BuildWorkListStmt(realOcc->GetMeStmt(), realOcc->GetSequence(), true, regOrVar); + BuildWorkListStmt(realOcc.GetMeStmt(), realOcc.GetSequence(), true, regOrVar); } - realOcc->SetSavedExpr(*regOrVar); + realOcc.SetSavedExpr(*regOrVar); } -void SSAEPre::GenerateReloadRealOcc(MeRealOcc *realOcc) { - CHECK_FATAL(!realOcc->IsLHS(), "GenerateReloadRealOcc: cannot be LHS occurrence"); +void SSAEPre::GenerateReloadRealOcc(MeRealOcc &realOcc) { + CHECK_FATAL(!realOcc.IsLHS(), "GenerateReloadRealOcc: cannot be LHS occurrence"); MeExpr *regOrVar = nullptr; - MeOccur *defOcc = realOcc->GetDef(); + MeOccur *defOcc = realOcc.GetDef(); if (defOcc->GetOccType() == kOccReal) { auto *defRealOcc = static_cast(defOcc); regOrVar = defRealOcc->GetSavedExpr(); @@ -144,31 +149,30 @@ void SSAEPre::GenerateReloadRealOcc(MeRealOcc *realOcc) { } ASSERT(regOrVar != nullptr, "temp not yet generated"); // replace realOcc->GetMeStmt()'s occ with regOrVar - bool isReplaced = irMap->ReplaceMeExprStmt(*realOcc->GetMeStmt(), *realOcc->GetMeExpr(), *regOrVar); + bool isReplaced = irMap->ReplaceMeExprStmt(*realOcc.GetMeStmt(), *realOcc.GetMeExpr(), *regOrVar); // update worklist if (isReplaced) { - BuildWorkListStmt(realOcc->GetMeStmt(), realOcc->GetSequence(), true, regOrVar); + BuildWorkListStmt(realOcc.GetMeStmt(), realOcc.GetSequence(), true, regOrVar); } } -// for each variable in realz that is defined by a phi, replace it by the jth -// phi opnd -MeExpr *SSAEPre::PhiOpndFromRes(MeRealOcc *realZ, size_t j) { - MeOccur *defZ = realZ->GetDef(); +// for each variable in realz that is defined by a phi, replace it by the jth phi opnd +MeExpr *SSAEPre::PhiOpndFromRes(MeRealOcc &realZ, size_t j) const { + MeOccur *defZ = realZ.GetDef(); CHECK_FATAL(defZ != nullptr, "must be def by phiocc"); CHECK_FATAL(defZ->GetOccType() == kOccPhiocc, "must be def by phiocc"); - MeExpr *exprQ = CopyMeExpr(utils::ToRef(realZ->GetMeExpr())); + MeExpr *exprQ = CopyMeExpr(utils::ToRef(realZ.GetMeExpr())); BB *ePhiBB = defZ->GetBB(); CHECK_FATAL(exprQ != nullptr, "nullptr check"); switch (exprQ->GetMeOp()) { case kMeOpOp: { auto *opMeExpr = static_cast(exprQ); - for (size_t i = 0; i < 3; i++) { + for (size_t i = 0; i < kMeOpOpNum; ++i) { MeExpr *opnd = opMeExpr->GetOpnd(i); if (opnd == nullptr) { break; }; - MeExpr *retOpnd = GetReplaceMeExpr(opnd, ePhiBB, j); + MeExpr *retOpnd = GetReplaceMeExpr(*opnd, *ePhiBB, j); if (retOpnd != nullptr) { opMeExpr->SetOpnd(i, retOpnd); } @@ -179,7 +183,7 @@ MeExpr *SSAEPre::PhiOpndFromRes(MeRealOcc *realZ, size_t j) { auto *naryMeExpr = static_cast(exprQ); MapleVector &opnds = naryMeExpr->GetOpnds(); for (size_t i = 0; i < opnds.size(); i++) { - MeExpr *retOpnd = GetReplaceMeExpr(opnds[i], ePhiBB, j); + MeExpr *retOpnd = GetReplaceMeExpr(*opnds[i], *ePhiBB, j); if (retOpnd != nullptr) { opnds[i] = retOpnd; } @@ -188,11 +192,11 @@ MeExpr *SSAEPre::PhiOpndFromRes(MeRealOcc *realZ, size_t j) { } case kMeOpIvar: { auto *ivarMeExpr = static_cast(exprQ); - MeExpr *retOpnd = GetReplaceMeExpr(ivarMeExpr->GetBase(), ePhiBB, j); + MeExpr *retOpnd = GetReplaceMeExpr(*ivarMeExpr->GetBase(), *ePhiBB, j); if (retOpnd != nullptr) { ivarMeExpr->SetBase(retOpnd); } - MeExpr *muOpnd = GetReplaceMeExpr(ivarMeExpr->GetMu(), ePhiBB, j); + MeExpr *muOpnd = GetReplaceMeExpr(*ivarMeExpr->GetMu(), *ePhiBB, j); if (muOpnd != nullptr) { ivarMeExpr->SetMuVal(static_cast(muOpnd)); } @@ -219,10 +223,10 @@ void SSAEPre::ComputeVarAndDfPhis() { switch (meExpr->GetMeOp()) { case kMeOpOp: { auto *meExprOp = static_cast(meExpr); - for (uint32 i = 0; i < 3; i++) { + for (uint32 i = 0; i < kMeOpOpNum; ++i) { MeExpr *kidExpr = meExprOp->GetOpnd(i); if (kidExpr != nullptr) { - SetVarPhis(kidExpr); + SetVarPhis(*kidExpr); } } break; @@ -233,14 +237,14 @@ void SSAEPre::ComputeVarAndDfPhis() { for (size_t i = 0; i < opnds.size(); i++) { MeExpr *kidExpr = opnds[i]; if (kidExpr != nullptr) { - SetVarPhis(kidExpr); + SetVarPhis(*kidExpr); } } break; } case kMeOpIvar: { auto *ivarMeExpr = static_cast(meExpr); - SetVarPhis(ivarMeExpr->GetBase()); + SetVarPhis(*ivarMeExpr->GetBase()); break; } default: @@ -253,22 +257,22 @@ void SSAEPre::ComputeVarAndDfPhis() { // isRebuild means the expression is built from second time, in which case, // tempVar is not nullptr, and it matches only expressions with tempVar as one of // its operands; isRebuild is true only when called from the code motion phase -void SSAEPre::BuildWorkListExpr(MeStmt *meStmt, int32 seqStmt, MeExpr *meExpr, bool isRebuild, MeExpr *tempVar, +void SSAEPre::BuildWorkListExpr(MeStmt &meStmt, int32 seqStmt, MeExpr &meExpr, bool isRebuild, MeExpr *tempVar, bool isRootExpr) { - if (meExpr->GetTreeID() == (curTreeId + 1)) { + if (meExpr.GetTreeID() == (curTreeId + 1)) { return; // already visited twice in the same tree } - MeExprOp meOp = meExpr->GetMeOp(); + MeExprOp meOp = meExpr.GetMeOp(); switch (meOp) { case kMeOpOp: { - auto *meOpExpr = static_cast(meExpr); + auto *meOpExpr = static_cast(&meExpr); bool isHypo = true; bool hasTempVarAs1Opnd = false; - for (uint32 i = 0; i < 3; i++) { + for (uint32 i = 0; i < kMeOpOpNum; i++) { MeExpr *opnd = meOpExpr->GetOpnd(i); if (opnd != nullptr) { if (!opnd->IsLeaf()) { - BuildWorkListExpr(meStmt, seqStmt, opnd, isRebuild, tempVar, false); + BuildWorkListExpr(meStmt, seqStmt, *opnd, isRebuild, tempVar, false); isHypo = false; } else if (LeafIsVolatile(opnd)) { isHypo = false; @@ -277,7 +281,7 @@ void SSAEPre::BuildWorkListExpr(MeStmt *meStmt, int32 seqStmt, MeExpr *meExpr, b } } } - if (meExpr->GetPrimType() == PTY_agg) { + if (meExpr.GetPrimType() == PTY_agg) { isHypo = false; } if (isHypo && (!isRebuild || hasTempVarAs1Opnd) && !(isRootExpr && kOpcodeInfo.IsCompare(meOpExpr->GetOp())) && @@ -285,19 +289,19 @@ void SSAEPre::BuildWorkListExpr(MeStmt *meStmt, int32 seqStmt, MeExpr *meExpr, b (epreIncludeRef || meOpExpr->GetPrimType() != PTY_ref)) { // create a HypotheTemp for this expr // Exclude cmp operator - (void)CreateRealOcc(*meStmt, seqStmt, *meExpr, isRebuild); + (void)CreateRealOcc(meStmt, seqStmt, meExpr, isRebuild); } break; } case kMeOpNary: { - auto *naryMeExpr = static_cast(meExpr); + auto *naryMeExpr = static_cast(&meExpr); bool isHypo = true; bool hasTempVarAs1Opnd = false; MapleVector &opnds = naryMeExpr->GetOpnds(); for (auto it = opnds.begin(); it != opnds.end(); ++it) { MeExpr *opnd = *it; if (!opnd->IsLeaf()) { - BuildWorkListExpr(meStmt, seqStmt, opnd, isRebuild, tempVar, false); + BuildWorkListExpr(meStmt, seqStmt, *opnd, isRebuild, tempVar, false); isHypo = false; } else if (LeafIsVolatile(opnd)) { isHypo = false; @@ -305,24 +309,24 @@ void SSAEPre::BuildWorkListExpr(MeStmt *meStmt, int32 seqStmt, MeExpr *meExpr, b hasTempVarAs1Opnd = true; } } - if (meExpr->GetPrimType() == PTY_agg) { + if (meExpr.GetPrimType() == PTY_agg) { isHypo = false; } if (isHypo && (!isRebuild || hasTempVarAs1Opnd) && naryMeExpr->GetPrimType() != PTY_u1 && (GetPrimTypeSize(naryMeExpr->GetPrimType()) >= 4 || IsPrimitivePoint(naryMeExpr->GetPrimType()) || (naryMeExpr->GetOp() == OP_intrinsicop && IntrinDesc::intrinTable[naryMeExpr->GetIntrinsic()].IsPure())) && (epreIncludeRef || naryMeExpr->GetPrimType() != PTY_ref)) { - if (meExpr->GetOp() == OP_array) { + if (meExpr.GetOp() == OP_array) { MIRType *mirType = GlobalTables::GetTypeTable().GetTypeTable().at(naryMeExpr->GetTyIdx()); CHECK_FATAL(mirType->GetKind() == kTypePointer, "array must have pointer type"); auto *ptrMIRType = static_cast(mirType); MIRJarrayType *arryType = safe_cast(ptrMIRType->GetPointedType()); if (arryType == nullptr) { - (void)CreateRealOcc(*meStmt, seqStmt, *meExpr, isRebuild); + (void)CreateRealOcc(meStmt, seqStmt, meExpr, isRebuild); } else { int dim = arryType->GetDim(); // to compute the dim field - if (dim < 2) { - (void)CreateRealOcc(*meStmt, seqStmt, *meExpr, isRebuild); + if (dim <= 1) { + (void)CreateRealOcc(meStmt, seqStmt, meExpr, isRebuild); } else { if (GetSSAPreDebug()) { mirModule->GetOut() << "----- real occ suppressed for jarray with dim " << dim << '\n'; @@ -341,20 +345,20 @@ void SSAEPre::BuildWorkListExpr(MeStmt *meStmt, int32 seqStmt, MeExpr *meExpr, b } } if (!intrinDesc->IsLoadMem()) { - (void)CreateRealOcc(*meStmt, seqStmt, *meExpr, isRebuild); + (void)CreateRealOcc(meStmt, seqStmt, meExpr, isRebuild); } } } break; } case kMeOpIvar: { - auto *ivarMeExpr = static_cast(meExpr); + auto *ivarMeExpr = static_cast(&meExpr); MeExpr *base = ivarMeExpr->GetBase(); - if (meExpr->GetPrimType() == PTY_agg) { + if (meExpr.GetPrimType() == PTY_agg) { break; } if (!base->IsLeaf()) { - BuildWorkListExpr(meStmt, seqStmt, ivarMeExpr->GetBase(), isRebuild, tempVar, false); + BuildWorkListExpr(meStmt, seqStmt, *ivarMeExpr->GetBase(), isRebuild, tempVar, false); } else if (ivarMeExpr->IsVolatile()) { break; } else if (IsThreadObjField(*ivarMeExpr)) { @@ -362,7 +366,7 @@ void SSAEPre::BuildWorkListExpr(MeStmt *meStmt, int32 seqStmt, MeExpr *meExpr, b } else if (!epreIncludeRef && ivarMeExpr->GetPrimType() == PTY_ref) { break; } else if (!isRebuild || base->IsUseSameSymbol(*tempVar)) { - (void)CreateRealOcc(*meStmt, seqStmt, *meExpr, isRebuild); + (void)CreateRealOcc(meStmt, seqStmt, meExpr, isRebuild); } break; } @@ -380,25 +384,21 @@ void SSAEPre::BuildWorkListExpr(MeStmt *meStmt, int32 seqStmt, MeExpr *meExpr, b default: CHECK_FATAL(false, "MeOP NIY"); } - if (meExpr->GetTreeID() == curTreeId) { - meExpr->SetTreeID(curTreeId + 1); // just processed 2nd time; not + if (meExpr.GetTreeID() == curTreeId) { + meExpr.SetTreeID(curTreeId + 1); // just processed 2nd time; not + } else { // to be processed again in this tree + meExpr.SetTreeID(curTreeId); // just processed 1st time; willing to process one more time } - // to be processed again in this tree - else { - meExpr->SetTreeID(curTreeId); // just processed 1st time; willing to - } - // process one more time - return; } -void SSAEPre::BuildWorkListIvarLHSOcc(MeStmt *meStmt, int32 seqStmt, bool isRebuild, MeExpr *tempVar) { +void SSAEPre::BuildWorkListIvarLHSOcc(MeStmt &meStmt, int32 seqStmt, bool isRebuild, MeExpr *tempVar) { if (!enableLHSIvar || GetPlacementRCOn()) { return; } - if (meStmt->GetOp() != OP_iassign) { + if (meStmt.GetOp() != OP_iassign) { return; } - auto *iass = static_cast(meStmt); + auto *iass = static_cast(&meStmt); IvarMeExpr *ivarMeExpr = iass->GetLHSVal(); if (ivarMeExpr->GetPrimType() == PTY_agg) { return; @@ -414,27 +414,27 @@ void SSAEPre::BuildWorkListIvarLHSOcc(MeStmt *meStmt, int32 seqStmt, bool isRebu return; } if (!isRebuild || base->IsUseSameSymbol(*tempVar)) { - (void)CreateRealOcc(*meStmt, seqStmt, *ivarMeExpr, isRebuild, true); + (void)CreateRealOcc(meStmt, seqStmt, *ivarMeExpr, isRebuild, true); } } // collect meExpr's variables and put them into varVec // varVec can only store RegMeExpr and VarMeExpr -void SSAEPre::CollectVarForMeExpr(MeExpr *meExpr, std::vector &varVec) { - switch (meExpr->GetMeOp()) { +void SSAEPre::CollectVarForMeExpr(MeExpr &meExpr, std::vector &varVec) const { + switch (meExpr.GetMeOp()) { case kMeOpOp: { - for (uint32 i = 0; i < 3; i++) { - auto *opMeExpr = static_cast(meExpr); + for (uint32 i = 0; i < kMeOpOpNum; i++) { + auto *opMeExpr = static_cast(&meExpr); MeExpr *opnd = opMeExpr->GetOpnd(i); - if (opnd && (opnd->GetMeOp() == kMeOpVar || opnd->GetMeOp() == kMeOpReg)) { + if (opnd != nullptr && (opnd->GetMeOp() == kMeOpVar || opnd->GetMeOp() == kMeOpReg)) { varVec.push_back(opnd); } } break; } case kMeOpNary: { - auto *naryMeExpr = static_cast(meExpr); - MapleVector &opnds = naryMeExpr->GetOpnds(); + auto *naryMeExpr = static_cast(&meExpr); + const MapleVector &opnds = naryMeExpr->GetOpnds(); for (MeExpr *kidExpr : opnds) { if (kidExpr->GetMeOp() == kMeOpVar || kidExpr->GetMeOp() == kMeOpReg) { varVec.push_back(kidExpr); @@ -443,7 +443,7 @@ void SSAEPre::CollectVarForMeExpr(MeExpr *meExpr, std::vector &varVec) break; } case kMeOpIvar: { - auto *ivarMeExpr = static_cast(meExpr); + auto *ivarMeExpr = static_cast(&meExpr); CHECK_FATAL(ivarMeExpr->GetBase()->GetMeOp() == kMeOpVar || ivarMeExpr->GetBase()->GetMeOp() == kMeOpConst || ivarMeExpr->GetBase()->GetMeOp() == kMeOpAddrof || ivarMeExpr->GetBase()->GetMeOp() == kMeOpReg, "ivarMeExpr not first order expr"); @@ -456,10 +456,11 @@ void SSAEPre::CollectVarForMeExpr(MeExpr *meExpr, std::vector &varVec) } default: ASSERT(false, "should not be here"); + break; } } -void SSAEPre::CollectVarForCand(MeRealOcc *realOcc, std::vector &varVec) { - CollectVarForMeExpr(realOcc->GetMeExpr(), varVec); +void SSAEPre::CollectVarForCand(MeRealOcc &realOcc, std::vector &varVec) const { + CollectVarForMeExpr(*realOcc.GetMeExpr(), varVec); } } // namespace maple diff --git a/src/maple_me/src/ssa_mir_nodes.cpp b/src/maple_me/src/ssa_mir_nodes.cpp index afa2bc0396eb39b4b550e961bb04f6cb2bdb8b9a..6af8a8c91f4783f9cf4a7a47c0123bf955073011 100644 --- a/src/maple_me/src/ssa_mir_nodes.cpp +++ b/src/maple_me/src/ssa_mir_nodes.cpp @@ -19,7 +19,7 @@ #include "ssa_tab.h" namespace maple { -void GenericSSAPrint(MIRModule &mod, const StmtNode &stmtNode, int32 indent, StmtsSSAPart &stmtsSSAPart) { +void GenericSSAPrint(const MIRModule &mod, const StmtNode &stmtNode, int32 indent, StmtsSSAPart &stmtsSSAPart) { stmtNode.Dump(indent); // print SSAPart Opcode op = stmtNode.GetOpCode(); diff --git a/src/maple_me/src/ssa_pre.cpp b/src/maple_me/src/ssa_pre.cpp index 78be95dcf60b903779a6f1879793ae2153e4bd7a..7cdf18e8ac9b91058b6ad55343aabef4176cfcf0 100644 --- a/src/maple_me/src/ssa_pre.cpp +++ b/src/maple_me/src/ssa_pre.cpp @@ -15,6 +15,7 @@ #include "ssa_pre.h" #include "dominance.h" #include "mir_builder.h" + namespace maple { // Implementation of SSAPRE based on the paper "Partial Redundancy Elimination // in SSA Form" Kennedy et al. @@ -29,7 +30,7 @@ namespace maple { // 4. STMTFRE (Full Redundancy Elimination for Statements) - me_stmt_fre.cpp // (called when performing STMTPRE). // ================ Step 6: Code Motion ================= -MeExpr *SSAPre::CreateNewCurTemp(MeExpr *meExpr) { +MeExpr *SSAPre::CreateNewCurTemp(const MeExpr &meExpr) { if (workCand->NeedLocalRefVar() && GetPlacementRCOn()) { curTemp = CreateNewCurLocalRefVar(); return curTemp; @@ -48,14 +49,14 @@ MeExpr *SSAPre::CreateNewCurTemp(MeExpr *meExpr) { // allocate a new temp SetCurFunction(workCand->GetPUIdx()); RegMeExpr *regVar = nullptr; - if (meExpr->GetMeOp() == kMeOpVar) { - auto *varMeExpr = static_cast(meExpr); + if (meExpr.GetMeOp() == kMeOpVar) { + auto *varMeExpr = static_cast(&meExpr); const MIRSymbol *sym = ssaTab->GetMIRSymbolFromID(varMeExpr->GetOStIdx()); MIRType *ty = GlobalTables::GetTypeTable().GetTypeFromTyIdx(sym->GetTyIdx()); regVar = ty->GetPrimType() == PTY_ref ? irMap->CreateRegRefMeExpr(*ty) : irMap->CreateRegMeExpr(ty->GetPrimType()); - } else if (meExpr->GetMeOp() == kMeOpIvar) { - auto *ivarMeExpr = static_cast(meExpr); + } else if (meExpr.GetMeOp() == kMeOpIvar) { + auto *ivarMeExpr = static_cast(&meExpr); MIRType *ptrMIRType = GlobalTables::GetTypeTable().GetTypeFromTyIdx(ivarMeExpr->GetTyIdx()); CHECK_FATAL(ptrMIRType->GetKind() == kTypePointer, "must be point type for ivar"); auto *realMIRType = static_cast(ptrMIRType); @@ -66,24 +67,24 @@ MeExpr *SSAPre::CreateNewCurTemp(MeExpr *meExpr) { } else { ty = realMIRType->GetPointedType(); } - CHECK_FATAL(ty->GetPrimType() == meExpr->GetPrimType() || - !(IsAddress(ty->GetPrimType()) && IsAddress(meExpr->GetPrimType())) || - (ty->GetPrimType() == PTY_ptr && meExpr->GetPrimType() == PTY_ref) || - (ty->GetPrimType() == PTY_ref && meExpr->GetPrimType() == PTY_ptr), + CHECK_FATAL(ty->GetPrimType() == meExpr.GetPrimType() || + !(IsAddress(ty->GetPrimType()) && IsAddress(meExpr.GetPrimType())) || + (ty->GetPrimType() == PTY_ptr && meExpr.GetPrimType() == PTY_ref) || + (ty->GetPrimType() == PTY_ref && meExpr.GetPrimType() == PTY_ptr), "inconsistent type"); regVar = (ty->GetPrimType() == PTY_ref) ? (irMap->CreateRegRefMeExpr(*ty)) : (irMap->CreateRegMeExpr(ty->GetPrimType())); } else { - regVar = meExpr->GetPrimType() != PTY_ref ? irMap->CreateRegMeExpr(meExpr->GetPrimType()) - : irMap->CreateRegRefMeExpr(*meExpr); + regVar = meExpr.GetPrimType() != PTY_ref ? irMap->CreateRegMeExpr(meExpr.GetPrimType()) + : irMap->CreateRegRefMeExpr(meExpr); } curTemp = regVar; if (preKind == kLoadPre) { - irMap->SetLpreTmps(static_cast(meExpr)->GetOStIdx(), *regVar); + irMap->SetLpreTmps(static_cast(&meExpr)->GetOStIdx(), *regVar); } return regVar; } else { - VarMeExpr *tempVar = irMap->CreateNewGlobalTmp(NewTempStrIdx(), meExpr->GetPrimType()); + VarMeExpr *tempVar = irMap->CreateNewGlobalTmp(NewTempStrIdx(), meExpr.GetPrimType()); curTemp = tempVar; return tempVar; } @@ -108,51 +109,51 @@ VarMeExpr *SSAPre::CreateNewCurLocalRefVar() { } } -void SSAPre::GenerateSaveInsertedOcc(MeInsertedOcc *insertedOcc) { +void SSAPre::GenerateSaveInsertedOcc(MeInsertedOcc &insertedOcc) { ASSERT(GetPUIdx() == workCand->GetPUIdx() || workCand->GetPUIdx() == 0, "GenerateSaveInsertedOcc: inconsistent puIdx"); - MeExpr *regOrVar = CreateNewCurTemp(insertedOcc->GetMeExpr()); + MeExpr *regOrVar = CreateNewCurTemp(*insertedOcc.GetMeExpr()); MeStmt *newMeStmt = nullptr; if (!workCand->NeedLocalRefVar() || GetPlacementRCOn()) { if (regOrVar->GetMeOp() == kMeOpReg) { - newMeStmt = irMap->CreateRegassignMeStmt(*regOrVar, *insertedOcc->GetMeExpr(), *insertedOcc->GetBB()); + newMeStmt = irMap->CreateRegassignMeStmt(*regOrVar, *insertedOcc.GetMeExpr(), *insertedOcc.GetBB()); } else { - newMeStmt = irMap->CreateDassignMeStmt(*regOrVar, *insertedOcc->GetMeExpr(), *insertedOcc->GetBB()); + newMeStmt = irMap->CreateDassignMeStmt(*regOrVar, *insertedOcc.GetMeExpr(), *insertedOcc.GetBB()); } regOrVar->SetDefByStmt(*newMeStmt); - insertedOcc->GetBB()->InsertMeStmtLastBr(newMeStmt); - insertedOcc->SetSavedExpr(*regOrVar); + insertedOcc.GetBB()->InsertMeStmtLastBr(newMeStmt); + insertedOcc.SetSavedExpr(*regOrVar); } else { // regOrVar is MeOp_reg and lcoalrefvar is kMeOpVar VarMeExpr *localRefVar = CreateNewCurLocalRefVar(); temp2LocalRefVarMap[static_cast(regOrVar)] = localRefVar; - newMeStmt = irMap->CreateDassignMeStmt(*localRefVar, *insertedOcc->GetMeExpr(), *insertedOcc->GetBB()); + newMeStmt = irMap->CreateDassignMeStmt(*localRefVar, *insertedOcc.GetMeExpr(), *insertedOcc.GetBB()); localRefVar->SetDefByStmt(*newMeStmt); - insertedOcc->GetBB()->InsertMeStmtLastBr(newMeStmt); - EnterCandsForSSAUpdate(localRefVar->GetOStIdx(), insertedOcc->GetBB()); - newMeStmt = irMap->CreateRegassignMeStmt(*regOrVar, *localRefVar, *insertedOcc->GetBB()); + insertedOcc.GetBB()->InsertMeStmtLastBr(newMeStmt); + EnterCandsForSSAUpdate(localRefVar->GetOStIdx(), *insertedOcc.GetBB()); + newMeStmt = irMap->CreateRegassignMeStmt(*regOrVar, *localRefVar, *insertedOcc.GetBB()); regOrVar->SetDefByStmt(*newMeStmt); - insertedOcc->GetBB()->InsertMeStmtLastBr(newMeStmt); - insertedOcc->SetSavedExpr(*regOrVar); + insertedOcc.GetBB()->InsertMeStmtLastBr(newMeStmt); + insertedOcc.SetSavedExpr(*regOrVar); } } -void SSAPre::GenerateSavePhiOcc(MePhiOcc *phiOcc) { +void SSAPre::GenerateSavePhiOcc(MePhiOcc &phiOcc) { // generate a regOrVar ASSERT(GetPUIdx() == workCand->GetPUIdx() || workCand->GetPUIdx() == 0, "GenerateSavePhiOcc: inconsistent puIdx"); - MeExpr *regOrVar = CreateNewCurTemp(workCand->GetTheMeExpr()); + MeExpr *regOrVar = CreateNewCurTemp(*workCand->GetTheMeExpr()); CHECK_NULL_FATAL(regOrVar); if (instance_of(regOrVar)) { // create a reg phi MeRegPhiNode *phiReg = irMap->CreateMeRegPhi(static_cast(*regOrVar)); - phiReg->SetDefBB(phiOcc->GetBB()); - phiOcc->SetRegPhi(*phiReg); + phiReg->SetDefBB(phiOcc.GetBB()); + phiOcc.SetRegPhi(*phiReg); } else { MeVarPhiNode *phiVar = irMap->CreateMeVarPhi(static_cast(*regOrVar)); CHECK_NULL_FATAL(phiVar); - phiVar->SetDefBB(phiOcc->GetBB()); - phiOcc->SetVarPhi(*phiVar); + phiVar->SetDefBB(phiOcc.GetBB()); + phiOcc.SetVarPhi(*phiVar); } // update the phi opnds later if (workCand->NeedLocalRefVar() && !GetPlacementRCOn()) { @@ -160,10 +161,10 @@ void SSAPre::GenerateSavePhiOcc(MePhiOcc *phiOcc) { temp2LocalRefVarMap[static_cast(regOrVar)] = localRefVar; // create a var phi MeVarPhiNode *phiVar = irMap->CreateMeVarPhi(*localRefVar); - phiVar->SetDefBB(phiOcc->GetBB()); - phiOcc->SetVarPhi(*phiVar); - EnterCandsForSSAUpdate(localRefVar->GetOStIdx(), phiOcc->GetBB()); + phiVar->SetDefBB(phiOcc.GetBB()); + phiOcc.SetVarPhi(*phiVar); // update the phi opnds later + EnterCandsForSSAUpdate(localRefVar->GetOStIdx(), *phiOcc.GetBB()); } } @@ -236,9 +237,9 @@ void SSAPre::CodeMotion() { auto *realOcc = static_cast(occ); if (realOcc->IsSave()) { CHECK_FATAL(!(realOcc->IsReload()), "reload failed"); - GenerateSaveRealOcc(realOcc); + GenerateSaveRealOcc(*realOcc); } else if (realOcc->IsReload()) { - GenerateReloadRealOcc(realOcc); + GenerateReloadRealOcc(*realOcc); } break; } @@ -251,7 +252,7 @@ void SSAPre::CodeMotion() { if (defOcc->GetOccType() == kOccInserted) { // generate a save of the result in to a new version of t if (!phiOpnd->IsPhiOpndReload()) { - GenerateSaveInsertedOcc(static_cast(defOcc)); + GenerateSaveInsertedOcc(*static_cast(defOcc)); } } break; @@ -261,7 +262,7 @@ void SSAPre::CodeMotion() { if (phiOcc->IsExtraneous() || !phiOcc->IsWillBeAvail()) { break; }; - GenerateSavePhiOcc(phiOcc); + GenerateSavePhiOcc(*phiOcc); break; } case kOccExit: @@ -271,6 +272,7 @@ void SSAPre::CodeMotion() { break; default: ASSERT(false, "should not be here"); + break; } } // update the inserted phiOcc's operand @@ -278,7 +280,7 @@ void SSAPre::CodeMotion() { if (GetSSAPreDebug()) { mirModule->GetOut() << "========ssapre candidate " << workCand->GetIndex() << " after CodeMotion ===================\n"; - if (curTemp) { + if (curTemp != nullptr) { mirModule->GetOut() << "curTemp is"; curTemp->Dump(irMap, 0); mirModule->GetOut() << "\n"; @@ -303,7 +305,7 @@ void SSAPre::Finalize1() { case kOccReal: { MeOccur *availDef = availDefVec[classX]; auto *realOcc = static_cast(occ); - if (availDef == nullptr || !availDef->IsDominate(dom, occ)) { + if (availDef == nullptr || !availDef->IsDominate(*dom, *occ)) { realOcc->SetIsReload(false); availDefVec[classX] = realOcc; } else { @@ -333,7 +335,7 @@ void SSAPre::Finalize1() { MeExpr *insertedExpr = phiOpnd->GetCurrentMeExpr(); ASSERT(insertedExpr != nullptr, "NYI"); MeInsertedOcc *insertedOcc = - perCandMemPool->New(insertedExpr, static_cast(nullptr), phiOpnd->GetBB()); + perCandMemPool->New(insertedExpr, static_cast(nullptr), *phiOpnd->GetBB()); insertedOcc->SetClassID(classCount++); phiOpnd->SetDef(insertedOcc); phiOpnd->SetClassID(insertedOcc->GetClassID()); @@ -354,6 +356,7 @@ void SSAPre::Finalize1() { break; default: ASSERT(false, "should not be here"); + break; } } if (!GetSSAPreDebug()) { @@ -361,7 +364,7 @@ void SSAPre::Finalize1() { } PreWorkCand *curCand = workCand; mirModule->GetOut() << "========ssapre candidate " << curCand->GetIndex() << - " after Finalize1===================\n"; + " after Finalize1===================\n"; for (auto it = phiOccs.begin(); it != phiOccs.end(); ++it) { MePhiOcc *phiOcc = *it; if (!phiOcc->IsWillBeAvail()) { @@ -383,23 +386,21 @@ void SSAPre::Finalize1() { // set save the real occurrence of definition to register // set the PHI occurence to be needed (extraneous being false) -void SSAPre::SetSave(MeOccur *defX) { - CHECK_FATAL(defX != nullptr, "invalid defX"); - if (defX->GetOccType() == kOccReal) { - auto *realOcc = static_cast(defX); +void SSAPre::SetSave(MeOccur &defX) { + if (defX.GetOccType() == kOccReal) { + auto *realOcc = static_cast(&defX); realOcc->SetIsSave(true); ASSERT(!realOcc->IsReload(), "real occ with isReload cannot be set isSave"); - } else if (defX->GetOccType() == kOccPhiocc) { - for (MePhiOpndOcc *phiOpnd : static_cast(defX)->GetPhiOpnds()) { + } else if (defX.GetOccType() == kOccPhiocc) { + for (MePhiOpndOcc *phiOpnd : static_cast(&defX)->GetPhiOpnds()) { if (!phiOpnd->IsProcessed()) { phiOpnd->SetIsProcessed(true); - ASSERT(phiOpnd->GetDef() != nullptr, "EPhiFinalizer::SetSave: phiopndocc cannot have no def"); - SetSave(phiOpnd->GetDef()); + SetSave(*phiOpnd->GetDef()); } } } - if (defX->GetOccType() == kOccReal || defX->GetOccType() == kOccInserted) { - BB *fromBb = defX->GetBB(); + if (defX.GetOccType() == kOccReal || defX.GetOccType() == kOccInserted) { + BB *fromBb = defX.GetBB(); MapleSet itFrontier(perCandAllocator.Adapter()); CHECK_FATAL(!dom->IsBBVecEmpty(), "the size to be allocated is 0"); std::vector visitedMap(dom->GetBBVecSize(), false); @@ -416,18 +417,18 @@ void SSAPre::SetSave(MeOccur *defX) { } } -void SSAPre::SetReplacement(MePhiOcc *occ, MeOccur *repDef) { - occ->SetIsRemoved(true); // exclude recursive PhiOcc +void SSAPre::SetReplacement(MePhiOcc &occ, MeOccur *repDef) { + occ.SetIsRemoved(true); // exclude recursive PhiOcc for (auto it = phiOccs.begin(); it != phiOccs.end(); ++it) { MePhiOcc *phiOcc = *it; if (phiOcc->IsRemoved()) { continue; } for (MePhiOpndOcc *phiOpnd : phiOcc->GetPhiOpnds()) { - if (phiOpnd->GetDef() == occ) { + if (phiOpnd->GetDef() == &occ) { if (phiOcc->IsExtraneous()) { // exclude recursive def - SetReplacement(phiOcc, repDef); + SetReplacement(*phiOcc, repDef); } else { phiOpnd->SetDef(repDef); // replace phiOpnd of phiOcc by replacing def repDef phiOpnd->SetClassID(repDef->GetClassID()); @@ -439,7 +440,7 @@ void SSAPre::SetReplacement(MePhiOcc *occ, MeOccur *repDef) { for (auto it = workCand->GetRealOccs().begin(); it != workCand->GetRealOccs().end(); ++it) { MeRealOcc *realOcc = *it; // when realOcc satisfying reload and def of it is occ, do the replacement - if (realOcc->IsReload() && realOcc->GetDef() == occ) { + if (realOcc->IsReload() && realOcc->GetDef() == &occ) { realOcc->SetDef(repDef); realOcc->SetClassID(repDef->GetClassID()); } @@ -459,7 +460,7 @@ void SSAPre::Finalize2() { for (auto it = workCand->GetRealOccs().begin(); it != workCand->GetRealOccs().end(); ++it) { MeRealOcc *realOcc = *it; if (realOcc->IsReload()) { - SetSave(realOcc->GetDef()); + SetSave(*realOcc->GetDef()); } } for (auto it = phiOccs.begin(); it != phiOccs.end(); ++it) { @@ -476,11 +477,11 @@ void SSAPre::Finalize2() { switch (defOcc->GetOccType()) { case kOccReal: case kOccInserted: - SetReplacement(phiOcc, defOcc); + SetReplacement(*phiOcc, defOcc); break; case kOccPhiocc: if (!static_cast(defOcc)->IsExtraneous()) { - SetReplacement(phiOcc, defOcc); + SetReplacement(*phiOcc, defOcc); } break; default: @@ -521,23 +522,23 @@ void SSAPre::Finalize2() { // ================ Step 4: WillBeAvail Computation ================= // propagate not-can_be_avail attribute forward // along def-use chain to not-downsafety nodes -void SSAPre::ResetCanBeAvail(MePhiOcc *occ) { - occ->SetIsCanBeAvail(false); +void SSAPre::ResetCanBeAvail(MePhiOcc &occ) const { + occ.SetIsCanBeAvail(false); // the following loop is to find occ's use list and reset them for (auto it = phiOccs.begin(); it != phiOccs.end(); ++it) { MePhiOcc *phiOcc = *it; for (MePhiOpndOcc *phiOpnd : phiOcc->GetPhiOpnds()) { - if (phiOpnd->GetDef() && phiOpnd->GetDef() == occ) { + if (phiOpnd->GetDef() != nullptr && phiOpnd->GetDef() == &occ) { // when comes here, phiOpnd->GetDef() is a use of occ if (!phiOpnd->HasRealUse() && !phiOcc->IsDownSafe() && phiOcc->IsCanBeAvail()) { - ResetCanBeAvail(phiOcc); + ResetCanBeAvail(*phiOcc); } } } } } -void SSAPre::ComputeCanBeAvail() { +void SSAPre::ComputeCanBeAvail() const { for (auto it = phiOccs.begin(); it != phiOccs.end(); ++it) { MePhiOcc *phiOcc = *it; if (!phiOcc->IsDownSafe() && phiOcc->IsCanBeAvail()) { @@ -549,7 +550,7 @@ void SSAPre::ComputeCanBeAvail() { } } if (existNullDef) { - ResetCanBeAvail(phiOcc); + ResetCanBeAvail(*phiOcc); } } if (workCand->Redo2HandleCritEdges() && phiOcc->IsCanBeAvail()) { @@ -561,19 +562,19 @@ void SSAPre::ComputeCanBeAvail() { break; } if (existCritEdge) { - ResetCanBeAvail(phiOcc); + ResetCanBeAvail(*phiOcc); } } } } -void SSAPre::ResetLater(MePhiOcc *occ) { +void SSAPre::ResetLater(MePhiOcc *occ) const { occ->SetIsLater(false); // the following loop is to find occ's use list and reset them for (auto it = phiOccs.begin(); it != phiOccs.end(); ++it) { MePhiOcc *phiOcc = *it; for (MePhiOpndOcc *phiOpnd : phiOcc->GetPhiOpnds()) { - if (phiOpnd->GetDef() && phiOpnd->GetDef() == occ) { + if (phiOpnd->GetDef() != nullptr && phiOpnd->GetDef() == occ) { // when comes here, phiOpnd->GetDef() is a use of occ if (phiOcc->IsLater()) { ResetLater(phiOcc); @@ -583,7 +584,7 @@ void SSAPre::ResetLater(MePhiOcc *occ) { } } -void SSAPre::ComputeLater() { +void SSAPre::ComputeLater() const { for (auto it = phiOccs.begin(); it != phiOccs.end(); ++it) { MePhiOcc *phiOcc = *it; phiOcc->SetIsLater(phiOcc->IsCanBeAvail()); @@ -631,11 +632,11 @@ void SSAPre::ComputeLater() { // ================ Step 3: Downsafe Computation ================= // reset downsafety -void SSAPre::ResetDS(MePhiOpndOcc *phiOpnd) { - if (phiOpnd->HasRealUse()) { +void SSAPre::ResetDS(MePhiOpndOcc &phiOpnd) const { + if (phiOpnd.HasRealUse()) { return; } - MeOccur *defOcc = phiOpnd->GetDef(); + MeOccur *defOcc = phiOpnd.GetDef(); if (defOcc == nullptr || defOcc->GetOccType() != kOccPhiocc) { return; } @@ -648,18 +649,18 @@ void SSAPre::ResetDS(MePhiOpndOcc *phiOpnd) { } defPhiOcc->SetIsDownSafe(false); for (MePhiOpndOcc *mePhiOpnd : defPhiOcc->GetPhiOpnds()) { - ResetDS(mePhiOpnd); + ResetDS(*mePhiOpnd); } } // compute downsafety for each PHI -void SSAPre::ComputeDS() { +void SSAPre::ComputeDS() const { for (auto it = phiOccs.begin(); it != phiOccs.end(); ++it) { MePhiOcc *phiOcc = *it; if (!phiOcc->IsDownSafe()) { // propagate not-downsafety along use-def edges for (MePhiOpndOcc *phiOpnd : phiOcc->GetPhiOpnds()) { - ResetDS(phiOpnd); + ResetDS(*phiOpnd); } } } @@ -694,7 +695,7 @@ void SSAPre::Rename1() { classCount = 1; // iterate the occurrence according to its preorder dominator tree for (MeOccur *occ : allOccs) { - while (!occStack.empty() && !occStack.top()->IsDominate(dom, occ)) { + while (!occStack.empty() && !occStack.top()->IsDominate(*dom, *occ)) { occStack.pop(); } switch (occ->GetOccType()) { @@ -714,7 +715,7 @@ void SSAPre::Rename1() { auto *realOcc = static_cast(occ); if (topOccur->GetOccType() == kOccReal) { auto *realTopOccur = static_cast(topOccur); - if (AllVarsSameVersion(realTopOccur, realOcc)) { + if (AllVarsSameVersion(*realTopOccur, *realOcc)) { // all corresponding variables are the same realOcc->SetClassID(realTopOccur->GetClassID()); if (realTopOccur->GetDef() != nullptr) { @@ -731,14 +732,14 @@ void SSAPre::Rename1() { // top of stack is a PHI occurrence ASSERT(topOccur->GetOccType() == kOccPhiocc, "invalid kOccPhiocc"); std::vector varVec; - CollectVarForCand(realOcc, varVec); + CollectVarForCand(*realOcc, varVec); bool isAllDom = true; if (realOcc->IsLHS()) { isAllDom = false; } else { for (auto varIt = varVec.begin(); varIt != varVec.end(); ++varIt) { MeExpr *varMeExpr = *varIt; - if (!DefVarDominateOcc(varMeExpr, topOccur)) { + if (!DefVarDominateOcc(varMeExpr, *topOccur)) { isAllDom = false; } } @@ -825,6 +826,7 @@ void SSAPre::Rename1() { } default: ASSERT(false, "should not be here"); + break; } } if (GetSSAPreDebug()) { @@ -848,25 +850,25 @@ void SSAPre::Rename1() { // if opnd is defined by phi, return the jth opnd of the phi; // return nullptr otherwise -MeExpr *SSAPre::GetReplaceMeExpr(MeExpr *opnd, const BB *ePhiBB, size_t j) { - if (opnd->GetMeOp() != kMeOpVar && opnd->GetMeOp() != kMeOpReg) { +MeExpr *SSAPre::GetReplaceMeExpr(const MeExpr &opnd, const BB &ePhiBB, size_t j) const { + if (opnd.GetMeOp() != kMeOpVar && opnd.GetMeOp() != kMeOpReg) { return nullptr; } MeExpr *retExpr = nullptr; - if (opnd->GetMeOp() == kMeOpVar) { - MeVarPhiNode *defPhi = static_cast(opnd)->GetMeVarPhiDef(); + if (opnd.GetMeOp() == kMeOpVar) { + MeVarPhiNode *defPhi = static_cast(&opnd)->GetMeVarPhiDef(); if (defPhi != nullptr) { - if (ePhiBB->GetBBId() == defPhi->GetDefBB()->GetBBId()) { - ASSERT(defPhi->GetOpnds()[j]->GetMeOp() == opnd->GetMeOp(), "invalid defPhi"); + if (ePhiBB.GetBBId() == defPhi->GetDefBB()->GetBBId()) { + ASSERT(defPhi->GetOpnds()[j]->GetMeOp() == opnd.GetMeOp(), "invalid defPhi"); retExpr = defPhi->GetOpnds()[j]; } } } else { - MeRegPhiNode *defPhi = static_cast(opnd)->GetMeRegPhiDef(); + MeRegPhiNode *defPhi = static_cast(&opnd)->GetMeRegPhiDef(); if (defPhi != nullptr) { - if (ePhiBB->GetBBId() == defPhi->GetDefBB()->GetBBId()) { + if (ePhiBB.GetBBId() == defPhi->GetDefBB()->GetBBId()) { ASSERT(j < defPhi->GetOpnds().size(), "index out of range in SSAPre::GetReplaceMeExpr"); - ASSERT(defPhi->GetOpnds()[j]->GetMeOp() == opnd->GetMeOp(), "invalid defPhi"); + ASSERT(defPhi->GetOpnds()[j]->GetMeOp() == opnd.GetMeOp(), "invalid defPhi"); retExpr = defPhi->GetOpnds()[j]; } } @@ -894,7 +896,7 @@ void SSAPre::Rename2() { continue; } phiOpnd->SetIsProcessed(true); - MeExpr *exprY = PhiOpndFromRes(realOcc, i); + MeExpr *exprY = PhiOpndFromRes(*realOcc, i); phiOpnd->SetCurrentMeExpr(*exprY); // expr_y might be inserted at the end of the block MeOccur *defX = phiOpnd->GetDef(); if (defX == nullptr) { @@ -904,8 +906,8 @@ void SSAPre::Rename2() { auto *realDefX = static_cast(defX); std::vector varVecX; std::vector varVecY; - CollectVarForMeExpr(realDefX->GetMeExpr(), varVecX); - CollectVarForMeExpr(exprY, varVecY); + CollectVarForMeExpr(*realDefX->GetMeExpr(), varVecX); + CollectVarForMeExpr(*exprY, varVecY); CHECK_FATAL(varVecX.size() == varVecY.size(), "invalid size of varVecY"); bool hasSameVersion = true; for (size_t ii = 0; ii < varVecX.size(); ii++) { @@ -920,9 +922,9 @@ void SSAPre::Rename2() { } else if (defX->GetOccType() == kOccPhiocc) { std::vector varVecY; bool alldom = true; - CollectVarForMeExpr(exprY, varVecY); + CollectVarForMeExpr(*exprY, varVecY); for (size_t ii = 0; ii < varVecY.size(); ++ii) { - if (!DefVarDominateOcc(varVecY[ii], defX)) { + if (!DefVarDominateOcc(varVecY[ii], *defX)) { alldom = false; } } @@ -961,25 +963,25 @@ void SSAPre::Rename2() { } // ================ Step 1: Phi Insertion ================= -void SSAPre::SetVarPhis(MeExpr *meExpr) { - MeExprOp meOp = meExpr->GetMeOp(); +void SSAPre::SetVarPhis(const MeExpr &meExpr) { + MeExprOp meOp = meExpr.GetMeOp(); if (meOp != kMeOpVar && meOp != kMeOpReg) { return; } if (meOp == kMeOpVar) { - MeVarPhiNode *phiMeNode = static_cast(meExpr)->GetMeVarPhiDef(); + MeVarPhiNode *phiMeNode = static_cast(&meExpr)->GetMeVarPhiDef(); if (phiMeNode != nullptr) { BBId defBBId = phiMeNode->GetDefBB()->GetBBId(); if (varPhiDfns.find(dom->GetDtDfnItem(defBBId)) == varPhiDfns.end() && ScreenPhiBB(defBBId)) { varPhiDfns.insert(dom->GetDtDfnItem(defBBId)); for (auto opndIt = phiMeNode->GetOpnds().begin(); opndIt != phiMeNode->GetOpnds().end(); ++opndIt) { VarMeExpr *opnd = *opndIt; - SetVarPhis(opnd); + SetVarPhis(*opnd); } } } } else { - MeRegPhiNode *phiMeNode = static_cast(meExpr)->GetMeRegPhiDef(); + MeRegPhiNode *phiMeNode = static_cast(&meExpr)->GetMeRegPhiDef(); if (phiMeNode != nullptr) { BBId defBbId = phiMeNode->GetDefBB()->GetBBId(); CHECK(defBbId < dom->GetDtDfnSize(), "defBbId.idx out of range in SSAPre::SetVarPhis"); @@ -988,7 +990,7 @@ void SSAPre::SetVarPhis(MeExpr *meExpr) { for (auto opndIt = phiMeNode->GetOpnds().begin(); opndIt != phiMeNode->GetOpnds().end(); ++opndIt) { RegMeExpr *opnd = *opndIt; - SetVarPhis(opnd); + SetVarPhis(*opnd); } } } @@ -1031,12 +1033,11 @@ void SSAPre::CreateSortedOccs() { } MePhiOcc *nextPhiOcc = nullptr; if (phiDfnIt != dfPhiDfns.end()) { - CHECK_FATAL(GetBB(dom->GetDtPreOrderItem(*phiDfnIt)) != nullptr, "GetBB return nullptr!"); - nextPhiOcc = perCandMemPool->New(GetBB(dom->GetDtPreOrderItem(*phiDfnIt)), &perCandAllocator); + nextPhiOcc = perCandMemPool->New(*GetBB(dom->GetDtPreOrderItem(*phiDfnIt)), perCandAllocator); } MePhiOpndOcc *nextPhiOpndOcc = nullptr; if (phiOpndDfnIt != phiOpndDfns.end()) { - nextPhiOpndOcc = perCandMemPool->New(GetBB(dom->GetDtPreOrderItem(*phiOpndDfnIt))); + nextPhiOpndOcc = perCandMemPool->New(*GetBB(dom->GetDtPreOrderItem(*phiOpndDfnIt))); auto it = bb2PhiOpndMap.find(dom->GetDtPreOrderItem(*phiOpndDfnIt)); if (it == bb2PhiOpndMap.end()) { std::forward_list newlist = { nextPhiOpndOcc }; @@ -1054,17 +1055,17 @@ void SSAPre::CreateSortedOccs() { if (nextPhiOcc != nullptr) { pickedOcc = nextPhiOcc; } - if (nextRealOcc && (pickedOcc == nullptr || - dom->GetDtDfnItem(nextRealOcc->GetBB()->GetBBId()) < - dom->GetDtDfnItem(pickedOcc->GetBB()->GetBBId()))) { + if (nextRealOcc != nullptr && (pickedOcc == nullptr || + dom->GetDtDfnItem(nextRealOcc->GetBB()->GetBBId()) < + dom->GetDtDfnItem(pickedOcc->GetBB()->GetBBId()))) { pickedOcc = nextRealOcc; } - if (nextExitOcc && (pickedOcc == nullptr || - dom->GetDtDfnItem(nextExitOcc->GetBB()->GetBBId()) < - dom->GetDtDfnItem(pickedOcc->GetBB()->GetBBId()))) { + if (nextExitOcc != nullptr && (pickedOcc == nullptr || + dom->GetDtDfnItem(nextExitOcc->GetBB()->GetBBId()) < + dom->GetDtDfnItem(pickedOcc->GetBB()->GetBBId()))) { pickedOcc = nextExitOcc; } - if (nextPhiOpndOcc && + if (nextPhiOpndOcc != nullptr && (pickedOcc == nullptr || *phiOpndDfnIt < dom->GetDtDfnItem(pickedOcc->GetBB()->GetBBId()))) { pickedOcc = nextPhiOpndOcc; } @@ -1092,9 +1093,7 @@ void SSAPre::CreateSortedOccs() { phiOccs.push_back(static_cast(pickedOcc)); ++phiDfnIt; if (phiDfnIt != dfPhiDfns.end()) { - CHECK_FATAL(GetBB(dom->GetDtPreOrderItem(*phiDfnIt)) != nullptr, - "GetBB return null in SSAPre::CreateSortedOccs"); - nextPhiOcc = perCandMemPool->New(GetBB(dom->GetDtPreOrderItem(*phiDfnIt)), &perCandAllocator); + nextPhiOcc = perCandMemPool->New(*GetBB(dom->GetDtPreOrderItem(*phiDfnIt)), perCandAllocator); } else { nextPhiOcc = nullptr; } @@ -1102,7 +1101,7 @@ void SSAPre::CreateSortedOccs() { case kOccPhiopnd: ++phiOpndDfnIt; if (phiOpndDfnIt != phiOpndDfns.end()) { - nextPhiOpndOcc = perCandMemPool->New(GetBB(dom->GetDtPreOrderItem(*phiOpndDfnIt))); + nextPhiOpndOcc = perCandMemPool->New(*GetBB(dom->GetDtPreOrderItem(*phiOpndDfnIt))); auto it = bb2PhiOpndMap.find(dom->GetDtPreOrderItem(*phiOpndDfnIt)); if (it == bb2PhiOpndMap.end()) { std::forward_list newlist = { nextPhiOpndOcc }; @@ -1116,6 +1115,7 @@ void SSAPre::CreateSortedOccs() { break; default: ASSERT(false, "CreateSortedOccs: unexpected occty"); + break; } } } while (pickedOcc != nullptr); @@ -1139,34 +1139,34 @@ void SSAPre::CreateSortedOccs() { } // ================ End of Step 1: Phi Insertion ================= -IassignMeStmt *SSAPre::CopyIassignMeStmt(const IassignMeStmt &iaStmt) { +IassignMeStmt *SSAPre::CopyIassignMeStmt(const IassignMeStmt &iaStmt) const { IassignMeStmt *meStmt = irMap->NewInPool(iaStmt); return meStmt; } -MeStmt *SSAPre::CopyMeStmt(MeStmt &meStmt) { +MeStmt *SSAPre::CopyMeStmt(const MeStmt &meStmt) const { CHECK_FATAL(meStmt.GetOp() == OP_assertlt || meStmt.GetOp() == OP_assertge, "invalid value of meStmt.GetOp()"); - auto *oldStmt = static_cast(&meStmt); + auto *oldStmt = static_cast(&meStmt); AssertMeStmt *newStmt = irMap->New(*oldStmt); return newStmt; } -MeExpr *SSAPre::CopyMeExpr(MeExpr &expr) { +MeExpr *SSAPre::CopyMeExpr(const MeExpr &expr) const { MapleAllocator *irMapAlloc = &irMap->GetIRMapAlloc(); switch (expr.GetMeOp()) { case kMeOpOp: { - auto &opExpr = static_cast(expr); + auto &opExpr = static_cast(expr); OpMeExpr *newExpr = irMapAlloc->GetMemPool()->New(opExpr, -1); newExpr->InitBase(opExpr.GetOp(), opExpr.GetPrimType(), opExpr.GetNumOpnds()); return newExpr; } case kMeOpNary: { - auto &naryMeExpr = static_cast(expr); + auto &naryMeExpr = static_cast(expr); NaryMeExpr *newNaryMeExpr = irMapAlloc->GetMemPool()->New(irMapAlloc, -1, naryMeExpr); return newNaryMeExpr; } case kMeOpIvar: { - auto &ivarMeExpr = static_cast(expr); + auto &ivarMeExpr = static_cast(expr); IvarMeExpr *newIvar = irMapAlloc->GetMemPool()->New(-1, ivarMeExpr); newIvar->InitBase(ivarMeExpr.GetOp(), ivarMeExpr.GetPrimType(), ivarMeExpr.GetNumOpnds()); return newIvar; @@ -1177,15 +1177,15 @@ MeExpr *SSAPre::CopyMeExpr(MeExpr &expr) { } // if the definition of varMeExpr dominate meocc then return true. otherwise return false; -bool SSAPre::DefVarDominateOcc(MeExpr *meExpr, MeOccur *meOcc) { +bool SSAPre::DefVarDominateOcc(const MeExpr *meExpr, const MeOccur &meOcc) const { if (meExpr == nullptr) { // can be nullptr in the case of LHS occurrence return false; } - CHECK_FATAL(meOcc->GetOccType() == kOccPhiocc, "invalid value of meOcc->GetOccType()"); - BB *occBB = (static_cast(meOcc))->GetBB(); + CHECK_FATAL(meOcc.GetOccType() == kOccPhiocc, "invalid value of meOcc->GetOccType()"); + const BB *occBB = (static_cast(&meOcc))->GetBB(); if (meExpr->GetMeOp() == kMeOpVar) { - auto *varMeExpr = static_cast(meExpr); + auto *varMeExpr = static_cast(meExpr); switch (varMeExpr->GetDefBy()) { case kDefByNo: return true; // it's an original variable which dominates everything @@ -1195,29 +1195,27 @@ bool SSAPre::DefVarDominateOcc(MeExpr *meExpr, MeOccur *meOcc) { BB *defBB = meStmt->GetBB(); if (occBB == defBB) { return false; - } else { - return dom->Dominate(*defBB, *occBB); } + return dom->Dominate(*defBB, *occBB); } case kDefByPhi: { - MeVarPhiNode &phiMeNode = varMeExpr->GetDefPhi(); - BB *defBB = phiMeNode.GetDefBB(); + const MeVarPhiNode &phiMeNode = varMeExpr->GetDefPhi(); + const BB *defBB = phiMeNode.GetDefBB(); if (defBB->GetBBId() == occBB->GetBBId()) { return true; } return dom->Dominate(*defBB, *occBB); } case kDefByMustDef: { - MeStmt *meStmt = varMeExpr->GetDefMustDef().GetBase(); + const MeStmt *meStmt = varMeExpr->GetDefMustDef().GetBase(); if (meStmt == nullptr) { return true; // it's a original variable dominate everything } BB *defBB = meStmt->GetBB(); if (occBB == defBB) { return false; - } else { - return dom->Dominate(*defBB, *occBB); } + return dom->Dominate(*defBB, *occBB); } case kDefByChi: { MeStmt *meStmt = varMeExpr->GetDefChi().GetBase(); @@ -1227,16 +1225,15 @@ bool SSAPre::DefVarDominateOcc(MeExpr *meExpr, MeOccur *meOcc) { BB *defBB = meStmt->GetBB(); if (occBB == defBB) { return false; - } else { - return dom->Dominate(*defBB, *occBB); } + return dom->Dominate(*defBB, *occBB); } default: CHECK_FATAL(false, "to be done"); } } else { CHECK_FATAL(meExpr->GetMeOp() == kMeOpReg, "invalid value of meExpr->GetMeOp()"); - auto *regMeExpr = static_cast(meExpr); + auto *regMeExpr = static_cast(meExpr); switch (regMeExpr->GetDefBy()) { case kDefByNo: return true; // original st dominates everything @@ -1246,12 +1243,11 @@ bool SSAPre::DefVarDominateOcc(MeExpr *meExpr, MeOccur *meOcc) { BB *defBB = meStmt->GetBB(); if (occBB == defBB) { return false; - } else { - return dom->Dominate(*defBB, *occBB); } + return dom->Dominate(*defBB, *occBB); } case kDefByPhi: { - MeRegPhiNode &phiMeNode = regMeExpr->GetDefPhi(); + const MeRegPhiNode &phiMeNode = regMeExpr->GetDefPhi(); BB *defBB = phiMeNode.GetDefBB(); if (defBB->GetBBId() == occBB->GetBBId()) { return true; @@ -1259,16 +1255,15 @@ bool SSAPre::DefVarDominateOcc(MeExpr *meExpr, MeOccur *meOcc) { return dom->Dominate(*defBB, *occBB); } case kDefByMustDef: { - MeStmt *meStmt = regMeExpr->GetDefMustDef().GetBase(); + const MeStmt *meStmt = regMeExpr->GetDefMustDef().GetBase(); if (meStmt == nullptr) { return true; // it's a original variable dominate everything } BB *defBB = meStmt->GetBB(); if (occBB == defBB) { return false; - } else { - return dom->Dominate(*defBB, *occBB); } + return dom->Dominate(*defBB, *occBB); } default: CHECK_FATAL(false, "to be done"); @@ -1276,39 +1271,42 @@ bool SSAPre::DefVarDominateOcc(MeExpr *meExpr, MeOccur *meOcc) { } } -bool SSAPre::CheckIfAnyLocalOpnd(MeExpr *meExpr) { - switch (meExpr->GetMeOp()) { +bool SSAPre::CheckIfAnyLocalOpnd(const MeExpr &meExpr) const { + switch (meExpr.GetMeOp()) { case kMeOpReg: return true; case kMeOpVar: { - auto *varMeExpr = static_cast(meExpr); + auto *varMeExpr = static_cast(&meExpr); const MIRSymbol *st = ssaTab->GetMIRSymbolFromID(varMeExpr->GetOStIdx()); return st->IsLocal(); } case kMeOpIvar: { - auto *ivarMeExpr = static_cast(meExpr); - return CheckIfAnyLocalOpnd(ivarMeExpr->GetBase()); + auto *ivarMeExpr = static_cast(&meExpr); + return CheckIfAnyLocalOpnd(*ivarMeExpr->GetBase()); } case kMeOpOp: { - auto *opMeExpr = static_cast(meExpr); - if (CheckIfAnyLocalOpnd(opMeExpr->GetOpnd(0))) { + auto *opMeExpr = static_cast(&meExpr); + constexpr size_t firstOpnd = 0; + if (CheckIfAnyLocalOpnd(*opMeExpr->GetOpnd(firstOpnd))) { return true; } - if (opMeExpr->GetOpnd(1) == nullptr) { + constexpr size_t secondOpnd = 1; + if (opMeExpr->GetOpnd(secondOpnd) == nullptr) { return false; } - if (CheckIfAnyLocalOpnd(opMeExpr->GetOpnd(1))) { + if (CheckIfAnyLocalOpnd(*opMeExpr->GetOpnd(secondOpnd))) { return true; } - if (opMeExpr->GetOpnd(2) == nullptr) { + constexpr size_t thirdOpnd = 2; + if (opMeExpr->GetOpnd(thirdOpnd) == nullptr) { return false; } - return CheckIfAnyLocalOpnd(opMeExpr->GetOpnd(2)); + return CheckIfAnyLocalOpnd(*opMeExpr->GetOpnd(thirdOpnd)); } case kMeOpNary: { - auto *naryMeExpr = static_cast(meExpr); + auto *naryMeExpr = static_cast(&meExpr); for (MeExpr *opnd : naryMeExpr->GetOpnds()) { - if (CheckIfAnyLocalOpnd(opnd)) { + if (CheckIfAnyLocalOpnd(*opnd)) { return true; } } @@ -1344,8 +1342,8 @@ MeRealOcc *SSAPre::CreateRealOcc(MeStmt &meStmt, int seqStmt, MeExpr &meExpr, bo return newOcc; } // workcand not yet created; create a new one and add to worklist - wkCand = ssaPreMemPool->New(&ssaPreAllocator, workList.size(), &meExpr, GetPUIdx()); - wkCand->SetHasLocalOpnd(CheckIfAnyLocalOpnd(&meExpr)); + wkCand = ssaPreMemPool->New(ssaPreAllocator, workList.size(), &meExpr, GetPUIdx()); + wkCand->SetHasLocalOpnd(CheckIfAnyLocalOpnd(meExpr)); if (EpreLocalRefVar() && wkCand->GetTheMeExpr()->GetMeOp() == kMeOpIvar) { // set wkCand->NeedLocalRefVar() flag auto *ivarMeExpr = static_cast(wkCand->GetTheMeExpr()); @@ -1424,42 +1422,42 @@ void SSAPre::BuildWorkListStmt(MeStmt *meStmt, uint32 seqStmt, bool isRebuilt, M break; case OP_throw: { auto *thrMeStmt = static_cast(meStmt); - BuildWorkListExpr(meStmt, seqStmt, thrMeStmt->GetOpnd(), isRebuilt, tempVar, true); + BuildWorkListExpr(*meStmt, seqStmt, *thrMeStmt->GetOpnd(), isRebuilt, tempVar, true); break; } case OP_iassign: { auto *ivarStmt = static_cast(meStmt); - BuildWorkListExpr(meStmt, seqStmt, ivarStmt->GetRHS(), isRebuilt, tempVar, true); - BuildWorkListExpr(meStmt, seqStmt, ivarStmt->GetLHSVal()->GetBase(), isRebuilt, tempVar, true); - BuildWorkListIvarLHSOcc(meStmt, seqStmt, isRebuilt, tempVar); + BuildWorkListExpr(*meStmt, seqStmt, *ivarStmt->GetRHS(), isRebuilt, tempVar, true); + BuildWorkListExpr(*meStmt, seqStmt, *ivarStmt->GetLHSVal()->GetBase(), isRebuilt, tempVar, true); + BuildWorkListIvarLHSOcc(*meStmt, seqStmt, isRebuilt, tempVar); break; } case OP_brtrue: case OP_brfalse: { auto *condGotoStmt = static_cast(meStmt); - BuildWorkListExpr(meStmt, seqStmt, condGotoStmt->GetOpnd(), isRebuilt, tempVar, true); + BuildWorkListExpr(*meStmt, seqStmt, *condGotoStmt->GetOpnd(), isRebuilt, tempVar, true); break; } case OP_switch: { auto *switchStmt = static_cast(meStmt); - BuildWorkListExpr(meStmt, seqStmt, switchStmt->GetOpnd(), isRebuilt, tempVar, true); + BuildWorkListExpr(*meStmt, seqStmt, *switchStmt->GetOpnd(), isRebuilt, tempVar, true); break; } case OP_dassign: { auto *dassMeStmt = static_cast(meStmt); - BuildWorkListExpr(meStmt, seqStmt, dassMeStmt->GetRHS(), isRebuilt, tempVar, true); - BuildWorkListLHSOcc(meStmt, seqStmt); + BuildWorkListExpr(*meStmt, seqStmt, *dassMeStmt->GetRHS(), isRebuilt, tempVar, true); + BuildWorkListLHSOcc(*meStmt, seqStmt); break; } case OP_regassign: { auto *rassMeStmt = static_cast(meStmt); - BuildWorkListExpr(meStmt, seqStmt, rassMeStmt->GetRHS(), isRebuilt, tempVar, true); + BuildWorkListExpr(*meStmt, seqStmt, *rassMeStmt->GetRHS(), isRebuilt, tempVar, true); break; } case OP_maydassign: { auto *dassMeStmt = static_cast(meStmt); - BuildWorkListExpr(meStmt, seqStmt, dassMeStmt->GetRHS(), isRebuilt, tempVar, true); - BuildWorkListLHSOcc(meStmt, seqStmt); + BuildWorkListExpr(*meStmt, seqStmt, *dassMeStmt->GetRHS(), isRebuilt, tempVar, true); + BuildWorkListLHSOcc(*meStmt, seqStmt); break; } case OP_decref: { @@ -1468,7 +1466,7 @@ void SSAPre::BuildWorkListStmt(MeStmt *meStmt, uint32 seqStmt, bool isRebuilt, M // affects LPRE only; will cause CI failure if this is allowed break; } - BuildWorkListExpr(meStmt, seqStmt, unaryStmt->GetOpnd(), isRebuilt, tempVar, true); + BuildWorkListExpr(*meStmt, seqStmt, *unaryStmt->GetOpnd(), isRebuilt, tempVar, true); break; } case OP_incref: @@ -1477,7 +1475,7 @@ void SSAPre::BuildWorkListStmt(MeStmt *meStmt, uint32 seqStmt, bool isRebuilt, M case OP_assertnonnull: case OP_free: { auto *unaryStmt = static_cast(meStmt); - BuildWorkListExpr(meStmt, seqStmt, unaryStmt->GetOpnd(), isRebuilt, tempVar, true); + BuildWorkListExpr(*meStmt, seqStmt, *unaryStmt->GetOpnd(), isRebuilt, tempVar, true); break; } case OP_syncenter: @@ -1485,7 +1483,7 @@ void SSAPre::BuildWorkListStmt(MeStmt *meStmt, uint32 seqStmt, bool isRebuilt, M auto *syncMeStmt = static_cast(meStmt); const MapleVector &opnds = syncMeStmt->GetOpnds(); for (auto it = opnds.begin(); it != opnds.end(); ++it) { - BuildWorkListExpr(meStmt, seqStmt, *it, isRebuilt, tempVar, true); + BuildWorkListExpr(*meStmt, seqStmt, **it, isRebuilt, tempVar, true); } break; } @@ -1508,7 +1506,7 @@ void SSAPre::BuildWorkListStmt(MeStmt *meStmt, uint32 seqStmt, bool isRebuilt, M } } } - BuildWorkListExpr(meStmt, seqStmt, *it, isRebuilt, tempVar, true); + BuildWorkListExpr(*meStmt, seqStmt, **it, isRebuilt, tempVar, true); } break; } @@ -1533,7 +1531,7 @@ void SSAPre::BuildWorkListStmt(MeStmt *meStmt, uint32 seqStmt, bool isRebuilt, M auto *naryMeStmt = static_cast(meStmt); const MapleVector &opnds = naryMeStmt->GetOpnds(); for (auto it = opnds.begin(); it != opnds.end(); ++it) { - BuildWorkListExpr(meStmt, seqStmt, *it, isRebuilt, tempVar, true); + BuildWorkListExpr(*meStmt, seqStmt, **it, isRebuilt, tempVar, true); } break; } @@ -1564,15 +1562,15 @@ void SSAPre::BuildWorkListStmt(MeStmt *meStmt, uint32 seqStmt, bool isRebuilt, M continue; } } - BuildWorkListExpr(meStmt, seqStmt, *it, isRebuilt, tempVar, true); + BuildWorkListExpr(*meStmt, seqStmt, **it, isRebuilt, tempVar, true); } break; } case OP_assertlt: case OP_assertge: { auto *assMeStmt = static_cast(meStmt); - BuildWorkListExpr(meStmt, seqStmt, assMeStmt->GetOpnd(0), isRebuilt, tempVar, true); - BuildWorkListExpr(meStmt, seqStmt, assMeStmt->GetOpnd(1), isRebuilt, tempVar, true); + BuildWorkListExpr(*meStmt, seqStmt, *assMeStmt->GetOpnd(0), isRebuilt, tempVar, true); + BuildWorkListExpr(*meStmt, seqStmt, *assMeStmt->GetOpnd(1), isRebuilt, tempVar, true); break; } default: @@ -1580,7 +1578,7 @@ void SSAPre::BuildWorkListStmt(MeStmt *meStmt, uint32 seqStmt, bool isRebuilt, M break; } if (kOpcodeInfo.IsCallAssigned(op)) { - BuildWorkListLHSOcc(meStmt, seqStmt); + BuildWorkListLHSOcc(*meStmt, seqStmt); } } @@ -1593,21 +1591,21 @@ void SSAPre::BuildWorkListBB(BB *bb) { BuildWorkListStmt(&stmt, ++seqStmt, false); } if (bb->GetAttributes(kBBAttrIsExit) || bb->GetAttributes(kBBAttrWontExit)) { - CreateExitOcc(bb); + CreateExitOcc(*bb); } } -void SSAPre::DumpWorkListWrap() { +void SSAPre::DumpWorkListWrap() const { if (GetSSAPreDebug()) { DumpWorkList(); } } -void SSAPre::DumpWorkList() { +void SSAPre::DumpWorkList() const { mirModule->GetOut() << "======== in SSAPRE worklist==============\n"; for (size_t i = 0; i < workList.size(); i++) { PreWorkCand *workListCand = workList[i]; - workListCand->Dump(irMap); + workListCand->Dump(*irMap); } } diff --git a/src/maple_me/src/ver_symbol.cpp b/src/maple_me/src/ver_symbol.cpp index b8226cf71aaa04d8b187b3ec4a0f47c2558cbb58..3afae4ac14a2521ad6eb4768fc6f0f57108b289e 100644 --- a/src/maple_me/src/ver_symbol.cpp +++ b/src/maple_me/src/ver_symbol.cpp @@ -65,7 +65,7 @@ VersionSt *VersionStTable::FindOrCreateVersionSt(OriginalSt *ost, size_t version return CreateVersionSt(ost, version); } -void VersionStTable::Dump(MIRModule *mod) const { +void VersionStTable::Dump(const MIRModule *mod) const { ASSERT(mod != nullptr, "nullptr check"); LogInfo::MapleLogger() << "=======version st table entries=======\n"; for (size_t i = 1; i < versionStVector.size(); ++i) { diff --git a/src/maple_util/include/name_mangler.h b/src/maple_util/include/name_mangler.h index 8d05ee40e84097db5766035eac4b6628d8b71b1e..ef7d93eec114ea146fd512204124676f8c352496 100644 --- a/src/maple_util/include/name_mangler.h +++ b/src/maple_util/include/name_mangler.h @@ -159,16 +159,14 @@ static constexpr const char kFuncGetCurrentCl[] = "MCC_GetCurrentClassLoader"; extern bool doCompression; // Return the input string if the compression is not on; otherwise, return its compressed version -std::string GetInternalNameLiteral(const std::string &name); -std::string GetOriginalNameLiteral(const char *name); +std::string GetInternalNameLiteral(std::string name); +std::string GetOriginalNameLiteral(std::string name); std::string EncodeName(const std::string &name); -std::string EncodeName(const char *name); std::string DecodeName(const std::string &name); -std::string DecodeName(const char *name); void DecodeMapleNameToJavaDescriptor(const std::string &nameIn, std::string &nameOut); -std::string NativeJavaName(const char *name, bool overLoaded = true); +std::string NativeJavaName(const std::string &name, bool overLoaded = true); __attribute__((visibility("default"))) unsigned UTF16ToUTF8(std::string &str, const std::u16string &str16, unsigned short num = 0, bool isBigEndian = false); diff --git a/src/maple_util/include/profile_type.h b/src/maple_util/include/profile_type.h index cb871f321dbdfbcbdc08ddd66828ee368055a675..2e45d3389484111d8200bd117a70dfeb3ee0727b 100644 --- a/src/maple_util/include/profile_type.h +++ b/src/maple_util/include/profile_type.h @@ -31,7 +31,7 @@ enum ProfileType : uint8_t { kReflectionStr = 0x04, kLiteral = 0x05, kBBInfo = 0x06, - kAll = 0x06, + kAll = 0x07, kFileDesc = 0xFF }; diff --git a/src/mpl2mpl/include/class_init.h b/src/mpl2mpl/include/class_init.h index ae3bf0e4308b46fb9747b07ff9354718cd1a163f..007240d224c1ec3b82739578fced8a82937be3e3 100644 --- a/src/mpl2mpl/include/class_init.h +++ b/src/mpl2mpl/include/class_init.h @@ -32,7 +32,7 @@ class ClassInit : public FuncOptimizeImpl { private: void GenClassInitCheckProfile(MIRFunction &func, const MIRSymbol &classInfo, StmtNode *clinit) const; - void GenPreClassInitCheck(MIRFunction &func, const MIRSymbol &classInfo, StmtNode *clinit) const; + void GenPreClassInitCheck(MIRFunction &func, const MIRSymbol &classInfo, const StmtNode *clinit) const; void GenPostClassInitCheck(MIRFunction &func, const MIRSymbol &classInfo, StmtNode *clinit) const; MIRSymbol *GetClassInfo(const std::string &classname); bool CanRemoveClinitCheck(const std::string &clinitClassname) const; diff --git a/src/mpl2mpl/include/constantfold.h b/src/mpl2mpl/include/constantfold.h index bac3d4cc9b022562930dde02ebd9d383f0d9bacc..8bea0dc5d70f840717bf37fd641a712277b1fcd8 100644 --- a/src/mpl2mpl/include/constantfold.h +++ b/src/mpl2mpl/include/constantfold.h @@ -99,19 +99,19 @@ class ConstantFold : public FuncOptimizeImpl { const MIRConst &const0, const MIRConst &const1) const; ConstvalNode *FoldFPConstBinary(Opcode opcode, PrimType resultType, const ConstvalNode &const0, const ConstvalNode &const1) const; - ConstvalNode *FoldConstUnary(Opcode opcode, PrimType resultType, ConstvalNode *c) const; - ConstvalNode *FoldIntConstUnary(Opcode opcode, PrimType resultType, const ConstvalNode *c) const; + ConstvalNode *FoldConstUnary(Opcode opcode, PrimType resultType, ConstvalNode *constNode) const; + ConstvalNode *FoldIntConstUnary(Opcode opcode, PrimType resultType, const ConstvalNode *constNode) const; template - ConstvalNode *FoldFPConstUnary(Opcode opcode, PrimType resultType, ConstvalNode *c) const; + ConstvalNode *FoldFPConstUnary(Opcode opcode, PrimType resultType, ConstvalNode *constNode) const; BaseNode *NegateTree(BaseNode *node) const; BaseNode *Negate(BaseNode *node) const; BaseNode *Negate(UnaryNode *node) const; BaseNode *Negate(const ConstvalNode *node) const; - BinaryNode *NewBinaryNode(BinaryNode *old, Opcode op, PrimType primeType, BaseNode *l, BaseNode *r) const; - UnaryNode *NewUnaryNode(UnaryNode *old, Opcode op, PrimType primeType, BaseNode *e) const; + BinaryNode *NewBinaryNode(BinaryNode *old, Opcode op, PrimType primeType, BaseNode *lhs, BaseNode *rhs) const; + UnaryNode *NewUnaryNode(UnaryNode *old, Opcode op, PrimType primeType, BaseNode *expr) const; std::pair DispatchFold(BaseNode *node); - BaseNode *PairToExpr(PrimType resultType, const std::pair &p) const; - BaseNode *SimplifyDoubleCompare(CompareNode *node) const; + BaseNode *PairToExpr(PrimType resultType, const std::pair &pair) const; + BaseNode *SimplifyDoubleCompare(CompareNode &node) const; }; class DoConstantFold : public ModulePhase { diff --git a/src/mpl2mpl/include/muid_replacement.h b/src/mpl2mpl/include/muid_replacement.h index 2c7f3d44d638f4bf5e3e0d9fab8b7439fa87c5b2..122f4e663e73c0f4b72fdf6065804770bf931569 100644 --- a/src/mpl2mpl/include/muid_replacement.h +++ b/src/mpl2mpl/include/muid_replacement.h @@ -94,12 +94,12 @@ class MUIDReplacement : public FuncOptimizeImpl { void ReplaceAddrofConst(MIRConst *&entry); void ReplaceDataTable(const std::string &name); void ReplaceDirectInvokeOrAddroffunc(MIRFunction ¤tFunc, StmtNode &stmt); - void ReplaceDassign(MIRFunction ¤tFunc, DassignNode &dassignNode); + void ReplaceDassign(MIRFunction ¤tFunc, const DassignNode &dassignNode); void ReplaceDreadStmt(MIRFunction *currentFunc, StmtNode *stmt); void ClearVtabItab(const std::string &name); void ReplaceDecoupleKeyTable(MIRAggConst *oldConst); BaseNode *ReplaceDreadExpr(MIRFunction *currentFunc, StmtNode *stmt, BaseNode *expr); - BaseNode *ReplaceDread(MIRFunction ¤tFunc, StmtNode *stmt, BaseNode *opnd); + BaseNode *ReplaceDread(MIRFunction ¤tFunc, const StmtNode *stmt, BaseNode *opnd); void CollectDread(MIRFunction ¤tFunc, StmtNode &stmt, BaseNode &opnd); void DumpMUIDFile(bool isFunc); void ReplaceStmts(); diff --git a/src/mpl2mpl/src/analyzector.cpp b/src/mpl2mpl/src/analyzector.cpp index 7559c3538936c755cbd74c4f7bc5033a50e18f04..fb521b55bfb2c294d747dde19b823eb1fe78b9d0 100644 --- a/src/mpl2mpl/src/analyzector.cpp +++ b/src/mpl2mpl/src/analyzector.cpp @@ -14,7 +14,8 @@ */ #include "analyzector.h" #include "utils.h" -// AnalyzeCtor analyzes which fields are assgiend inside of of each constructor + +// AnalyzeCtor analyzes which fields are assigned inside of of each constructor namespace maple { void AnalyzeCtor::ProcessFunc(MIRFunction *func) { if (!func->IsConstructor() || func->IsEmpty() || func->GetParamSize() == 0) { diff --git a/src/mpl2mpl/src/class_init.cpp b/src/mpl2mpl/src/class_init.cpp index b621f7892033d57f5f60362f1ed98eff472eb027..215a45626ff8495512626c831baff4f7d40c9b3e 100644 --- a/src/mpl2mpl/src/class_init.cpp +++ b/src/mpl2mpl/src/class_init.cpp @@ -36,7 +36,7 @@ void ClassInit::GenClassInitCheckProfile(MIRFunction &func, const MIRSymbol &cla GenPostClassInitCheck(func, classInfo, clinit); } -void ClassInit::GenPreClassInitCheck(MIRFunction &func, const MIRSymbol &classInfo, StmtNode *clinit) const { +void ClassInit::GenPreClassInitCheck(MIRFunction &func, const MIRSymbol &classInfo, const StmtNode *clinit) const { MIRFunction *preClinit = builder->GetOrCreateFunction(kMCCPreClinitCheck, (TyIdx)(PTY_void)); BaseNode *classInfoNode = builder->CreateExprAddrof(0, classInfo); MapleVector args(builder->GetCurrentFuncCodeMpAllocator()->Adapter()); diff --git a/src/mpl2mpl/src/coderelayout.cpp b/src/mpl2mpl/src/coderelayout.cpp index d9edfa737553788967e7736f9b259cdb6357f0b8..14580bba1cd5d87ace2cfffd998fb5d5691ea46c 100644 --- a/src/mpl2mpl/src/coderelayout.cpp +++ b/src/mpl2mpl/src/coderelayout.cpp @@ -54,7 +54,6 @@ CodeReLayout::CodeReLayout(MIRModule *mod, KlassHierarchy *kh, bool dump) : Func if (!staticFields.is_open()) { ERR(kLncErr, " %s open failed!", staticFieldsFile.c_str()); } - staticFields.close(); } } @@ -132,9 +131,8 @@ void CodeReLayout::FindDreadRecur(const StmtNode *stmt, BaseNode *node) { bOpnds = static_cast(bNode); FindDreadRecur(stmt, bOpnds->GetBOpnd(0)); FindDreadRecur(stmt, bOpnds->GetBOpnd(1)); - } else { - break; } + break; } } } diff --git a/src/mpl2mpl/src/constantfold.cpp b/src/mpl2mpl/src/constantfold.cpp index 34c1b713630be672c2902ddafc5a14479ea01f28..c86d4b7dcb176040dd5348c27a5a5fd86be381c0 100644 --- a/src/mpl2mpl/src/constantfold.cpp +++ b/src/mpl2mpl/src/constantfold.cpp @@ -21,7 +21,7 @@ #include "global_tables.h" namespace { -constexpr maple::uint64 kJsTypeNumber = 4; // JSTYPE_NUMBER +constexpr maple::uint64 kJsTypeNumber = 4; constexpr maple::uint64 kJsTypeNumberInHigh32Bit = kJsTypeNumber << 32; // set high 32 bit as JSTYPE_NUMBER constexpr maple::uint32 kByteSizeOfBit64 = 8; // byte number for 64 bit enum CompareRes : maple::int64 { @@ -53,37 +53,37 @@ BinaryNode *ConstantFold::NewBinaryNode(BinaryNode *old, Opcode op, PrimType pri return result; } -UnaryNode *ConstantFold::NewUnaryNode(UnaryNode *old, Opcode op, PrimType primType, BaseNode *e) const { +UnaryNode *ConstantFold::NewUnaryNode(UnaryNode *old, Opcode op, PrimType primType, BaseNode *expr) const { CHECK_NULL_FATAL(old); UnaryNode *result = nullptr; - if (old->GetOpCode() == op && old->GetPrimType() == primType && old->Opnd(0) == e) { + if (old->GetOpCode() == op && old->GetPrimType() == primType && old->Opnd(0) == expr) { result = old; } else { - result = mirModule->CurFuncCodeMemPool()->New(op, primType, e); + result = mirModule->CurFuncCodeMemPool()->New(op, primType, expr); } return result; } -BaseNode *ConstantFold::PairToExpr(PrimType resultType, const std::pair &p) const { - CHECK_NULL_FATAL(p.first); - BaseNode *result = p.first; - if (p.second == 0) { +BaseNode *ConstantFold::PairToExpr(PrimType resultType, const std::pair &pair) const { + CHECK_NULL_FATAL(pair.first); + BaseNode *result = pair.first; + if (pair.second == 0) { return result; } - if (p.first->GetOpCode() == OP_neg && p.second > 0) { + if (pair.first->GetOpCode() == OP_neg && pair.second > 0) { // -a, 5 -> 5 - a - ConstvalNode *val = mirModule->GetMIRBuilder()->CreateIntConst(p.second, resultType); - BaseNode *r = static_cast(p.first)->Opnd(0); + ConstvalNode *val = mirModule->GetMIRBuilder()->CreateIntConst(pair.second, resultType); + BaseNode *r = static_cast(pair.first)->Opnd(0); result = mirModule->CurFuncCodeMemPool()->New(OP_sub, resultType, val, r); } else { - if (p.second > 0) { + if (pair.second > 0) { // +-a, 5 -> a + 5 - ConstvalNode *val = mirModule->GetMIRBuilder()->CreateIntConst(p.second, resultType); - result = mirModule->CurFuncCodeMemPool()->New(OP_add, resultType, p.first, val); + ConstvalNode *val = mirModule->GetMIRBuilder()->CreateIntConst(pair.second, resultType); + result = mirModule->CurFuncCodeMemPool()->New(OP_add, resultType, pair.first, val); } else { // +-a, -5 -> a + -5 - ConstvalNode *val = mirModule->GetMIRBuilder()->CreateIntConst(-p.second, resultType); - result = mirModule->CurFuncCodeMemPool()->New(OP_sub, resultType, p.first, val); + ConstvalNode *val = mirModule->GetMIRBuilder()->CreateIntConst(-pair.second, resultType); + result = mirModule->CurFuncCodeMemPool()->New(OP_sub, resultType, pair.first, val); } } return result; @@ -800,9 +800,9 @@ ConstvalNode *ConstantFold::FoldConstBinary(Opcode opcode, PrimType resultType, return returnValue; } -ConstvalNode *ConstantFold::FoldIntConstUnary(Opcode opcode, PrimType resultType, const ConstvalNode *c) const { - CHECK_NULL_FATAL(c); - const MIRIntConst *cst = safe_cast(c->GetConstVal()); +ConstvalNode *ConstantFold::FoldIntConstUnary(Opcode opcode, PrimType resultType, const ConstvalNode *constNode) const { + CHECK_NULL_FATAL(constNode); + const MIRIntConst *cst = safe_cast(constNode->GetConstVal()); uint32 result32 = 0; uint64 result64 = 0; bool useResult64 = (GetPrimTypeSize(resultType) == kByteSizeOfBit64); @@ -880,11 +880,10 @@ ConstvalNode *ConstantFold::FoldIntConstUnary(Opcode opcode, PrimType resultType } template -ConstvalNode *ConstantFold::FoldFPConstUnary(Opcode opcode, PrimType resultType, ConstvalNode *c) const { - CHECK_NULL_FATAL(c); - ConstvalNode *resultConst = c; +ConstvalNode *ConstantFold::FoldFPConstUnary(Opcode opcode, PrimType resultType, ConstvalNode *constNode) const { + CHECK_NULL_FATAL(constNode); typename T::value_type constValue = 0.0; - T *fpCst = static_cast(c->GetConstVal()); + T *fpCst = static_cast(constNode->GetConstVal()); switch (opcode) { case OP_recip: case OP_neg: @@ -914,7 +913,7 @@ ConstvalNode *ConstantFold::FoldFPConstUnary(Opcode opcode, PrimType resultType, ASSERT(false, "Unknown opcode for FoldFPConstUnary"); break; } - resultConst = mirModule->CurFuncCodeMemPool()->New(); + auto *resultConst = mirModule->CurFuncCodeMemPool()->New(); resultConst->SetPrimType(resultType); if (resultType == PTY_f32) { resultConst->SetConstVal(GlobalTables::GetFpConstTable().GetOrCreateFloatConst(constValue)); @@ -924,14 +923,14 @@ ConstvalNode *ConstantFold::FoldFPConstUnary(Opcode opcode, PrimType resultType, return resultConst; } -ConstvalNode *ConstantFold::FoldConstUnary(Opcode opcode, PrimType resultType, ConstvalNode *c) const { +ConstvalNode *ConstantFold::FoldConstUnary(Opcode opcode, PrimType resultType, ConstvalNode *constNode) const { ConstvalNode *returnValue = nullptr; if (IsPrimitiveInteger(resultType) || IsPrimitiveDynInteger(resultType)) { - returnValue = FoldIntConstUnary(opcode, resultType, c); + returnValue = FoldIntConstUnary(opcode, resultType, constNode); } else if (resultType == PTY_f32) { - returnValue = FoldFPConstUnary(opcode, resultType, c); + returnValue = FoldFPConstUnary(opcode, resultType, constNode); } else if (resultType == PTY_f64) { - returnValue = FoldFPConstUnary(opcode, resultType, c); + returnValue = FoldFPConstUnary(opcode, resultType, constNode); } else if (PTY_f128 == resultType) { } else { ASSERT(false, "Unhandled case for FoldConstUnary"); @@ -973,8 +972,7 @@ std::pair ConstantFold::FoldGcmallocjarray(JarrayMallocNode *n BaseNode *result = node; std::pair p = DispatchFold(node->Opnd(0)); if (node->Opnd(0) != p.first) { - JarrayMallocNode *newRetNode; - newRetNode = node->CloneTree(mirModule->GetCurFuncCodeMPAllocator()); + JarrayMallocNode *newRetNode = node->CloneTree(mirModule->GetCurFuncCodeMPAllocator()); CHECK_FATAL(newRetNode != nullptr, "newRetNode is null in ConstantFold::FoldGcmallocjarray"); newRetNode->SetOpnd(PairToExpr(node->Opnd(0)->GetPrimType(), p), 0); result = newRetNode; @@ -1464,10 +1462,10 @@ std::pair ConstantFold::FoldBinary(BinaryNode *node) { return std::make_pair(result, sum); } -BaseNode *ConstantFold::SimplifyDoubleCompare(CompareNode *node) const { +BaseNode *ConstantFold::SimplifyDoubleCompare(CompareNode &compareNode) const { // For cases on gitlab issue 636. // See arm manual B.cond(P2993) and FCMP(P1091) - CHECK_NULL_FATAL(node); + CompareNode *node = &compareNode; BaseNode *result = node; BaseNode *l = node->Opnd(0); BaseNode *r = node->Opnd(1); @@ -1555,7 +1553,9 @@ std::pair ConstantFold::FoldCompare(CompareNode *node) { } else { result = node; } - result = SimplifyDoubleCompare(static_cast(result)); + auto *compareNode = static_cast(result); + CHECK_NULL_FATAL(compareNode); + result = SimplifyDoubleCompare(*compareNode); } return std::make_pair(result, 0); } diff --git a/src/mpl2mpl/src/muid_replacement.cpp b/src/mpl2mpl/src/muid_replacement.cpp index b9fc099e2e9119d17393bf88838d4a7ba5d6c0cb..49bdaacf73cff754d2faae98bad251f17d2350da 100644 --- a/src/mpl2mpl/src/muid_replacement.cpp +++ b/src/mpl2mpl/src/muid_replacement.cpp @@ -131,11 +131,13 @@ void MUIDReplacement::CollectFuncAndDataFromGlobalTab() { CHECK_FATAL(mirSymbol != nullptr, "Invalid global data symbol at index %u", i); if (mirSymbol->GetStorageClass() == kScGlobal) { if (mirSymbol->IsReflectionClassInfo()) { + mirSymbol->SetStorageClass(kScFstatic); if (mirSymbol->GetKonst() != nullptr) { // Use this to exclude forward-declared classinfo symbol AddDefData(mirSymbol); } } else if (mirSymbol->IsStatic()) { + mirSymbol->SetStorageClass(kScFstatic); AddDefData(mirSymbol); } } else if (mirSymbol->GetStorageClass() == kScExtern && @@ -996,7 +998,7 @@ void MUIDReplacement::ReplaceDirectInvokeOrAddroffunc(MIRFunction ¤tFunc, } } -void MUIDReplacement::ReplaceDassign(MIRFunction ¤tFunc, DassignNode &dassignNode) { +void MUIDReplacement::ReplaceDassign(MIRFunction ¤tFunc, const DassignNode &dassignNode) { MIRSymbol *mirSymbol = currentFunc.GetLocalOrGlobalSymbol(dassignNode.GetStIdx()); ASSERT(mirSymbol != nullptr, "null ptr check!"); if (!mirSymbol->IsStatic()) { @@ -1125,7 +1127,7 @@ BaseNode *MUIDReplacement::ReplaceDreadExpr(MIRFunction *currentFunc, StmtNode * return expr; } -BaseNode *MUIDReplacement::ReplaceDread(MIRFunction ¤tFunc, StmtNode *stmt, BaseNode *opnd) { +BaseNode *MUIDReplacement::ReplaceDread(MIRFunction ¤tFunc, const StmtNode *stmt, BaseNode *opnd) { if (opnd == nullptr || (opnd->GetOpCode() != OP_dread && opnd->GetOpCode() != OP_addrof)) { return opnd; }