diff --git a/build/build.sh b/build/build.sh index 38c22fe66bfb06cc902e29d7732bc580c4385587..5c72bf5df04b8928ff632047c84bc710e5a944e0 100644 --- a/build/build.sh +++ b/build/build.sh @@ -1,4 +1,4 @@ -#! /bin/bash +#!/bin/bash # # Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved. # diff --git a/src/bin/jbc2mpl b/src/bin/jbc2mpl index 149d26fd005fe5b32434f5e7c80a9ac2203337b2..f13448197f30bbe53b1a4f85c3e0fbdadae09984 100755 Binary files a/src/bin/jbc2mpl and b/src/bin/jbc2mpl differ diff --git a/src/bin/maple b/src/bin/maple index 271525d7734c3c5d2a7a729109740e199928f9ad..6cbaac7585ed053bb2ed0b949952f0bf77c522d8 100755 Binary files a/src/bin/maple and b/src/bin/maple differ diff --git a/src/deplibs/libmplphase.a b/src/deplibs/libmplphase.a index 5b221deccacc159835074b6aceb35262063a7186..4906adc29934edbfa11e0d237f4f49c9f1819b85 100644 Binary files a/src/deplibs/libmplphase.a and b/src/deplibs/libmplphase.a differ diff --git a/src/deplibs/libmplutil.a b/src/deplibs/libmplutil.a index 859285c74cf1ec3b363b973a26b24f203d42565f..f58af516af6afcfdcd5942f4ccf55d58f65217c0 100644 Binary files a/src/deplibs/libmplutil.a and b/src/deplibs/libmplutil.a differ diff --git a/src/maple_ir/include/global_tables.h b/src/maple_ir/include/global_tables.h index e6619dd38bc6132f1a8fe3e3df6b3edae4cfd7f5..250be9c70235ea93199e4ce7f6d8c8768c667265 100644 --- a/src/maple_ir/include/global_tables.h +++ b/src/maple_ir/include/global_tables.h @@ -88,10 +88,7 @@ class TypeTable { return typeTable.at(tyIdx)->GetPrimType(); } - void SetTypeWithTyIdx(TyIdx tyIdx, MIRType *type) { - CHECK_FATAL(tyIdx < typeTable.size(), "array index out of range"); - typeTable.at(tyIdx) = type; - } + void SetTypeWithTyIdx(TyIdx tyIdx, MIRType *type); TyIdx GetOrCreateMIRType(MIRType *pType); diff --git a/src/maple_ir/include/intrinsics.def b/src/maple_ir/include/intrinsics.def index 80e95079597c165a6b4173509cc6be615ba8f122..5bb44c353218a73019335e5bdd3aab30aafe7d8c 100644 --- a/src/maple_ir/include/intrinsics.def +++ b/src/maple_ir/include/intrinsics.def @@ -1,5 +1,5 @@ /* - * Copyright (c) [2019-2020] Huawei Technologies Co.,Ltd.All rights reserved. + * Copyright (c) [2019] Huawei Technologies Co.,Ltd.All rights reserved. * * OpenArkCompiler is licensed under the Mulan PSL v1. * You can use this software according to the terms and conditions of the Mulan PSL v1. @@ -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 | INTRNISSPECIAL, kArgTyVoid, kArgTyDynany, kArgTyUndef, kArgTyUndef, kArgTyUndef, kArgTyUndef, kArgTyUndef) + "__mpl_clinit_check", INTRNISJAVA | INTRNNOSIDEEFFECT, 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,\ @@ -53,8 +53,6 @@ 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,\ @@ -111,20 +109,19 @@ DEF_MIR_INTRINSIC(MCCWriteWeak,\ "MCC_WriteWeakField", INTRNISRC | INTRNNOSIDEEFFECT, kArgTyVoid, kArgTyRef, kArgTyRef, kArgTyRef) DEF_MIR_INTRINSIC(MPL_CLEANUP_LOCALREFVARS,\ - "__mpl_cleanup_localrefvars", INTRNISJAVA | INTRNNOSIDEEFFECT | INTRNISSPECIAL, kArgTyUndef, kArgTyRef, kArgTyRef, kArgTyRef, kArgTyRef, kArgTyRef, kArgTyRef) + "__mpl_cleanup_localrefvars", INTRNISJAVA | INTRNNOSIDEEFFECT, kArgTyUndef, kArgTyRef, kArgTyRef, kArgTyRef, kArgTyRef, kArgTyRef, kArgTyRef) DEF_MIR_INTRINSIC(MPL_CLEANUP_LOCALREFVARS_SKIP,\ - "__mpl_cleanup_localrefvars_skip", INTRNISJAVA | INTRNNOSIDEEFFECT | INTRNISSPECIAL, kArgTyUndef, kArgTyRef, kArgTyRef, kArgTyRef, kArgTyRef, kArgTyRef, kArgTyRef) + "__mpl_cleanup_localrefvars_skip", INTRNISJAVA | INTRNNOSIDEEFFECT, 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 | INTRNISSPECIAL, kArgTyUndef, kArgTyRef, kArgTyRef,\ + "__mpl_cleanup_noretescobjs", INTRNISJAVA | INTRNNOSIDEEFFECT, 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 780e4d4a9352482be30f9888109fe789c50c3a21..d9c3ae5ceac66b6ba3a5a28f74ae1d9f3b2ac1ff 100644 --- a/src/maple_ir/include/intrinsics.h +++ b/src/maple_ir/include/intrinsics.h @@ -1,5 +1,5 @@ /* - * Copyright (c) [2019-2020] Huawei Technologies Co.,Ltd.All rights reserved. + * Copyright (c) [2019] Huawei Technologies Co.,Ltd.All rights reserved. * * OpenArkCompiler is licensed under the Mulan PSL v1. * You can use this software according to the terms and conditions of the Mulan PSL v1. @@ -32,8 +32,7 @@ enum IntrinProperty { kIntrnIsPure, kIntrnNeverReturn, kIntrnIsAtomic, - kIntrnIsRC, - kIntrnIsSpecial + kIntrnIsRC }; enum IntrinArgType { @@ -86,7 +85,6 @@ 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 { @@ -138,10 +136,6 @@ struct IntrinDesc { return properties & INTRNISRC; } - bool IsSpecial() const { - return properties & INTRNISSPECIAL; - } - bool HasNoSideEffect() const { return properties & INTRNNOSIDEEFFECT; } diff --git a/src/maple_ir/include/mir_function.h b/src/maple_ir/include/mir_function.h index 0e2c130afd7764d781ed4d1f37fea6f3e80ad515..b3e20a8b528fc17447627abbd07ff79ac1655aa1 100644 --- a/src/maple_ir/include/mir_function.h +++ b/src/maple_ir/include/mir_function.h @@ -136,7 +136,7 @@ class MIRFunction { size_t GetParamSize() const { return funcType->GetParamTypeList().size(); } - const std::vector &GetParamTypes() const { + const MapleVector &GetParamTypes() const { return funcType->GetParamTypeList(); } TyIdx GetNthParamTyIdx(size_t i) const { diff --git a/src/maple_ir/include/mir_type.h b/src/maple_ir/include/mir_type.h index 1c83404ac34149020ffcc7200b99a0d4d8302b93..6ec9ac2fa43d8a6b8098623c078995c4f75be656 100644 --- a/src/maple_ir/include/mir_type.h +++ b/src/maple_ir/include/mir_type.h @@ -1345,15 +1345,28 @@ class MIRBitFieldType : public MIRType { class MIRFuncType : public MIRType { public: - MIRFuncType() : MIRType(kTypeFunction, PTY_ptr) {} + MIRFuncType(MapleAllocator &ma) + : MIRType(kTypeFunction, PTY_ptr), + paramTypeList(ma.Adapter()), + paramAttrsList(ma.Adapter()) {} - explicit MIRFuncType(GStrIdx strIdx) : MIRType(kTypeFunction, PTY_ptr, strIdx) {} + explicit MIRFuncType(GStrIdx strIdx, MapleAllocator &ma) + : MIRType(kTypeFunction, PTY_ptr, strIdx), + paramTypeList(ma.Adapter()), + paramAttrsList(ma.Adapter()) {} - MIRFuncType(TyIdx retTyIdx, const std::vector &vecTy, const std::vector &vecAt) + MIRFuncType(TyIdx retTyIdx, const std::vector &vecTy, const std::vector &vecAt, MapleAllocator &ma) : MIRType(kTypeFunction, PTY_ptr), retTyIdx(retTyIdx), - paramTypeList(vecTy), - paramAttrsList(vecAt) {} + paramTypeList(ma.Adapter()), + paramAttrsList(ma.Adapter()) { + for (auto tyIdx : vecTy) { + paramTypeList.push_back(tyIdx); + } + for (auto tyAttr : vecAt) { + paramAttrsList.push_back(tyAttr); + } + } ~MIRFuncType() override = default; @@ -1375,11 +1388,11 @@ class MIRFuncType : public MIRType { retTyIdx = idx; } - const std::vector &GetParamTypeList() const { + const MapleVector &GetParamTypeList() const { return paramTypeList; } - std::vector &GetParamTypeList() { + MapleVector &GetParamTypeList() { return paramTypeList; } @@ -1389,14 +1402,17 @@ class MIRFuncType : public MIRType { } void SetParamTypeList(const std::vector &list) { - paramTypeList = list; + paramTypeList.clear(); + for (auto tyIdx : list) { + paramTypeList.push_back(tyIdx); + } } - const std::vector &GetParamAttrsList() const { + const MapleVector &GetParamAttrsList() const { return paramAttrsList; } - std::vector &GetParamAttrsList() { + MapleVector &GetParamAttrsList() { return paramAttrsList; } @@ -1411,7 +1427,10 @@ class MIRFuncType : public MIRType { } void SetParamAttrsList(const std::vector &list) { - paramAttrsList = list; + paramAttrsList.clear(); + for (auto tyAttr : list) { + paramAttrsList.push_back(tyAttr); + } } void SetNthParamAttrs(size_t i, const TypeAttrs &attrs) { @@ -1437,8 +1456,8 @@ class MIRFuncType : public MIRType { private: TyIdx retTyIdx{ 0 }; - std::vector paramTypeList{}; - std::vector paramAttrsList{}; + MapleVector paramTypeList; + MapleVector paramAttrsList; bool isVarArgs = false; }; diff --git a/src/maple_ir/include/option.h b/src/maple_ir/include/option.h index cd3c1de0f56d527869d7bb9ab43bdcfaa2829675..102d7e4f438ca451e259b32a72ee2bf736124571 100644 --- a/src/maple_ir/include/option.h +++ b/src/maple_ir/include/option.h @@ -82,7 +82,6 @@ class Options { #if MIR_JAVA static bool skipVirtualMethod; #endif - static bool checkArrayStore; private: MapleAllocator optionAlloc; std::vector phaseSeq; diff --git a/src/maple_ir/include/simplifyintrinsics.def b/src/maple_ir/include/simplifyintrinsics.def deleted file mode 100644 index 30c04a7c4576da4d1562a9e3f4ff346b3b3ad804..0000000000000000000000000000000000000000 --- a/src/maple_ir/include/simplifyintrinsics.def +++ /dev/null @@ -1,31 +0,0 @@ -/* - * 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_ir/src/bin_mpl_import.cpp b/src/maple_ir/src/bin_mpl_import.cpp index f078d6159be74e7e94a58d2bd56f8ad81923bc6f..51c867ec1a4e91c12ea82de0500bfcf0bbf2c446 100644 --- a/src/maple_ir/src/bin_mpl_import.cpp +++ b/src/maple_ir/src/bin_mpl_import.cpp @@ -575,7 +575,7 @@ TyIdx BinaryMplImport::ImportType(bool forPointedType) { return origType->GetTypeIndex(); } case kBinKindTypeFunction: { - MIRFuncType type(strIdx); + MIRFuncType type(strIdx, mod.GetMPAllocator()); type.SetNameIsLocal(nameIsLocal); size_t idx = typTab.size(); typTab.push_back(nullptr); diff --git a/src/maple_ir/src/global_tables.cpp b/src/maple_ir/src/global_tables.cpp index e423470c3063443ea1f70e9489f1f32444c19649..ac9fda89ca4c86bcc2337516a382dc90a6e908e6 100644 --- a/src/maple_ir/src/global_tables.cpp +++ b/src/maple_ir/src/global_tables.cpp @@ -42,6 +42,16 @@ TypeTable::TypeTable() { } } +void TypeTable::SetTypeWithTyIdx(TyIdx tyIdx, MIRType *type) { + CHECK_FATAL(tyIdx < typeTable.size(), "array index out of range"); + MIRType *oldType = typeTable.at(tyIdx); + typeTable.at(tyIdx) = type; + if (oldType != nullptr && oldType != type) { + typeHashTable.erase(oldType); + delete oldType; + } +} + TypeTable::~TypeTable() { for (auto index = static_cast(PTY_void); index < typeTable.size(); ++index) { delete typeTable[index]; @@ -124,7 +134,7 @@ MIRType *TypeTable::GetOrCreateJarrayType(const MIRType &elem) { MIRType *TypeTable::GetOrCreateFunctionType(MIRModule &module, TyIdx retTyIdx, const std::vector &vecType, const std::vector &vecAttrs, bool isVarg, bool isSimpCreate) { - auto *funcType = module.GetMemPool()->New(retTyIdx, vecType, vecAttrs); + auto *funcType = module.GetMemPool()->New(retTyIdx, vecType, vecAttrs, module.GetMPAllocator()); funcType->SetVarArgs(isVarg); if (isSimpCreate) { return funcType; diff --git a/src/maple_ir/src/mir_builder.cpp b/src/maple_ir/src/mir_builder.cpp index cf09e91b895485ad3d435df196996225191139e0..f8e11d5a57397f0af38588b605d36996282eeecd 100644 --- a/src/maple_ir/src/mir_builder.cpp +++ b/src/maple_ir/src/mir_builder.cpp @@ -225,7 +225,7 @@ MIRFunction *MIRBuilder::GetOrCreateFunction(const std::string &str, TyIdx retTy auto *fn = mirModule->GetMemPool()->New(mirModule, funcSt->GetStIdx()); fn->Init(); fn->SetPuidx(GlobalTables::GetFunctionTable().GetFuncTable().size()); - auto *funcType = mirModule->GetMemPool()->New(); + auto *funcType = mirModule->GetMemPool()->New(mirModule->GetMPAllocator()); fn->SetMIRFuncType(funcType); fn->SetReturnTyIdx(retTyIdx); GlobalTables::GetFunctionTable().GetFuncTable().push_back(fn); @@ -296,7 +296,7 @@ MIRFunction *MIRBuilder::CreateFunction(StIdx stIdx, bool addToTable) const { GlobalTables::GetFunctionTable().GetFuncTable().push_back(fn); } - auto *funcType = mirModule->GetMemPool()->New(); + auto *funcType = mirModule->GetMemPool()->New(mirModule->GetMPAllocator()); fn->SetMIRFuncType(funcType); return fn; } diff --git a/src/maple_ir/src/mir_parser.cpp b/src/maple_ir/src/mir_parser.cpp index ce7dbf7470dd7286970cbdee6b11b7bcfe6a15e9..6ca8dd84f0f1b1729fd83115206fe5b98cce0ad5 100644 --- a/src/maple_ir/src/mir_parser.cpp +++ b/src/maple_ir/src/mir_parser.cpp @@ -700,7 +700,7 @@ PUIdx MIRParser::EnterUndeclaredFunction(bool isMcount) { fn->SetPuidx(GlobalTables::GetFunctionTable().GetFuncTable().size()); GlobalTables::GetFunctionTable().GetFuncTable().push_back(fn); funcSt->SetFunction(fn); - auto *funcType = mod.GetMemPool()->New(); + auto *funcType = mod.GetMemPool()->New(mod.GetMPAllocator()); fn->SetMIRFuncType(funcType); if (isMcount) { MIRType *retType = GlobalTables::GetTypeTable().GetTypeFromTyIdx(TyIdx(PTY_void)); diff --git a/src/maple_ir/src/option.cpp b/src/maple_ir/src/option.cpp index 813d18839e115e161e2b3669159de42f24352c0d..e6eeda9c9388eabf6825852c186d6b42aae663b1 100644 --- a/src/maple_ir/src/option.cpp +++ b/src/maple_ir/src/option.cpp @@ -55,7 +55,6 @@ bool Options::emitVtableImpl = false; #if MIR_JAVA bool Options::skipVirtualMethod = false; #endif -bool Options::checkArrayStore = false; enum OptionIndex { kUnknown, kHelp, @@ -90,7 +89,6 @@ enum OptionIndex { kMapleLinker, kMplnkDumpMuid, kEmitVtableImpl, - kCheckArrayStore, }; const Descriptor kUsage[] = { @@ -165,8 +163,6 @@ const Descriptor kUsage[] = { #if MIR_JAVA { kSkipVirtual, 0, "", "skipvirtual", kBuildTypeAll, kArgCheckPolicyNone, " --skipvirtual" }, #endif - { kCheckArrayStore, 0, "", "check-array-store", kBuildTypeAll, kArgCheckPolicyNone, - " --check-array-store Check array store[default off]" }, { 0, 0, nullptr, nullptr, kBuildTypeAll, kArgCheckPolicyNone, nullptr } }; @@ -282,9 +278,6 @@ bool Options::ParseOptions(int argc, char **argv, std::string &fileName) const { Options::skipVirtualMethod = true; break; #endif - case kCheckArrayStore: - Options::checkArrayStore = true; - break; default: result = false; ASSERT(false, "unhandled case in Options"); diff --git a/src/maple_me/include/dse.h b/src/maple_me/include/dse.h index 6ea25d2928bbb872a53bb55d48a728166583ff43..ed87b8bacbb1bb6e3bed1ef15a2ebb442ca65aff 100644 --- a/src/maple_me/include/dse.h +++ b/src/maple_me/include/dse.h @@ -63,7 +63,7 @@ class DSE { void MarkStmtUseLive(const StmtNode &stmt); void MarkSingleUseLive(const BaseNode &exprNode); - // step 4: proppagate live + // step 4: propagate live void PropagateLive() { while (!workList.empty()) { auto vst = workList.front(); diff --git a/src/maple_me/include/hdse.h b/src/maple_me/include/hdse.h index e24897a15a1ec73d25bdb6dbcbe668ed8df633f4..083d39571fb628399a4324dd8c7ff1ca55382e83 100644 --- a/src/maple_me/include/hdse.h +++ b/src/maple_me/include/hdse.h @@ -22,14 +22,14 @@ namespace maple { class MeIRMap; class HDSE { public: - HDSE(MIRModule &mod, const MapleVector &bbVec, BB &commonEntryBB, BB &commonExitBB, SSATab &stab, + HDSE(MIRModule &mod, const MapleVector &bbVec, BB &commonEntryBB, BB &commonExitBB, SSATab &ssaTab, Dominance &pDom, IRMap &map, bool enabledDebug = false) : hdseDebug(enabledDebug), mirModule(mod), bbVec(bbVec), commonEntryBB(commonEntryBB), commonExitBB(commonExitBB), - ssaTab(stab), + ssaTab(ssaTab), postDom(pDom), irMap(map), bbRequired(bbVec.size(), false) {} @@ -65,17 +65,17 @@ class HDSE { void MarkVarDefByStmt(VarMeExpr &varMeExpr); void MarkRegDefByStmt(RegMeExpr ®MeExpr); - bool IsExprNeeded(const MeExpr *meExpr) { - return exprLive.at(meExpr->GetExprID()); + bool IsExprNeeded(const MeExpr &meExpr) const { + return exprLive.at(meExpr.GetExprID()); } void SetExprNeeded(const MeExpr *meExpr) { exprLive.at(meExpr->GetExprID()) = true; } void PropagateLive() { - while (!worklist.empty()) { - MeExpr *meExpr = worklist.front(); - worklist.pop_front(); + while (!workList.empty()) { + MeExpr *meExpr = workList.front(); + workList.pop_front(); PropagateUseLive(*meExpr); } } @@ -98,7 +98,7 @@ class HDSE { IRMap &irMap; std::vector bbRequired; std::vector exprLive; - std::forward_list worklist; + std::forward_list workList; }; } // namespace maple #endif // MAPLE_ME_INCLUDE_HDSE_H diff --git a/src/maple_me/include/me_abco.h b/src/maple_me/include/me_abco.h index 28f54918389847f5df56b72ed7cd152ae76e46f8..4b81b91f043872828dc6125c2ff7ec9656ce5a1e 100644 --- a/src/maple_me/include/me_abco.h +++ b/src/maple_me/include/me_abco.h @@ -19,6 +19,7 @@ #include "me_ir.h" #include "me_inequality_graph.h" #include "me_cfg.h" + namespace maple { struct StmtComparator { bool operator()(const std::pair &lhs, const std::pair &rhs) const { @@ -29,6 +30,7 @@ struct StmtComparator { } } }; + class CarePoint { public: enum CareKind { @@ -81,6 +83,7 @@ class CarePoint { }; CareStmt value; }; + class DefPoint { public: enum DefineKind { @@ -191,6 +194,7 @@ class DefPoint { }; DefStmt value; }; + class MeABC { public: static bool kDebug; @@ -207,26 +211,6 @@ class MeABC { void executeABCO(); private: - MeFunction *meFunc; - Dominance *dom; - MeIRMap *irMap; - MemPool *memPool; - MapleAllocator allocator; - std::unique_ptr inequalityGraph; - std::unique_ptr prove; - MeStmt *forbidenPi; - std::map arrayChecks; - std::map arrayNewChecks; - std::set careMeStmts; - std::set careMePhis; - std::map> containsBB; - std::vector newDefPoints; - std::vector carePoints; - std::map newDef2Old; - std::map, MeExpr*, StmtComparator> modifiedStmt; - std::map> modifiedPhi; - std::set visitedBBs; - std::set targetMeStmt; bool CollectABC(); void RemoveExtraNodes(); void InsertPiNodes(); @@ -285,7 +269,29 @@ class MeABC { MeIRMap *GetIRMap() { return irMap; }; + + MeFunction *meFunc; + Dominance *dom; + MeIRMap *irMap; + MemPool *memPool; + MapleAllocator allocator; + std::unique_ptr inequalityGraph; + std::unique_ptr prove; + MeStmt *forbidenPi; + std::map arrayChecks; + std::map arrayNewChecks; + std::set careMeStmts; + std::set careMePhis; + std::map> containsBB; + std::vector newDefPoints; + std::vector carePoints; + std::map newDef2Old; + std::map, MeExpr*, StmtComparator> modifiedStmt; + std::map> modifiedPhi; + std::set visitedBBs; + std::set targetMeStmt; }; + class MeDoABCOpt : public MeFuncPhase { public: explicit MeDoABCOpt(MePhaseID id) : MeFuncPhase(id) {} diff --git a/src/maple_me/include/me_cond_based_rc.h b/src/maple_me/include/me_cond_based_rc.h index 0f640bc6e05959b387e02fb34273afc6d4f813cd..ea4bf853c0ee119e99259f2cd9fcbb05a953abda 100644 --- a/src/maple_me/include/me_cond_based_rc.h +++ b/src/maple_me/include/me_cond_based_rc.h @@ -23,6 +23,7 @@ class CondBasedRC : public MeCondBased { virtual ~CondBasedRC() = default; }; + class MeDoCondBasedRC : public MeFuncPhase { public: explicit MeDoCondBasedRC(MePhaseID id) : MeFuncPhase(id) {} diff --git a/src/maple_me/include/me_function.h b/src/maple_me/include/me_function.h index c3077c3dc3e1d76ffa27b7b72f3cec982c22679b..e1597c33f746f511a6535bedb373ee604111b509 100644 --- a/src/maple_me/include/me_function.h +++ b/src/maple_me/include/me_function.h @@ -293,7 +293,7 @@ class MeFunction : public FuncEmit { } BB *NewBasicBlock(); - BB *InsertNewBasicBlock(const BB &position); + BB &InsertNewBasicBlock(const BB &position); void DeleteBasicBlock(const BB &bb); BB *NextBB(const BB *bb); BB *PrevBB(const BB *bb); diff --git a/src/maple_me/include/me_hdse.h b/src/maple_me/include/me_hdse.h index 4d3baa2045aec1867a8301d290295bcdd9154eae..2552246cb2a952c63e113f94478abaad3f07632f 100644 --- a/src/maple_me/include/me_hdse.h +++ b/src/maple_me/include/me_hdse.h @@ -24,9 +24,9 @@ namespace maple { class MeHDSE : public HDSE { public: - MeHDSE(MeFunction &f, Dominance &pdom, IRMap &map, bool enabledDebug) + MeHDSE(MeFunction &f, Dominance &pDom, IRMap &map, bool enabledDebug) : HDSE(f.GetMIRModule(), f.GetAllBBs(), *f.GetCommonEntryBB(), *f.GetCommonExitBB(), *f.GetMeSSATab(), - pdom, map, enabledDebug) {} + pDom, map, enabledDebug) {} virtual ~MeHDSE() = default; void RunHDSE(); diff --git a/src/maple_me/include/me_inequality_graph.h b/src/maple_me/include/me_inequality_graph.h index f76b97b7dc62f9a5e999220599e5dcbed3db0a50..8ca41d3177d28666fc7ada86ccff40322048f504 100644 --- a/src/maple_me/include/me_inequality_graph.h +++ b/src/maple_me/include/me_inequality_graph.h @@ -241,13 +241,13 @@ class ESSABaseNode { class ESSAVarNode : public ESSABaseNode { public: - explicit ESSAVarNode(int i, MeExpr &e) : ESSABaseNode(i, &e, kVarNode) {} + ESSAVarNode(int i, MeExpr &e) : ESSABaseNode(i, &e, kVarNode) {} ~ESSAVarNode() = default; }; class ESSAConstNode : public ESSABaseNode { public: - explicit ESSAConstNode(int i, int v) : ESSABaseNode(i, nullptr, kConstNode), value(v) {} + ESSAConstNode(int i, int v) : ESSABaseNode(i, nullptr, kConstNode), value(v) {} ~ESSAConstNode() = default; int GetValue() const { @@ -264,13 +264,13 @@ class ESSAConstNode : public ESSABaseNode { class ESSAArrayNode : public ESSABaseNode { public: - explicit ESSAArrayNode(int i, MeExpr &e) : ESSABaseNode(i, &e, kArrayNode) {} + ESSAArrayNode(int i, MeExpr &e) : ESSABaseNode(i, &e, kArrayNode) {} ~ESSAArrayNode() = default; }; class ESSAPhiNode : public ESSABaseNode { public: - explicit ESSAPhiNode(int i, MeExpr &e) : ESSABaseNode(i, &e, kPhiNode) {} + ESSAPhiNode(int i, MeExpr &e) : ESSABaseNode(i, &e, kPhiNode) {} ~ESSAPhiNode() = default; const std::vector &GetPhiOpnds() const { diff --git a/src/maple_me/include/me_loop_analysis.h b/src/maple_me/include/me_loop_analysis.h index 0c5fa6f8a7d3166c73da69f88eb463d3d78e520b..2bf8f52a9df72d3521d5ea94acb22485c1210f17 100644 --- a/src/maple_me/include/me_loop_analysis.h +++ b/src/maple_me/include/me_loop_analysis.h @@ -58,7 +58,7 @@ class IdentifyLoops : public AnalysisResult { } LoopDesc *CreateLoopDesc(BB *hd, BB *tail); - void SetLoopParent4BB(const BB *bb, LoopDesc *aloop); + void SetLoopParent4BB(const BB *bb, LoopDesc *loopDesc); void ProcessBB(BB *bb); void MarkBB(); void Dump(); diff --git a/src/maple_me/include/me_prop.h b/src/maple_me/include/me_prop.h index 161fdc1f621fca0cfb283c8acf2f6a55c7426e6c..ff381119fc186ff56ae84fda1bdfd11fc3e548f8 100644 --- a/src/maple_me/include/me_prop.h +++ b/src/maple_me/include/me_prop.h @@ -22,10 +22,10 @@ namespace maple { class MeProp : public Prop { public: - MeProp(MeIRMap &hmap, Dominance &dom, MemPool &memPool, const PropConfig &config) - : Prop(hmap, dom, memPool, std::vector(hmap.GetFunc().GetAllBBs().begin(), - hmap.GetFunc().GetAllBBs().end()), - *hmap.GetFunc().GetCommonEntryBB(), config) {} + 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) {} virtual ~MeProp() = default; }; diff --git a/src/maple_me/include/me_rc_lowering.h b/src/maple_me/include/me_rc_lowering.h index 58d996fa5e8b666de0f096b5d9e09c0a411f9631..6a58eae885f524576b3912362bc4a1939c1119d1 100644 --- a/src/maple_me/include/me_rc_lowering.h +++ b/src/maple_me/include/me_rc_lowering.h @@ -89,8 +89,6 @@ class RCLowering { void HandleReturnStmt(); void HandleAssignMeStmt(MeStmt &stmt, MeExpr *pendingDec); MIRIntrinsicID SelectWriteBarrier(const MeStmt &stmt); - MIRType *GetArrayNodeType(VarMeExpr &var); - void CheckArrayStore(IntrinsiccallMeStmt &writeRefCall); MeFunction &func; MIRModule &mirModule; IRMap &irMap; diff --git a/src/maple_me/include/me_rename2preg.h b/src/maple_me/include/me_rename2preg.h index a72782e9aa2fcf962d15f2e16f8b750c5a58a667..999f8569177a3f665bc2af22e84eedd9ec80dc17 100644 --- a/src/maple_me/include/me_rename2preg.h +++ b/src/maple_me/include/me_rename2preg.h @@ -18,16 +18,13 @@ #include "me_function.h" namespace maple { - class MeDoSSARename2Preg : public MeFuncPhase { public: - MeDoSSARename2Preg(MePhaseID id) : MeFuncPhase(id) {} + explicit MeDoSSARename2Preg(MePhaseID id) : MeFuncPhase(id) {} virtual ~MeDoSSARename2Preg() = default; - AnalysisResult *Run(MeFunction *func, MeFuncResultMgr *funcRst, ModuleResultMgr *) override; + AnalysisResult *Run(MeFunction *func, MeFuncResultMgr *funcRst, ModuleResultMgr*) override; std::string PhaseName() const override; }; - } // namespace maple - #endif // MAPLE_ME_INCLUDE_MERENAME2PREG_H diff --git a/src/maple_me/include/me_ssu_pre.h b/src/maple_me/include/me_ssu_pre.h index 10c5e8920497cf785ac383f5d65d0f4e2598aa96..a9bff37707b159394cf1c76879f41e3d157c41c7 100644 --- a/src/maple_me/include/me_ssu_pre.h +++ b/src/maple_me/include/me_ssu_pre.h @@ -17,6 +17,7 @@ #include "me_function.h" #include "me_irmap.h" #include "me_dominance.h" + namespace maple { enum SOccType { kSOccUndef, @@ -27,6 +28,7 @@ enum SOccType { kSOccUse, kSOccPhi }; + class SOcc { public: SOcc(SOccType ty, BB *bb) : occTy(ty), classId(0), mirBB(bb), use(nullptr) {} @@ -81,6 +83,7 @@ class SOcc { BB *mirBB; // the BB it occurs in SOcc *use; // points to its single use }; + class SRealOcc : public SOcc { public: SRealOcc() @@ -129,7 +132,9 @@ class SRealOcc : public SOcc { bool realFromDef; // used only by placementRC bool redundant; }; + class SLambdaOcc; + class SLambdaResOcc : public SOcc { public: SLambdaResOcc(BB *bb) : SOcc(kSOccLambdaRes, bb), useLambdaOcc(nullptr), hasRealUse(false), insertHere(false) {} @@ -167,6 +172,7 @@ class SLambdaResOcc : public SOcc { bool hasRealUse; bool insertHere; }; + class SLambdaOcc : public SOcc { public: SLambdaOcc(BB *bb, MapleAllocator *alloc) @@ -221,6 +227,7 @@ class SLambdaOcc : public SOcc { bool isEarlier; MapleVector lambdaRes; }; + class SEntryOcc : public SOcc { public: explicit SEntryOcc(BB *bb) : SOcc(kSOccEntry, bb) {} @@ -230,6 +237,7 @@ class SEntryOcc : public SOcc { LogInfo::MapleLogger() << "EntryOcc at bb" << GetBB()->GetBBId(); } }; + class SUseOcc : public SOcc { public: explicit SUseOcc(BB *bb) : SOcc(kSOccUse, bb) {} @@ -239,6 +247,7 @@ class SUseOcc : public SOcc { 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) {}; @@ -268,6 +277,7 @@ class SPhiOcc : public SOcc { MeVarPhiNode *phi; // the phinode of this real occurrence; VarMeExpr *vMeExpr; // the varmeexpr of this real occurrence }; + class SpreWorkCand { public: SpreWorkCand(MapleAllocator *alloc, const OriginalSt *ost) @@ -324,6 +334,7 @@ class SpreWorkCand { bool hasStoreOcc; // true if there is any store occurrence bool hasCriticalEdge; // determined by Finalize step }; + class MeSSUPre { public: enum PreKind { diff --git a/src/maple_me/include/me_stmt_pre.h b/src/maple_me/include/me_stmt_pre.h index 41b568136e0ce3875dc610603ca9693bbb51d06b..04fec9015c90eaf14b323a8bb28ec661068e6f1b 100644 --- a/src/maple_me/include/me_stmt_pre.h +++ b/src/maple_me/include/me_stmt_pre.h @@ -54,7 +54,7 @@ class MeStmtPre : public SSAEPre { void Finalize1() override; void Finalize2() override {}; // fully available (replaces downsafety, canbeavail and later under SSAFRE) - void ResetFullyAvail(MePhiOcc *occg); + void ResetFullyAvail(MePhiOcc *occ); void ComputeFullyAvail(); // rename phase bool AllVarsSameVersion(MeRealOcc *realOcc1, MeRealOcc *realOcc2) override; @@ -68,7 +68,7 @@ class MeStmtPre : public SSAEPre { // phi insertion phase void ComputeVarAndDfPhis() override; void CreateSortedOccs() override; - void ConstructUseOccurMapExpr(uint32 bbDfn, MeExpr *x); + void ConstructUseOccurMapExpr(uint32 bbDfn, MeExpr *meExpr); void ConstructUseOccurMap() override; // build useOccurMap for dassign candidates PreStmtWorkCand *CreateStmtRealOcc(MeStmt &meStmt, int seqStmt); void VersionStackChiListUpdate(const MapleMap &chiList); diff --git a/src/maple_me/include/me_store_pre.h b/src/maple_me/include/me_store_pre.h index 29f67663932cab738647d8a1fe71248ff2c687d8..78e2f2bac9aec94e339cd63c01a6456a24c11fef 100644 --- a/src/maple_me/include/me_store_pre.h +++ b/src/maple_me/include/me_store_pre.h @@ -26,6 +26,9 @@ class MeStorePre : public MeSSUPre { virtual ~MeStorePre() = default; private: + inline bool IsJavaLang() { + return mirModule->IsJavaModule(); + } AliasClass *aliasClass; // step 6 code motion RegMeExpr *curTemp; // the preg for the RHS of inserted stores @@ -38,7 +41,7 @@ class MeStorePre : public MeSSUPre { void CreateRealOcc(OStIdx ostIdx, MeStmt *meStmt); void CreateUseOcc(OStIdx ostIdx, BB *bb); void CreateSpreUseOccsThruAliasing(const OriginalSt *muOst, BB *bb); - void FindAndCreateSpreUseOccs(MeExpr *x, BB *bb); + void FindAndCreateSpreUseOccs(MeExpr *meExpr, BB *bb); void CreateSpreUseOccsForAll(BB *bb); void BuildWorkListBB(BB *bb); void PerCandInit() { diff --git a/src/maple_me/include/occur.h b/src/maple_me/include/occur.h index 8cabbe83a85fea49654060cbb654dde25410d52c..ccfb644be1cd2a09fc9ed1f26a6d9b9fd42ff427 100644 --- a/src/maple_me/include/occur.h +++ b/src/maple_me/include/occur.h @@ -260,8 +260,8 @@ class MeInsertedOcc : public MeOccur { class MePhiOpndOcc : public MeOccur { public: - MePhiOpndOcc(BB *dbb) - : MeOccur(kOccPhiopnd, 0, dbb, nullptr), + MePhiOpndOcc(BB *bb) + : MeOccur(kOccPhiopnd, 0, bb, nullptr), isProcessed(false), hasRealUse(false), isInsertedOcc(false), diff --git a/src/maple_me/include/prop.h b/src/maple_me/include/prop.h index ce798b8909444d9d6bbfe1d39e873b8fb5a807ee..9fa41df0f5d46ea919e298337ef821095865795b 100644 --- a/src/maple_me/include/prop.h +++ b/src/maple_me/include/prop.h @@ -60,7 +60,7 @@ class Prop { bool IsVersionConsistent(const std::vector &vstVec, const std::vector> &vstLiveStack) const; bool IvarIsFinalField(const IvarMeExpr &ivarMeExpr) const; - bool Propagatable(const MeExpr &expr, const BB &frombb, bool atParm) 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); diff --git a/src/maple_me/include/ssa_pre.h b/src/maple_me/include/ssa_pre.h index 878053f51d539c68fd18b4ccfd4176e0793487a8..b9c19bfabc1ee67552ac7e8584808d1a02840c11 100644 --- a/src/maple_me/include/ssa_pre.h +++ b/src/maple_me/include/ssa_pre.h @@ -175,14 +175,14 @@ class SSAPre { virtual void CodeMotion(); // step 5 Finalize methods virtual void Finalize1(); - void SetSave(MeOccur *defx); - void SetReplacement(MePhiOcc *occg, MeOccur *repDef); + void SetSave(MeOccur *defX); + void SetReplacement(MePhiOcc *occ, MeOccur *repDef); virtual void Finalize2(); // step 4 willbevail methods void ComputeCanBeAvail(); - void ResetCanBeAvail(MePhiOcc *occg); + void ResetCanBeAvail(MePhiOcc *occ); void ComputeLater(); - void ResetLater(MePhiOcc *occg); + void ResetLater(MePhiOcc *occ); // step 3 downsafety methods void ResetDS(MePhiOpndOcc *phiOpnd); void ComputeDS(); @@ -220,7 +220,7 @@ class SSAPre { exitOccs.push_back(exitOcc); } - bool CheckIfAnyLocalOpnd(MeExpr *x); + bool CheckIfAnyLocalOpnd(MeExpr *meExpr); MeRealOcc *CreateRealOcc(MeStmt &meStmt, int32 seqStmt, MeExpr &meExpr, bool isRebuilt, bool isLHS = false); virtual bool ScreenPhiBB(BBId bbId) const = 0; virtual bool EpreLocalRefVar() { diff --git a/src/maple_me/src/dse.cpp b/src/maple_me/src/dse.cpp index 342694e35819a19388b201b28aab2b835c72a1db..59d5dc714d912663d011d5ef4b3ef577600467fd 100644 --- a/src/maple_me/src/dse.cpp +++ b/src/maple_me/src/dse.cpp @@ -58,8 +58,8 @@ bool DSE::ExprNonDeletable(const BaseNode &expr) { // may throw exception return true; case OP_intrinsicop: { - auto &innode = static_cast(expr); - const IntrinDesc &intrinDesc = innode.GetIntrinDesc(); + auto &node = static_cast(expr); + const IntrinDesc &intrinDesc = node.GetIntrinDesc(); return (!intrinDesc.HasNoSideEffect()); } default: { @@ -137,9 +137,9 @@ void DSE::CheckRemoveCallAssignedReturn(StmtNode &stmt) { continue; } DumpStmt(stmt, "**** DSE1 deleting return value assignment in: "); - CallReturnVector *nrets = stmt.GetCallReturnVector(); - CHECK_FATAL(nrets != nullptr, "null ptr check "); - nrets->clear(); + CallReturnVector *rets = stmt.GetCallReturnVector(); + CHECK_FATAL(rets != nullptr, "null ptr check "); + rets->clear(); mustDefs.clear(); break; } @@ -152,9 +152,8 @@ void DSE::OnRemoveBranchStmt(BB &bb, const StmtNode &stmt) { // update BB pred/succ bb.SetKind(kBBFallthru); cfgUpdated = true; // tag cfg is changed - LabelIdx labelIdx = (stmt.GetOpCode() == OP_goto) - ? static_cast(stmt).GetOffset() - : static_cast(stmt).GetOffset(); + LabelIdx labelIdx = (stmt.GetOpCode() == OP_goto) ? static_cast(stmt).GetOffset() + : static_cast(stmt).GetOffset(); for (size_t i = 0; i < bb.GetSucc().size(); ++i) { if (bb.GetSucc(i)->GetBBLabel() == labelIdx) { BB *succBB = bb.GetSucc(i); @@ -196,15 +195,15 @@ void DSE::PropagateUseLive(const VersionSt &vst) { ASSERT(phi->GetResult() == &vst, "MarkVst: wrong corresponding version st in phi"); MarkControlDependenceLive(ToRef(dfBB)); for (size_t i = 0; i < phi->GetPhiOpnds().size(); ++i) { - const VersionSt *vsym = phi->GetPhiOpnds()[i]; - AddToWorkList(vsym); + const VersionSt *verSt = phi->GetPhiOpnds()[i]; + AddToWorkList(verSt); } } else if (vst.GetDefType() == VersionSt::kMayDef) { - const MayDefNode *mdef = vst.GetMayDef(); - ASSERT(mdef->GetResult() == &vst, "MarkVst: wrong corresponding version st in maydef"); - const VersionSt *vsym = mdef->GetOpnd(); - MarkStmtRequired(ToRef(mdef->GetStmt()), ToRef(dfBB)); - AddToWorkList(vsym); + const MayDefNode *mayDef = vst.GetMayDef(); + ASSERT(mayDef->GetResult() == &vst, "MarkVst: wrong corresponding version st in maydef"); + const VersionSt *verSt = mayDef->GetOpnd(); + MarkStmtRequired(ToRef(mayDef->GetStmt()), ToRef(dfBB)); + AddToWorkList(verSt); } else { const MustDefNode *mustdef = vst.GetMustDef(); ASSERT(mustdef->GetResult() == &vst, "MarkVst: wrong corresponding version st in mustdef"); @@ -269,23 +268,23 @@ void DSE::MarkSingleUseLive(const BaseNode &mirNode) { switch (op) { case OP_dread: { auto &addrofSSANode = static_cast(mirNode); - const VersionSt *vsym = addrofSSANode.GetSSAVar(); - AddToWorkList(vsym); + const VersionSt *verSt = addrofSSANode.GetSSAVar(); + AddToWorkList(verSt); break; } case OP_regread: { auto ®readSSANode = static_cast(mirNode); - const VersionSt *vsym = regreadSSANode.GetSSAVar(); - AddToWorkList(vsym); + const VersionSt *verSt = regreadSSANode.GetSSAVar(); + AddToWorkList(verSt); break; } case OP_iread: { auto &ireadSSANode = static_cast(mirNode); - const VersionSt *vsym = ireadSSANode.GetSSAVar(); - CHECK_FATAL(vsym != nullptr, "DSE::MarkSingleUseLive: iread has no mayUse opnd"); - AddToWorkList(vsym); - if (!vsym->IsInitVersion()) { - auto *mayDefList = SSAGenericGetMayDefsFromVersionSt(ToRef(vsym), ssaTab.GetStmtsSSAPart()); + const VersionSt *verSt = ireadSSANode.GetSSAVar(); + CHECK_FATAL(verSt != nullptr, "DSE::MarkSingleUseLive: iread has no mayUse opnd"); + AddToWorkList(verSt); + if (!verSt->IsInitVersion()) { + auto *mayDefList = SSAGenericGetMayDefsFromVersionSt(ToRef(verSt), ssaTab.GetStmtsSSAPart()); if (mayDefList != nullptr) { for (auto it = mayDefList->begin(); it != mayDefList->end(); ++it) { AddToWorkList(it->second.GetResult()); diff --git a/src/maple_me/src/hdse.cpp b/src/maple_me/src/hdse.cpp index 27736486c0d91fdd26cf0536c353da11dd1af082..7df4fa3b96782c6d8fc2b95dde3fe311dc2771f6 100644 --- a/src/maple_me/src/hdse.cpp +++ b/src/maple_me/src/hdse.cpp @@ -47,8 +47,8 @@ void HDSE::RemoveNotRequiredStmtsInBB(BB &bb) { if (meStmt.GetOp() != OP_dassign && (meStmt.IsCondBr() || meStmt.GetOp() == OP_switch)) { // update CFG while (bb.GetSucc().size() != 1) { - BB *succbb = bb.GetSucc().back(); - succbb->RemoveBBFromPred(&bb); + BB *succ = bb.GetSucc().back(); + succ->RemoveBBFromPred(&bb); bb.GetSucc().pop_back(); } bb.SetKind(kBBFallthru); @@ -60,7 +60,7 @@ void HDSE::RemoveNotRequiredStmtsInBB(BB &bb) { void HDSE::MarkMuListRequired(MapleMap &muList) { for (auto &pair : muList) { - worklist.push_front(pair.second); + workList.push_front(pair.second); } } @@ -69,7 +69,7 @@ void HDSE::MarkChiNodeRequired(ChiMeNode &chiNode) { return; } chiNode.SetIsLive(true); - worklist.push_front(chiNode.GetRHS()); + workList.push_front(chiNode.GetRHS()); MeStmt *meStmt = chiNode.GetBase(); MarkStmtRequired(*meStmt); } @@ -301,7 +301,7 @@ void HDSE::MarkControlDependenceLive(BB &bb) { } void HDSE::MarkSingleUseLive(MeExpr &meExpr) { - if (IsExprNeeded(&meExpr)) { + if (IsExprNeeded(meExpr)) { return; } SetExprNeeded(&meExpr); @@ -309,7 +309,7 @@ void HDSE::MarkSingleUseLive(MeExpr &meExpr) { switch (meOp) { case kMeOpVar: case kMeOpReg: { - worklist.push_front(&meExpr); + workList.push_front(&meExpr); break; } case kMeOpIvar: { diff --git a/src/maple_me/src/me_abco.cpp b/src/maple_me/src/me_abco.cpp index c249437d0e4b9d0fd995c43a487d1adbd26ce10e..4bc60a130f0f269c784cfa566b3b668b5f5b7587 100644 --- a/src/maple_me/src/me_abco.cpp +++ b/src/maple_me/src/me_abco.cpp @@ -84,7 +84,7 @@ VarMeExpr *MeABC::CreateNewPiExpr(MeExpr &opnd) { OriginalSt *ost = ssaTab.GetOriginalStFromID(static_cast(&opnd)->GetOStIdx()); CHECK_FATAL(ost != nullptr && !ost->IsVolatile(), "must be"); VarMeExpr *var = irMap->NewInPool(irMap->GetExprID(), ost->GetIndex(), - irMap->GetVerst2MeExprTable().size()); + irMap->GetVerst2MeExprTable().size()); irMap->SetExprID(irMap->GetExprID() + 1); irMap->PushBackVerst2MeExprTable(var); ost->PushbackVersionIndex(var->GetVstIdx()); @@ -256,30 +256,30 @@ void MeABC::InsertPhiNodes() { void MeABC::RenameStartPiBr(DefPoint &newDefPoint) { const OStIdx &ostIdx = newDefPoint.GetOStIdx(); BB *newDefBB = newDefPoint.GetBB(); - if (ExistedPhiNode(*(newDefPoint.GetBB()), *(newDefPoint.GetRHS()))) { - MeVarPhiNode* phi = newDefBB->GetMevarPhiList()[ostIdx]; - BB *genByBB = newDefPoint.GetGeneratedByBB(); - size_t index = 0; - while (index < newDefBB->GetPred().size()) { - if (newDefBB->GetPred(index) == genByBB) { - break; - } - ++index; + if (!ExistedPhiNode(*(newDefPoint.GetBB()), *(newDefPoint.GetRHS()))) { + RenameStartPhi(newDefPoint); + return; + } + MeVarPhiNode* phi = newDefBB->GetMevarPhiList()[ostIdx]; + BB *genByBB = newDefPoint.GetGeneratedByBB(); + size_t index = 0; + while (index < newDefBB->GetPred().size()) { + if (newDefBB->GetPred(index) == genByBB) { + break; } - CHECK_FATAL(index < newDefBB->GetPred().size(), "must be"); - VarMeExpr *oldVar = phi->GetOpnd(index); - phi->SetOpnd(index, newDefPoint.GetLHS()); - if (!phi->IsPiAdded()) { - if (modifiedPhi.find(phi) == modifiedPhi.end()) { - modifiedPhi[phi] = std::vector(phi->GetOpnds().size(), nullptr); - } - if (modifiedPhi[phi][index] == nullptr) { - modifiedPhi[phi][index] = oldVar; - } + ++index; + } + CHECK_FATAL(index < newDefBB->GetPred().size(), "must be"); + VarMeExpr *oldVar = phi->GetOpnd(index); + phi->SetOpnd(index, newDefPoint.GetLHS()); + if (!phi->IsPiAdded()) { + if (modifiedPhi.find(phi) == modifiedPhi.end()) { + modifiedPhi[phi] = std::vector(phi->GetOpnds().size(), nullptr); + } + if (modifiedPhi[phi][index] == nullptr) { + modifiedPhi[phi][index] = oldVar; } - return; } - RenameStartPhi(newDefPoint); } void MeABC::RenameStartPiArray(DefPoint &newDefPoint) { @@ -483,20 +483,17 @@ bool MeABC::ReplaceMeExprStmtOpnd(uint32 opndID, MeStmt &meStmt, MeExpr &oldVar, } bool MeABC::ReplaceStmtWithNewVar(MeStmt &meStmt, MeExpr &oldVar, MeExpr &newVar, bool update) { - bool isReplaced = false; switch (meStmt.GetOp()) { case OP_dassign: case OP_maydassign: case OP_brtrue: case OP_brfalse: { - isReplaced = ReplaceMeExprStmtOpnd(0, meStmt, oldVar, newVar, update); - break; + return ReplaceMeExprStmtOpnd(0, meStmt, oldVar, newVar, update); } case OP_iassign: { bool baseIsReplaced = ReplaceMeExprStmtOpnd(0, meStmt, oldVar, newVar, update); bool rhsReplaced = ReplaceMeExprStmtOpnd(1, meStmt, oldVar, newVar, update); - isReplaced = baseIsReplaced || rhsReplaced; - break; + return baseIsReplaced || rhsReplaced; } case OP_regassign: { CHECK_FATAL(false, "should not happen"); @@ -505,7 +502,7 @@ bool MeABC::ReplaceStmtWithNewVar(MeStmt &meStmt, MeExpr &oldVar, MeExpr &newVar break; } } - return isReplaced; + return false; } bool MeABC::ReplaceStmt(MeStmt &meStmt, VarMeExpr &newVar, VarMeExpr &oldVar) { @@ -527,10 +524,7 @@ bool MeABC::ReplaceStmt(MeStmt &meStmt, VarMeExpr &newVar, VarMeExpr &oldVar) { return true; } lhs = meStmt.GetLHS(); - if (lhs != nullptr && lhs->GetMeOp() == kMeOpVar && static_cast(lhs)->GetOStIdx() == ostIdx) { - return true; - } - return false; + return (lhs != nullptr && lhs->GetMeOp() == kMeOpVar && static_cast(lhs)->GetOStIdx() == ostIdx); } void MeABC::Rename() { @@ -908,7 +902,6 @@ bool MeABC::BuildAssignInGraph(MeStmt &meStmt) { return true; }else { // support this pattern later - // CHECK_FATAL(false, "consider this pattern"); return false; } } else if (opnd1->GetMeOp() == kMeOpVar && opnd2->GetMeOp() == kMeOpVar) { @@ -916,26 +909,25 @@ bool MeABC::BuildAssignInGraph(MeStmt &meStmt) { std::set visitedPhi; ConstMeExpr dummyExpr(kInvalidExprID, nullptr); opnd2 = TryToResolveVar(*opnd2, visitedPhi, dummyExpr, true); - if (opnd2 != nullptr && opnd2 != &dummyExpr) { - CHECK_FATAL(opnd2->GetMeOp() == kMeOpConst, "must be"); - ESSABaseNode *rhsNode = GetOrCreateRHSNode(*opnd1); - AddUseDef(*opnd1); - InequalEdge *pairEdge1 = inequalityGraph->AddEdge(*rhsNode, *lhsNode, - -static_cast(opnd2)->GetIntValue(), EdgeType::kUpper); - InequalEdge *pairEdge2 = inequalityGraph->AddEdge(*lhsNode, *rhsNode, - static_cast(opnd2)->GetIntValue(), EdgeType::kUpper); - pairEdge1->SetPairEdge(*pairEdge2); - pairEdge2->SetPairEdge(*pairEdge1); - pairEdge1 = inequalityGraph->AddEdge(*lhsNode, *rhsNode, - static_cast(opnd2)->GetIntValue(), EdgeType::kLower); - pairEdge2 = inequalityGraph->AddEdge(*rhsNode, *lhsNode, - -static_cast(opnd2)->GetIntValue(), EdgeType::kLower); - pairEdge1->SetPairEdge(*pairEdge2); - pairEdge2->SetPairEdge(*pairEdge1); - return true; - } else { + if (opnd2 == nullptr || opnd2 == &dummyExpr) { return false; } + CHECK_FATAL(opnd2->GetMeOp() == kMeOpConst, "must be"); + ESSABaseNode *rhsNode = GetOrCreateRHSNode(*opnd1); + AddUseDef(*opnd1); + InequalEdge *pairEdge1 = inequalityGraph->AddEdge(*rhsNode, *lhsNode, + -static_cast(opnd2)->GetIntValue(), EdgeType::kUpper); + InequalEdge *pairEdge2 = inequalityGraph->AddEdge(*lhsNode, *rhsNode, + static_cast(opnd2)->GetIntValue(), EdgeType::kUpper); + pairEdge1->SetPairEdge(*pairEdge2); + pairEdge2->SetPairEdge(*pairEdge1); + pairEdge1 = inequalityGraph->AddEdge(*lhsNode, *rhsNode, + static_cast(opnd2)->GetIntValue(), EdgeType::kLower); + pairEdge2 = inequalityGraph->AddEdge(*rhsNode, *lhsNode, + -static_cast(opnd2)->GetIntValue(), EdgeType::kLower); + pairEdge1->SetPairEdge(*pairEdge2); + pairEdge2->SetPairEdge(*pairEdge1); + return true; } else { // support this pattern later return false; @@ -950,46 +942,45 @@ bool MeABC::BuildAssignInGraph(MeStmt &meStmt) { return false; } ESSAVarNode *lhsNode = inequalityGraph->GetOrCreateVarNode(*lhs); - if (opnd1->GetMeOp() == kMeOpConst || opnd2->GetMeOp() == kMeOpConst) { - if (opnd1->GetMeOp() == kMeOpConst && opnd2->GetMeOp() == kMeOpConst) { - CHECK_FATAL(false, "consider this pattern"); - } else if (opnd2->GetMeOp() == kMeOpConst) { - ESSABaseNode *rhsNode = GetOrCreateRHSNode(*opnd1); - AddUseDef(*opnd1); - InequalEdge *pairEdge1 = inequalityGraph->AddEdge(*rhsNode, *lhsNode, - static_cast(opnd2)->GetIntValue(), EdgeType::kUpper); - InequalEdge *pairEdge2 = inequalityGraph->AddEdge(*lhsNode, *rhsNode, - -static_cast(opnd2)->GetIntValue(), EdgeType::kUpper); - pairEdge1->SetPairEdge(*pairEdge2); - pairEdge2->SetPairEdge(*pairEdge1); - pairEdge1 = inequalityGraph->AddEdge(*lhsNode, *rhsNode, - -static_cast(opnd2)->GetIntValue(), EdgeType::kLower); - pairEdge2 = inequalityGraph->AddEdge(*rhsNode, *lhsNode, - static_cast(opnd2)->GetIntValue(), EdgeType::kLower); - pairEdge1->SetPairEdge(*pairEdge2); - pairEdge2->SetPairEdge(*pairEdge1); - return true; - } else { - ESSABaseNode *rhsNode = GetOrCreateRHSNode(*opnd2); - AddUseDef(*opnd2); - InequalEdge *pairEdge1 = inequalityGraph->AddEdge(*rhsNode, *lhsNode, - static_cast(opnd1)->GetIntValue(), EdgeType::kUpper); - InequalEdge *pairEdge2 = inequalityGraph->AddEdge(*lhsNode, *rhsNode, - -static_cast(opnd1)->GetIntValue(), EdgeType::kUpper); - pairEdge1->SetPairEdge(*pairEdge2); - pairEdge2->SetPairEdge(*pairEdge1); - pairEdge1 = inequalityGraph->AddEdge(*lhsNode, *rhsNode, - -static_cast(opnd1)->GetIntValue(), EdgeType::kLower); - pairEdge2 = inequalityGraph->AddEdge(*rhsNode, *lhsNode, - static_cast(opnd1)->GetIntValue(), EdgeType::kLower); - pairEdge1->SetPairEdge(*pairEdge2); - pairEdge2->SetPairEdge(*pairEdge1); - return true; - } - } else { + if (opnd1->GetMeOp() != kMeOpConst && opnd2->GetMeOp() != kMeOpConst) { // support this pattern later return false; } + if (opnd1->GetMeOp() == kMeOpConst && opnd2->GetMeOp() == kMeOpConst) { + CHECK_FATAL(false, "consider this pattern"); + } else if (opnd2->GetMeOp() == kMeOpConst) { + ESSABaseNode *rhsNode = GetOrCreateRHSNode(*opnd1); + AddUseDef(*opnd1); + InequalEdge *pairEdge1 = inequalityGraph->AddEdge(*rhsNode, *lhsNode, + static_cast(opnd2)->GetIntValue(), EdgeType::kUpper); + InequalEdge *pairEdge2 = inequalityGraph->AddEdge(*lhsNode, *rhsNode, + -static_cast(opnd2)->GetIntValue(), EdgeType::kUpper); + pairEdge1->SetPairEdge(*pairEdge2); + pairEdge2->SetPairEdge(*pairEdge1); + pairEdge1 = inequalityGraph->AddEdge(*lhsNode, *rhsNode, + -static_cast(opnd2)->GetIntValue(), EdgeType::kLower); + pairEdge2 = inequalityGraph->AddEdge(*rhsNode, *lhsNode, + static_cast(opnd2)->GetIntValue(), EdgeType::kLower); + pairEdge1->SetPairEdge(*pairEdge2); + pairEdge2->SetPairEdge(*pairEdge1); + return true; + } else { + ESSABaseNode *rhsNode = GetOrCreateRHSNode(*opnd2); + AddUseDef(*opnd2); + InequalEdge *pairEdge1 = inequalityGraph->AddEdge(*rhsNode, *lhsNode, + static_cast(opnd1)->GetIntValue(), EdgeType::kUpper); + InequalEdge *pairEdge2 = inequalityGraph->AddEdge(*lhsNode, *rhsNode, + -static_cast(opnd1)->GetIntValue(), EdgeType::kUpper); + pairEdge1->SetPairEdge(*pairEdge2); + pairEdge2->SetPairEdge(*pairEdge1); + pairEdge1 = inequalityGraph->AddEdge(*lhsNode, *rhsNode, + -static_cast(opnd1)->GetIntValue(), EdgeType::kLower); + pairEdge2 = inequalityGraph->AddEdge(*rhsNode, *lhsNode, + static_cast(opnd1)->GetIntValue(), EdgeType::kLower); + pairEdge1->SetPairEdge(*pairEdge2); + pairEdge2->SetPairEdge(*pairEdge1); + return true; + } CHECK_FATAL(false, "impossible"); } case OP_band: { diff --git a/src/maple_me/src/me_bypath_eh.cpp b/src/maple_me/src/me_bypath_eh.cpp index 0432ed1b0ab0ecaeb3c06a9aaafc685b79aa8051..b761812a570c54d4d894a305c4371de08cf7b0d1 100644 --- a/src/maple_me/src/me_bypath_eh.cpp +++ b/src/maple_me/src/me_bypath_eh.cpp @@ -121,7 +121,7 @@ bool MeDoBypathEH::DoBypathException(BB *tryBB, BB *catchBB, Klass *catchClass, StmtNode *MeDoBypathEH::IsSyncExit(BB *syncBB, MeFunction *func, LabelIdx secondLabel) { StmtNode *syncExitStmt = nullptr; StmtNode *stmt = syncBB->GetFirst().GetNext(); - for (; stmt && stmt != syncBB->GetLast().GetNext(); stmt = stmt->GetNext()) { + for (; stmt != nullptr && stmt != syncBB->GetLast().GetNext(); stmt = stmt->GetNext()) { if (stmt->GetOpCode() != OP_comment) { break; } @@ -135,7 +135,7 @@ StmtNode *MeDoBypathEH::IsSyncExit(BB *syncBB, MeFunction *func, LabelIdx second if (regreadNode->GetRegIdx() != -kSregThrownval) { return nullptr; } - for (stmt = stmt->GetNext(); stmt && 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; } @@ -162,7 +162,7 @@ StmtNode *MeDoBypathEH::IsSyncExit(BB *syncBB, MeFunction *func, LabelIdx second return nullptr; } bool findThrow = false; - for (stmt = &bbTmp->GetFirst(); stmt && stmt != bbTmp->GetLast().GetNext(); stmt = stmt->GetNext()) { + for (stmt = &bbTmp->GetFirst(); stmt != nullptr && stmt != bbTmp->GetLast().GetNext(); stmt = stmt->GetNext()) { if (stmt->GetOpCode() == OP_comment) { continue; } @@ -211,116 +211,118 @@ void MeDoBypathEH::BypathException(MeFunction *func, KlassHierarchy *kh) { continue; } visited.emplace(bb); - for (StmtNode *stmt = &bb->GetFirst(); stmt && stmt != bb->GetLast().GetNext(); stmt = stmt->GetNext()) { - if (stmt->GetOpCode() == OP_try) { - labelIdx = static_cast(-1); - StmtNode *syncExitStmt = nullptr; - auto *tryNode = static_cast(stmt); - if (tryNode->GetOffsetsCount() == 1) { - labelIdx = tryNode->GetOffset(0); - } else if (tryNode->GetOffsetsCount() == 2) { // Deal with sync - BB *catchBB = nullptr; - for (BB *bbInner : func->GetAllBBs()) { - if (bbInner == nullptr) { - continue; - } - if (bbInner->GetBBLabel() == tryNode->GetOffset(0)) { - catchBB = bbInner; - } + for (StmtNode *stmt = &bb->GetFirst(); stmt != nullptr && stmt != bb->GetLast().GetNext(); stmt = stmt->GetNext()) { + if (stmt->GetOpCode() != OP_try) { + continue; + } + labelIdx = static_cast(-1); + StmtNode *syncExitStmt = nullptr; + auto *tryNode = static_cast(stmt); + if (tryNode->GetOffsetsCount() == 1) { + labelIdx = tryNode->GetOffset(0); + } else if (tryNode->GetOffsetsCount() == 2) { // Deal with sync + BB *catchBB = nullptr; + for (BB *bbInner : func->GetAllBBs()) { + if (bbInner == nullptr) { + continue; } - ASSERT(catchBB, "must not be null"); - StmtNode &stmtInner = catchBB->GetFirst(); - if (stmtInner.GetOpCode() != OP_catch) { // Finally is not a catch - break; + if (bbInner->GetBBLabel() == tryNode->GetOffset(0)) { + catchBB = bbInner; } - auto &catchStmt = static_cast(stmtInner); - if (catchStmt.GetExceptionTyIdxVec().size() == 1) { - MIRType *type = GlobalTables::GetTypeTable().GetTypeFromTyIdx(catchStmt.GetExceptionTyIdxVecElement(0)); - ASSERT(type->GetKind() == kTypePointer, "Must be pointer"); - auto *pType = static_cast(type); - if (pType->GetPointedTyIdx() == PTY_void) { - syncExitStmt = IsSyncExit(catchBB, func, tryNode->GetOffset(1)); - if (syncExitStmt != nullptr) { - labelIdx = tryNode->GetOffset(1); - } + } + ASSERT(catchBB != nullptr, "must not be null"); + StmtNode &stmtInner = catchBB->GetFirst(); + if (stmtInner.GetOpCode() != OP_catch) { // Finally is not a catch + break; + } + auto &catchStmt = static_cast(stmtInner); + if (catchStmt.GetExceptionTyIdxVec().size() == 1) { + MIRType *type = GlobalTables::GetTypeTable().GetTypeFromTyIdx(catchStmt.GetExceptionTyIdxVecElement(0)); + ASSERT(type->GetKind() == kTypePointer, "Must be pointer"); + auto *pType = static_cast(type); + if (pType->GetPointedTyIdx() == PTY_void) { + syncExitStmt = IsSyncExit(catchBB, func, tryNode->GetOffset(1)); + if (syncExitStmt != nullptr) { + labelIdx = tryNode->GetOffset(1); } } } - if (labelIdx != static_cast(-1)) { - // Find catch label, and create a new bb - for (BB *bbInner : func->GetAllBBs()) { - if (bbInner == nullptr) { + } + + if (labelIdx == static_cast(-1)) { + continue; + } + // Find catch label, and create a new bb + for (BB *bbInner : func->GetAllBBs()) { + if (bbInner == nullptr || bbInner->GetBBLabel() != labelIdx) { + continue; + } + StmtNode &stmtInner = bbInner->GetFirst(); + ASSERT(stmtInner.GetOpCode() == OP_catch, "Must be java catch."); + auto &catchNode = static_cast(stmtInner); + if (catchNode.GetExceptionTyIdxVec().size() != 1) { + continue; + } + MIRType *type = GlobalTables::GetTypeTable().GetTypeFromTyIdx(catchNode.GetExceptionTyIdxVecElement(0)); + ASSERT(type->GetKind() == kTypePointer, "Must be pointer"); + auto *pType = static_cast(type); + Klass *catchClass = nullptr; + if (pType->GetPointedTyIdx() == PTY_void) { + catchClass = kh->GetKlassFromName(NameMangler::kJavaLangExceptionStr); + } else { + catchClass = kh->GetKlassFromTyIdx(pType->GetPointedTyIdx()); + } + if (stmtInner.GetNext() == nullptr || stmtInner.GetNext()->GetOpCode() != OP_dassign) { + labelIdx = static_cast(-1); + continue; + } + auto *dassignNode = static_cast(stmtInner.GetNext()); + ASSERT(dassignNode->Opnd(0)->GetOpCode() == OP_regread, "Must be regread"); + auto *regreadNode = static_cast(dassignNode->Opnd(0)); + if (regreadNode->GetRegIdx() != -kSregThrownval) { + continue; + } + // Insert goto label + GStrIdx labelStrIdx = GlobalTables::GetStrTable().GetOrCreateStrIdxFromName("bypatheh" + + 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); + newBB->SetBBLabel(labIdx); + } else { + hasCreated = true; + for (BB *newBBIter : func->GetAllBBs()) { + if (newBBIter == nullptr) { continue; } - if (bbInner->GetBBLabel() == labelIdx) { - StmtNode &stmtInner = bbInner->GetFirst(); - ASSERT(stmtInner.GetOpCode() == OP_catch, "Must be java catch."); - auto &catchNode = static_cast(stmtInner); - if (catchNode.GetExceptionTyIdxVec().size() == 1) { - MIRType *type = - GlobalTables::GetTypeTable().GetTypeFromTyIdx(catchNode.GetExceptionTyIdxVecElement(0)); - ASSERT(type->GetKind() == kTypePointer, "Must be pointer"); - auto *pType = static_cast(type); - Klass *catchClass = nullptr; - if (pType->GetPointedTyIdx() == PTY_void) - catchClass = kh->GetKlassFromName(NameMangler::kJavaLangExceptionStr); - else { - catchClass = kh->GetKlassFromTyIdx(pType->GetPointedTyIdx()); - } - if (stmtInner.GetNext() == nullptr || stmtInner.GetNext()->GetOpCode() != OP_dassign) { - labelIdx = static_cast(-1); - } else { - auto *dassignNode = static_cast(stmtInner.GetNext()); - ASSERT(dassignNode->Opnd(0)->GetOpCode() == OP_regread, "Must be regread"); - auto *regreadNode = static_cast(dassignNode->Opnd(0)); - if (regreadNode->GetRegIdx() == -kSregThrownval) { - // Insert goto label - GStrIdx labelStrIdx = GlobalTables::GetStrTable().GetOrCreateStrIdxFromName("bypatheh" + - 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); - newBB->SetBBLabel(labIdx); - } else { - hasCreated = true; - for (BB *newBBIter : func->GetAllBBs()) { - if (newBBIter == nullptr) { - continue; - } - if (newBBIter->GetBBLabel() == it->second) { - newBB = newBBIter; - break; - } - } - } - 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); - } - } 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); - } - } - labelIdx = static_cast(-1); - break; - } - } - } + if (newBBIter->GetBBLabel() == it->second) { + newBB = newBBIter; + break; } } } + 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); + } + } 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); + } + } + labelIdx = static_cast(-1); + break; } } } diff --git a/src/maple_me/src/me_cond_based_opt.cpp b/src/maple_me/src/me_cond_based_opt.cpp index 90204d006acf9729bd2b6722542f1118fa8abdd1..e9de6d842878c58292ed51299204f4bcbe2ce692 100644 --- a/src/maple_me/src/me_cond_based_opt.cpp +++ b/src/maple_me/src/me_cond_based_opt.cpp @@ -191,7 +191,7 @@ bool MeCondBased::PointerWasDereferencedRightAfter(VarMeExpr &var, const UnaryMe // we can't remove assertnonnull(var) safely, because if var is null, then the position of throwing exception is // not the same. MeStmt *nextMeStmt = assertMeStmt.GetNextMeStmt(); - return nextMeStmt && StmtHasDereferencedBase(*nextMeStmt, var); + return (nextMeStmt != nullptr) && StmtHasDereferencedBase(*nextMeStmt, var); } bool MeCondBased::IsNotNullValue(VarMeExpr &varMeExpr, UnaryMeStmt &assertMeStmt, BB *bb) { @@ -215,10 +215,7 @@ bool MeCondBased::IsNotNullValue(VarMeExpr &varMeExpr, UnaryMeStmt &assertMeStmt if (PointerWasDereferencedBefore(varMeExpr, assertMeStmt, bb)) { return true; } - if (PointerWasDereferencedRightAfter(varMeExpr, assertMeStmt)) { - return true; - } - return false; + return PointerWasDereferencedRightAfter(varMeExpr, assertMeStmt); } void CondBasedNPC::DoCondBasedNPC() { @@ -279,7 +276,7 @@ AnalysisResult *MeDoCondBasedRC::Run(MeFunction *func, MeFuncResultMgr *m, Modul AnalysisResult *MeDoCondBasedNPC::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"); CondBasedNPC condBasedNPC(func, dom); condBasedNPC.DoCondBasedNPC(); return nullptr; diff --git a/src/maple_me/src/me_function.cpp b/src/maple_me/src/me_function.cpp index acf0204104b81ccdfedffbb102564cbffa5435ee..743ae038c3c8226f4bf470160b16d244da4b05b6 100644 --- a/src/maple_me/src/me_function.cpp +++ b/src/maple_me/src/me_function.cpp @@ -431,7 +431,7 @@ BB *MeFunction::NewBasicBlock() { } // new a basic block and insert before position -BB *MeFunction::InsertNewBasicBlock(const BB &position) { +BB &MeFunction::InsertNewBasicBlock(const BB &position) { BB *newBB = memPool->New(&alloc, &versAlloc, BBId(nextBBId++)); auto bIt = std::find(begin(), end(), &position); @@ -445,7 +445,7 @@ BB *MeFunction::InsertNewBasicBlock(const BB &position) { } ++idx; } - return newBB; + return *newBB; } void MeFunction::DeleteBasicBlock(const BB &bb) { diff --git a/src/maple_me/src/me_hdse.cpp b/src/maple_me/src/me_hdse.cpp index 48bcdcb52979970c1c62bde8208f2bfb645b7f63..623b1a95416b14798caf1c36cc5259664bb7ea07 100644 --- a/src/maple_me/src/me_hdse.cpp +++ b/src/maple_me/src/me_hdse.cpp @@ -116,7 +116,7 @@ AnalysisResult *MeDoHDSE::Run(MeFunction *func, MeFuncResultMgr *m, ModuleResult auto *postDom = static_cast(m->GetAnalysisResult(MeFuncPhase_DOMINANCE, func)); CHECK_NULL_FATAL(postDom); auto *hMap = static_cast(m->GetAnalysisResult(MeFuncPhase_IRMAP, func)); - CHECK_FATAL(hMap != nullptr, "hssamap is nullptr"); + CHECK_NULL_FATAL(hMap); MeHDSE hdse(*func, *postDom, *hMap, DEBUGFUNC(func)); hdse.RunHDSE(); MakeEmptyTrysUnreachable(*func); diff --git a/src/maple_me/src/me_inequality_graph.cpp b/src/maple_me/src/me_inequality_graph.cpp index 506d9ec9b8d194edab173cad1f0d821f7544aae0..26953f67f3e56e3499d462b23547a45351be1094 100644 --- a/src/maple_me/src/me_inequality_graph.cpp +++ b/src/maple_me/src/me_inequality_graph.cpp @@ -354,7 +354,7 @@ namespace maple { if (recursiveCount > kDFSLimit) { return kFalse; } - // std::cout << "Traversing Node : " << bNode.GetExprID() << '\n'; + tracing.push_back(&bNode); if (&aNode == &bNode) { if (edge.geq(0)) { diff --git a/src/maple_me/src/me_loop_analysis.cpp b/src/maple_me/src/me_loop_analysis.cpp index 32e6a25902f15068f0462e1c7c427479d9099502..86bff7118d69baad1fec3d7e1265f5aa339e01c4 100644 --- a/src/maple_me/src/me_loop_analysis.cpp +++ b/src/maple_me/src/me_loop_analysis.cpp @@ -27,14 +27,14 @@ LoopDesc *IdentifyLoops::CreateLoopDesc(BB *hd, BB *tail) { return newLoop; } -void IdentifyLoops::SetLoopParent4BB(const BB *bb, LoopDesc *loop) { +void IdentifyLoops::SetLoopParent4BB(const BB *bb, LoopDesc *loopDesc) { if (bbLoopParent[bb->GetBBId()] != nullptr) { - if (loop->parent == nullptr) { - loop->parent = bbLoopParent[bb->GetBBId()]; - loop->nestDepth = loop->parent->nestDepth + 1; + if (loopDesc->parent == nullptr) { + loopDesc->parent = bbLoopParent[bb->GetBBId()]; + loopDesc->nestDepth = loopDesc->parent->nestDepth + 1; } } - bbLoopParent[bb->GetBBId()] = loop; + bbLoopParent[bb->GetBBId()] = loopDesc; } // process each BB in preorder traversal of dominator tree diff --git a/src/maple_me/src/me_loop_canon.cpp b/src/maple_me/src/me_loop_canon.cpp index edfece37439c3c613ceafd10152a1bfd4c7262f4..d67947703acf4e530094024f2ac3772259296743 100644 --- a/src/maple_me/src/me_loop_canon.cpp +++ b/src/maple_me/src/me_loop_canon.cpp @@ -83,7 +83,7 @@ bool MeDoLoopCanon::NeedConvert(BB *bb, BB *pred, MapleAllocator &localAlloc, Ma } inLoop.insert(curr->GetBBId()); for (BB *tmpPred : curr->GetPred()) { - ASSERT(tmpPred != nullptr, ""); + ASSERT_NOT_NULL(tmpPred); bodyList.push_back(tmpPred); tmpPred->SetAttributes(kBBAttrIsInLoop); } @@ -225,7 +225,7 @@ AnalysisResult *MeDoLoopCanon::Run(MeFunction *func, MeFuncResultMgr *m, ModuleR MapleVector &preds = bb->GetPred(); for (BB *pred : preds) { ASSERT(func->GetCommonEntryBB(), "impossible"); - ASSERT(pred, "impossible"); + 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))) { diff --git a/src/maple_me/src/me_prop.cpp b/src/maple_me/src/me_prop.cpp index 9695f08ab26023ec4ce583d67b44da7ee2c8c315..d400b123a3224bef7c6c885fb9ccb0728d8d3595 100644 --- a/src/maple_me/src/me_prop.cpp +++ b/src/maple_me/src/me_prop.cpp @@ -29,12 +29,12 @@ AnalysisResult *MeDoMeProp::Run(MeFunction *func, MeFuncResultMgr *m, ModuleResu CHECK_NULL_FATAL(func); auto *dom = static_cast(m->GetAnalysisResult(MeFuncPhase_DOMINANCE, func)); CHECK_NULL_FATAL(dom); - auto *hmap = static_cast(m->GetAnalysisResult(MeFuncPhase_IRMAP, func)); - CHECK_NULL_FATAL(hmap); - MeProp meprop(*hmap, *dom, *NewMemPool(), Prop::PropConfig{ MeOption::propBase, + auto *hMap = static_cast(m->GetAnalysisResult(MeFuncPhase_IRMAP, func)); + CHECK_NULL_FATAL(hMap); + MeProp meProp(*hMap, *dom, *NewMemPool(), Prop::PropConfig { MeOption::propBase, MeOption::propIloadRef, MeOption::propGlobalRef, MeOption::propFinaliLoadRef, MeOption::propIloadRefNonParm, MeOption::propAtPhi }); - meprop.DoProp(); + meProp.DoProp(); if (DEBUGFUNC(func)) { LogInfo::MapleLogger() << "\n============== After Copy Propagation =============" << '\n'; func->Dump(false); diff --git a/src/maple_me/src/me_rc_lowering.cpp b/src/maple_me/src/me_rc_lowering.cpp index 8abc62b3dd1c3a3b8bbfe395e21c25266245515d..d5467bab225bf3c72b68b75159bfd6aebc41eab1 100644 --- a/src/maple_me/src/me_rc_lowering.cpp +++ b/src/maple_me/src/me_rc_lowering.cpp @@ -342,66 +342,6 @@ void RCLowering::HandleAssignMeStmtVarLHS(MeStmt &stmt, MeExpr *pendingDec) { assignedPtrSym.insert(lsym); } -MIRType *RCLowering::GetArrayNodeType(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(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(MeStmt &stmt) { MeExpr *lhs = stmt.GetLHS(); CHECK_FATAL(lhs != nullptr, "null ptr check"); @@ -413,7 +353,6 @@ 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) { @@ -497,7 +436,6 @@ 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) { @@ -716,10 +654,6 @@ void RCLowering::HandleReturnRegread(RetMeStmt &ret) { opnds->erase(iter); opnds->push_back(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; } } diff --git a/src/maple_me/src/me_rename2preg.cpp b/src/maple_me/src/me_rename2preg.cpp index e2a4d2e81e37660bee07793c2efc4f9c74e2f184..8c98d234ad343fdda70e30a0e6536a2a08ad566d 100644 --- a/src/maple_me/src/me_rename2preg.cpp +++ b/src/maple_me/src/me_rename2preg.cpp @@ -64,7 +64,7 @@ class OStCache final { private: SSATab &ssaTab; - std::map cache; // map var to reg in original symbol + std::map cache; // map var to reg in original symbol }; class PregCache final { @@ -86,15 +86,15 @@ class PregCache final { RegMeExpr &CreatePregExpr(const VarMeExpr &varExpr, TyIdx symbolIdx) { MIRType &ty = utils::ToRef(GlobalTables::GetTypeTable().GetTypeFromTyIdx(symbolIdx)); - RegMeExpr *regExpr = ty.GetPrimType() == PTY_ref ? - irMap.CreateRegRefMeExpr(ty) : irMap.CreateRegMeExpr(varExpr.GetPrimType()); + RegMeExpr *regExpr = ty.GetPrimType() == PTY_ref ? irMap.CreateRegRefMeExpr(ty) + : irMap.CreateRegMeExpr(varExpr.GetPrimType()); cache.insert(std::make_pair(varExpr.GetExprID(), regExpr)); return utils::ToRef(regExpr); } private: MeIRMap &irMap; - std::unordered_map cache; // maps the VarMeExpr's exprID to RegMeExpr + std::unordered_map cache; // maps the VarMeExpr's exprID to RegMeExpr }; class CacheProxy final { @@ -153,8 +153,8 @@ class FormalRenaming final { // in this case, the paramter is not used by any statement, promote it MIRType &irTy = utils::ToRef(irFunc.GetNthParamType(i)); MIRPregTable &irPregTbl = utils::ToRef(irFunc.GetPregTab()); - PregIdx16 regIdx = (irTy.GetPrimType() == PTY_ref) ? - irPregTbl.CreateRefPreg(irTy) : irPregTbl.CreatePreg(irTy.GetPrimType()); + PregIdx16 regIdx = (irTy.GetPrimType() == PTY_ref) ? irPregTbl.CreateRefPreg(irTy) + : irPregTbl.CreatePreg(irTy.GetPrimType()); irFunc.SetFormal(i, irBuilder.CreatePregFormalSymbol(irTy.GetTypeIndex(), regIdx, irFunc)); } else { RegMeExpr *regExpr = renamedReg[i]; diff --git a/src/maple_me/src/me_ssu_pre.cpp b/src/maple_me/src/me_ssu_pre.cpp index d310b093c4fdeb0cea4cad6d9dfd2e3b78452cc1..23a7a385d52cebbbfa995c5143322ad419997dfb 100644 --- a/src/maple_me/src/me_ssu_pre.cpp +++ b/src/maple_me/src/me_ssu_pre.cpp @@ -22,22 +22,22 @@ void MeSSUPre::Finalize() { std::vector anticipatedDefVec(classCount + 1, nullptr); // preorder traversal of post-dominator tree for (SOcc *occ : allOccs) { - size_t classx = static_cast(occ->GetClassId()); + size_t classId = static_cast(occ->GetClassId()); switch (occ->GetOccTy()) { case kSOccLambda: { auto *lambdaOcc = static_cast(occ); if (lambdaOcc->WillBeAnt()) { - anticipatedDefVec[classx] = lambdaOcc; + anticipatedDefVec[classId] = lambdaOcc; } break; } case kSOccReal: { - auto *realocc = static_cast(occ); - if (anticipatedDefVec[classx] == nullptr || !anticipatedDefVec[classx]->IsPostDominate(dom, occ)) { - realocc->SetRedundant(false); - anticipatedDefVec[classx] = realocc; + auto *realOcc = static_cast(occ); + if (anticipatedDefVec[classId] == nullptr || !anticipatedDefVec[classId]->IsPostDominate(dom, occ)) { + realOcc->SetRedundant(false); + anticipatedDefVec[classId] = realOcc; } else { - realocc->SetRedundant(true); + realOcc->SetRedundant(true); } break; } @@ -69,7 +69,7 @@ void MeSSUPre::Finalize() { } lambdaResOcc->SetInsertHere(true); } else { - lambdaResOcc->SetUse(anticipatedDefVec[classx]); + lambdaResOcc->SetUse(anticipatedDefVec[classId]); } } break; @@ -86,8 +86,8 @@ void MeSSUPre::Finalize() { LogInfo::MapleLogger() << " _______ after finalize _______" << '\n'; for (SOcc *occ : allOccs) { if (occ->GetOccTy() == kSOccReal) { - auto *realocc = static_cast(occ); - if (realocc->GetRedundant()) { + auto *realOcc = static_cast(occ); + if (realOcc->GetRedundant()) { occ->Dump(); LogInfo::MapleLogger() << " deleted" << '\n'; } @@ -137,7 +137,7 @@ void MeSSUPre::ResetCanBeAnt(SLambdaOcc *lambda) { // the following loop finds lambda's defs and reset them for (SLambdaOcc *lambdaOcc : lambdaOccs) { for (SLambdaResOcc *lambdaResOcc : lambdaOcc->GetLambdaRes()) { - if (lambdaResOcc->GetUse() && lambdaResOcc->GetUse() == lambda) { + if (lambdaResOcc->GetUse() != nullptr && lambdaResOcc->GetUse() == lambda) { if (!lambdaResOcc->GetHasRealUse() && !lambdaOcc->GetIsUpsafe() && lambdaOcc->GetIsCanBeAnt()) { ResetCanBeAnt(lambdaOcc); } @@ -169,7 +169,7 @@ void MeSSUPre::ResetEarlier(SLambdaOcc *lambda) { // the following loop finds lambda's defs and reset them for (SLambdaOcc *lambdaOcc : lambdaOccs) { for (SLambdaResOcc *lambdaResOcc : lambdaOcc->GetLambdaRes()) { - if (lambdaResOcc->GetUse() && lambdaResOcc->GetUse() == lambda) { + if (lambdaResOcc->GetUse() != nullptr && lambdaResOcc->GetUse() == lambda) { if (lambdaOcc->GetIsEarlier()) { ResetEarlier(lambdaOcc); } @@ -186,7 +186,7 @@ void MeSSUPre::ComputeEarlier() { if (lambdaOcc->GetIsEarlier()) { bool existNonNullUse = false; for (SLambdaResOcc *lambdaResOcc : lambdaOcc->GetLambdaRes()) { - if (lambdaResOcc->GetUse() && lambdaResOcc->GetHasRealUse()) { + if (lambdaResOcc->GetUse() != nullptr && lambdaResOcc->GetHasRealUse()) { existNonNullUse = true; break; } @@ -280,17 +280,17 @@ void MeSSUPre::Rename() { SOcc *topOcc = occStack.top(); if (topOcc->GetOccTy() == kSOccLambda) { // make sure this lambda is dominated by at least one kill occurrence - for (SOcc *realocc : workCand->GetRealOccs()) { - if (realocc->GetOccTy() == kSOccUse || realocc->GetOccTy() == kSOccPhi) { + for (SOcc *realOcc : workCand->GetRealOccs()) { + if (realOcc->GetOccTy() == kSOccUse || realOcc->GetOccTy() == kSOccPhi) { continue; } - CHECK_FATAL(realocc->GetOccTy() == kSOccReal, "just check"); + CHECK_FATAL(realOcc->GetOccTy() == kSOccReal, "just check"); if ((preKind == kDecrefPre || preKind == kSecondDecrefPre) && - !static_cast(realocc)->GetRealFromDef()) { + !static_cast(realOcc)->GetRealFromDef()) { continue; } CHECK_NULL_FATAL(dom); - if (!dom->Dominate(*realocc->GetBB(), *topOcc->GetBB())) { + if (!dom->Dominate(*realOcc->GetBB(), *topOcc->GetBB())) { continue; } static_cast(topOcc)->SetIsUpsafe(false); @@ -441,16 +441,16 @@ void MeSSUPre::CreateSortedOccs() { if (nextLambdaOcc != nullptr) { pickedOcc = nextLambdaOcc; } - if (nextRealOcc && (pickedOcc == nullptr || dom->GetPdtDfnItem(nextRealOcc->GetBB()->GetBBId()) < - dom->GetPdtDfnItem(pickedOcc->GetBB()->GetBBId()))) { + if (nextRealOcc != nullptr && (pickedOcc == nullptr || dom->GetPdtDfnItem(nextRealOcc->GetBB()->GetBBId()) < + dom->GetPdtDfnItem(pickedOcc->GetBB()->GetBBId()))) { pickedOcc = nextRealOcc; } - if (nextLambdaResOcc && + if (nextLambdaResOcc != nullptr && (pickedOcc == nullptr || *lambdaResDfnIt < dom->GetPdtDfnItem(pickedOcc->GetBB()->GetBBId()))) { pickedOcc = nextLambdaResOcc; } - if (nextEntryOcc && (pickedOcc == nullptr || dom->GetPdtDfnItem(nextEntryOcc->GetBB()->GetBBId()) < - dom->GetPdtDfnItem(pickedOcc->GetBB()->GetBBId()))) { + if (nextEntryOcc != nullptr && (pickedOcc == nullptr || dom->GetPdtDfnItem(nextEntryOcc->GetBB()->GetBBId()) < + dom->GetPdtDfnItem(pickedOcc->GetBB()->GetBBId()))) { pickedOcc = nextEntryOcc; } if (pickedOcc != nullptr) { diff --git a/src/maple_me/src/me_stmt_fre.cpp b/src/maple_me/src/me_stmt_fre.cpp index 84bfdaf8495b4e8ac04813041703d11169b84051..5c1bd24898a56a85a804d293ae4e2546344bd294 100644 --- a/src/maple_me/src/me_stmt_fre.cpp +++ b/src/maple_me/src/me_stmt_fre.cpp @@ -15,14 +15,14 @@ #include "me_stmt_pre.h" namespace maple { -void MeStmtPre::ResetFullyAvail(MePhiOcc *occg) { - occg->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() && phiOpnd->GetDef() == occg) { - // phiOpnd is a use of occg + if (phiOpnd->GetDef() != nullptr && phiOpnd->GetDef() == occ) { + // phiOpnd is a use of occ if (!phiOpnd->HasRealUse()) { ResetCanBeAvail(phiOcc); } diff --git a/src/maple_me/src/me_stmt_pre.cpp b/src/maple_me/src/me_stmt_pre.cpp index fd9207fd2829c62a6f341dc3da37701f9e8928e1..671788f639a600bd705df809d943bd5970e801c5 100644 --- a/src/maple_me/src/me_stmt_pre.cpp +++ b/src/maple_me/src/me_stmt_pre.cpp @@ -12,8 +12,8 @@ * FIT FOR A PARTICULAR PURPOSE. * See the Mulan PSL v1 for more details. */ -#include "utils.h" #include "me_stmt_pre.h" +#include "utils.h" #include "me_dominance.h" #include "me_option.h" #include "me_ssa_update.h" @@ -117,8 +117,8 @@ void MeStmtPre::CodeMotion() { // insert at earlist point in BB, but after statements required // to be first statement in BB MeStmt *curStmt = to_ptr(insertBB->GetMeStmts().begin()); - while (curStmt && (curStmt->GetOp() == OP_catch || curStmt->GetOp() == OP_try || - curStmt->GetOp() == OP_comment)) { + while (curStmt != nullptr && (curStmt->GetOp() == OP_catch || curStmt->GetOp() == OP_try || + curStmt->GetOp() == OP_comment)) { curStmt = curStmt->GetNext(); } if (curStmt == nullptr) { @@ -149,25 +149,25 @@ void MeStmtPre::Finalize1() { std::vector availDefVec(classCount, nullptr); // traversal in preoder DT for (MeOccur *occ : allOccs) { - uint32 classx = static_cast(occ->GetClassID()); + uint32 classId = static_cast(occ->GetClassID()); switch (occ->GetOccType()) { case kOccPhiocc: { auto *phiOcc = static_cast(occ); if (phiOcc->IsWillBeAvail()) { - availDefVec[classx] = phiOcc; + availDefVec[classId] = phiOcc; } break; } case kOccReal: { - MeOccur *availDef = availDefVec[classx]; + MeOccur *availDef = availDefVec[classId]; auto *realOcc = static_cast(occ); if (availDef == nullptr || !availDef->IsDominate(dom, occ)) { realOcc->SetIsReload(false); - availDefVec[classx] = realOcc; + availDefVec[classId] = realOcc; } else { realOcc->SetIsReload(true); ASSERT(!realOcc->IsSave(), "real occ with isSave cannot be set isReload"); - realOcc->SetDef(availDefVec[classx]); + realOcc->SetDef(availDefVec[classId]); CHECK_NULL_FATAL(realOcc->GetDef()); } break; @@ -200,7 +200,7 @@ void MeStmtPre::Finalize1() { } phiOpnd->SetIsInsertedOcc(true); } else { - phiOpnd->SetDef(availDefVec[classx]); + phiOpnd->SetDef(availDefVec[classId]); } } break; @@ -211,17 +211,18 @@ void MeStmtPre::Finalize1() { break; default: ASSERT(false, "should not be here"); + break; } } if (GetSSAPreDebug()) { PreWorkCand *curCand = workCand; - mirModule->GetOut() << "========ssapre candidate " << curCand->GetIndex() - << " after Finalize1===================\n"; + mirModule->GetOut() << "========ssapre candidate " << curCand->GetIndex() << + " after Finalize1===================\n"; for (auto it = phiOccs.begin(); it != phiOccs.end(); ++it) { MePhiOcc *phiOcc = *it; if (phiOcc->IsWillBeAvail()) { for (MePhiOpndOcc *phiOpnd : phiOcc->GetPhiOpnds()) { - ASSERT(phiOpnd->GetDef(), "EPhiFinalizer::DumpFinalize1: phiopndocc cannot have no def"); + ASSERT(phiOpnd->GetDef() != nullptr, "EPhiFinalizer::DumpFinalize1: phiopndocc cannot have no def"); MeOccur *defOcc = phiOpnd->GetDef(); if (defOcc->GetOccType() == kOccInserted) { auto *realDefOcc = static_cast(defOcc); @@ -334,13 +335,13 @@ MeStmt *MeStmtPre::PhiOpndFromRes4Stmt(MeRealOcc *realZ, size_t j, MeExpr *&lhsV CHECK_FATAL(defZ, "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(); - BB *ephiBB = defZ->GetBB(); + 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(), ephiBB, j); + MeExpr *retOpnd = GetReplaceMeExpr(unaryStmtQ->GetOpnd(), phiBB, j); if (retOpnd != nullptr) { unaryStmtQ->SetMeStmtOpndValue(retOpnd); } @@ -348,7 +349,7 @@ MeStmt *MeStmtPre::PhiOpndFromRes4Stmt(MeRealOcc *realZ, size_t j, MeExpr *&lhsV } case OP_dassign: { auto *dassQ = static_cast(stmtQ); - MeExpr *retOpnd = GetReplaceMeExpr(dassQ->GetRHS(), ephiBB, j); + MeExpr *retOpnd = GetReplaceMeExpr(dassQ->GetRHS(), phiBB, j); if (retOpnd != nullptr) { dassQ->SetRHS(retOpnd); } @@ -359,7 +360,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->GetOpnds()[i], ephiBB, j); + MeExpr *retOpnd = GetReplaceMeExpr(nStmtQ->GetOpnds()[i], phiBB, j); if (retOpnd != nullptr) { nStmtQ->GetOpnds()[i] = retOpnd; } @@ -370,7 +371,7 @@ MeStmt *MeStmtPre::PhiOpndFromRes4Stmt(MeRealOcc *realZ, size_t j, MeExpr *&lhsV ASSERT(false, "MeStmtPre::PhiOpndFromRes4Stmt: NYI"); } if (stmtQ->GetOp() == OP_dassign || stmtQ->GetOp() == OP_callassigned) { - MeExpr *retOpnd = GetReplaceMeExpr(realZ->GetMeExpr(), ephiBB, j); + MeExpr *retOpnd = GetReplaceMeExpr(realZ->GetMeExpr(), phiBB, j); if (retOpnd != nullptr) { lhsVar = retOpnd; } @@ -385,7 +386,7 @@ void MeStmtPre::Rename2() { MeRealOcc *realOcc = workCand->GetRealOcc(*it); rename2Set.erase(it); MeOccur *defOcc = realOcc->GetDef(); - CHECK_FATAL(defOcc, "should be def by phiocc"); + CHECK_FATAL(defOcc != nullptr, "should be def by phiocc"); CHECK_FATAL(defOcc->GetOccType() == kOccPhiocc, "should be def by phiocc"); auto *defPhiOcc = static_cast(defOcc); MapleVector &phiOpnds = defPhiOcc->GetPhiOpnds(); @@ -599,7 +600,7 @@ void MeStmtPre::CreateSortedOccs() { if (nextPhiOcc != nullptr) { pickedOcc = nextPhiOcc; } - if (nextRealOcc && (pickedOcc == nullptr || + if (nextRealOcc != nullptr && (pickedOcc == nullptr || dom->GetDtDfnItem(nextRealOcc->GetBB()->GetBBId()) < dom->GetDtDfnItem(pickedOcc->GetBB()->GetBBId()))) { pickedOcc = nextRealOcc; } @@ -607,12 +608,12 @@ void MeStmtPre::CreateSortedOccs() { dom->GetDtDfnItem(nextUseOcc->GetBB()->GetBBId()) < dom->GetDtDfnItem(pickedOcc->GetBB()->GetBBId()))) { pickedOcc = nextUseOcc; } - if (nextExitOcc && (pickedOcc == nullptr || + if (nextExitOcc != nullptr && (pickedOcc == nullptr || dom->GetDtDfnItem(nextExitOcc->GetBB()->GetBBId()) < dom->GetDtDfnItem(pickedOcc->GetBB()->GetBBId()))) { pickedOcc = nextExitOcc; } - if (nextPhiOpndOcc && (pickedOcc == nullptr || - *phiOpndDfnIt < dom->GetDtDfnItem(pickedOcc->GetBB()->GetBBId()))) { + if (nextPhiOpndOcc != nullptr && (pickedOcc == nullptr || + *phiOpndDfnIt < dom->GetDtDfnItem(pickedOcc->GetBB()->GetBBId()))) { pickedOcc = nextPhiOpndOcc; } if (pickedOcc != nullptr) { @@ -677,6 +678,7 @@ void MeStmtPre::CreateSortedOccs() { break; default: ASSERT(false, "CreateSortedOccs: unexpected occty"); + break; } } } while (pickedOcc != nullptr); @@ -694,8 +696,8 @@ void MeStmtPre::CreateSortedOccs() { bb2PhiOpndMap[pred->GetBBId()].pop_front(); } if (GetSSAPreDebug()) { - mirModule->GetOut() << "========ssapre candidate " << workCand->GetIndex() - << " after phi insert===================\n"; + mirModule->GetOut() << "========ssapre candidate " << workCand->GetIndex() << + " after phi insert===================\n"; for (MeOccur *occ : allOccs) { occ->Dump(*irMap); mirModule->GetOut() << '\n'; @@ -703,9 +705,9 @@ void MeStmtPre::CreateSortedOccs() { } } -void MeStmtPre::ConstructUseOccurMapExpr(uint32 bbDfn, MeExpr *x) { - if (x->GetMeOp() == kMeOpVar) { - OStIdx ostIdx = static_cast(x)->GetOStIdx(); +void MeStmtPre::ConstructUseOccurMapExpr(uint32 bbDfn, MeExpr *meExpr) { + if (meExpr->GetMeOp() == kMeOpVar) { + OStIdx ostIdx = static_cast(meExpr)->GetOStIdx(); MapleMap*>::iterator mapIt; mapIt = useOccurMap.find(ostIdx); if (mapIt == useOccurMap.end()) { @@ -715,8 +717,8 @@ void MeStmtPre::ConstructUseOccurMapExpr(uint32 bbDfn, MeExpr *x) { bbDfnSet->insert(bbDfn); return; } - for (int32 i = 0; i < x->GetNumOpnds(); ++i) { - ConstructUseOccurMapExpr(bbDfn, x->GetOpnd(i)); + for (uint8 i = 0; i < meExpr->GetNumOpnds(); ++i) { + ConstructUseOccurMapExpr(bbDfn, meExpr->GetOpnd(i)); } } @@ -753,9 +755,9 @@ PreStmtWorkCand *MeStmtPre::CreateStmtRealOcc(MeStmt &meStmt, int seqStmt) { uint32 hashIdx = PreStmtWorkCand::ComputeStmtWorkCandHashIndex(meStmt); auto *wkCand = static_cast(PreWorkCand::GetWorkcandFromIndex(hashIdx)); while (wkCand != nullptr) { - MeStmt *x = wkCand->GetTheMeStmt(); - ASSERT(x != nullptr, "CreateStmtRealOcc: found workcand with theMeStmt as nullptr"); - if (x->IsTheSameWorkcand(meStmt)) { + MeStmt *currStmt = wkCand->GetTheMeStmt(); + ASSERT(currStmt != nullptr, "CreateStmtRealOcc: found workcand with theMeStmt as nullptr"); + if (currStmt->IsTheSameWorkcand(meStmt)) { break; } wkCand = static_cast(wkCand->GetNext()); @@ -857,7 +859,6 @@ void MeStmtPre::BuildWorkListBB(BB *bb) { case OP_retsub: case OP_throw: case OP_return: - // CreateExitOcc(bb); break; case OP_iassign: { auto &iass = static_cast(stmt); @@ -987,7 +988,7 @@ void MeStmtPre::BuildWorkListBB(BB *bb) { break; } default: - ASSERT(stmt.GetOp() == OP_comment, ""); + ASSERT(stmt.GetOp() == OP_comment, "must be OP_comment"); break; } if (kOpcodeInfo.IsCallAssigned(stmt.GetOp())) { @@ -1033,9 +1034,9 @@ void MeStmtPre::BuildWorkList() { if (!ost->IsSymbolOst() || ost->GetIndirectLev() != 0) { continue; } - MapleStack *versStack = ssaPreMemPool->New>(ssaPreAllocator.Adapter()); - versStack->push(static_cast(irMap->GetOrCreateZeroVersionVarMeExpr(*ost))); - versionStackVec[ost->GetIndex()] = versStack; + MapleStack *varStack = ssaPreMemPool->New>(ssaPreAllocator.Adapter()); + varStack->push(static_cast(irMap->GetOrCreateZeroVersionVarMeExpr(*ost))); + versionStackVec[ost->GetIndex()] = varStack; } BuildWorkListBB(func->GetCommonEntryBB()); } @@ -1065,9 +1066,9 @@ AnalysisResult *MeDoStmtPre::Run(MeFunction *func, MeFuncResultMgr *m, ModuleRes } ssaPre.ApplySSAPRE(); if (!ssaPre.GetCandsForSSAUpdate().empty()) { - MemPool *tmp = memPoolCtrler.NewMemPool("MeSSAUpdate"); - CHECK_FATAL(tmp != nullptr, "must be"); - MeSSAUpdate ssaUpdate(*func, *func->GetMeSSATab(), *dom, ssaPre.GetCandsForSSAUpdate(), *tmp); + MemPool *memPool = memPoolCtrler.NewMemPool("MeSSAUpdate"); + CHECK_FATAL(memPool != nullptr, "must be"); + MeSSAUpdate ssaUpdate(*func, *func->GetMeSSATab(), *dom, ssaPre.GetCandsForSSAUpdate(), *memPool); ssaUpdate.Run(); } if (DEBUGFUNC(func)) { diff --git a/src/maple_me/src/me_store_pre.cpp b/src/maple_me/src/me_store_pre.cpp index 4b270153b62e6d3f5154f15790d35f49802fb00d..9007c1bcf4d893ed54f427d9c8bf390d81e52494 100644 --- a/src/maple_me/src/me_store_pre.cpp +++ b/src/maple_me/src/me_store_pre.cpp @@ -15,8 +15,6 @@ #include "me_store_pre.h" namespace maple { -#define JAVALANG (mirModule->IsJavaModule()) - // ================ Step 6: Code Motion ================ void MeStorePre::CheckCreateCurTemp() { if (curTemp != nullptr) { @@ -261,25 +259,25 @@ void MeStorePre::CreateSpreUseOccsThruAliasing(const OriginalSt *muOst, BB *bb) } } -void MeStorePre::FindAndCreateSpreUseOccs(MeExpr *x, BB *bb) { - ASSERT_NOT_NULL(x); +void MeStorePre::FindAndCreateSpreUseOccs(MeExpr *meExpr, BB *bb) { + ASSERT_NOT_NULL(meExpr); ASSERT_NOT_NULL(bb); - if (x->GetMeOp() == kMeOpVar) { - auto *varx = static_cast(x); - const OriginalSt *ost = ssaTab->GetOriginalStFromID(varx->GetOStIdx()); + if (meExpr->GetMeOp() == kMeOpVar) { + auto *var = static_cast(meExpr); + const OriginalSt *ost = ssaTab->GetOriginalStFromID(var->GetOStIdx()); if (!ost->IsVolatile()) { - CreateUseOcc(varx->GetOStIdx(), bb); + CreateUseOcc(var->GetOStIdx(), bb); } return; } - for (uint8 i = 0; i < x->GetNumOpnds(); i++) { - FindAndCreateSpreUseOccs(x->GetOpnd(i), bb); + for (uint8 i = 0; i < meExpr->GetNumOpnds(); i++) { + FindAndCreateSpreUseOccs(meExpr->GetOpnd(i), bb); } - if (JAVALANG) { + if (IsJavaLang()) { return; } - if (x->GetMeOp() == kMeOpIvar) { - auto *ivarMeExpr = static_cast(x); + if (meExpr->GetMeOp() == kMeOpIvar) { + auto *ivarMeExpr = static_cast(meExpr); if (ivarMeExpr->GetMu() != nullptr) { CreateSpreUseOccsThruAliasing(ssaTab->GetOriginalStFromID(ivarMeExpr->GetMu()->GetOStIdx()), bb); } @@ -336,7 +334,7 @@ void MeStorePre::BuildWorkListBB(BB *bb) { CHECK_NULL_FATAL(stmt->GetOpnd(i)); FindAndCreateSpreUseOccs(stmt->GetOpnd(i), stmt->GetBB()); } - if (!JAVALANG) { + if (!IsJavaLang()) { // go thru mu list NaryMeStmt *naryMeStmt = safe_cast(to_ptr(stmt)); if (naryMeStmt != nullptr) { diff --git a/src/maple_me/src/occur.cpp b/src/maple_me/src/occur.cpp index d5293600a8bb85c65f611297843ee88b37ea8149..2cceb78595ed648cf5e91f354214d5692b1af7a3 100644 --- a/src/maple_me/src/occur.cpp +++ b/src/maple_me/src/occur.cpp @@ -38,7 +38,7 @@ void MeOccur::DumpOccur(IRMap &irMap) { mod->GetOut() << "MeOccur "; Dump(irMap); mod->GetOut() << "\n class: " << classID << '\n'; - if (def) { + if (def != nullptr) { mod->GetOut() << " def by class: " << def->GetClassID(); } else { mod->GetOut() << " no-def"; @@ -111,7 +111,7 @@ MeExpr *MeOccur::GetSavedExpr() { // operand is nullptr (def is null), or // hasRealUse is false and defined by a PHI not will be avail bool MePhiOpndOcc::IsOkToInsert() { - if (!GetDef()) { + if (GetDef() == nullptr) { return true; } if (!hasRealUse) { @@ -152,12 +152,12 @@ void MeRealOcc::Dump(IRMap &irMap) { } else { mod->GetOut() << "RealOcc(LHS) "; } - if (meExpr) { + if (meExpr != nullptr) { meExpr->Dump(&irMap); } else { meStmt->Dump(&irMap); } - if (meStmt && meStmt->GetBB()) { + if (meStmt != nullptr && meStmt->GetBB()) { mod->GetOut() << " at bb" << meStmt->GetBB()->GetBBId() << " seq " << seq << " classID " << GetClassID(); } else { mod->GetOut() << " classID " << GetClassID(); @@ -229,19 +229,18 @@ uint32 PreWorkCand::ComputeWorkCandHashIndex(MeExpr &meExpr) { } case kMeOpOp: { hIdx = static_cast(meExpr.GetOp()); - for (size_t idx = 0; idx < kOperandNumTernary; idx++) { + for (size_t idx = 0; idx < kOperandNumTernary; ++idx) { MeExpr *opnd = meExpr.GetOpnd(idx); - if (opnd != nullptr) { - hIdx += ComputeWorkCandHashIndex(*opnd) << kOffsetOpMeExprOpnd; - } else { + if (opnd == nullptr) { break; } + hIdx += ComputeWorkCandHashIndex(*opnd) << kOffsetOpMeExprOpnd; } break; } case kMeOpNary: { hIdx = static_cast(meExpr.GetOp()); - for (uint8 i = 0; i < meExpr.GetNumOpnds(); i++) { + for (uint8 i = 0; i < meExpr.GetNumOpnds(); ++i) { hIdx += ComputeWorkCandHashIndex(*meExpr.GetOpnd(i)) << kOffsetNaryMeExprOpnd; } break; @@ -292,10 +291,10 @@ void PreWorkCand::AddRealOccSorted(Dominance &dom, MeRealOcc &occ, PUIdx pIdx) { bool found = false; do { if (occDfn > dom.GetDtDfnItem((*it)->GetBB()->GetBBId())) { - it++; + ++it; } else if (occDfn == dom.GetDtDfnItem((*it)->GetBB()->GetBBId())) { if (occ.GetSequence() > (*it)->GetSequence()) { - it++; + ++it; } else { found = true; } @@ -334,7 +333,7 @@ uint32 PreStmtWorkCand::ComputeStmtWorkCandHashIndex(MeStmt &stmt) { if (stmt.GetOp() == OP_intrinsiccallwithtype) { hIdx += static_cast(intrnStmt.GetTyIdx()) << 1; } - for (size_t i = 0; i < intrnStmt.NumMeStmtOpnds(); i++) { + for (size_t i = 0; i < intrnStmt.NumMeStmtOpnds(); ++i) { hIdx += ComputeWorkCandHashIndex(*intrnStmt.GetOpnd(i)) << 1; } break; @@ -342,7 +341,7 @@ uint32 PreStmtWorkCand::ComputeStmtWorkCandHashIndex(MeStmt &stmt) { case OP_callassigned: { auto &callAss = static_cast(stmt); hIdx += callAss.GetPUIdx(); - for (size_t i = 0; i < callAss.NumMeStmtOpnds(); i++) { + for (size_t i = 0; i < callAss.NumMeStmtOpnds(); ++i) { hIdx += ComputeWorkCandHashIndex(*callAss.GetOpnd(i)) << kOffsetNaryMeStmtOpnd; } if (!callAss.GetMustDefList()->empty()) { diff --git a/src/maple_me/src/prop.cpp b/src/maple_me/src/prop.cpp index 89a3f8c6826c32f489fd031c7e144823373647dd..a3141471644ffba113a48315369ced39d2d51a8c 100644 --- a/src/maple_me/src/prop.cpp +++ b/src/maple_me/src/prop.cpp @@ -167,13 +167,11 @@ MeExpr *Prop::SimplifyMeExpr(OpMeExpr &opMeExpr) { return SimplifyCompareMeExpr(opMeExpr); } - switch (opcode) { - case OP_cvt: { - return SimplifyCvtMeExpr(opMeExpr); - } - default: - return nullptr; + if (opcode == OP_cvt) { + return SimplifyCvtMeExpr(opMeExpr); } + + return nullptr; } void Prop::PropUpdateDef(MeExpr &meExpr) { @@ -240,8 +238,7 @@ bool Prop::IsVersionConsistent(const std::vector &vstVec, continue; } SafeMeExprPtr curDef = pStack.top(); - CHECK_FATAL(curDef->GetMeOp() == kMeOpVar || curDef->GetMeOp() == kMeOpReg, - "error: cur def error"); + CHECK_FATAL(curDef->GetMeOp() == kMeOpVar || curDef->GetMeOp() == kMeOpReg, "error: cur def error"); if (subExpr != curDef.get()) { return false; } @@ -278,14 +275,14 @@ bool Prop::Propagatable(const MeExpr &expr, const BB &fromBB, bool atParm) const break; } case kMeOpReg: { - auto ®readx = static_cast(expr); - if (regreadx.GetRegIdx() < 0) { + auto ®Read = static_cast(expr); + if (regRead.GetRegIdx() < 0) { return false; } // get the current definition version - std::vector regreadVec; - CollectSubVarMeExpr(expr, regreadVec); - if (!IsVersionConsistent(regreadVec, vstLiveStackVec)) { + std::vector regReadVec; + CollectSubVarMeExpr(expr, regReadVec); + if (!IsVersionConsistent(regReadVec, vstLiveStackVec)) { return false; } break; diff --git a/src/maple_me/src/ssa_epre.cpp b/src/maple_me/src/ssa_epre.cpp index a0ca7bada54c62ba4a89ce609b2515af79f56293..47f09a482a8f40ad5b7c32d3c9e0c8212766abca 100644 --- a/src/maple_me/src/ssa_epre.cpp +++ b/src/maple_me/src/ssa_epre.cpp @@ -142,7 +142,7 @@ void SSAEPre::GenerateReloadRealOcc(MeRealOcc *realOcc) { } else { CHECK_FATAL(false, "NYI"); } - ASSERT(regOrVar, "temp not yet generated"); + ASSERT(regOrVar != nullptr, "temp not yet generated"); // replace realOcc->GetMeStmt()'s occ with regOrVar bool isReplaced = irMap->ReplaceMeExprStmt(*realOcc->GetMeStmt(), *realOcc->GetMeExpr(), *regOrVar); // update worklist @@ -155,7 +155,7 @@ void SSAEPre::GenerateReloadRealOcc(MeRealOcc *realOcc) { // phi opnd MeExpr *SSAEPre::PhiOpndFromRes(MeRealOcc *realZ, size_t j) { MeOccur *defZ = realZ->GetDef(); - CHECK_FATAL(defZ, "must be def by phiocc"); + 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())); BB *ePhiBB = defZ->GetBB(); diff --git a/src/maple_me/src/ssa_pre.cpp b/src/maple_me/src/ssa_pre.cpp index 71d3c41b7728641bf82e993f72c11efe6e7e6f32..3e87b86888fa49a0133833bac15d7f221f114c19 100644 --- a/src/maple_me/src/ssa_pre.cpp +++ b/src/maple_me/src/ssa_pre.cpp @@ -89,7 +89,6 @@ MeExpr *SSAPre::CreateNewCurTemp(MeExpr *meExpr) { } } - VarMeExpr *SSAPre::CreateNewCurLocalRefVar() { if (curLocalRefVar) { // only need to create a new version @@ -171,56 +170,57 @@ void SSAPre::GenerateSavePhiOcc(MePhiOcc *phiOcc) { void SSAPre::UpdateInsertedPhiOccOpnd() { for (auto it = phiOccs.begin(); it != phiOccs.end(); ++it) { MePhiOcc *phiOcc = *it; - if (phiOcc->IsWillBeAvail() && !phiOcc->IsExtraneous()) { - if (phiOcc->GetRegPhi()) { - MeRegPhiNode *phiReg = phiOcc->GetRegPhi(); + if (!phiOcc->IsWillBeAvail() || phiOcc->IsExtraneous()) { + continue; + } + if (phiOcc->GetRegPhi()) { + MeRegPhiNode *phiReg = phiOcc->GetRegPhi(); + for (MePhiOpndOcc *phiOpnd : phiOcc->GetPhiOpnds()) { + auto *regOpnd = static_cast(phiOpnd->GetDef()->GetSavedExpr()); + if (regOpnd == nullptr) { + // create a zero version + CHECK_FATAL(curTemp != nullptr, "curTemp can't be null in SSAPre::UpdateInsertedPhiOccOpnd"); + regOpnd = irMap->CreateRegMeExprVersion(static_cast(*curTemp)); + } + phiReg->GetOpnds().push_back(regOpnd); + regOpnd->GetPhiUseSet().insert(phiReg); // record all the uses phi node for preg renaming + } + phiOcc->GetBB()->GetMeRegPhiList().insert(std::make_pair(phiReg->GetOpnd(0)->GetOstIdx(), phiReg)); + if (workCand->NeedLocalRefVar() && phiOcc->GetVarPhi() != nullptr) { + MeVarPhiNode *phiVar = phiOcc->GetVarPhi(); for (MePhiOpndOcc *phiOpnd : phiOcc->GetPhiOpnds()) { auto *regOpnd = static_cast(phiOpnd->GetDef()->GetSavedExpr()); + VarMeExpr *localRefVarOpnd = nullptr; if (regOpnd == nullptr) { // create a zero version - CHECK_FATAL(curTemp != nullptr, "curTemp can't be null in SSAPre::UpdateInsertedPhiOccOpnd"); - regOpnd = irMap->CreateRegMeExprVersion(static_cast(*curTemp)); - } - phiReg->GetOpnds().push_back(regOpnd); - regOpnd->GetPhiUseSet().insert(phiReg); // record all the uses phi node for preg renaming - } - phiOcc->GetBB()->GetMeRegPhiList().insert(std::make_pair(phiReg->GetOpnd(0)->GetOstIdx(), phiReg)); - if (workCand->NeedLocalRefVar() && phiOcc->GetVarPhi() != nullptr) { - MeVarPhiNode *phiVar = phiOcc->GetVarPhi(); - for (MePhiOpndOcc *phiOpnd : phiOcc->GetPhiOpnds()) { - auto *regOpnd = static_cast(phiOpnd->GetDef()->GetSavedExpr()); - VarMeExpr *localRefVarOpnd = nullptr; - if (regOpnd == nullptr) { - // create a zero version + CHECK_FATAL(curLocalRefVar != nullptr, "null ptr check"); + const OriginalSt *ost = ssaTab->GetOriginalStFromID(curLocalRefVar->GetOStIdx()); + localRefVarOpnd = irMap->GetOrCreateZeroVersionVarMeExpr(*ost); + } else { + MapleMap::iterator mapIt = temp2LocalRefVarMap.find(regOpnd); + if (mapIt == temp2LocalRefVarMap.end()) { CHECK_FATAL(curLocalRefVar != nullptr, "null ptr check"); const OriginalSt *ost = ssaTab->GetOriginalStFromID(curLocalRefVar->GetOStIdx()); localRefVarOpnd = irMap->GetOrCreateZeroVersionVarMeExpr(*ost); } else { - MapleMap::iterator mapIt = temp2LocalRefVarMap.find(regOpnd); - if (mapIt == temp2LocalRefVarMap.end()) { - CHECK_FATAL(curLocalRefVar != nullptr, "null ptr check"); - const OriginalSt *ost = ssaTab->GetOriginalStFromID(curLocalRefVar->GetOStIdx()); - localRefVarOpnd = irMap->GetOrCreateZeroVersionVarMeExpr(*ost); - } else { - localRefVarOpnd = mapIt->second; - } + localRefVarOpnd = mapIt->second; } - phiVar->GetOpnds().push_back(localRefVarOpnd); - } - phiOcc->GetBB()->GetMevarPhiList().insert(std::make_pair(phiVar->GetOpnd(0)->GetOStIdx(), phiVar)); - } - } else { - MeVarPhiNode *phiVar = phiOcc->GetVarPhi(); - for (MePhiOpndOcc *phiOpnd : phiOcc->GetPhiOpnds()) { - auto *varOpnd = static_cast(phiOpnd->GetDef()->GetSavedExpr()); - if (varOpnd == nullptr) { - CHECK_FATAL(curTemp != nullptr, "curTemp can't be null in SSAPre::UpdateInsertedPhiOccOpnd"); - varOpnd = irMap->CreateVarMeExprVersion(static_cast(*curTemp)); } - phiVar->GetOpnds().push_back(varOpnd); + phiVar->GetOpnds().push_back(localRefVarOpnd); } phiOcc->GetBB()->GetMevarPhiList().insert(std::make_pair(phiVar->GetOpnd(0)->GetOStIdx(), phiVar)); } + } else { + MeVarPhiNode *phiVar = phiOcc->GetVarPhi(); + for (MePhiOpndOcc *phiOpnd : phiOcc->GetPhiOpnds()) { + auto *varOpnd = static_cast(phiOpnd->GetDef()->GetSavedExpr()); + if (varOpnd == nullptr) { + CHECK_FATAL(curTemp != nullptr, "curTemp can't be null in SSAPre::UpdateInsertedPhiOccOpnd"); + varOpnd = irMap->CreateVarMeExprVersion(static_cast(*curTemp)); + } + phiVar->GetOpnds().push_back(varOpnd); + } + phiOcc->GetBB()->GetMevarPhiList().insert(std::make_pair(phiVar->GetOpnd(0)->GetOStIdx(), phiVar)); } } } @@ -317,32 +317,33 @@ void SSAPre::Finalize1() { // we assume one phiOpnd has only one phiOcc use because critical edge split the blocks auto *phiOpnd = static_cast(occ); MePhiOcc *phiOcc = phiOpnd->GetDefPhiOcc(); - if (phiOcc->IsWillBeAvail()) { - if (phiOpnd->IsOkToInsert()) { - // insert the current expression at the end of the block containing phiOpnd - if (phiOpnd->GetBB()->GetSucc().size() > 1) { - CHECK_FATAL(!workCand->Redo2HandleCritEdges(), "Finalize1: insertion at critical edge, aborting"); - workCand->SetRedo2HandleCritEdges(true); - if (GetSSAPreDebug()) { - mirModule->GetOut() << "<<<<< Re-doing this candidate due to existence of critical edge >>>>>\n"; - } - return; - } - MeExpr *insertedExpr = phiOpnd->GetCurrentMeExpr(); - ASSERT(insertedExpr != nullptr, "NYI"); - MeInsertedOcc *insertedOcc = - perCandMemPool->New(insertedExpr, static_cast(nullptr), phiOpnd->GetBB()); - insertedOcc->SetClassID(classCount++); - phiOpnd->SetDef(insertedOcc); - phiOpnd->SetClassID(insertedOcc->GetClassID()); - if (workCand->GetPUIdx() != GetPUIdx()) { - ASSERT(!workCand->HasLocalOpnd(), "candidate with local opnd cannot be inserted outside its PU"); - workCand->SetPUIdx(0); + if (!phiOcc->IsWillBeAvail()) { + break; + } + if (phiOpnd->IsOkToInsert()) { + // insert the current expression at the end of the block containing phiOpnd + if (phiOpnd->GetBB()->GetSucc().size() > 1) { + CHECK_FATAL(!workCand->Redo2HandleCritEdges(), "Finalize1: insertion at critical edge, aborting"); + workCand->SetRedo2HandleCritEdges(true); + if (GetSSAPreDebug()) { + mirModule->GetOut() << "<<<<< Re-doing this candidate due to existence of critical edge >>>>>\n"; } - phiOpnd->SetIsInsertedOcc(true); - } else { - phiOpnd->SetDef(availDefVec[classX]); + return; } + MeExpr *insertedExpr = phiOpnd->GetCurrentMeExpr(); + ASSERT(insertedExpr != nullptr, "NYI"); + MeInsertedOcc *insertedOcc = + perCandMemPool->New(insertedExpr, static_cast(nullptr), phiOpnd->GetBB()); + insertedOcc->SetClassID(classCount++); + phiOpnd->SetDef(insertedOcc); + phiOpnd->SetClassID(insertedOcc->GetClassID()); + if (workCand->GetPUIdx() != GetPUIdx()) { + ASSERT(!workCand->HasLocalOpnd(), "candidate with local opnd cannot be inserted outside its PU"); + workCand->SetPUIdx(0); + } + phiOpnd->SetIsInsertedOcc(true); + } else { + phiOpnd->SetDef(availDefVec[classX]); } break; } @@ -355,24 +356,26 @@ void SSAPre::Finalize1() { ASSERT(false, "should not be here"); } } - if (GetSSAPreDebug()) { - PreWorkCand *curCand = workCand; - mirModule->GetOut() << "========ssapre candidate " << curCand->GetIndex() << - " after Finalize1===================\n"; - for (auto it = phiOccs.begin(); it != phiOccs.end(); ++it) { - MePhiOcc *phiOcc = *it; - if (phiOcc->IsWillBeAvail()) { - for (MePhiOpndOcc *phiOpnd : phiOcc->GetPhiOpnds()) { - ASSERT(phiOpnd->GetDef(), "EPhiFinalizer::DumpFinalize1: phiopndocc cannot have no def"); - MeOccur *defOcc = phiOpnd->GetDef(); - if (defOcc->GetOccType() == kOccInserted) { - auto *realDefOcc = static_cast(defOcc); - phiOpnd->Dump(*irMap); - mirModule->GetOut() << " was inserted by "; - realDefOcc->Dump(*irMap); - mirModule->GetOut() << "\n"; - } - } + if (!GetSSAPreDebug()) { + return; + } + PreWorkCand *curCand = workCand; + mirModule->GetOut() << "========ssapre candidate " << curCand->GetIndex() << + " after Finalize1===================\n"; + for (auto it = phiOccs.begin(); it != phiOccs.end(); ++it) { + MePhiOcc *phiOcc = *it; + if (!phiOcc->IsWillBeAvail()) { + continue; + } + for (MePhiOpndOcc *phiOpnd : phiOcc->GetPhiOpnds()) { + ASSERT(phiOpnd->GetDef() != nullptr, "EPhiFinalizer::DumpFinalize1: phiopndocc cannot have no def"); + MeOccur *defOcc = phiOpnd->GetDef(); + if (defOcc->GetOccType() == kOccInserted) { + auto *realDefOcc = static_cast(defOcc); + phiOpnd->Dump(*irMap); + mirModule->GetOut() << " was inserted by "; + realDefOcc->Dump(*irMap); + mirModule->GetOut() << "\n"; } } } @@ -381,7 +384,7 @@ 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, "invalid defX"); + CHECK_FATAL(defX != nullptr, "invalid defX"); if (defX->GetOccType() == kOccReal) { auto *realOcc = static_cast(defX); realOcc->SetIsSave(true); @@ -390,7 +393,7 @@ void SSAPre::SetSave(MeOccur *defX) { for (MePhiOpndOcc *phiOpnd : static_cast(defX)->GetPhiOpnds()) { if (!phiOpnd->IsProcessed()) { phiOpnd->SetIsProcessed(true); - ASSERT(phiOpnd->GetDef(), "EPhiFinalizer::SetSave: phiopndocc cannot have no def"); + ASSERT(phiOpnd->GetDef() != nullptr, "EPhiFinalizer::SetSave: phiopndocc cannot have no def"); SetSave(phiOpnd->GetDef()); } } @@ -413,15 +416,15 @@ void SSAPre::SetSave(MeOccur *defX) { } } -void SSAPre::SetReplacement(MePhiOcc *occg, MeOccur *repDef) { - occg->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() == occg) { + if (phiOpnd->GetDef() == occ) { if (phiOcc->IsExtraneous()) { // exclude recursive def SetReplacement(phiOcc, repDef); @@ -435,8 +438,8 @@ void SSAPre::SetReplacement(MePhiOcc *occg, 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 occg, do the replacement - if (realOcc->IsReload() && realOcc->GetDef() == occg) { + // when realOcc satisfying reload and def of it is occ, do the replacement + if (realOcc->IsReload() && realOcc->GetDef() == occ) { realOcc->SetDef(repDef); realOcc->SetClassID(repDef->GetClassID()); } @@ -505,9 +508,9 @@ void SSAPre::Finalize2() { mirModule->GetOut() << " isSave\n"; } } else if (occ->GetOccType() == kOccPhiopnd) { - auto *phiopndocc = static_cast(occ); - if (phiopndocc->IsInsertedOcc()) { - phiopndocc->Dump(*irMap); + auto *phiOpndOcc = static_cast(occ); + if (phiOpndOcc->IsInsertedOcc()) { + phiOpndOcc->Dump(*irMap); mirModule->GetOut() << " inserthere\n"; } } @@ -518,14 +521,14 @@ 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 *occg) { - occg->SetIsCanBeAvail(false); - // the following loop is to find occg's use list and reset them +void SSAPre::ResetCanBeAvail(MePhiOcc *occ) { + 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() == occg) { - // when comes here, phiOpnd->GetDef() is a use of occg + if (phiOpnd->GetDef() && phiOpnd->GetDef() == occ) { + // when comes here, phiOpnd->GetDef() is a use of occ if (!phiOpnd->HasRealUse() && !phiOcc->IsDownSafe() && phiOcc->IsCanBeAvail()) { ResetCanBeAvail(phiOcc); } @@ -564,14 +567,14 @@ void SSAPre::ComputeCanBeAvail() { } } -void SSAPre::ResetLater(MePhiOcc *occg) { - occg->SetIsLater(false); - // the following loop is to find occg's use list and reset them +void SSAPre::ResetLater(MePhiOcc *occ) { + 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() == occg) { - // when comes here, phiOpnd->GetDef() is a use of occg + if (phiOpnd->GetDef() && phiOpnd->GetDef() == occ) { + // when comes here, phiOpnd->GetDef() is a use of occ if (phiOcc->IsLater()) { ResetLater(phiOcc); } @@ -887,60 +890,61 @@ void SSAPre::Rename2() { auto &phiOpnds = defPhiOcc->GetPhiOpnds(); for (size_t i = 0; i < phiOpnds.size(); i++) { MePhiOpndOcc *phiOpnd = phiOpnds[i]; - if (!phiOpnd->IsProcessed()) { - phiOpnd->SetIsProcessed(true); - 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) { - continue; - } - if (defX->GetOccType() == kOccReal) { - auto *realDefX = static_cast(defX); - std::vector varvecX; - std::vector 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++) { - if (varvecX[ii] != varvecY[ii]) { - hasSameVersion = false; - } + if (phiOpnd->IsProcessed()) { + continue; + } + phiOpnd->SetIsProcessed(true); + 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) { + continue; + } + if (defX->GetOccType() == kOccReal) { + auto *realDefX = static_cast(defX); + std::vector varVecX; + std::vector 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++) { + if (varVecX[ii] != varVecY[ii]) { + hasSameVersion = false; } - if (!hasSameVersion) { - phiOpnd->SetDef(nullptr); - phiOpnd->SetHasRealUse(false); + } + if (!hasSameVersion) { + phiOpnd->SetDef(nullptr); + phiOpnd->SetHasRealUse(false); + } + } else if (defX->GetOccType() == kOccPhiocc) { + std::vector varVecY; + bool alldom = true; + CollectVarForMeExpr(exprY, varVecY); + for (size_t ii = 0; ii < varVecY.size(); ++ii) { + if (!DefVarDominateOcc(varVecY[ii], defX)) { + alldom = false; } - } else if (defX->GetOccType() == kOccPhiocc) { - std::vector varvecY; - bool alldom = true; - CollectVarForMeExpr(exprY, varvecY); - for (size_t ii = 0; ii < varvecY.size(); ++ii) { - if (!DefVarDominateOcc(varvecY[ii], defX)) { - alldom = false; - } + } + if (alldom) { + // create a realOcc and add to rename2 set + MeRealOcc *occY = perCandMemPool->New(static_cast(nullptr), 0, exprY); + occY->SetPosition(workCand->GetRealOccs().size()); + workCand->GetRealOccs().push_back(occY); + occY->SetDef(defX); + occY->SetClassID(defX->GetClassID()); + rename2Set.insert(occY->GetPosition()); + if (GetSSAPreDebug()) { + mirModule->GetOut() << "--- rename2 adds to rename2Set manufactured "; + occY->Dump(*irMap); + mirModule->GetOut() << '\n'; } - if (alldom) { - // create a realOcc and add to rename2 set - MeRealOcc *occY = perCandMemPool->New(static_cast(nullptr), 0, exprY); - occY->SetPosition(workCand->GetRealOccs().size()); - workCand->GetRealOccs().push_back(occY); - occY->SetDef(defX); - occY->SetClassID(defX->GetClassID()); - rename2Set.insert(occY->GetPosition()); - if (GetSSAPreDebug()) { - mirModule->GetOut() << "--- rename2 adds to rename2Set manufactured "; - occY->Dump(*irMap); - mirModule->GetOut() << '\n'; - } - } else { - phiOpnd->SetDef(nullptr); - phiOpnd->SetHasRealUse(false); - auto *phidefx = static_cast(defX); - if (!phidefx->SpeculativeDownSafe()) { - phidefx->SetIsDownSafe(false); - } + } else { + phiOpnd->SetDef(nullptr); + phiOpnd->SetHasRealUse(false); + auto *phidefx = static_cast(defX); + if (!phidefx->SpeculativeDownSafe()) { + phidefx->SetIsDownSafe(false); } } } @@ -965,9 +969,9 @@ void SSAPre::SetVarPhis(MeExpr *meExpr) { if (meOp == kMeOpVar) { 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)); + 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); @@ -1012,7 +1016,7 @@ void SSAPre::CreateSortedOccs() { if (GetRcLoweringOn()) { BuildEntryLHSOcc4Formals(); } - std::unordered_map> bb2phiopndMap; + std::unordered_map> bb2PhiOpndMap; MapleVector::iterator realOccIt = workCand->GetRealOccs().begin(); MapleVector::iterator exitOccIt = exitOccs.begin(); auto phiDfnIt = dfPhiDfns.begin(); @@ -1033,11 +1037,11 @@ void SSAPre::CreateSortedOccs() { MePhiOpndOcc *nextPhiOpndOcc = nullptr; if (phiOpndDfnIt != phiOpndDfns.end()) { nextPhiOpndOcc = perCandMemPool->New(GetBB(dom->GetDtPreOrderItem(*phiOpndDfnIt))); - auto it = bb2phiopndMap.find(dom->GetDtPreOrderItem(*phiOpndDfnIt)); - if (it == bb2phiopndMap.end()) { + auto it = bb2PhiOpndMap.find(dom->GetDtPreOrderItem(*phiOpndDfnIt)); + if (it == bb2PhiOpndMap.end()) { std::forward_list newlist = { nextPhiOpndOcc }; CHECK(*phiOpndDfnIt < dom->GetDtPreOrderSize(), "index out of range in SSAPre::CreateSortedOccs"); - bb2phiopndMap[dom->GetDtPreOrderItem(*phiOpndDfnIt)] = newlist; + bb2PhiOpndMap[dom->GetDtPreOrderItem(*phiOpndDfnIt)] = newlist; } else { it->second.push_front(nextPhiOpndOcc); } @@ -1099,10 +1103,10 @@ void SSAPre::CreateSortedOccs() { ++phiOpndDfnIt; if (phiOpndDfnIt != phiOpndDfns.end()) { nextPhiOpndOcc = perCandMemPool->New(GetBB(dom->GetDtPreOrderItem(*phiOpndDfnIt))); - auto it = bb2phiopndMap.find(dom->GetDtPreOrderItem(*phiOpndDfnIt)); - if (it == bb2phiopndMap.end()) { + auto it = bb2PhiOpndMap.find(dom->GetDtPreOrderItem(*phiOpndDfnIt)); + if (it == bb2PhiOpndMap.end()) { std::forward_list newlist = { nextPhiOpndOcc }; - bb2phiopndMap[dom->GetDtPreOrderItem(*phiOpndDfnIt)] = newlist; + bb2PhiOpndMap[dom->GetDtPreOrderItem(*phiOpndDfnIt)] = newlist; } else { it->second.push_front(nextPhiOpndOcc); } @@ -1119,10 +1123,10 @@ void SSAPre::CreateSortedOccs() { // each MePhiOpndOcc node for (MePhiOcc *phiOcc : phiOccs) for (BB *pred : phiOcc->GetBB()->GetPred()) { - MePhiOpndOcc *phiopndocc = bb2phiopndMap[pred->GetBBId()].front(); - phiOcc->AddPhiOpnd(*phiopndocc); - phiopndocc->SetDefPhiOcc(*phiOcc); - bb2phiopndMap[pred->GetBBId()].pop_front(); + MePhiOpndOcc *phiOpndOcc = bb2PhiOpndMap[pred->GetBBId()].front(); + phiOcc->AddPhiOpnd(*phiOpndOcc); + phiOpndOcc->SetDefPhiOcc(*phiOcc); + bb2PhiOpndMap[pred->GetBBId()].pop_front(); } if (GetSSAPreDebug()) { mirModule->GetOut() << "========ssapre candidate " << workCand->GetIndex() << @@ -1272,21 +1276,21 @@ bool SSAPre::DefVarDominateOcc(MeExpr *meExpr, MeOccur *meOcc) { } } -bool SSAPre::CheckIfAnyLocalOpnd(MeExpr *x) { - switch (x->GetMeOp()) { +bool SSAPre::CheckIfAnyLocalOpnd(MeExpr *meExpr) { + switch (meExpr->GetMeOp()) { case kMeOpReg: return true; case kMeOpVar: { - auto *varMeExpr = static_cast(x); + auto *varMeExpr = static_cast(meExpr); const MIRSymbol *st = ssaTab->GetMIRSymbolFromID(varMeExpr->GetOStIdx()); return st->IsLocal(); } case kMeOpIvar: { - auto *ivarMeExpr = static_cast(x); + auto *ivarMeExpr = static_cast(meExpr); return CheckIfAnyLocalOpnd(ivarMeExpr->GetBase()); } case kMeOpOp: { - auto *opMeExpr = static_cast(x); + auto *opMeExpr = static_cast(meExpr); if (CheckIfAnyLocalOpnd(opMeExpr->GetOpnd(0))) { return true; } @@ -1302,11 +1306,12 @@ bool SSAPre::CheckIfAnyLocalOpnd(MeExpr *x) { return CheckIfAnyLocalOpnd(opMeExpr->GetOpnd(2)); } case kMeOpNary: { - auto *naryMeExpr = static_cast(x); - for (MeExpr *opnd : naryMeExpr->GetOpnds()) + auto *naryMeExpr = static_cast(meExpr); + for (MeExpr *opnd : naryMeExpr->GetOpnds()) { if (CheckIfAnyLocalOpnd(opnd)) { return true; } + } return false; } default: @@ -1319,9 +1324,9 @@ MeRealOcc *SSAPre::CreateRealOcc(MeStmt &meStmt, int seqStmt, MeExpr &meExpr, bo uint32 hashIdx = PreWorkCand::ComputeWorkCandHashIndex(meExpr); PreWorkCand *wkCand = PreWorkCand::GetWorkcandFromIndex(hashIdx); while (wkCand != nullptr) { - MeExpr *x = wkCand->GetTheMeExpr(); - ASSERT(x != nullptr, "CreateRealOcc: found workcand with theMeExpr as nullptr"); - if (x->IsTheSameWorkcand(meExpr)) { + MeExpr *currMeExpr = wkCand->GetTheMeExpr(); + ASSERT(currMeExpr != nullptr, "CreateRealOcc: found workcand with theMeExpr as nullptr"); + if (currMeExpr->IsTheSameWorkcand(meExpr)) { break; } wkCand = static_cast(wkCand->GetNext()); @@ -1567,9 +1572,9 @@ void SSAPre::BuildWorkListStmt(MeStmt *meStmt, uint32 seqStmt, bool isRebuilt, M } 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); + auto *assMeStmt = static_cast(meStmt); + BuildWorkListExpr(meStmt, seqStmt, assMeStmt->GetOpnd(0), isRebuilt, tempVar, true); + BuildWorkListExpr(meStmt, seqStmt, assMeStmt->GetOpnd(1), isRebuilt, tempVar, true); break; } default: diff --git a/src/maple_util/include/name_mangler.h b/src/maple_util/include/name_mangler.h index 221f90a1b04bd66718f4364d9e9ffb5498d1fab4..8d05ee40e84097db5766035eac4b6628d8b71b1e 100644 --- a/src/maple_util/include/name_mangler.h +++ b/src/maple_util/include/name_mangler.h @@ -20,7 +20,6 @@ // This is a general name mangler which is shared between maple compiler and runtime. // maple-compiler-specific data structure may NOT be used here. namespace NameMangler { - #define TO_STR(s) TO_STR2(s) #define TO_STR2(s) #s @@ -135,6 +134,7 @@ static constexpr const char kJavaLangStringStr[] = "Ljava_2Flang_2FString_3B"; static constexpr const char kJavaLangExceptionStr[] = "Ljava_2Flang_2FException_3B"; static constexpr const char kThrowClassStr[] = "Ljava_2Flang_2FThrowable_3B"; static constexpr const char kReflectionClassesPrefixStr[] = "Ljava_2Flang_2Freflect_2F"; +static constexpr const char kReflectionClassMethodStr[] = "Ljava_2Flang_2Freflect_2FMethod_241_3B"; static constexpr const char kClassMetadataTypeName[] = "__class_meta__"; static constexpr const char kPtrPrefixStr[] = "_PTR"; static constexpr const char kClassINfoPtrPrefixStr[] = "_PTR__cinf_"; @@ -183,7 +183,6 @@ int64_t GetSleb128Decode(uint64_t val); size_t GetUleb128Size(uint64_t val); size_t GetSleb128Size(int32_t val); bool NeedConvertUTF16(const std::string &str8); - } // namespace NameMangler #endif diff --git a/src/maple_util/include/utils/iterator.h b/src/maple_util/include/utils/iterator.h new file mode 100644 index 0000000000000000000000000000000000000000..293b5cf5242102e68d53d85e978f929307566a53 --- /dev/null +++ b/src/maple_util/include/utils/iterator.h @@ -0,0 +1,201 @@ +/* + * 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. + */ +#ifndef MAPLE_UTIL_INCLUDE_ITERATOR_H +#define MAPLE_UTIL_INCLUDE_ITERATOR_H +#include +#include "meta.h" + +namespace maple { namespace utils { + +template +struct mpl_iterator_traits { + using iterator_category = typename std::iterator_traits::iterator_category; + using value_type = typename std::iterator_traits::value_type; + using difference_type = typename std::iterator_traits::difference_type; + using pointer = typename std::iterator_traits::pointer; + using reference = typename std::iterator_traits::reference; + + static reference operator_dereference(Iterator iter) { + return *iter; + }; + + static Iterator operator_arrow(Iterator iter) { + return iter; + } + + static reference operator_bracket(Iterator iter, difference_type n) { + return iter[n]; + } +}; + +template +class mpl_iterator { + using Traits = mpl_iterator_traits; + public: + using iterator_category = typename Traits::iterator_category; + using value_type = typename Traits::value_type; + using difference_type = typename Traits::difference_type; + using pointer = typename Traits::pointer; + using reference = typename Traits::reference; + + explicit mpl_iterator(Iterator iter) + : iter(iter) {} + + template >> + mpl_iterator(const mpl_iterator &iter) + : iter(iter.base()) {} + + ~mpl_iterator() noexcept = default; + + reference operator*() const noexcept { + return Traits::operator_dereference(iter); + } + + pointer operator->() const noexcept { + return Traits::operator_arrow(iter); + } + + mpl_iterator &operator++() noexcept { + ++iter; + return *this; + } + + mpl_iterator operator++(int) noexcept { + return mpl_iterator(iter++); + } + + mpl_iterator &operator--() noexcept { + --iter; + return *this; + } + + mpl_iterator operator--(int) noexcept { + return mpl_iterator(iter--); + } + + reference operator[](difference_type n) const noexcept { + return Traits::operator_bracket(iter, n); + } + + mpl_iterator &operator+=(difference_type n) noexcept { + iter += n; + return *this; + } + + mpl_iterator &operator-=(difference_type n) noexcept { + iter -= n; + return *this; + } + + Iterator base() const noexcept { + return iter; + } + + private: + Iterator iter; +}; + +template +inline bool operator==(const mpl_iterator &lhs, const mpl_iterator &rhs) noexcept { + return lhs.base() == rhs.base(); +} + +template >> +inline bool operator==(const mpl_iterator &lhs, const mpl_iterator &rhs) noexcept { + return lhs.base() == rhs.base(); +} + +template +inline bool operator!=(const mpl_iterator &lhs, const mpl_iterator &rhs) noexcept { + return !(lhs == rhs); +} + +template >> +inline bool operator!=(const mpl_iterator &lhs, const mpl_iterator &rhs) noexcept { + return !(lhs == rhs); +} + +template +inline bool operator<(const mpl_iterator &lhs, const mpl_iterator &rhs) noexcept { + return lhs.base() < rhs.base(); +} + +template >> +inline bool operator<(const mpl_iterator &lhs, const mpl_iterator &rhs) noexcept { + return lhs.base() < rhs.base(); +} + +template +inline bool operator<=(const mpl_iterator &lhs, const mpl_iterator &rhs) noexcept { + return lhs.base() <= rhs.base(); +} + +template >> +inline bool operator<=(const mpl_iterator &lhs, const mpl_iterator &rhs) noexcept { + return lhs.base() <= rhs.base(); +} + +template +inline bool operator>(const mpl_iterator &lhs, const mpl_iterator &rhs) noexcept { + return lhs.base() > rhs.base(); +} + +template >> +inline bool operator>(const mpl_iterator &lhs, const mpl_iterator &rhs) noexcept { + return lhs.base() > rhs.base(); +} + +template +inline bool operator>=(const mpl_iterator &lhs, const mpl_iterator &rhs) noexcept { + return lhs.base() >= rhs.base(); +} + +template >> +inline bool operator>=(const mpl_iterator &lhs, const mpl_iterator &rhs) noexcept { + return lhs.base() >= rhs.base(); +} + +template +mpl_iterator operator+(const mpl_iterator &iter, + typename mpl_iterator::difference_type n) noexcept { + return mpl_iterator(iter.base() + n); +} + +template +mpl_iterator operator+(typename mpl_iterator::difference_type n, + const mpl_iterator &iter) noexcept { + return mpl_iterator(n + iter.base()); +} + +template +mpl_iterator operator-(const mpl_iterator &iter, + typename mpl_iterator::difference_type n) noexcept { + return mpl_iterator(iter.base() - n); +} + +template +inline auto operator-(const mpl_iterator &lhs, const mpl_iterator &rhs) noexcept +-> typename mpl_iterator::difference_type { + return lhs.base() - rhs.base(); +} + +template >> +inline auto operator-(const mpl_iterator &lhs, const mpl_iterator &rhs) noexcept +-> decltype(lhs.base() - rhs.base()) { + return lhs.base() - rhs.base(); +} +}} + +#endif //MAPLE_UTIL_INCLUDE_ITERATOR_H diff --git a/src/maple_util/include/utils/ref_vector.h b/src/maple_util/include/utils/ref_vector.h new file mode 100644 index 0000000000000000000000000000000000000000..dac2b00e709078e354701a2b7c556338b588040d --- /dev/null +++ b/src/maple_util/include/utils/ref_vector.h @@ -0,0 +1,342 @@ +/* + * 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. + */ +#ifndef MAPLE_UTIL_INCLUDE_REF_VECTOR_H +#define MAPLE_UTIL_INCLUDE_REF_VECTOR_H +#include +#include "iterator.h" + +// The `utils::ref_vector` is a decorator of `std::vector` which won't destory any `T`s and just refer to them. +// +// It is designed mainly to solve the problem that only the owner who is very familiar can tell whether the `T*` can be +// nullptr. As time goes by, the others, even the owner may forget it. Or with more coding base on it, some will start +// to check nullptr, it will make the code more confusion and hard to maintain. +// Based on that, the ref_vector picks up the meaning of keeping objects' reference, it won't destory any of its +// elements or require to check null(Never to be nullptr). +// +// etc. +// `std::vector` +// ``` +// int a = 0, b = 1; +// +// std::vector data; +// data.push_back(&a); +// data.push_back(&b); +// ASSERT_EQ(*data[0], 0); +// ASSERT_EQ(*data[1], 1); +// ``` +// +// `utils::ref_vector` +// ``` +// int a = 0, b = 1; +// +// ref_vector data; +// data.push_back(a); +// data.push_back(b); +// ASSERT_EQ(data[0], 0); +// ASSERT_EQ(data[1], 1); +// ``` + +namespace maple { namespace utils { +class ref_vector_tag; +template +struct mpl_iterator_traits { + using iterator_category = typename std::iterator_traits::iterator_category; + using value_type = std::remove_pointer_t::value_type>; + using difference_type = typename std::iterator_traits::difference_type; + using pointer = value_type*; + using reference = value_type&; + + static constexpr reference operator_dereference(Iterator iter) { + return *(*iter); + }; + + static constexpr Iterator operator_arrow(Iterator iter) { + return *iter; + } + + static reference operator_bracket(Iterator iter, difference_type n) { + return *(iter[n]); + } +}; + +template > +class ref_vector { + using base_vector = std::vector; + public: + using value_type = T; + using allocator_type = Alloc; + using size_type = typename base_vector::size_type; + using difference_type = typename base_vector::difference_type; + using reference = value_type&; + using const_reference = const value_type&; + using pointer = value_type*; + using const_pointer = const value_type*; + using iterator = mpl_iterator; + using const_iterator = mpl_iterator; + using reverse_iterator = std::reverse_iterator; + using const_reverse_iterator = std::reverse_iterator; + + ref_vector() noexcept = default; + + explicit ref_vector(const allocator_type &alloc) noexcept + : base(alloc) {} + + // There shouldn't be any situation that initialize this with all the same reference. Maybe an initial small size. + explicit ref_vector(size_type count, const value_type &value, + const allocator_type &alloc = allocator_type()) = delete; + explicit ref_vector(size_type count, const allocator_type &alloc = allocator_type()) = delete; + + // The pointer is stored in the base, and the Iter owns objects instead of their pointers. + template + ref_vector(Iter first, Iter last, const allocator_type &alloc = allocator_type()) = delete; + + ref_vector(const ref_vector &other) + : base(other.base) {} + + ref_vector(const ref_vector &other, const allocator_type &alloc) + : base(other.base, alloc) {} + + ref_vector(ref_vector &&other) noexcept + : base(std::move(other)) {} + + ref_vector(ref_vector &&other, const allocator_type &alloc) noexcept + : base(std::move(other), alloc) {} + + ref_vector(std::initializer_list init, const allocator_type &alloc = allocator_type()) = delete; + + ~ref_vector() noexcept = default; + + ref_vector &operator=(const ref_vector &other) { + base = other.base; + return *this; + } + + ref_vector &operator=(ref_vector &&other) noexcept { + base = std::move(other); + } + + ref_vector &operator=(std::initializer_list init) = delete; + + void assign(size_type count, const value_type &value) = delete; + + // The pointer is stored in the base, and the Iter owns objects instead of their pointers. + template + void assign(Iter first, Iter last) = delete; + + void assign(std::initializer_list init) = delete; + + allocator_type get_allocator() const { + return base.get_allocator(); + } + + iterator begin() noexcept { + return iterator(base.begin()); + } + + const_iterator begin() const noexcept { + return const_iterator(base.begin()); + } + + iterator end() noexcept { + return iterator(base.end()); + } + + const_iterator end() const noexcept { + return const_iterator(base.end()); + } + + reverse_iterator rbegin() noexcept { + return reverse_iterator(base.rbegin()); + } + + const_reverse_iterator rbegin() const noexcept { + return const_reverse_iterator(base.rbegin()); + } + + reverse_iterator rend() noexcept { + return reverse_iterator(base.rend()); + } + + const_reverse_iterator rend() const noexcept { + return const_reverse_iterator(base.rend()); + } + + const_iterator cbegin() const noexcept { + return const_iterator(base.cbegin()); + } + + const_iterator cend() const noexcept { + return const_iterator(base.cend()); + } + + const_reverse_iterator crbegin() const noexcept { + return const_reverse_iterator(base.crbegin()); + } + + const_reverse_iterator crend() const noexcept { + return const_reverse_iterator(base.crend()); + } + + reference front() noexcept { + return *begin(); + } + + const_reference front() const noexcept { + return *begin(); + } + + reference back() noexcept { + return *(end() - 1); + } + + const_reference back() const noexcept { + return *(end() - 1); + } + + pointer data() noexcept = delete; + + const_pointer data() const noexcept = delete; + + reference at(size_type pos) { + return *(base.at(pos)); + } + + const_reference at(size_type pos) const { + return *(base.at(pos)); + } + + reference operator[](size_type pos) noexcept { + return *(base[pos]); + } + + const_reference operator[](size_type pos) const noexcept { + return *(base[pos]); + } + + bool empty() const noexcept { + return base.empty(); + } + + size_type size() const noexcept { + return base.size(); + } + + size_type max_size() const noexcept { + return base.max_size(); + } + + size_type capacity() const noexcept { + return base.capacity(); + } + + void resize(size_type n) { + base.resize(n); + } + + void resize(size_type n, value_type &value) = delete; + + void reserve(size_type n) { + base.reserve(n); + } + + void shrink_to_fit() { + base.shrink_to_fit(); + } + + void push_back(value_type &value) { + base.push_back(&value); + } + + void push_back(value_type &&value) = delete; + + template + void emplace_back(Args &&... args) = delete; + + void pop_back() noexcept { + base.pop_back(); + } + + iterator insert(const_iterator pos, value_type &value) { + return base.insert(pos, &value); + } + + iterator insert(const_iterator pos, value_type &&value) = delete; + + template + iterator insert(const_iterator pos, Iter first, Iter last) = delete; + + iterator insert(const_iterator pos, std::initializer_list init) = delete; + + template + iterator emplace(const_iterator pos, Args &&... args) = delete; + + iterator erase(const_iterator pos) { + return iterator(base.erase(pos)); + } + + iterator erase(const_iterator first, const_iterator last) { + return iterator(first.base(), last.base()); + } + + void swap(ref_vector &other) noexcept { + base.swap(other.base); + } + + void clear() noexcept { + base.clear(); + } + + private: + base_vector base; +}; + +template +inline bool operator==(const ref_vector &lhs, const ref_vector &rhs) { + return (lhs.size() == rhs.size() && std::equal(lhs.begin(), lhs.end(), rhs.begin())); +} + +template +inline bool operator!=(const ref_vector &lhs, const ref_vector &rhs) { + return !(lhs == rhs); +} + +template +inline bool operator<(const ref_vector &lhs, const ref_vector &rhs) { + return std::lexicographical_compare(lhs.begin(), lhs.end(), rhs.begin(), rhs.end()); +} + +template +inline bool operator>(const ref_vector &lhs, const ref_vector &rhs) { + return rhs < lhs; +} + +template +inline bool operator<=(const ref_vector &lhs, const ref_vector &rhs) { + return !(rhs < lhs); +} + +template +inline bool operator>=(const ref_vector &lhs, const ref_vector &rhs) { + return !(lhs < rhs); +} +}} + +namespace std { +template +inline void swap(maple::utils::ref_vector &lhs, maple::utils::ref_vector &rhs) noexcept { + lhs.swap(rhs); +} +} +#endif diff --git a/src/mpl2mpl/include/vtable_impl.h b/src/mpl2mpl/include/vtable_impl.h index d3d63eeba90f09aeba67e7d25d951451a66fb541..afbf28acf9f47cf512bf7cfc2c9224c0decf829c 100644 --- a/src/mpl2mpl/include/vtable_impl.h +++ b/src/mpl2mpl/include/vtable_impl.h @@ -1,5 +1,5 @@ /* - * Copyright (c) [2019-2020] Huawei Technologies Co.,Ltd.All rights reserved. + * Copyright (c) [2019] Huawei Technologies Co.,Ltd.All rights reserved. * * OpenArkCompiler is licensed under the Mulan PSL v1. * You can use this software according to the terms and conditions of the Mulan PSL v1. @@ -37,7 +37,6 @@ class VtableImpl : public FuncOptimizeImpl { private: void ReplaceResolveInterface(StmtNode &stmt, const ResolveFuncNode &resolveNode); - void Intrinsify(MIRFunction &func, CallNode &cnode); MIRModule *mirModule; MIRFunction *mccItabFunc; }; diff --git a/src/mpl2mpl/src/reflection_analysis.cpp b/src/mpl2mpl/src/reflection_analysis.cpp index d8a9d4adf0acc0fb92c414a54ae118c5ac29b77c..a5d8b33beed8e3ddfb0663654f27ec9396c42fec 100644 --- a/src/mpl2mpl/src/reflection_analysis.cpp +++ b/src/mpl2mpl/src/reflection_analysis.cpp @@ -1757,6 +1757,7 @@ void ReflectionAnalysis::MarkWeakMethods() { GStrIdx classNames[] = { GetOrCreateGStrIdxFromName(NameMangler::kJavaLangClassStr), GetOrCreateGStrIdxFromName(NameMangler::kJavaLangObjectStr), + GetOrCreateGStrIdxFromName(NameMangler::kReflectionClassMethodStr), GetOrCreateGStrIdxFromName(kReflectionReferencePrefixStr) }; for (GStrIdx nameIdx : classNames) { Klass *klass = klassH->GetKlassFromStrIdx(nameIdx); diff --git a/src/mpl2mpl/src/vtable_impl.cpp b/src/mpl2mpl/src/vtable_impl.cpp index 7dfa1c750b257375a51603b808fa2bb375b6ce74..99de42f21740f26bd630a46748e941d1f5350528 100644 --- a/src/mpl2mpl/src/vtable_impl.cpp +++ b/src/mpl2mpl/src/vtable_impl.cpp @@ -32,43 +32,7 @@ VtableImpl::VtableImpl(MIRModule *mod, KlassHierarchy *kh, bool dump) mccItabFunc = builder->GetOrCreateFunction(kInterfaceMethod, TyIdx(PTY_ptr)); mccItabFunc->SetAttr(FUNCATTR_nosideeffect); } -#if TARGARM || TARGAARCH64 -void VtableImpl::Intrinsify(MIRFunction &func, CallNode &cnode) { - MIRFunction *calleeFunc = GlobalTables::GetFunctionTable().GetFunctionFromPuidx(cnode.GetPUIdx()); - const std::string funcName = calleeFunc->GetName(); - MIRIntrinsicID intrnId = INTRN_UNDEFINED; - if (funcName == "Lsun_2Fmisc_2FUnsafe_3B_7CgetAndAddInt_7C_28Ljava_2Flang_2FObject_3BJI_29I") { - intrnId = INTRN_GET_AND_ADDI; - } else if (funcName == "Lsun_2Fmisc_2FUnsafe_3B_7CgetAndAddLong_7C_28Ljava_2Flang_2FObject_3BJJ_29J") { - intrnId = INTRN_GET_AND_ADDL; - } else if (funcName == "Lsun_2Fmisc_2FUnsafe_3B_7CgetAndSetInt_7C_28Ljava_2Flang_2FObject_3BJI_29I") { - intrnId = INTRN_GET_AND_SETI; - } else if (funcName == "Lsun_2Fmisc_2FUnsafe_3B_7CgetAndSetLong_7C_28Ljava_2Flang_2FObject_3BJJ_29J") { - intrnId = INTRN_GET_AND_SETL; - } else if (funcName == "Lsun_2Fmisc_2FUnsafe_3B_7CcompareAndSwapInt_7C_28Ljava_2Flang_2FObject_3BJII_29Z") { - intrnId = INTRN_COMP_AND_SWAPI; - } else if (funcName == "Lsun_2Fmisc_2FUnsafe_3B_7CcompareAndSwapLong_7C_28Ljava_2Flang_2FObject_3BJJJ_29Z") { - intrnId = INTRN_COMP_AND_SWAPL; - } - if (intrnId == INTRN_UNDEFINED) { - return; - } - CallReturnVector retvs = cnode.GetReturnVec(); - if (!retvs.empty()) { - StIdx stidx = retvs.begin()->first; - StmtNode *intrnCallStmt = nullptr; - if (stidx.Idx() != 0) { - MIRSymbol *retSt = currFunc->GetLocalOrGlobalSymbol(stidx); - intrnCallStmt = builder->CreateStmtIntrinsicCallAssigned(intrnId, cnode.GetNopnd(), retSt); - } else { - ASSERT (retvs.begin()->second.IsReg(), "return value must be preg"); - PregIdx pregIdx = retvs.begin()->second.GetPregIdx(); - intrnCallStmt = builder->CreateStmtIntrinsicCallAssigned(intrnId, cnode.GetNopnd(), pregIdx); - } - func.GetBody()->ReplaceStmt1WithStmt2(&cnode, intrnCallStmt); - } -} -#endif + void VtableImpl::ProcessFunc(MIRFunction *func) { if (func->IsEmpty()) { return; @@ -79,27 +43,6 @@ void VtableImpl::ProcessFunc(MIRFunction *func) { while (stmt != nullptr) { next = stmt->GetNext(); Opcode opcode = stmt->GetOpCode(); -#if TARGARM || TARGAARCH64 - if (kOpcodeInfo.IsCallAssigned(opcode)) { - CallNode *cnode = static_cast(stmt); - MIRFunction *calleefunc = GlobalTables::GetFunctionTable().GetFunctionFromPuidx(cnode->GetPUIdx()); - const std::set intrisicsList { -#define DEF_MIR_INTRINSIC(X, NAME, INTRN_CLASS, RETURN_TYPE, ...) NAME, -#include "simplifyintrinsics.def" -#undef DEF_MIR_INTRINSIC - }; - const std::string funcName = calleefunc->GetName(); - if (funcName == "Ljava_2Flang_2FString_3B_7CindexOf_7C_28Ljava_2Flang_2FString_3B_29I") { - stmt = next; - continue; - } - if (Options::O2 && intrisicsList.find(funcName) != intrisicsList.end()) { - Intrinsify(*func, *cnode); - stmt = next; - continue; - } - } -#endif switch (opcode) { case OP_regassign: { auto *regassign = static_cast(stmt);