diff --git a/src/bin/jbc2mpl b/src/bin/jbc2mpl index 26893d03c4e2bf675d69bd0385ca61a64b85c255..511c5e1f1085e930806672b0ec9b0a9b62b90d89 100755 Binary files a/src/bin/jbc2mpl and b/src/bin/jbc2mpl differ diff --git a/src/bin/maple b/src/bin/maple index a7b69e8730219fdca4a276195c15d37fac0569bf..ab27eab5c0f069267c970bcd026c393ed3377760 100755 Binary files a/src/bin/maple and b/src/bin/maple differ diff --git a/src/bin/mplcg b/src/bin/mplcg index a7da3f16d43c0d9ff299b9ce04fe92059e64cc06..5bf56c64418dbe5651dbfa580acb10a0e927e120 100755 Binary files a/src/bin/mplcg and b/src/bin/mplcg differ diff --git a/src/deplibs/libmaple_driverutil.a b/src/deplibs/libmaple_driverutil.a index 2b49fd1e96ee2b8bbbf3732a55788b347c86d190..b124907aba39bf639bdf4235aa8d897239b346df 100644 Binary files a/src/deplibs/libmaple_driverutil.a and b/src/deplibs/libmaple_driverutil.a differ diff --git a/src/deplibs/libmempool.a b/src/deplibs/libmempool.a index 0c5583e86483ef8540eb10645b5823c05b357c00..c9946baf59fe0819105e47043f4a5979d4f343e2 100644 Binary files a/src/deplibs/libmempool.a and b/src/deplibs/libmempool.a differ diff --git a/src/deplibs/libmplutil.a b/src/deplibs/libmplutil.a index 8ac35620d909d91934585a1ad68f288e133a356f..eaf22ff8046484ddcebd35536151e586d9b04224 100644 Binary files a/src/deplibs/libmplutil.a and b/src/deplibs/libmplutil.a differ diff --git a/src/maple_driver/defs/default/O0_options_me.def b/src/maple_driver/defs/default/O0_options_me.def index 0993b584bd892abc8df94b89ac89e55c30384f97..cd590df215e52881859dc6089afeded372e10875 100644 --- a/src/maple_driver/defs/default/O0_options_me.def +++ b/src/maple_driver/defs/default/O0_options_me.def @@ -12,4 +12,4 @@ * FIT FOR A PARTICULAR PURPOSE. * See the Mulan PSL v1 for more details. */ -{ "--quiet", "", "", false, "", false }, \ No newline at end of file +{ "--quiet", "", "", false, "", false }, diff --git a/src/maple_driver/src/driver_runner.cpp b/src/maple_driver/src/driver_runner.cpp index e1eb1559a7c0058812d17c883d529e5c9651016e..2348af7c1dae0c4c8433628895b58bc7f4105019 100644 --- a/src/maple_driver/src/driver_runner.cpp +++ b/src/maple_driver/src/driver_runner.cpp @@ -16,6 +16,7 @@ #include #include #include +#include #include "mpl_timer.h" #include "mir_function.h" #include "mir_parser.h" diff --git a/src/maple_driver/src/maple_comb_compiler.cpp b/src/maple_driver/src/maple_comb_compiler.cpp index 27cb49ba530dedae08bff49b482585b90deb787f..0cd38604d576b567922796286befe44c220bac93 100644 --- a/src/maple_driver/src/maple_comb_compiler.cpp +++ b/src/maple_driver/src/maple_comb_compiler.cpp @@ -84,7 +84,7 @@ MeOption *MapleCombCompiler::MakeMeOptions(const MplOptions &options, maple::Mem } switch (opt.Index()) { case kMeSkipPhases: - meOption->SplitPhases(opt.Args(), meOption->GetSkipPhases()); + meOption->SplitSkipPhases(opt.Args()); break; case kMeRange: meOption->useRange = true; diff --git a/src/maple_ir/include/bin_mir_file.h b/src/maple_ir/include/bin_mir_file.h index 2f594e17134b33282168417f6a769377d181f6cb..4363dda4a452553425a6f234e6703a4aff4c0563 100644 --- a/src/maple_ir/include/bin_mir_file.h +++ b/src/maple_ir/include/bin_mir_file.h @@ -21,6 +21,7 @@ namespace maple { const std::string kBinMirFileID = "HWCMPL"; // for magic in file header constexpr int kVersionMajor = 0; // experimental version constexpr int kVersionMinor = 1; +constexpr int kMagicSize = 7; enum BinMirFileType { kMjsvmFileTypeCmplV1, @@ -32,11 +33,10 @@ enum BinMirFileType { // file header for binary format kMmpl, 8B in total // Note the header is different with the specification struct BinMIRFileHeader { - char magic[7]; // “HWCMPL”, or "HWLOS_" + char magic[kMagicSize]; // “HWCMPL”, or "HWLOS_" maple::uint8 segNum; // number of segments (e.g. one raw IR file is a segment unit) maple::uint8 type; // enum of type of VM file (e.g. MapleIR, TE) maple::uint8 version; // version of IR format (should be major.minor) }; - } // namespace maple #endif // MAPLE_IR_INCLUDE_BIN_MIR_FILE_H diff --git a/src/maple_ir/include/bin_mpl_export.h b/src/maple_ir/include/bin_mpl_export.h index 6a602d1c387c03c0078bb3f2af8e074c95a4b867..7566bceb8a4702907da5344271f6f5bca957f3e0 100644 --- a/src/maple_ir/include/bin_mpl_export.h +++ b/src/maple_ir/include/bin_mpl_export.h @@ -132,6 +132,5 @@ class BinaryMplExport { void ExpandFourBuffSize(); }; - } // namespace maple #endif // MAPLE_IR_INCLUDE_BIN_MPL_EXPORT_H diff --git a/src/maple_ir/include/bin_mpl_import.h b/src/maple_ir/include/bin_mpl_import.h index d9311fa959c459ab15e784690d4ac69019cc4d27..a3dbfdb48bf701aee3b963630c1069cb2382c15a 100644 --- a/src/maple_ir/include/bin_mpl_import.h +++ b/src/maple_ir/include/bin_mpl_import.h @@ -139,6 +139,5 @@ class BinaryMplImport { void SkipTotalSize(); void ImportFieldsOfStructType(FieldVector &fields, uint32 methodSize); }; - } // namespace maple #endif // MAPLE_IR_INCLUDE_BIN_MPL_IMPORT_H diff --git a/src/maple_ir/include/bin_mplt.h b/src/maple_ir/include/bin_mplt.h index f7633ed222781c9e6c1ad30470c3e084d0274092..a4ad9271de37273c573ca2e2d4d7a14426ffa20a 100644 --- a/src/maple_ir/include/bin_mplt.h +++ b/src/maple_ir/include/bin_mplt.h @@ -60,6 +60,5 @@ class BinaryMplt { BinaryMplExport binExport; std::string importFileName; }; - } // namespace maple #endif // MAPLE_IR_INCLUDE_BIN_MPLT_H diff --git a/src/maple_ir/include/cfg_primitive_types.h b/src/maple_ir/include/cfg_primitive_types.h index 1f3041294120c2318120d92813904355f84c7e3b..8ce704de83b136751664290612c11c2e687eb466 100644 --- a/src/maple_ir/include/cfg_primitive_types.h +++ b/src/maple_ir/include/cfg_primitive_types.h @@ -16,7 +16,6 @@ #define MAPLE_IR_INCLUDE_CFG_PRIMITIVE_TYPES_H namespace maple { - // Declaration of enum PrimType #define LOAD_ALGO_PRIMARY_TYPE enum PrimType { @@ -27,8 +26,6 @@ enum PrimType { #undef PRIMTYPE }; - - constexpr PrimType kPtyInvalid = PTY_begin; // just for test, no primitive type for derived SIMD types to be defined constexpr PrimType kPtyDerived = PTY_end; @@ -47,7 +44,6 @@ struct PrimitiveTypeProperty { }; const PrimitiveTypeProperty &GetPrimitiveTypeProperty(PrimType pType); - } // namespace maple #endif // MAPLE_IR_INCLUDE_CFG_PRIMITIVE_TYPES_H diff --git a/src/maple_ir/include/global_tables.h b/src/maple_ir/include/global_tables.h index 9e902f9e8e1446411f4c7856b8eafbf01ffd1671..1f630b2af42daabacba15a3358c911fe6facde0b 100644 --- a/src/maple_ir/include/global_tables.h +++ b/src/maple_ir/include/global_tables.h @@ -623,6 +623,5 @@ class GlobalTables { u16StringTable.Init(); } }; - } // namespace maple #endif // MAPLE_IR_INCLUDE_GLOBAL_TABLES_H diff --git a/src/maple_ir/include/intrinsic_java.def b/src/maple_ir/include/intrinsic_java.def index 49a67935849735d0ced872478492310d7bd4668d..df21d2329293083e70529e41756d17e87f2e9118 100644 --- a/src/maple_ir/include/intrinsic_java.def +++ b/src/maple_ir/include/intrinsic_java.def @@ -32,4 +32,4 @@ DEF_MIR_INTRINSIC(JAVA_CLINIT_CHECK,\ DEF_MIR_INTRINSIC(JAVA_POLYMORPHIC_CALL,\ "__java_polymorphic_call", INTRNISJAVA, kArgTyDynany, kArgTyDynany, kArgTyDynany, kArgTyUndef, kArgTyUndef, kArgTyUndef, kArgTyUndef) DEF_MIR_INTRINSIC(JAVA_THROW_ARITHMETIC,\ - "MCC_ThrowArithmeticException", INTRNISJAVA | INTRNNEVERRETURN, kArgTyVoid, kArgTyUndef, kArgTyUndef, kArgTyUndef, kArgTyUndef, kArgTyUndef, kArgTyUndef) \ No newline at end of file + "MCC_ThrowArithmeticException", INTRNISJAVA | INTRNNEVERRETURN, kArgTyVoid, kArgTyUndef, kArgTyUndef, kArgTyUndef, kArgTyUndef, kArgTyUndef, kArgTyUndef) diff --git a/src/maple_ir/include/intrinsic_op.h b/src/maple_ir/include/intrinsic_op.h index 32eeb537348d899e3aafda7c9cdc546fc649cb34..0f627c37b898b3847b20affd50273f9460b40527 100644 --- a/src/maple_ir/include/intrinsic_op.h +++ b/src/maple_ir/include/intrinsic_op.h @@ -21,6 +21,5 @@ enum MIRIntrinsicID { #include "intrinsics.def" #undef DEF_MIR_INTRINSIC }; - } // namespace maple #endif // MAPLE_IR_INCLUDE_INTRINSIC_OP_H diff --git a/src/maple_ir/include/intrinsics.h b/src/maple_ir/include/intrinsics.h index 2337e0c3cad67e30aedbea5c76d64c26ba49f303..ea739024abd4a2d4bb8b2bfdf47238818052c1b4 100644 --- a/src/maple_ir/include/intrinsics.h +++ b/src/maple_ir/include/intrinsics.h @@ -149,6 +149,5 @@ struct IntrinDesc { static MIRType *GetOrCreateJSValueType(); static IntrinDesc intrinTable[INTRN_LAST + 1]; }; - } // namespace maple #endif // MAPLE_IR_INCLUDE_INTRINSICS_H diff --git a/src/maple_ir/include/java_eh_lower.h b/src/maple_ir/include/java_eh_lower.h index 3a130aafc8d7a14e4a655bb07f588007b4de3b3f..ace88f8df0bd9f8144b67e0e5e92d794ec8852b6 100644 --- a/src/maple_ir/include/java_eh_lower.h +++ b/src/maple_ir/include/java_eh_lower.h @@ -63,6 +63,5 @@ class JavaEHLowererPhase : public ModulePhase { return nullptr; } }; - } // namespace maple #endif // MAPLE_IR_INCLUDE_JAVA_EH_LOWER_H diff --git a/src/maple_ir/include/lexer.h b/src/maple_ir/include/lexer.h index b1116654818168f85a001afeefa9aaed5bfab92e..99e929368832846a358d6f69b894aae6c7b940bd 100644 --- a/src/maple_ir/include/lexer.h +++ b/src/maple_ir/include/lexer.h @@ -166,6 +166,5 @@ inline bool IsConstValue(TokenKind tk) { inline bool IsConstAddrExpr(TokenKind tk) { return tk == TK_addrof || tk == TK_addroffunc || tk == TK_conststr || tk == TK_conststr16; } - } // namespace maple #endif // MAPLE_IR_INCLUDE_LEXER_H diff --git a/src/maple_ir/include/metadata_layout.h b/src/maple_ir/include/metadata_layout.h index aa96da30d7ec986752f027fe926882f163fc7dd3..0c49ae1cc7562a8d450b07239701d329bb832156 100644 --- a/src/maple_ir/include/metadata_layout.h +++ b/src/maple_ir/include/metadata_layout.h @@ -152,11 +152,17 @@ struct ClassMetadata { void *iTable; // iTable of current class, used for virtual call, will insert the content into classinfo void *vTable; // vTable of current class, used for interface call, will insert the content into classinfo void *gctib; // for rc - ClassMetadataRO *classInfoRo; + + union { + ClassMetadataRO *classinforo64; // ifndef USE_32BIT_REF + struct { + uint32_t classinforo32; // ifdef USE_32BIT_REF + uint32_t padding; + }; + }; union { intptr_t initState; // if class is not initialized - void *staticFields; // if class is already initialized }; // class init state, this field must be accessed atomically. }; @@ -165,11 +171,6 @@ static inline intptr_t ClassMetadataOffsetOfInitFlag() { return reinterpret_cast(&(base->initState)); } -static inline intptr_t ClassMetadataOffsetOfStaticFields() { - ClassMetadata *base = reinterpret_cast(0); - return reinterpret_cast(&(base->staticFields)); -} - #ifdef __cplusplus } #endif diff --git a/src/maple_ir/include/mir_builder.h b/src/maple_ir/include/mir_builder.h index 69d12e4d0fe8b3218d55a4cbc00ad9c1dfefaedd..4db4ac89450a3c972a89b32190aba4062c314774 100644 --- a/src/maple_ir/include/mir_builder.h +++ b/src/maple_ir/include/mir_builder.h @@ -45,14 +45,6 @@ class MIRBuilder { kFoundInChild = 8, // found in child }; - private: - MIRModule *mirModule; - MapleSet incompleteTypeRefedSet; - // - std::vector> extraFieldsTuples; - unsigned int lineNum; - - public: explicit MIRBuilder(MIRModule *module) : mirModule(module), incompleteTypeRefedSet(std::less(), mirModule->GetMPAllocator().Adapter()), @@ -111,21 +103,21 @@ class MIRBuilder { void AddAddrofFieldConst(const MIRStructType &sType, MIRAggConst &newConst, uint32 fieldID, const MIRSymbol &fieldSt); void AddAddroffuncFieldConst(const MIRStructType &sType, MIRAggConst &newConst, uint32 fieldID, const MIRSymbol &funcSt); - bool TraverseToNamedField(MIRStructType *structType, GStrIdx nameIdx, uint32 &fieldID); - bool IsOfSameType(MIRType *type1, MIRType *type2); - bool TraverseToNamedFieldWithTypeAndMatchStyle(MIRStructType *structType, GStrIdx nameIdx, TyIdx typeIdx, + bool TraverseToNamedField(MIRStructType &structType, GStrIdx nameIdx, uint32 &fieldID); + bool IsOfSameType(MIRType &type1, MIRType &type2); + bool TraverseToNamedFieldWithTypeAndMatchStyle(MIRStructType &structType, GStrIdx nameIdx, TyIdx typeIdx, uint32 &fieldID, unsigned int matchStyle); - void TraverseToNamedFieldWithType(MIRStructType *structType, GStrIdx nameIdx, TyIdx typeIdx, uint32 &fieldID, + void TraverseToNamedFieldWithType(MIRStructType &structType, GStrIdx nameIdx, TyIdx typeIdx, uint32 &fieldID, uint32 &idx); - FieldID GetStructFieldIDFromNameAndType(MIRType *type, const std::string &name, TyIdx idx, unsigned int matchStyle); - FieldID GetStructFieldIDFromNameAndType(MIRType *type, const std::string &name, TyIdx idx); - FieldID GetStructFieldIDFromNameAndTypeParentFirst(MIRType *type, const std::string &name, TyIdx idx); - FieldID GetStructFieldIDFromNameAndTypeParentFirstFoundInChild(MIRType *type, const std::string &name, TyIdx idx); - FieldID GetStructFieldIDFromFieldName(MIRType *type, const std::string &name); + FieldID GetStructFieldIDFromNameAndType(MIRType &type, const std::string &name, TyIdx idx, unsigned int matchStyle); + FieldID GetStructFieldIDFromNameAndType(MIRType &type, const std::string &name, TyIdx idx); + FieldID GetStructFieldIDFromNameAndTypeParentFirst(MIRType &type, const std::string &name, TyIdx idx); + FieldID GetStructFieldIDFromNameAndTypeParentFirstFoundInChild(MIRType &type, const std::string &name, TyIdx idx); + FieldID GetStructFieldIDFromFieldName(MIRType &type, const std::string &name); FieldID GetStructFieldIDFromFieldNameParentFirst(MIRType *type, const std::string &name); - void SetStructFieldIDFromFieldName(MIRType *structtype, const std::string &name, GStrIdx newStrIdx, - const MIRType *newFieldType); + void SetStructFieldIDFromFieldName(MIRType &structtype, const std::string &name, GStrIdx newStrIdx, + const MIRType &newFieldType); // for creating Function. MIRSymbol *GetFunctionArgument(MIRFunction *fun, uint32 index) const { CHECK(index < fun->GetFormalCount(), "index out of range in GetFunctionArgument"); @@ -140,8 +132,6 @@ class MIRBuilder { } MIRSymbol *GetSymbolFromEnclosingScope(StIdx stIdx); - - public: virtual MIRSymbol *GetOrCreateLocalDecl(const std::string &str, MIRType *type); MIRSymbol *GetLocalDecl(const std::string &str); MIRSymbol *CreateLocalDecl(const std::string &str, const MIRType *type); @@ -295,6 +285,12 @@ class MIRBuilder { return ret.GetStorageClass() == kScAuto || ret.GetStorageClass() == kScFormal || ret.GetStorageClass() == kScExtern || ret.GetStorageClass() == kScGlobal; } + + MIRModule *mirModule; + MapleSet incompleteTypeRefedSet; + // + std::vector> extraFieldsTuples; + unsigned int lineNum; }; } // namespace maple diff --git a/src/maple_ir/include/mir_config.h b/src/maple_ir/include/mir_config.h index 067041b12489d9bcf36065a3602e2429a8a9dee1..84aa16acfa9a2770907aba4ff5d57d30b7c54425 100644 --- a/src/maple_ir/include/mir_config.h +++ b/src/maple_ir/include/mir_config.h @@ -90,6 +90,5 @@ namespace maple { // Note: fix size definition cannot handle arbitary long MIR lines, such // as those array initialization lines. constexpr int kMirMaxLineSize = 3072; // a max of 3K characters per line initially - } // namespace maple #endif // MAPLE_IR_INCLUDE_MIR_CONFIG_H diff --git a/src/maple_ir/include/mir_function.h b/src/maple_ir/include/mir_function.h index 6bdb07a2f801310f8f9b37be49a96407c2fb716c..91e393c526f1d15de1d73316caf0df511cbf4f06 100644 --- a/src/maple_ir/include/mir_function.h +++ b/src/maple_ir/include/mir_function.h @@ -1013,6 +1013,5 @@ class MIRFunction { // funcname + types of args, no type of retv GStrIdx signatureStrIdx; }; - } // namespace maple #endif // MAPLE_IR_INCLUDE_MIR_FUNCTION_H diff --git a/src/maple_ir/include/mir_lower.h b/src/maple_ir/include/mir_lower.h index 7c17f9cf6e18d56244570364f23bebe25f913b06..c055ce9371ae1f7df239e57f126e943fd849bd9d 100644 --- a/src/maple_ir/include/mir_lower.h +++ b/src/maple_ir/include/mir_lower.h @@ -105,6 +105,5 @@ class MIRLower { MIRBuilder *mirBuilder; uint32 lowerPhase; }; - } // namespace maple #endif // MAPLE_IR_INCLUDE_MIR_LOWER_H diff --git a/src/maple_ir/include/mir_parser.h b/src/maple_ir/include/mir_parser.h index 0a3ef3b8de8257ee92a5d08cb65ab4950e7cda94..8e1fede512c35306c6d8f0c01973fbbb15f45290 100644 --- a/src/maple_ir/include/mir_parser.h +++ b/src/maple_ir/include/mir_parser.h @@ -302,6 +302,5 @@ class MIRParser { // common func void SetSrcPos(StmtNodePtr stmt, uint32 mplNum); }; - } // namespace maple #endif // MAPLE_IR_INCLUDE_MIR_PARSER_H diff --git a/src/maple_ir/include/mir_pragma.h b/src/maple_ir/include/mir_pragma.h index ce97437871a19a6a4c83ba5292263d031f30a90b..60b57a4b18a17bf03a02e888454bde7bebfd729e 100644 --- a/src/maple_ir/include/mir_pragma.h +++ b/src/maple_ir/include/mir_pragma.h @@ -266,6 +266,5 @@ class MIRPragma { int32 paramNum; // paramNum th param in function, -1 not for param annotation MapleVector elementVec; }; - } // namespace maple #endif // MAPLE_IR_INCLUDE_MIR_PRAGMA_H diff --git a/src/maple_ir/include/mir_symbol.h b/src/maple_ir/include/mir_symbol.h index 128d1baad580626804bc911c2b23f71d4417ae0f..515363fa7673bfb4e95cbd8eae3aafc56bb1a0a0 100644 --- a/src/maple_ir/include/mir_symbol.h +++ b/src/maple_ir/include/mir_symbol.h @@ -546,6 +546,5 @@ class MIRLabelTable { MapleMap strIdxToLabIdxMap; MapleVector labelTable; // map label idx to label name }; - } // namespace maple #endif // MAPLE_IR_INCLUDE_MIR_SYMBOL_H diff --git a/src/maple_ir/include/mir_type.h b/src/maple_ir/include/mir_type.h index 546e6acc9d6bfc51cb9e39f5d96912d46857099a..fed05a6ae5175baf44447275b0cbc36f8fb7dcd8 100644 --- a/src/maple_ir/include/mir_type.h +++ b/src/maple_ir/include/mir_type.h @@ -24,7 +24,6 @@ #endif // MIR_FEATURE_FULL namespace maple { - constexpr int kTypeHashLength = 12289; // hash length for mirtype, ref: planetmath.org/goodhashtableprimes class FieldAttrs; diff --git a/src/maple_ir/include/opcodes.h b/src/maple_ir/include/opcodes.h index ab3bca270f4207240d1eb2582659185d19a3c853..ce4198361bc9f5cf1dcd4aa1619cff944c39b5c8 100644 --- a/src/maple_ir/include/opcodes.h +++ b/src/maple_ir/include/opcodes.h @@ -23,6 +23,5 @@ enum Opcode : std::uint8_t { #undef OPCODE kOpLast, }; - } // namespace maple #endif // MAPLE_IR_INCLUDE_OPCODES_H diff --git a/src/maple_ir/include/option.h b/src/maple_ir/include/option.h index 55b7ce80318246481022b64ac96f6be91bfa0955..b621c47a3d2ccd598bb7aa2be006d780150124a2 100644 --- a/src/maple_ir/include/option.h +++ b/src/maple_ir/include/option.h @@ -22,7 +22,6 @@ #include "types_def.h" namespace maple { - class Options { public: explicit Options(maple::MemPool &memPool) : optionAlloc(&memPool) {} @@ -63,7 +62,6 @@ class Options { MapleAllocator optionAlloc; std::vector phaseSeq; }; - } // namespace maple #ifndef TRACE_PHASE #define TRACE_PHASE (Options::dumpPhase.compare(PhaseName()) == 0) diff --git a/src/maple_ir/include/parser_opt.h b/src/maple_ir/include/parser_opt.h index 97d3918b7f33f71bebd0e6139de6ecc8a561cafb..33cc2cf8793a7ecb577134dc3e8c1e70de6eae12 100644 --- a/src/maple_ir/include/parser_opt.h +++ b/src/maple_ir/include/parser_opt.h @@ -25,6 +25,5 @@ enum ParserOptions: uint8 { kWithProfileInfo = 0x4, kParseOptFunc = 0x08, // parse optimized function mpl file }; - } // namespace maple #endif // MAPLE_IR_INCLUDE_PARSER_OPT_H diff --git a/src/maple_ir/include/prim_types.h b/src/maple_ir/include/prim_types.h index e7be267b0b4a8065378fe6f283c79bb5d5aa7998..4f1c49202abb6c5cc508730a2ad8fd3dc01b62ab 100644 --- a/src/maple_ir/include/prim_types.h +++ b/src/maple_ir/include/prim_types.h @@ -18,7 +18,6 @@ #include "cfg_primitive_types.h" namespace maple { - class PrimitiveType { public: PrimitiveType(PrimType type) { @@ -61,6 +60,5 @@ class PrimitiveType { private: const PrimitiveTypeProperty *property; }; - } // namespace maple #endif // MAPLE_IR_INCLUDE_PRIM_TYPES_H diff --git a/src/maple_ir/include/tokens.h b/src/maple_ir/include/tokens.h index d6ee523bd60834fabc2897779d2bcf1bcfafdc08..56842432e3d1c0babf3bafad134e6a0336ebc50b 100644 --- a/src/maple_ir/include/tokens.h +++ b/src/maple_ir/include/tokens.h @@ -59,6 +59,5 @@ enum TokenKind { kTkString, // a literal string enclosed between " kTkEof }; - } // namespace maple #endif // MAPLE_IR_INCLUDE_TOKENS_H diff --git a/src/maple_ir/include/types_def.h b/src/maple_ir/include/types_def.h index ebbc47397e98778498dd1f35a162994b804e5c3b..30fa6761e4465b2bd5ade371ec3c81596f7bfbed 100644 --- a/src/maple_ir/include/types_def.h +++ b/src/maple_ir/include/types_def.h @@ -22,7 +22,6 @@ #include namespace maple { - // Let's keep the following definitions so that existing code will continue to work. using int8 = std::int8_t; using int16 = std::int16_t; @@ -270,6 +269,5 @@ class U16StrIdx { // user string table index (from the conststr opcode) private: uint32 idx; }; - } // namespace maple #endif // MAPLE_IR_INCLUDE_TYPES_DEF_H diff --git a/src/maple_ir/src/bin_mpl_export.cpp b/src/maple_ir/src/bin_mpl_export.cpp index c842ba2dbed4afe5216c88e12ac27b63c7dc1fb8..39ff2bec09954752950fe9763582cb2237289d57 100644 --- a/src/maple_ir/src/bin_mpl_export.cpp +++ b/src/maple_ir/src/bin_mpl_export.cpp @@ -24,7 +24,6 @@ #include "factory.h" namespace { - using namespace maple; using OutputConstFactory = FunctionFactory; @@ -288,11 +287,9 @@ void InitOutputTypeFactory() { RegisterFactoryFunction(kTypeInterfaceIncomplete, OutputTypeInterface); RegisterFactoryFunction(kTypeConstString, OutputTypeConstString); } - }; // namespace namespace maple { - int BinaryMplExport::typeMarkOffset = 0; BinaryMplExport::BinaryMplExport(MIRModule &md) : mod(md) { @@ -774,5 +771,4 @@ void BinaryMplExport::OutputType(const TyIdx &tyIdx) { } } - } // namespace maple diff --git a/src/maple_ir/src/bin_mpl_import.cpp b/src/maple_ir/src/bin_mpl_import.cpp index 4b74c7eb462281a404a9c7dbab03a964d05f8cd0..10c36e6f9b7046b03c2821f30df4923a0288f391 100644 --- a/src/maple_ir/src/bin_mpl_import.cpp +++ b/src/maple_ir/src/bin_mpl_import.cpp @@ -25,7 +25,6 @@ #include "mir_builder.h" namespace maple { - uint8 BinaryMplImport::Read() { CHECK_FATAL(bufI < buf.size(), "Index out of bound in BinaryMplImport::Read()"); return buf[bufI++]; @@ -892,5 +891,4 @@ bool BinaryMplImport::Import(const std::string &fname, bool readSymbols, bool re SetupEHRootType(); return true; } - } // namespace maple diff --git a/src/maple_ir/src/global_tables.cpp b/src/maple_ir/src/global_tables.cpp index 043ee5ed31c678c95c2cc4369c64199d67d63c61..ab413206d046d63ed62b7bde380216630d9e258b 100644 --- a/src/maple_ir/src/global_tables.cpp +++ b/src/maple_ir/src/global_tables.cpp @@ -315,6 +315,5 @@ GlobalTables GlobalTables::globalTables; GlobalTables &GlobalTables::GetGlobalTables() { return globalTables; } - } // namespace maple #endif // MIR_FEATURE_FULL diff --git a/src/maple_ir/src/intrinsics.cpp b/src/maple_ir/src/intrinsics.cpp index e80cafa0ccebe567ef2e3564bd7b77399d1f1cd3..f53e163a9c894f533b1daba42d8fb6cf26ed370e 100644 --- a/src/maple_ir/src/intrinsics.cpp +++ b/src/maple_ir/src/intrinsics.cpp @@ -142,5 +142,4 @@ MIRType *IntrinDesc::GetArgType(uint32 index) const { MIRType *IntrinDesc::GetReturnType() const { return GetTypeFromArgTy(argTypes[0]); } - } // namespace maple diff --git a/src/maple_ir/src/lexer.cpp b/src/maple_ir/src/lexer.cpp index e9082379b627859928ead81b52ae2ddf3af660fd..8ec70ebcc5ffaee661e8f4b8eb2fc767d01b0349 100644 --- a/src/maple_ir/src/lexer.cpp +++ b/src/maple_ir/src/lexer.cpp @@ -737,5 +737,4 @@ std::string MIRLexer::GetTokenString() const { return temp; } } - } // namespace maple diff --git a/src/maple_ir/src/mir_builder.cpp b/src/maple_ir/src/mir_builder.cpp index 12c371d60bb8b089903994aa4055ee06e8625702..65f9a2fe93c829b4077d269e1594bfffcdbb5f24 100644 --- a/src/maple_ir/src/mir_builder.cpp +++ b/src/maple_ir/src/mir_builder.cpp @@ -51,76 +51,71 @@ void MIRBuilder::AddAddroffuncFieldConst(const MIRStructType &structType, MIRAgg // fieldID is continuously being updated during traversal; // when the field is found, its field id is returned via fieldID -bool MIRBuilder::TraverseToNamedField(MIRStructType *structType, GStrIdx nameIdx, uint32 &fieldID) { +bool MIRBuilder::TraverseToNamedField(MIRStructType &structType, GStrIdx nameIdx, uint32 &fieldID) { TyIdx tid(0); return TraverseToNamedFieldWithTypeAndMatchStyle(structType, nameIdx, tid, fieldID, kMatchAnyField); } -bool MIRBuilder::IsOfSameType(MIRType *type1, MIRType *type2) { - ASSERT(type1 != nullptr, "type1 is null"); - ASSERT(type2 != nullptr, "type2 is null"); - if (type2->GetKind() != type1->GetKind()) { +bool MIRBuilder::IsOfSameType(MIRType &type1, MIRType &type2) { + if (type2.GetKind() != type1.GetKind()) { return false; } - switch (type1->GetKind()) { + switch (type1.GetKind()) { case kTypeScalar: { - return (type1->GetTypeIndex() == type2->GetTypeIndex()); + return (type1.GetTypeIndex() == type2.GetTypeIndex()); } case kTypePointer: { - MIRPtrType *ptrType = static_cast(type1); - MIRPtrType *ptrTypeIt = static_cast(type2); - if (ptrType->GetPointedTyIdx() == ptrTypeIt->GetPointedTyIdx()) { + MIRPtrType &ptrType = static_cast(type1); + MIRPtrType &ptrTypeIt = static_cast(type2); + if (ptrType.GetPointedTyIdx() == ptrTypeIt.GetPointedTyIdx()) { return true; } else { - return IsOfSameType(GlobalTables::GetTypeTable().GetTypeFromTyIdx(ptrType->GetPointedTyIdx()), - GlobalTables::GetTypeTable().GetTypeFromTyIdx(ptrTypeIt->GetPointedTyIdx())); + return IsOfSameType(*GlobalTables::GetTypeTable().GetTypeFromTyIdx(ptrType.GetPointedTyIdx()), + *GlobalTables::GetTypeTable().GetTypeFromTyIdx(ptrTypeIt.GetPointedTyIdx())); } } case kTypeJArray: { - MIRJarrayType *atype1 = static_cast(type1); - MIRJarrayType *atype2 = static_cast(type2); - if (atype1->GetDim() != atype2->GetDim()) { + MIRJarrayType &atype1 = static_cast(type1); + MIRJarrayType &atype2 = static_cast(type2); + if (atype1.GetDim() != atype2.GetDim()) { return false; } - return IsOfSameType(atype1->GetElemType(), atype2->GetElemType()); + return IsOfSameType(*atype1.GetElemType(), *atype2.GetElemType()); } default: { - return type1->GetTypeIndex() == type2->GetTypeIndex(); + return type1.GetTypeIndex() == type2.GetTypeIndex(); } } } // traverse parent first but match self first. -void MIRBuilder::TraverseToNamedFieldWithType(MIRStructType *structType, GStrIdx nameIdx, TyIdx typeIdx, +void MIRBuilder::TraverseToNamedFieldWithType(MIRStructType &structType, GStrIdx nameIdx, TyIdx typeIdx, uint32 &fieldID, uint32 &idx) { - if (structType == nullptr) { - return; - } - if (structType->IsIncomplete()) { - incompleteTypeRefedSet.insert(structType->GetTypeIndex()); + if (structType.IsIncomplete()) { + incompleteTypeRefedSet.insert(structType.GetTypeIndex()); } // process parent - if (structType->GetKind() == kTypeClass || structType->GetKind() == kTypeClassIncomplete) { - MIRClassType *classType = static_cast(structType); - MIRType *type = GlobalTables::GetTypeTable().GetTypeFromTyIdx(classType->GetParentTyIdx()); + if (structType.GetKind() == kTypeClass || structType.GetKind() == kTypeClassIncomplete) { + MIRClassType &classType = static_cast(structType); + MIRType *type = GlobalTables::GetTypeTable().GetTypeFromTyIdx(classType.GetParentTyIdx()); MIRStructType *parentType = static_cast(type); if (parentType != nullptr) { fieldID++; - TraverseToNamedFieldWithType(parentType, nameIdx, typeIdx, fieldID, idx); + TraverseToNamedFieldWithType(*parentType, nameIdx, typeIdx, fieldID, idx); } } - for (uint32 fieldIdx = 0; fieldIdx < structType->GetFieldsSize(); fieldIdx++) { + for (uint32 fieldIdx = 0; fieldIdx < structType.GetFieldsSize(); fieldIdx++) { fieldID++; - TyIdx fieldTyIdx = structType->GetFieldsElemt(fieldIdx).second.first; + TyIdx fieldTyIdx = structType.GetFieldsElemt(fieldIdx).second.first; MIRType *fieldType = GlobalTables::GetTypeTable().GetTypeFromTyIdx(fieldTyIdx); - if (structType->GetFieldsElemt(fieldIdx).first == nameIdx) { + if (structType.GetFieldsElemt(fieldIdx).first == nameIdx) { if ((typeIdx == 0 || fieldTyIdx == typeIdx)) { idx = fieldID; continue; } // for pointer type, check their pointed type MIRType *type = GlobalTables::GetTypeTable().GetTypeFromTyIdx(typeIdx); - if (IsOfSameType(type, fieldType)) { + if (IsOfSameType(*type, *fieldType)) { idx = fieldID; } } @@ -129,7 +124,7 @@ void MIRBuilder::TraverseToNamedFieldWithType(MIRStructType *structType, GStrIdx fieldType->GetKind() == kTypeClass || fieldType->GetKind() == kTypeClassIncomplete || fieldType->GetKind() == kTypeInterface || fieldType->GetKind() == kTypeInterfaceIncomplete) { MIRStructType *subStructType = static_cast(fieldType); - TraverseToNamedFieldWithType(subStructType, nameIdx, typeIdx, fieldID, idx); + TraverseToNamedFieldWithType(*subStructType, nameIdx, typeIdx, fieldID, idx); } } } @@ -143,19 +138,16 @@ void MIRBuilder::TraverseToNamedFieldWithType(MIRStructType *structType, GStrIdx // 2: match any field // 4: traverse parent first // 0xc: do not match but traverse to update fieldID, traverse parent first, found in child -bool MIRBuilder::TraverseToNamedFieldWithTypeAndMatchStyle(MIRStructType *structType, GStrIdx nameIdx, TyIdx typeIdx, +bool MIRBuilder::TraverseToNamedFieldWithTypeAndMatchStyle(MIRStructType &structType, GStrIdx nameIdx, TyIdx typeIdx, uint32 &fieldID, unsigned int matchStyle) { - if (structType == nullptr) { - return false; - } - if (structType->IsIncomplete()) { - incompleteTypeRefedSet.insert(structType->GetTypeIndex()); + if (structType.IsIncomplete()) { + incompleteTypeRefedSet.insert(structType.GetTypeIndex()); } if (matchStyle & kParentFirst) { // process parent - if (structType->GetKind() == kTypeClass || structType->GetKind() == kTypeClassIncomplete) { - MIRClassType *classType = static_cast(structType); - MIRType *type = GlobalTables::GetTypeTable().GetTypeFromTyIdx(classType->GetParentTyIdx()); + if (structType.GetKind() == kTypeClass || structType.GetKind() == kTypeClassIncomplete) { + MIRClassType &classType = static_cast(structType); + MIRType *type = GlobalTables::GetTypeTable().GetTypeFromTyIdx(classType.GetParentTyIdx()); MIRStructType *parentType = static_cast(type); if (parentType != nullptr) { fieldID++; @@ -164,9 +156,9 @@ bool MIRBuilder::TraverseToNamedFieldWithTypeAndMatchStyle(MIRStructType *struct uint32 idxBackup = nameIdx.GetIdx(); nameIdx.SetIdx(0); // do not match but traverse to update fieldID, traverse parent first - TraverseToNamedFieldWithTypeAndMatchStyle(parentType, nameIdx, typeIdx, fieldID, matchStyle); + TraverseToNamedFieldWithTypeAndMatchStyle(*parentType, nameIdx, typeIdx, fieldID, matchStyle); nameIdx.SetIdx(idxBackup); - } else if (TraverseToNamedFieldWithTypeAndMatchStyle(parentType, nameIdx, typeIdx, fieldID, matchStyle)) { + } else if (TraverseToNamedFieldWithTypeAndMatchStyle(*parentType, nameIdx, typeIdx, fieldID, matchStyle)) { return true; } } @@ -174,18 +166,18 @@ bool MIRBuilder::TraverseToNamedFieldWithTypeAndMatchStyle(MIRStructType *struct return false; } } - for (uint32 fieldIdx = 0; fieldIdx < structType->GetFieldsSize(); fieldIdx++) { + for (uint32 fieldIdx = 0; fieldIdx < structType.GetFieldsSize(); fieldIdx++) { fieldID++; - TyIdx fieldTyIdx = structType->GetFieldsElemt(fieldIdx).second.first; + TyIdx fieldTyIdx = structType.GetFieldsElemt(fieldIdx).second.first; MIRType *fieldType = GlobalTables::GetTypeTable().GetTypeFromTyIdx(fieldTyIdx); ASSERT(fieldType != nullptr, "fieldType is null"); - if (matchStyle && structType->GetFieldsElemt(fieldIdx).first == nameIdx) { + if (matchStyle && structType.GetFieldsElemt(fieldIdx).first == nameIdx) { if ((typeIdx == 0 || fieldTyIdx == typeIdx)) { return true; } // for pointer type, check their pointed type MIRType *type = GlobalTables::GetTypeTable().GetTypeFromTyIdx(typeIdx); - if (IsOfSameType(type, fieldType)) { + if (IsOfSameType(*type, *fieldType)) { return true; } } @@ -194,7 +186,7 @@ bool MIRBuilder::TraverseToNamedFieldWithTypeAndMatchStyle(MIRStructType *struct fieldType->GetKind() == kTypeClass || fieldType->GetKind() == kTypeClassIncomplete || fieldType->GetKind() == kTypeInterface || fieldType->GetKind() == kTypeInterfaceIncomplete) { MIRStructType *subStructType = static_cast(fieldType); - if (TraverseToNamedFieldWithTypeAndMatchStyle(subStructType, nameIdx, typeIdx, fieldID, style)) { + if (TraverseToNamedFieldWithTypeAndMatchStyle(*subStructType, nameIdx, typeIdx, fieldID, style)) { return true; } } @@ -202,9 +194,9 @@ bool MIRBuilder::TraverseToNamedFieldWithTypeAndMatchStyle(MIRStructType *struct return false; } -FieldID MIRBuilder::GetStructFieldIDFromNameAndType(MIRType *type, const std::string &name, TyIdx idx, +FieldID MIRBuilder::GetStructFieldIDFromNameAndType(MIRType &type, const std::string &name, TyIdx idx, unsigned int matchStyle) { - MIRStructType *structType = static_cast(type); + MIRStructType &structType = static_cast(type); uint32 fieldID = 0; GStrIdx strIdx = GetStringIndex(name); if (TraverseToNamedFieldWithTypeAndMatchStyle(structType, strIdx, idx, fieldID, matchStyle)) { @@ -213,42 +205,42 @@ FieldID MIRBuilder::GetStructFieldIDFromNameAndType(MIRType *type, const std::st return 0; } -FieldID MIRBuilder::GetStructFieldIDFromNameAndType(MIRType *type, const std::string &name, TyIdx idx) { +FieldID MIRBuilder::GetStructFieldIDFromNameAndType(MIRType &type, const std::string &name, TyIdx idx) { return GetStructFieldIDFromNameAndType(type, name, idx, kMatchAnyField); } -FieldID MIRBuilder::GetStructFieldIDFromNameAndTypeParentFirst(MIRType *type, const std::string &name, TyIdx idx) { +FieldID MIRBuilder::GetStructFieldIDFromNameAndTypeParentFirst(MIRType &type, const std::string &name, TyIdx idx) { return GetStructFieldIDFromNameAndType(type, name, idx, kParentFirst); } -FieldID MIRBuilder::GetStructFieldIDFromNameAndTypeParentFirstFoundInChild(MIRType *type, const std::string &name, +FieldID MIRBuilder::GetStructFieldIDFromNameAndTypeParentFirstFoundInChild(MIRType &type, const std::string &name, TyIdx idx) { // do not match but traverse to update fieldid, traverse parent first, found in child return GetStructFieldIDFromNameAndType(type, name, idx, (kFoundInChild | kParentFirst | kUpdateFieldID)); } -FieldID MIRBuilder::GetStructFieldIDFromFieldName(MIRType *type, const std::string &name) { +FieldID MIRBuilder::GetStructFieldIDFromFieldName(MIRType &type, const std::string &name) { return GetStructFieldIDFromNameAndType(type, name, TyIdx(0), kMatchAnyField); } FieldID MIRBuilder::GetStructFieldIDFromFieldNameParentFirst(MIRType *type, const std::string &name) { - return GetStructFieldIDFromNameAndType(type, name, TyIdx(0), kParentFirst); + if (type == nullptr) { + return 0; + } + return GetStructFieldIDFromNameAndType(*type, name, TyIdx(0), kParentFirst); } -void MIRBuilder::SetStructFieldIDFromFieldName(MIRType *structtype, const std::string &name, GStrIdx newStrIdx, - const MIRType *newFieldType) { - MIRStructType *structType = static_cast(structtype); - CHECK_FATAL(structtype != nullptr, "structType is null"); +void MIRBuilder::SetStructFieldIDFromFieldName(MIRType &structtype, const std::string &name, GStrIdx newStrIdx, + const MIRType &newFieldType) { + MIRStructType &structType = static_cast(structtype); uint32 fieldID = 0; GStrIdx strIdx = GetStringIndex(name); while (true) { - if (structType->GetElemStrIdx(fieldID) == strIdx) { + if (structType.GetElemStrIdx(fieldID) == strIdx) { if (newStrIdx != 0) { - structType->SetElemStrIdx(fieldID, newStrIdx); - } - if (newFieldType) { - structType->SetElemtTyIdx(fieldID, newFieldType->GetTypeIndex()); + structType.SetElemStrIdx(fieldID, newStrIdx); } + structType.SetElemtTyIdx(fieldID, newFieldType.GetTypeIndex()); return; } fieldID++; diff --git a/src/maple_ir/src/mir_const.cpp b/src/maple_ir/src/mir_const.cpp index 7ab5e021490b08121574a778fbd0d46be5dedc80..fb298a0a99755e34b80cac5b413d874123259781 100644 --- a/src/maple_ir/src/mir_const.cpp +++ b/src/maple_ir/src/mir_const.cpp @@ -30,7 +30,8 @@ void MIRConst::Dump() const { void MIRIntConst::Dump() const { MIRConst::Dump(); - if (value <= 1024) { + constexpr int64 kValThreshold = 1024; + if (value <= kValThreshold) { LogInfo::MapleLogger() << value; } else { LogInfo::MapleLogger() << std::hex << "0x" << value << std::dec; @@ -174,11 +175,12 @@ void MIRDoubleConst::Dump() const { } void MIRFloat128Const::Dump() const { + constexpr int kFieldWidth = 16; MIRConst::Dump(); std::ios::fmtflags f(LogInfo::MapleLogger().flags()); LogInfo::MapleLogger().setf(std::ios::uppercase); - LogInfo::MapleLogger() << "0xL" << std::hex << std::setfill('0') << std::setw(16) << value[0] << std::setfill('0') - << std::setw(16) << value[1]; + LogInfo::MapleLogger() << "0xL" << std::hex << std::setfill('0') << std::setw(kFieldWidth) << value[0] << std::setfill('0') + << std::setw(kFieldWidth) << value[1]; LogInfo::MapleLogger().flags(f); } @@ -243,6 +245,5 @@ bool MIRStr16Const::operator==(MIRConst &rhs) const { } return (GetType() == rhs.GetType() && value == rhsCs->value); } - } // namespace maple #endif // MIR_FEATURE_FULL diff --git a/src/maple_ir/src/mir_function.cpp b/src/maple_ir/src/mir_function.cpp index c6f7eb5757aac6c7d84c300d139fed3c59e6c669..1a339b55dde9f4b8eed22e0ab2ff0215bc6fcf12 100644 --- a/src/maple_ir/src/mir_function.cpp +++ b/src/maple_ir/src/mir_function.cpp @@ -64,8 +64,9 @@ void MIRFunction::Dump(bool withoutBody) { LogInfo::MapleLogger() << "reg %" << symbol->GetPreg()->GetPregNo() << " "; } } + constexpr int kIndent = 2; MIRType *ty = GetNthParamType(i); - ty->Dump(2); + ty->Dump(kIndent); TypeAttrs tA = GetNthParamAttr(i); tA.DumpAttributes(); if (i != (argSize - 1)) { @@ -179,8 +180,9 @@ void MIRFunction::DumpFuncBody(int32 indent) { PrintIndentation(indent + 1); LogInfo::MapleLogger() << "funcinfo {\n"; size_t size = funcInfo.size(); + constexpr int kIndentOffset = 2; for (size_t i = 0; i < size; i++) { - PrintIndentation(indent + 2); + PrintIndentation(indent + kIndentOffset); LogInfo::MapleLogger() << "@" << GlobalTables::GetStrTable().GetStringFromStrIdx(funcInfo[i].first) << " "; if (!funcInfoIsString[i]) { LogInfo::MapleLogger() << funcInfo[i].second; diff --git a/src/maple_ir/src/mir_lower.cpp b/src/maple_ir/src/mir_lower.cpp index a61c4f14a751c321f7b4fe4f0c0ab5e9f47d758a..baa30652a4f402b1bb64ff8b7aec8e5772fd7159 100644 --- a/src/maple_ir/src/mir_lower.cpp +++ b/src/maple_ir/src/mir_lower.cpp @@ -485,5 +485,4 @@ bool MIRLower::ShouldOptArrayMrt(const MIRFunction *func) { ASSERT(func != nullptr, "func is null"); return (MIRLower::kSetArrayHotFunc.find(func->GetName()) != MIRLower::kSetArrayHotFunc.end()); } - } // namespace maple diff --git a/src/maple_ir/src/mir_module.cpp b/src/maple_ir/src/mir_module.cpp index 7ccfcb8728ff0a43fe8eb453825aebfca6eff86a..af4885045369983853f4aa57573d617844953717 100644 --- a/src/maple_ir/src/mir_module.cpp +++ b/src/maple_ir/src/mir_module.cpp @@ -509,5 +509,4 @@ void MIRModule::RemoveClass(TyIdx t) { void MIRModule::SetFuncInfoPrinted() const { CurFunction()->SetInfoPrinted(); } - } // namespace maple diff --git a/src/maple_ir/src/mir_nodes.cpp b/src/maple_ir/src/mir_nodes.cpp index 935256c823a9ed0044f562f0f95a6fa4ea1cf851..6b12c2437cc90ee8caf152b2c306b7ce49e1d5d0 100644 --- a/src/maple_ir/src/mir_nodes.cpp +++ b/src/maple_ir/src/mir_nodes.cpp @@ -1818,5 +1818,4 @@ bool IcallNode::Verify() const { bool IntrinsiccallNode::Verify() const { return VerifyOpnds(); } - } // namespace maple diff --git a/src/maple_ir/src/mir_parser.cpp b/src/maple_ir/src/mir_parser.cpp index 4b6ebc9095a5338da8dfc90a55f0a16e5289f6dc..c3ea914f26263405ac4b3643bf08aba544f4557e 100644 --- a/src/maple_ir/src/mir_parser.cpp +++ b/src/maple_ir/src/mir_parser.cpp @@ -2851,5 +2851,4 @@ void MIRParser::SetSrcPos(StmtNodePtr stmt, uint32 mplNum) { stmt->GetSrcPos().SetLineNum(lastLineNum); stmt->GetSrcPos().SetMplLineNum(mplNum); } - } // namespace maple diff --git a/src/maple_ir/src/mir_pragma.cpp b/src/maple_ir/src/mir_pragma.cpp index eaab8bea5394da809013db9ee835d07b432ccd2f..aaefeda10525492c8511ee1075617d68e89deaaf 100644 --- a/src/maple_ir/src/mir_pragma.cpp +++ b/src/maple_ir/src/mir_pragma.cpp @@ -162,7 +162,7 @@ MIRPragmaElement *MIRPragma::GetPragmaElemFromSignature(const std::string &signa MIRPragmaElement *etmp = mod->GetMemPool()->New(mod); etmp->SetType(kValueType); std::string typeStr = signature.substr(start, end - start); - etmp->SetU64Val((uint64)GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(typeStr).GetIdx()); + etmp->SetU64Val(static_cast(GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(typeStr).GetIdx())); elemStack.top()->PushSubElemVec(etmp); break; } @@ -170,7 +170,7 @@ MIRPragmaElement *MIRPragma::GetPragmaElemFromSignature(const std::string &signa MIRPragmaElement *etmp = mod->GetMemPool()->New(mod); etmp->SetType(kValueType); std::string typeStr = signature.substr(start, end - start) + ";"; - etmp->SetU64Val((uint64)GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(typeStr).GetIdx()); + etmp->SetU64Val(static_cast(GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(typeStr).GetIdx())); elemStack.top()->PushSubElemVec(etmp); break; } @@ -192,6 +192,9 @@ MIRPragmaElement *MIRPragma::GetPragmaElemFromSignature(const std::string &signa } void MIRPragmaElement::Dump(int indent) { + constexpr int kIndentOffset = 2; + constexpr int kFloatPrec = 7; + constexpr int kDoublePrec = 16; GStrIdx gStrIdx; std::string str = GetKind(valueType); switch (valueType) { @@ -211,12 +214,12 @@ void MIRPragmaElement::Dump(int indent) { LogInfo::MapleLogger() << str.c_str() << " " << val.j; break; case kValueFloat: - LogInfo::MapleLogger() << std::setiosflags(std::ios::scientific) << str.c_str() << " " << std::setprecision(7) - << val.f << "f"; + LogInfo::MapleLogger() << std::setiosflags(std::ios::scientific) << str.c_str() << " " + << std::setprecision(kFloatPrec) << val.f << "f"; break; case kValueDouble: - LogInfo::MapleLogger() << std::setiosflags(std::ios::scientific) << str.c_str() << " " << std::setprecision(16) - << val.d; + LogInfo::MapleLogger() << std::setiosflags(std::ios::scientific) << str.c_str() << " " + << std::setprecision(kDoublePrec) << val.d; break; case kValueMethodType: LogInfo::MapleLogger() << str.c_str() << " $" << std::hex << "0x" << val.u << std::dec; @@ -258,9 +261,9 @@ void MIRPragmaElement::Dump(int indent) { size_t i = 0; while (i < num) { if (num > 1) { - PrintIndentation(indent + 2); + PrintIndentation(indent + kIndentOffset); } - subElemVec[i]->Dump(indent + 2); + subElemVec[i]->Dump(indent + kIndentOffset); if (i != num - 1) { LogInfo::MapleLogger() << "," << std::endl; } @@ -283,12 +286,12 @@ void MIRPragmaElement::Dump(int indent) { size_t i = 0; while (i < num) { if (num > 1) { - PrintIndentation(indent + 2); + PrintIndentation(indent + kIndentOffset); } LogInfo::MapleLogger() << "@" << GlobalTables::GetStrTable().GetStringFromStrIdx(subElemVec[i]->nameStrIdx).c_str() << " "; - subElemVec[i]->Dump(indent + 2); + subElemVec[i]->Dump(indent + kIndentOffset); if (i != num - 1) { LogInfo::MapleLogger() << "," << std::endl; } @@ -358,5 +361,4 @@ void MIRPragma::Dump(int indent) { LogInfo::MapleLogger() << "}"; return; } - } // namespace maple diff --git a/src/maple_ir/src/mir_symbol.cpp b/src/maple_ir/src/mir_symbol.cpp index b85659c4298ab6527b5b4406304d26dee061b2d5..26840a2fa18eeb343672528b708e6041fb1e9cb0 100644 --- a/src/maple_ir/src/mir_symbol.cpp +++ b/src/maple_ir/src/mir_symbol.cpp @@ -23,9 +23,8 @@ #include "native_stub_func.h" #include "literal_str_name.h" -using namespace NameMangler; - namespace maple { +using namespace NameMangler; void MIRSymbol::SetNameStrIdx(const std::string &name) { nameStrIdx = GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(name); @@ -382,5 +381,4 @@ void MIRPregTable::DumpRef(int32 indent) { LogInfo::MapleLogger() << "\n"; } } - } // namespace maple diff --git a/src/maple_ir/src/mir_type.cpp b/src/maple_ir/src/mir_type.cpp index 3e26cdb78283482af715b7a2f43ffa52c92101a8..f916da92b4ea1ddf7feb39ec55c0a6df1c9bb816 100644 --- a/src/maple_ir/src/mir_type.cpp +++ b/src/maple_ir/src/mir_type.cpp @@ -26,7 +26,6 @@ #if MIR_FEATURE_FULL namespace maple { - #define LOAD_PRIMARY_TYPE_PROPERTY #include "prim_types.def" @@ -1475,6 +1474,5 @@ FieldAttrs GenericAttrs::ConvertToFieldAttrs() { } return attr; } - } // namespace maple #endif // MIR_FEATURE_FULL diff --git a/src/maple_ir/src/parser.cpp b/src/maple_ir/src/parser.cpp index 5ff7dc59918ce7aff4500c8cce9d0808581f0404..c5b032215866e7cbe028c3e287f7be396192d582 100644 --- a/src/maple_ir/src/parser.cpp +++ b/src/maple_ir/src/parser.cpp @@ -391,11 +391,11 @@ bool MIRParser::ParsePragmaElement(MIRPragmaElement *elem) { case TK_i8: case TK_i16: case TK_i32: - elem->SetI32Val((int32)lexer.GetTheIntVal()); + elem->SetI32Val(static_cast(lexer.GetTheIntVal())); break; case TK_u16: case TK_ref: - elem->SetU64Val((uint64)lexer.GetTheIntVal()); + elem->SetU64Val(static_cast(lexer.GetTheIntVal())); break; case TK_i64: case TK_retype: @@ -836,7 +836,18 @@ bool MIRParser::ParseStructType(TyIdx &styidx) { if (!ParseFields(structType)) { return false; } - styidx = GlobalTables::GetTypeTable().GetOrCreateMIRType(&structType); + if (styidx != 0) { + MIRType *prevType = GlobalTables::GetTypeTable().GetTypeFromTyIdx(styidx); + ASSERT(prevType->GetKind() == kTypeStruct || prevType->GetKind() == kTypeStructIncomplete, + "type kind should be consistent."); + if (static_cast(prevType)->IsIncomplete() && !(structType.IsIncomplete())) { + structType.SetNameStrIdx(prevType->GetNameStrIdx()); + structType.SetTypeIndex(styidx); + GlobalTables::GetTypeTable().SetTypeWithTyIdx(styidx, structType.CopyMIRTypeNode()); + } + } else { + styidx = GlobalTables::GetTypeTable().GetOrCreateMIRType(&structType); + } lexer.NextToken(); return true; } @@ -856,16 +867,27 @@ bool MIRParser::ParseClassType(TyIdx &styidx) { if (!ParseFields(classType)) { return false; } - styidx = GlobalTables::GetTypeTable().GetOrCreateMIRType(&classType); - // set up classTyIdx for methods - for (size_t i = 0; i < classType.GetMethods().size(); i++) { - StIdx stidx = classType.GetMethodsElement(i).first; - MIRSymbol *st = GlobalTables::GetGsymTable().GetSymbolFromStidx(stidx.Idx()); - ASSERT(st->GetSKind() == kStFunc, "unexpected st->sKind"); - st->GetFunction()->GetClassTyidx() = styidx; + if (styidx != 0) { + MIRType *prevType = GlobalTables::GetTypeTable().GetTypeFromTyIdx(styidx); + ASSERT(prevType->GetKind() == kTypeClass || prevType->GetKind() == kTypeClassIncomplete, + "type kind should be consistent."); + if (static_cast(prevType)->IsIncomplete() && !(classType.IsIncomplete())) { + classType.SetNameStrIdx(prevType->GetNameStrIdx()); + classType.SetTypeIndex(styidx); + GlobalTables::GetTypeTable().SetTypeWithTyIdx(styidx, classType.CopyMIRTypeNode()); + } + } else { + styidx = GlobalTables::GetTypeTable().GetOrCreateMIRType(&classType); + // set up classTyIdx for methods + for (size_t i = 0; i < classType.GetMethods().size(); i++) { + StIdx stidx = classType.GetMethodsElement(i).first; + MIRSymbol *st = GlobalTables::GetGsymTable().GetSymbolFromStidx(stidx.Idx()); + ASSERT(st->GetSKind() == kStFunc, "unexpected st->sKind"); + st->GetFunction()->GetClassTyidx() = styidx; + } + mod.AddClass(styidx); } lexer.NextToken(); - mod.AddClass(styidx); return true; } @@ -888,16 +910,27 @@ bool MIRParser::ParseInterfaceType(TyIdx &styidx) { if (!ParseFields(interfaceType)) { return false; } - styidx = GlobalTables::GetTypeTable().GetOrCreateMIRType(&interfaceType); - // set up classTyIdx for methods - for (size_t i = 0; i < interfaceType.GetMethods().size(); i++) { - StIdx stidx = interfaceType.GetMethodsElement(i).first; - MIRSymbol *st = GlobalTables::GetGsymTable().GetSymbolFromStidx(stidx.Idx()); - ASSERT(st != nullptr, "st is null"); - ASSERT(st->GetSKind() == kStFunc, "unexpected st->sKind"); - st->GetFunction()->GetClassTyidx() = styidx; + if (styidx != 0) { + MIRType *prevType = GlobalTables::GetTypeTable().GetTypeFromTyIdx(styidx); + ASSERT(prevType->GetKind() == kTypeInterface || prevType->GetKind() == kTypeInterfaceIncomplete, + "type kind should be consistent."); + if (static_cast(prevType)->IsIncomplete() && !(interfaceType.IsIncomplete())) { + interfaceType.SetNameStrIdx(prevType->GetNameStrIdx()); + interfaceType.SetTypeIndex(styidx); + GlobalTables::GetTypeTable().SetTypeWithTyIdx(styidx, interfaceType.CopyMIRTypeNode()); + } + } else { + styidx = GlobalTables::GetTypeTable().GetOrCreateMIRType(&interfaceType); + // set up classTyIdx for methods + for (size_t i = 0; i < interfaceType.GetMethods().size(); i++) { + StIdx stidx = interfaceType.GetMethodsElement(i).first; + MIRSymbol *st = GlobalTables::GetGsymTable().GetSymbolFromStidx(stidx.Idx()); + ASSERT(st != nullptr, "st is null"); + ASSERT(st->GetSKind() == kStFunc, "unexpected st->sKind"); + st->GetFunction()->GetClassTyidx() = styidx; + } + mod.AddClass(styidx); } - mod.AddClass(styidx); lexer.NextToken(); return true; } @@ -1461,7 +1494,7 @@ bool MIRParser::ParseTypedef() { // at this point,if prev_tyidx is not zero, this type name has been // forward-referenced tokenKind = lexer.NextToken(); - tyIdx = TyIdx(0); + tyIdx = prevTyIdx; if (IsPrimitiveType(tokenKind)) { if (!ParsePrimType(tyIdx)) { Error("expect primitive type after typedef but get "); @@ -1471,6 +1504,9 @@ bool MIRParser::ParseTypedef() { Error("error passing derived type at "); return false; } + if (prevTyIdx != 0) { + return true; + } // for class/interface types, prev_tyidx could also be set during processing // so we check again right before SetGStrIdxToTyIdx if (isLocal) { @@ -1490,12 +1526,6 @@ bool MIRParser::ParseTypedef() { GlobalTables::GetTypeTable().GetTypeFromTyIdx(tyIdx)->SetNameStrIdx(strIdx); } } - if (prevTyIdx != 0 && prevTyIdx != tyIdx) { - // replace all uses of prev_tyidx by tyIdx in type_table_ - typeDefIdxMap[prevTyIdx] = tyIdx; // record the real tydix - // remove prev_tyidx from classlist - mod.RemoveClass(prevTyIdx); - } // Merge class or interface type at the cross-module level ASSERT(GlobalTables::GetTypeTable().GetTypeTable().empty() == false, "container check"); MIRType *type = GlobalTables::GetTypeTable().GetTypeFromTyIdx(tyIdx); @@ -1504,19 +1534,6 @@ bool MIRParser::ParseTypedef() { prevTyIdx = GlobalTables::GetTypeNameTable().GetTyidxFromGstrIdx(strIdx); if (prevTyIdx == 0) { GlobalTables::GetTypeNameTable().SetGStrIdxToTyIdx(strIdx, tyIdx); - } else { - MIRStructType *structType = static_cast(GlobalTables::GetTypeTable().GetTypeFromTyIdx(tyIdx)); - MIRStructType *prevSType = static_cast(GlobalTables::GetTypeTable().GetTypeFromTyIdx(prevTyIdx)); - if (!structType->IsIncomplete()) { - if (prevSType->IsIncomplete()) { - // New definition is strong and previous definition is weak. - GlobalTables::GetTypeNameTable().SetGStrIdxToTyIdx(strIdx, tyIdx); - } else if (!prevSType->IsIncomplete() && !structType->IsIncomplete()) { - // Both are strong, something must be wrong - Error("redefined class/interface type name"); - return false; - } - } } // setup eh root type MIRType *ehType = GlobalTables::GetTypeTable().GetTypeFromTyIdx(tyIdx); @@ -1678,7 +1695,8 @@ bool MIRParser::ParseDeclareVar(MIRSymbol *symbol) { } if (symbol->GetStorageClass() == kScExtern && symbol->IsStatic()) { const std::string &staticFieldName = symbol->GetName(); - size_t pos = staticFieldName.find(NameMangler::kClassNameSplitterStr) + 3; + constexpr int kPosOffset = 3; + size_t pos = staticFieldName.find(NameMangler::kClassNameSplitterStr) + kPosOffset; if (pos != 0 && pos != std::string::npos) { std::string className = staticFieldName.substr(0, pos); MIRSymbol *classSt = @@ -2798,5 +2816,4 @@ void MIRParser::EmitWarning(const std::string &fileName) { } WARN(kLncWarn, "%s \n%s\n", fileName.c_str(), GetWarning().c_str()); } - } // namespace maple diff --git a/src/maple_ir/src/printing.cpp b/src/maple_ir/src/printing.cpp index 7e638f27baa827117c46faaf979fd9747b4184c6..782933bab92d3cc1ee7a691325a514396d5a91d5 100644 --- a/src/maple_ir/src/printing.cpp +++ b/src/maple_ir/src/printing.cpp @@ -20,7 +20,6 @@ constexpr int kIndentunit = 2; // number of blank chars of each indentation namespace maple { - std::string const kBlankString = " "; void PrintIndentation(int32 indent) { @@ -51,10 +50,11 @@ void PrintString(const std::string &str) { break; } } else { - LogInfo::MapleLogger() << "\\x" << std::hex << std::setfill('0') << std::setw(2) << (unsigned int)c << std::dec; + constexpr int kFieldWidth = 2; + LogInfo::MapleLogger() << "\\x" << std::hex << std::setfill('0') << std::setw(kFieldWidth) + << (unsigned int)c << std::dec; } } LogInfo::MapleLogger() << "\""; } - } // namespace maple diff --git a/src/maple_me/include/alias_class.h b/src/maple_me/include/alias_class.h index c68b72591a0686d49a56b129cf13e978391e7cf6..d1dfc4fe7b3fe6d231dd14c311b1fd2a7d619e4d 100644 --- a/src/maple_me/include/alias_class.h +++ b/src/maple_me/include/alias_class.h @@ -176,16 +176,16 @@ class AliasClass : public AnalysisResult { bool calleeHasSideEffect; KlassHierarchy *klassHierarchy; AliasAnalysisTable *aliasAnalysisTable; - bool CallHasNoSideEffectOrPrivateDefEffect(StmtNode &stmt, FuncAttrKind attrKind); - bool CallHasSideEffect(StmtNode &stmt); - bool CallHasNoPrivateDefEffect(StmtNode &stmt); + bool CallHasNoSideEffectOrPrivateDefEffect(CallNode &stmt, FuncAttrKind attrKind); + bool CallHasSideEffect(CallNode &stmt); + bool CallHasNoPrivateDefEffect(CallNode &stmt); AliasElem *FindOrCreateAliasElem(OriginalSt &ost); AliasElem *FindOrCreateExtraLevAliasElem(BaseNode &expr, TyIdx tyIdx, FieldID fieldId); AliasElem *CreateAliasElemsExpr(BaseNode &expr); void SetNotAllDefsSeenForMustDefs(const StmtNode &callas); void SetPtrOpndNextLevNADS(const BaseNode &opnd, AliasElem *ae, bool hasNoPrivateDefEffect); void SetPtrOpndsNextLevNADS(uint start, uint end, MapleVector &opnds, bool hasNoPrivateDefEffect); - void ApplyUnionForDassignCopy(const AliasElem &lhsAe, const AliasElem *rhsAe, const BaseNode *rhs); + void ApplyUnionForDassignCopy(const AliasElem &lhsAe, const AliasElem *rhsAe, const BaseNode &rhs); AliasElem *FindOrCreateDummyNADSAe(); void CollectMayDefForMustDefs(const StmtNode &stmt, std::set &mayDefOsts); void CollectMayUseForCallOpnd(const StmtNode &stmt, std::set &mayUseOsts); diff --git a/src/maple_me/include/bb.h b/src/maple_me/include/bb.h index 658672210cd8059dfa073b72ed8c9210e9ad04d0..7b530348506619a6347ae5fa093b37941aa0b2b9 100644 --- a/src/maple_me/include/bb.h +++ b/src/maple_me/include/bb.h @@ -171,6 +171,7 @@ class BB { void Dump(MIRModule *mod); void DumpHeader(MIRModule *mod); + void DumpPhi(MIRModule* mod); void DumpBBAttribute(MIRModule *mod); std::string StrAttribute() const; void InsertBefore(BB *bb); // insert this before bb in optimizer bb list @@ -181,11 +182,11 @@ class BB { } // This is to help new bb to keep some flags from original bb after logically splitting. - void CopyFlagsAfterSplit(const BB *bb) { - bb->GetAttributes(kBBAttrIsTry) ? SetAttributes(kBBAttrIsTry) : ClearAttributes(kBBAttrIsTry); - bb->GetAttributes(kBBAttrIsTryEnd) ? SetAttributes(kBBAttrIsTryEnd) : ClearAttributes(kBBAttrIsTryEnd); - bb->GetAttributes(kBBAttrIsExit) ? SetAttributes(kBBAttrIsExit) : ClearAttributes(kBBAttrIsExit); - bb->GetAttributes(kBBAttrWontExit) ? SetAttributes(kBBAttrWontExit) : ClearAttributes(kBBAttrWontExit); + void CopyFlagsAfterSplit(const BB &bb) { + bb.GetAttributes(kBBAttrIsTry) ? SetAttributes(kBBAttrIsTry) : ClearAttributes(kBBAttrIsTry); + bb.GetAttributes(kBBAttrIsTryEnd) ? SetAttributes(kBBAttrIsTryEnd) : ClearAttributes(kBBAttrIsTryEnd); + bb.GetAttributes(kBBAttrIsExit) ? SetAttributes(kBBAttrIsExit) : ClearAttributes(kBBAttrIsExit); + bb.GetAttributes(kBBAttrWontExit) ? SetAttributes(kBBAttrWontExit) : ClearAttributes(kBBAttrWontExit); } BBId GetBBId() const { @@ -200,7 +201,7 @@ class BB { return id.idx; } - StmtNode *GetTheOnlyStmtNode(); + StmtNode *GetTheOnlyStmtNode() const; bool IsEmpty() const { return stmtNodeList.empty(); } @@ -223,7 +224,7 @@ class BB { void SetFirstMe(MeStmt *stmt); void SetLastMe(MeStmt *stmt); - bool IsInList(MapleVector &) const; + bool IsInList(const MapleVector&) const; bool IsPredBB(BB *bb) const { // if this is a pred of bb return true; // otherwise return false; @@ -261,11 +262,10 @@ class BB { RemoveBBFromSucc(succBB); } - void FindReachableBBs(std::vector &); - void FindWillExitBBs(std::vector &); - const PhiNode *PhiofVerStInserted(VersionSt *vsym); + void FindReachableBBs(std::vector&) const; + void FindWillExitBBs(std::vector&) const; + const PhiNode *PhiofVerStInserted(VersionSt &vsym); void InsertPhi(MapleAllocator *alloc, VersionSt *vsym); - void DumpPhi(const MIRModule*); bool IsMeStmtEmpty() const { return meStmtList.empty(); } @@ -297,7 +297,7 @@ class BB { return meStmtList; } - virtual ~BB(){}; + virtual ~BB() = default; const LabelIdx GetBBLabel() const { return bbLabel; @@ -413,4 +413,4 @@ struct hash { }; } // namespace std -#endif // MAPLE_ME_INCLUDE_BB_H \ No newline at end of file +#endif // MAPLE_ME_INCLUDE_BB_H diff --git a/src/maple_me/include/dominance.h b/src/maple_me/include/dominance.h index 155c9d8db0d3dec72c140ebc1dbc41d8dab6fbd2..5f8f87439efb05c091aaa91ceb58bf66b8c6d17d 100644 --- a/src/maple_me/include/dominance.h +++ b/src/maple_me/include/dominance.h @@ -61,9 +61,6 @@ class Dominance : public AnalysisResult { bool PostDominate(const BB &b1, BB &b2); // true if b1 postdominates b2 void DumpPdoms(); - MapleVector &GetBBVec() { - return bbVec; - } const MapleVector &GetBBVec() const { return bbVec; } @@ -76,19 +73,19 @@ class Dominance : public AnalysisResult { return bbVec.size(); } - BB *GetBBAt(uint i) { + BB *GetBBAt(uint i) const { return bbVec[i]; } - BB &GetCommonEntryBB() { + BB &GetCommonEntryBB() const { return commonEntryBB; } - BB &GetCommonExitBB() { + BB &GetCommonExitBB() const { return commonExitBB; } - MapleVector &GetPostOrderIDVec() { + const MapleVector &GetPostOrderIDVec() const { return postOrderIDVec; } @@ -132,8 +129,8 @@ class Dominance : public AnalysisResult { return pdomChildren[idx]; } - MapleVector &GetPdtPreOrder() { - return pdtPreOrder; + void ResizePdtPreOrder(int n) { + return pdtPreOrder.resize(n); } BBId GetPdtPreOrderItem(size_t idx) const { @@ -195,11 +192,12 @@ class Dominance : public AnalysisResult { protected: MapleAllocator domAllocator; // stores the analysis results - void PostOrderWalk(BB &bb, int32 &pid, std::vector &visitedMap); + void PostOrderWalk(const BB &bb, int32 &pid, std::vector &visitedMap); BB *Intersect(BB &bb1, const BB &bb2); - bool CommonEntryBBIsPred(const BB &bb); + bool CommonEntryBBIsPred(const BB &bb) const; void PdomPostOrderWalk(BB &bb, int32 &pid, std::vector &visitedMap); BB *PdomIntersect(BB &bb1, const BB &bb2); + private: MapleAllocator tmpAllocator; // can be freed after dominator computation MapleVector &bbVec; diff --git a/src/maple_me/include/irmap.h b/src/maple_me/include/irmap.h index 9a8320063fe28f41e41e7275c8529aea273b688d..782bdb6191789323a1855d24bb8b44130b101ea3 100644 --- a/src/maple_me/include/irmap.h +++ b/src/maple_me/include/irmap.h @@ -23,10 +23,10 @@ namespace maple { class IRMap : public AnalysisResult { public: - IRMap(SSATab &ssatab, Dominance &dom, MemPool &memPool, MemPool &tmpMemPool, uint32 hashTableSize) + IRMap(SSATab &ssaTab, Dominance &dom, MemPool &memPool, MemPool &tmpMemPool, uint32 hashTableSize) : AnalysisResult(&memPool), - ssaTab(ssatab), - mirModule(ssatab.GetModule()), + ssaTab(ssaTab), + mirModule(ssaTab.GetModule()), dom(dom), irMapAlloc(&memPool), tempAlloc(&tmpMemPool), @@ -36,11 +36,11 @@ class IRMap : public AnalysisResult { regMeExprTable(irMapAlloc.Adapter()), curBB(nullptr) {} - virtual ~IRMap() {} + virtual ~IRMap() = default; virtual BB *GetBB(BBId id) = 0; virtual BB *GetBBForLabIdx(LabelIdx lidx, PUIdx pidx = 0) = 0; - Dominance *GetDominance() { + Dominance *GetDominance() const { return &dom; } @@ -64,9 +64,8 @@ class IRMap : public AnalysisResult { RegMeExpr *CreateRegMeExprVersion(const OriginalSt&); RegMeExpr *CreateRegMeExprVersion(const RegMeExpr&); MeExpr *ReplaceMeExprExpr(MeExpr&, MeExpr&, MeExpr&); - bool ReplaceMeExprStmtOpnd(uint32, MeStmt&, MeExpr&, MeExpr&); bool ReplaceMeExprStmt(MeStmt&, MeExpr&, MeExpr&); - MeExpr *GetMeExprByVerID(uint32 verid) { + MeExpr *GetMeExprByVerID(uint32 verid) const { return verst2MeExprTable[verid]; } @@ -202,14 +201,16 @@ class IRMap : public AnalysisResult { Dominance &dom; MapleAllocator irMapAlloc; MapleAllocator tempAlloc; - int32 exprID = 0; // for allocating exprid_ in MeExpr + int32 exprID = 0; // for allocating exprid_ in MeExpr uint32 mapHashLength; // size of hashTable MapleVector hashTable; // the value number hash table MapleVector verst2MeExprTable; // map versionst to MeExpr. MapleVector regMeExprTable; // record all the regmeexpr created by ssapre - bool needAnotherPass = false; // set to true if CFG has changed + bool needAnotherPass = false; // set to true if CFG has changed bool dumpStmtNum = false; BB *curBB; // current maple_me::BB being visited + + bool ReplaceMeExprStmtOpnd(uint32, MeStmt&, MeExpr&, MeExpr&); }; } // namespace maple #endif // MAPLE_ME_INCLUDE_IRMAP_H diff --git a/src/maple_me/include/me_cfg.h b/src/maple_me/include/me_cfg.h index cc82bafad81ed854354d5ebf8f92bd1dbaa7ce09..3e2664276559c9a90cc3a5bf22c78c0dc52328f2 100644 --- a/src/maple_me/include/me_cfg.h +++ b/src/maple_me/include/me_cfg.h @@ -20,31 +20,31 @@ namespace maple { class MeCFG { public: - MeCFG(MeFunction &f) : func(f) {} + explicit MeCFG(MeFunction &f) : func(f) {} - ~MeCFG() {} + ~MeCFG() = default; void BuildMirCFG(); void FixMirCFG(); void ConvertPhis2IdentityAssigns(BB &meBB); void UnreachCodeAnalysis(bool updatePhi = false); void WontExitAnalysis(); - void Verify(); + void Verify() const; void VerifyLabels(); void Dump(); void DumpToFile(const std::string &prefix, bool dumpInStrs = false); void AddAuxilaryBB(); - bool FindExprUse(BaseNode &expr, StIdx stIdx); - bool FindUse(StmtNode &stmt, StIdx stid); - bool FindDef(StmtNode &stmt, StIdx stid); - bool HasNoOccBetween(StmtNode &from, StmtNode &to, StIdx stIdx); + bool FindExprUse(const BaseNode &expr, StIdx stIdx) const; + bool FindUse(const StmtNode &stmt, StIdx stid) const; + bool FindDef(const StmtNode &stmt, StIdx stid) const; + bool HasNoOccBetween(StmtNode &from, const StmtNode &to, StIdx stIdx) const; - MeFunction &GetFunc() { + const MeFunction &GetFunc() { return func; } - bool GetHasDoWhile() { + bool GetHasDoWhile() const { return hasDoWhile; } diff --git a/src/maple_me/include/me_const.h b/src/maple_me/include/me_const.h index dd4106c80137dd110d884161e3000231abfe96a3..1ffb4492e24e2618b726151a05ebd29771fa70fd 100644 --- a/src/maple_me/include/me_const.h +++ b/src/maple_me/include/me_const.h @@ -12,6 +12,11 @@ * FIT FOR A PARTICULAR PURPOSE. * See the Mulan PSL v1 for more details. */ +/** + * + * define consts used by maple_me + * + */ #ifndef MAPLE_ME_INCLUDE_ME_CONST_H #define MAPLE_ME_INCLUDE_ME_CONST_H #include diff --git a/src/maple_me/include/me_function.h b/src/maple_me/include/me_function.h index b081b24713419ba9074d4fe8018998ae588ca69a..b84631a6449dbf574b4467018f29a276b3689be3 100644 --- a/src/maple_me/include/me_function.h +++ b/src/maple_me/include/me_function.h @@ -308,15 +308,15 @@ class MeFunction : public FuncEmit { } BB *NewBasicBlock(); - BB *InsertNewBasicBlock(BB *position); - void DeleteBasicBlock(const BB *bb); + BB *InsertNewBasicBlock(BB &position); + void DeleteBasicBlock(const BB &bb); BB *NextBB(const BB *bb); BB *PrevBB(const BB *bb); /* create label for bb */ - void CreateBBLabel(BB *bb); + void CreateBBLabel(BB &bb); /* clone stmtnodes from orig to newbb */ - void CloneBasicBlock(BB *newbb, BB *orig); - BB *SplitBB(BB *bb, StmtNode *splitPoint, BB *newBB = nullptr); + void CloneBasicBlock(BB &newbb, BB &orig); + BB *SplitBB(BB &bb, StmtNode &splitPoint, BB *newBB = nullptr); const bool HasException() const { return hasEH; } @@ -386,16 +386,19 @@ class MeFunction : public FuncEmit { irmap = currIRMap; } - MapleUnorderedMap &GetBBTryNodeMap() { + const MapleUnorderedMap &GetBBTryNodeMap() { return bbTryNodeMap; } - MapleUnorderedMap &GetEndTryBB2TryBB() { + const MapleUnorderedMap &GetEndTryBB2TryBB() { return endTryBB2TryBB; } - - BB *GetEndTryBB(BB *endTry) { - return endTryBB2TryBB[endTry]; + const BB* GetTryBBFromEndTryBB(BB *endTryBB) const { + auto it = endTryBB2TryBB.find(endTryBB); + return it == endTryBB2TryBB.end() ? nullptr : it->second; + } + void SetTryBBByOtherEndTryBB(BB *endTryBB, BB *otherTryBB) { + endTryBB2TryBB[endTryBB] = endTryBB2TryBB[otherTryBB]; } MeCFG *GetTheCfg() { @@ -417,10 +420,12 @@ class MeFunction : public FuncEmit { void SetNextBBId(uint32 currNextBBId) { nextBBId = currNextBBId; } - - uint32 &GetNextBBId() { + uint32 GetNextBBId() { return nextBBId; } + void DecNextBBId() { + --nextBBId; + } uint32 GetRegNum() const { return regNum; diff --git a/src/maple_me/include/me_ir.h b/src/maple_me/include/me_ir.h index 550f52df67973412581065750577d20756eb8196..7084f378a573d2423984f189e2752f77f3a5da43 100644 --- a/src/maple_me/include/me_ir.h +++ b/src/maple_me/include/me_ir.h @@ -105,10 +105,10 @@ class MeExpr { return next; } - void InitBase(Opcode o, PrimType t, uint32 n) { - op = o; - primType = t; - numOpnds = n; + void InitBase(Opcode op, PrimType primType, uint32 numOpnds) { + this->op = op; + this->primType = primType; + this->numOpnds = static_cast(numOpnds); } virtual void Dump(IRMap*, int32 indent = 0) const {} @@ -194,8 +194,7 @@ class VarMeExpr final : public MeExpr { inferredTyIdx(0), inferredTypeCandidates(alloc->Adapter()), defBy(kDefByNo), - maybeNull(true) { - } + maybeNull(true) {} ~VarMeExpr() = default; @@ -245,7 +244,7 @@ class VarMeExpr final : public MeExpr { fieldID = fieldId; } - TyIdx &GetInferredTyIdx() { + TyIdx GetInferredTyIdx() const { return inferredTyIdx; } @@ -253,9 +252,15 @@ class VarMeExpr final : public MeExpr { inferredTyIdx = inferredTyIdxVal; } - MapleVector &GetInferredTypeCandidates() { + const MapleVector &GetInferredTypeCandidates() const { return inferredTypeCandidates; } + void AddInferredTypeCandidate(TyIdx idx) { + inferredTypeCandidates.push_back(idx); + } + void ClearInferredTypeCandidates(TyIdx idx) { + inferredTypeCandidates.clear(); + } MeDefBy GetDefBy() const { return defBy; @@ -265,7 +270,7 @@ class VarMeExpr final : public MeExpr { defBy = defByVal; } - bool GetMaybeNull() { + bool GetMaybeNull() const { return maybeNull; } @@ -528,7 +533,7 @@ class MeRegPhiNode { return opnds; } - RegMeExpr *GetOpnd(size_t idx) { + RegMeExpr *GetOpnd(size_t idx) const { CHECK_FATAL(idx < opnds.size(), "out of range in MeRegPhiNode::GetOpnd"); return opnds[idx]; } @@ -542,7 +547,7 @@ class MeRegPhiNode { isLive = isLiveVal; } - bool GetIsLive() { + bool GetIsLive() const { return isLive; } @@ -550,7 +555,7 @@ class MeRegPhiNode { defBB = defBBVal; } - BB *GetDefBB() { + BB *GetDefBB() const { return defBB; } @@ -563,7 +568,7 @@ class MeRegPhiNode { class ConstMeExpr : public MeExpr { public: - ConstMeExpr(int32 exprID, MIRConst *constValParam) : MeExpr(exprID, kMeOpConst), constVal(constValParam){}; + ConstMeExpr(int32 exprID, MIRConst *constValParam) : MeExpr(exprID, kMeOpConst), constVal(constValParam) {} ~ConstMeExpr() = default; void Dump(IRMap*, int32 indent = 0) const; @@ -579,24 +584,23 @@ class ConstMeExpr : public MeExpr { } uint32 GetHashIndex() const { - MIRIntConst *intConst = dynamic_cast(constVal); - if (intConst != nullptr) { + if (constVal->GetKind() == kConstInt) { + MIRIntConst *intConst = static_cast(constVal); return intConst->GetValue(); } - MIRFloatConst *floatConst = dynamic_cast(constVal); - if (floatConst != nullptr) { + if (constVal->GetKind() == kConstFloatConst) { + MIRFloatConst *floatConst = static_cast(constVal); return floatConst->GetIntValue(); } - MIRDoubleConst *doubleConst = dynamic_cast(constVal); - if (doubleConst != nullptr) { + if (constVal->GetKind() == kConstDoubleConst) { + MIRDoubleConst *doubleConst = static_cast(constVal); return doubleConst->GetIntValue(); } - MIRLblConst *lblConst = dynamic_cast(constVal); - if (lblConst != nullptr) { + if (constVal->GetKind() == kConstLblConst) { + MIRLblConst *lblConst = static_cast(constVal); return lblConst->GetValue(); } ASSERT(false, "ComputeHash: const type not yet implemented"); - return 0; } @@ -606,13 +610,14 @@ class ConstMeExpr : public MeExpr { class ConststrMeExpr : public MeExpr { public: - ConststrMeExpr(int32 exprID, UStrIdx idx) : MeExpr(exprID, kMeOpConststr), strIdx(idx){}; + ConststrMeExpr(int32 exprID, UStrIdx idx) : MeExpr(exprID, kMeOpConststr), strIdx(idx) {} + ~ConststrMeExpr() = default; void Dump(IRMap*, int32 indent = 0) const; BaseNode &EmitExpr(SSATab &); - UStrIdx &GetStrIdx() { + UStrIdx GetStrIdx() const { return strIdx; } @@ -626,13 +631,13 @@ class ConststrMeExpr : public MeExpr { class Conststr16MeExpr : public MeExpr { public: - Conststr16MeExpr(int32 exprID, U16StrIdx idx) : MeExpr(exprID, kMeOpConststr16), strIdx(idx){}; + Conststr16MeExpr(int32 exprID, U16StrIdx idx) : MeExpr(exprID, kMeOpConststr16), strIdx(idx) {} ~Conststr16MeExpr() = default; void Dump(IRMap*, int32 indent = 0) const; BaseNode &EmitExpr(SSATab &); - U16StrIdx &GetStrIdx() { + U16StrIdx GetStrIdx() { return strIdx; } @@ -646,13 +651,13 @@ class Conststr16MeExpr : public MeExpr { class SizeoftypeMeExpr : public MeExpr { public: - SizeoftypeMeExpr(int32 exprid, TyIdx idx) : MeExpr(exprid, kMeOpSizeoftype), tyIdx(idx){}; + SizeoftypeMeExpr(int32 exprid, TyIdx idx) : MeExpr(exprid, kMeOpSizeoftype), tyIdx(idx) {} ~SizeoftypeMeExpr() = default; void Dump(IRMap*, int32 indent = 0) const; BaseNode &EmitExpr(SSATab &); - TyIdx &GetTyIdx() { + TyIdx GetTyIdx() const { return tyIdx; } @@ -673,7 +678,7 @@ class FieldsDistMeExpr : public MeExpr { void Dump(IRMap*, int32 indent = 0) const; BaseNode &EmitExpr(SSATab &); - TyIdx &GetTyIdx() { + TyIdx GetTyIdx() const { return tyIdx; } @@ -705,10 +710,6 @@ class AddrofMeExpr : public MeExpr { bool IsUseSameSymbol(const MeExpr &) const override; BaseNode &EmitExpr(SSATab &) override; - OStIdx &GetOstIdx() { - return ostIdx; - } - OStIdx GetOstIdx() const { return ostIdx; } @@ -760,10 +761,6 @@ class GcmallocMeExpr : public MeExpr { void Dump(IRMap*, int32 indent = 0) const; BaseNode &EmitExpr(SSATab &); - TyIdx &GetTyIdx() { - return tyIdx; - } - TyIdx GetTyIdx() const { return tyIdx; } @@ -781,15 +778,15 @@ class OpMeExpr : public MeExpr { public: explicit OpMeExpr(int32 exprID) : MeExpr(exprID, kMeOpOp), tyIdx(TyIdx(0)) {} - OpMeExpr(const OpMeExpr &opmeexpr, int32 exprID) + OpMeExpr(const OpMeExpr &opMeExpr, int32 exprID) : MeExpr(exprID, kMeOpOp), - opnds(opmeexpr.opnds), - opndType(opmeexpr.opndType), - bitsOffset(opmeexpr.bitsOffset), - bitsSize(opmeexpr.bitsSize), - tyIdx(opmeexpr.tyIdx), - fieldID(opmeexpr.fieldID) { - InitBase(opmeexpr.GetOp(), opmeexpr.GetPrimType(), opmeexpr.GetNumOpnds()); + opnds(opMeExpr.opnds), + opndType(opMeExpr.opndType), + bitsOffset(opMeExpr.bitsOffset), + bitsSize(opMeExpr.bitsSize), + tyIdx(opMeExpr.tyIdx), + fieldID(opMeExpr.fieldID) { + InitBase(opMeExpr.GetOp(), opMeExpr.GetPrimType(), opMeExpr.GetNumOpnds()); } ~OpMeExpr() = default; @@ -835,10 +832,6 @@ class OpMeExpr : public MeExpr { bitsSize = bitsSizeVal; } - TyIdx &GetTyIdx() { - return tyIdx; - } - TyIdx GetTyIdx() const { return tyIdx; } @@ -1022,11 +1015,7 @@ class NaryMeExpr : public MeExpr { return opnds[idx]; } - const TyIdx &GetTyIdx() const { - return tyIdx; - } - - TyIdx &GetTyIdx() { + TyIdx GetTyIdx() const { return tyIdx; } @@ -1121,12 +1110,11 @@ class MeStmt { return op == OP_dassign || op == OP_maydassign || op == OP_iassign || op == OP_regassign; } - void SetCallReturn(MeExpr &); virtual MIRType *GetReturnType() const { return nullptr; } - void EmitCallReturnVector(SSATab *ssatab, CallReturnVector *nrets); + void EmitCallReturnVector(SSATab &ssatab, CallReturnVector &nrets); virtual MapleVector *GetMustDefList() { return nullptr; } @@ -1147,10 +1135,10 @@ class MeStmt { return nullptr; } - void CopyBase(MeStmt *mestmt) { - bb = mestmt->bb; - srcPos = mestmt->srcPos; - isLive = mestmt->isLive; + void CopyBase(MeStmt &mestmt) { + bb = mestmt.bb; + srcPos = mestmt.srcPos; + isLive = mestmt.isLive; } bool IsTheSameWorkcand(MeStmt &) const; @@ -1674,7 +1662,7 @@ class MaydassignMeStmt : public MeStmt { needIncref = false; } - OriginalSt *GetMayDassignSym() const { + const OriginalSt *GetMayDassignSym() const { return mayDSSym; } @@ -2018,6 +2006,8 @@ class CallMeStmt : public NaryMeStmt, public MuChiMePart, public AssignedPart { StmtNode &EmitStmt(SSATab &ssatab); + void SetCallReturn(MeExpr &); + private: PUIdx puIdx; // Used in trim call graph @@ -2400,8 +2390,11 @@ class SwitchMeStmt : public UnaryMeStmt { void SetDefaultLabel(LabelIdx curr) { defaultLabel = curr; } + void SetCaseLabel(uint32 caseIdx, LabelIdx label) { + switchTable[caseIdx].second = label; + } - CaseVector &GetSwitchTable() { + const CaseVector &GetSwitchTable() { return switchTable; } @@ -2535,11 +2528,6 @@ class AssertMeStmt : public MeStmt { ~AssertMeStmt() = default; - bool HasSameVersion(const AssertMeStmt *assmestmt) const { - ASSERT(GetOp() == assmestmt->GetOp(), "runtime check error"); - return (opnds[0] == assmestmt->opnds[0] && opnds[1] == assmestmt->opnds[1]); - } - MeExpr *GetIndexExpr() const { return opnds[1]; } @@ -2574,9 +2562,9 @@ class AssertMeStmt : public MeStmt { } }; -MapleMap *GenericGetChiListFromVarMeExpr(VarMeExpr *expr); -void DumpMuList(IRMap *irmap, const MapleMap &mulist, int32 indent); -void DumpChiList(IRMap *irmap, const MapleMap &chilist); +MapleMap *GenericGetChiListFromVarMeExpr(VarMeExpr &expr); +void DumpMuList(IRMap *irMap, const MapleMap &muList, int32 indent); +void DumpChiList(IRMap *irMap, const MapleMap &chiList); class DumpOptions { public: static bool GetSimpleDump() { diff --git a/src/maple_me/include/me_irmap.h b/src/maple_me/include/me_irmap.h index 7a487946b8a9ee455ea1d5ea50bb9bec3c16df74..c24a0fc5a62edaabdfe6b40312e1ec4d56bf60ed 100644 --- a/src/maple_me/include/me_irmap.h +++ b/src/maple_me/include/me_irmap.h @@ -28,7 +28,7 @@ class MeIRMap : public IRMap { SetDumpStmtNum(MeOption::stmtNum); } - ~MeIRMap() {} + ~MeIRMap() = default; BB *GetBB(BBId id) override { return func.GetBBFromID(id); @@ -43,8 +43,8 @@ class MeIRMap : public IRMap { void EmitBB(BB&, BlockNode&); void EmitBBStmts(BB&, BlockNode&); - MeFunction *GetFunc() const { - return &func; + MeFunction &GetFunc() const { + return func; } private: @@ -55,7 +55,7 @@ class MeDoIRMap : public MeFuncPhase { public: explicit MeDoIRMap(MePhaseID id) : MeFuncPhase(id) {} - ~MeDoIRMap() {} + ~MeDoIRMap() = default; AnalysisResult *Run(MeFunction *func, MeFuncResultMgr *m, ModuleResultMgr *mrm) override; std::string PhaseName() const override { diff --git a/src/maple_me/include/me_option.h b/src/maple_me/include/me_option.h index 245a02a3fee28db5fcd3b3b660892ad436f4e803..8a2705c091cecc809dad1c74e2f54bf9def251f0 100644 --- a/src/maple_me/include/me_option.h +++ b/src/maple_me/include/me_option.h @@ -26,15 +26,17 @@ class MeOption { explicit MeOption(MemPool &memPool) : optionAlloc(&memPool) {} void ParseOptions(int argc, char **argv, std::string &fileName); - ~MeOption() {} + ~MeOption() = default; void DumpUsage(); static bool DumpPhase(const std::string &phase); static std::unordered_set dumpPhases; - static constexpr int kLevelZero = 0; - static constexpr int kLevelOne = 1; - static constexpr int kLevelTwo = 2; - static constexpr int kLevelThree = 3; + enum Level { + LEVEL_ZERO = 0, + LEVEL_ONE = 1, + LEVEL_TWO = 2, + LEVEL_THREE = 3 + }; static bool dumpAfter; static constexpr int kRangeArrayLen = 2; static unsigned long range[kRangeArrayLen]; @@ -53,9 +55,12 @@ class MeOption { static bool finalFieldAlias; static bool regreadAtReturn; void SplitPhases(const std::string &str, std::unordered_set &set); + void SplitSkipPhases(const std::string &str) { + SplitPhases(str, skipPhases); + } void GetRange(const std::string &str); - std::unordered_set &GetSkipPhases() { + const std::unordered_set &GetSkipPhases() const { return skipPhases; } diff --git a/src/maple_me/include/me_phase.h b/src/maple_me/include/me_phase.h index 83301607cb54a2ea0c3582d664fe6c4d71a4d8c2..5c0fa651a143d45eebd90acda683ddfa1c9ef80c 100644 --- a/src/maple_me/include/me_phase.h +++ b/src/maple_me/include/me_phase.h @@ -37,7 +37,7 @@ class MeFuncPhase : public Phase { public: explicit MeFuncPhase(MePhaseID id) : Phase() { phaseID = id; - prevPhaseName = ""; /* init prev_phasename is nullptr */ + prevPhaseName = ""; // init prev_phasename is nullptr isCFGChanged = false; } @@ -75,7 +75,7 @@ class MeFuncPhase : public Phase { private: MePhaseID phaseID; - std::string prevPhaseName; /* used in filename for emit */ + std::string prevPhaseName; // used in filename for emit bool isCFGChanged; // is this phase changed CFG }; } // namespace maple diff --git a/src/maple_me/include/me_phase_manager.h b/src/maple_me/include/me_phase_manager.h index 15b3f876d34d976e137a87fdf8b0fc09495d859f..5154bbe41c1de4f8b71eb5b0ec6eb643730178ba 100644 --- a/src/maple_me/include/me_phase_manager.h +++ b/src/maple_me/include/me_phase_manager.h @@ -44,8 +44,8 @@ class MeFuncPhaseManager : public PhaseManager { void RunFuncPhase(MeFunction *func, MeFuncPhase *phase); void RegisterFuncPhases(); - void AddPhases(std::unordered_set &skipPhases); - void AddPhasesNoDefault(std::vector &phases); + void AddPhases(const std::unordered_set &skipPhases); + void AddPhasesNoDefault(const std::vector &phases); void SetMePhase(MePhaseType mephase) { mePhaseType = mephase; } @@ -54,11 +54,11 @@ class MeFuncPhaseManager : public PhaseManager { modResMgr = mrm; } - void Run(MIRFunction *mirfunc, uint64 rangenum, const std::string &meinput); + void Run(MIRFunction *mirFunc, uint64 rangeNum, const std::string &meInput); void IPACleanUp(MeFunction *mirfunc); void Run() override {} - MeFuncResultMgr *GetAnalysisResultManager(void) { + MeFuncResultMgr *GetAnalysisResultManager() { return &arFuncManager; } @@ -80,7 +80,7 @@ class MeFuncPhaseManager : public PhaseManager { timePhases = phs; } - bool isIPA() { + bool IsIPA() const { return ipa; } @@ -99,4 +99,4 @@ class MeFuncPhaseManager : public PhaseManager { bool ipa; }; } // namespace maple -#endif // MAPLE_ME_INCLUDE_ME_PHASE_MANAGER_H \ No newline at end of file +#endif // MAPLE_ME_INCLUDE_ME_PHASE_MANAGER_H diff --git a/src/maple_me/include/me_rc_lowering.h b/src/maple_me/include/me_rc_lowering.h index 3f3461d447a31bd6e880603751641f46410fd9c0..f13ff520e859d6f03f2afe8a696295b250dc2196 100644 --- a/src/maple_me/include/me_rc_lowering.h +++ b/src/maple_me/include/me_rc_lowering.h @@ -23,6 +23,7 @@ namespace maple { class RCLowering { public: + RCLowering(MeFunction &f, KlassHierarchy &kh) : func(f), mirModule(f.GetMIRModule()), @@ -38,26 +39,14 @@ class RCLowering { void PostRCLower(); void Finish(); void FastBBLower(BB &bb); + std::string PhaseName() const { return "rclowering"; } - private: - MeFunction &func; - MIRModule &mirModule; - IRMap &irMap; - SSATab &ssaTab; - KlassHierarchy &klassHierarchy; - std::vector rets{}; // std::vector of return statement - unsigned int tmpCount = 0; - std::map cleanUpVars{}; - std::map varOstMap{}; - bool needSpecialHandleException = false; - std::set gcMallocObjects{}; - // used to store initialized map, help to optimize dec ref in first assignment - std::unordered_map*> initializedFields{}; - - void BBLower(BB *bb); + void MarkLocalRefVar(); + void MarkAllRefOpnds(); + void BBLower(BB &bb); void CreateCleanupIntrinsics(); void HandleArguments(); void InitRCFunc(); @@ -74,17 +63,24 @@ class RCLowering { IntrinsiccallMeStmt *GetVarRHSHandleStmt(MeStmt &stmt); IntrinsiccallMeStmt *GetIvarRHSHandleStmt(MeStmt &stmt); MIRIntrinsicID PrepareVolatileCall(MeStmt &stmt, MIRIntrinsicID index = INTRN_UNDEFINED); - IntrinsiccallMeStmt *CreateRCIntrinsic(MIRIntrinsicID intrnID, MeStmt &stmt, std::vector opnds, + IntrinsiccallMeStmt *CreateRCIntrinsic(MIRIntrinsicID intrnID, MeStmt &stmt, std::vector &opnds, bool assigned = false); void InitializedObjectFields(MeStmt &stmt); bool IsInitialized(IvarMeExpr &ivar); void PreprocessAssignMeStmt(MeStmt &stmt); void HandleAssignMeStmtRHS(MeStmt &stmt); void HandleAssignMeStmtRegLHS(MeStmt &stmt); + void HandleAssignToGlobalVar(MeStmt &stmt); + void HandleAssignToLocalVar(MeStmt &stmt, MeExpr *pendingDec); void HandleAssignMeStmtVarLHS(MeStmt &stmt, MeExpr *pendingDec); void HandleAssignMeStmtIvarLHS(MeStmt &stmt); void HandleCallAssignedMeStmt(MeStmt &stmt, MeExpr *pendingDec); + void IntroduceRegRetIntoCallAssigned(MeStmt &stmt); + void HandleRetOfCallAssignedMeStmt(MeStmt &stmt, MeExpr &pendingDec); void HandleReturnVar(RetMeStmt &ret); + void HandleReturnGlobal(RetMeStmt &ret); + void HandleReturnRegread(RetMeStmt &ret); + void HandleReturnFormal(RetMeStmt &ret); void HandleReturnIvar(RetMeStmt &ret); void HandleReturnReg(RetMeStmt &ret); void HandleReturnWithCleanup(); @@ -94,8 +90,21 @@ class RCLowering { MIRIntrinsicID SelectWriteBarrier(MeStmt &stmt); private: + MeFunction &func; + MIRModule &mirModule; + IRMap &irMap; + SSATab &ssaTab; + KlassHierarchy &klassHierarchy; + std::vector rets{}; // std::vector of return statement + unsigned int tmpCount = 0; std::set assignedPtrSym; std::set tmpLocalRefVars; + std::map cleanUpVars{}; + std::map varOStMap{}; + bool needSpecialHandleException = false; + std::set gcMallocObjects{}; + // used to store initialized map, help to optimize dec ref in first assignment + std::unordered_map*> initializedFields{}; }; class MeDoRCLowering : public MeFuncPhase { @@ -103,10 +112,12 @@ class MeDoRCLowering : public MeFuncPhase { explicit MeDoRCLowering(MePhaseID id) : MeFuncPhase(id) {} virtual ~MeDoRCLowering() = default; + AnalysisResult *Run(MeFunction*, MeFuncResultMgr*, ModuleResultMgr*) override; + std::string PhaseName() const override { return "rclowering"; } }; } // namespace maple -#endif // MAPLE_ME_INCLUDE_ME_RC_LOWERING_H \ No newline at end of file +#endif // MAPLE_ME_INCLUDE_ME_RC_LOWERING_H diff --git a/src/maple_me/include/me_ssa.h b/src/maple_me/include/me_ssa.h index 704c6e02adfc82775abe43ff78e76607d7df4ab3..7ec0f4fa50c842989deba951e43ebe87c8c6d259 100644 --- a/src/maple_me/include/me_ssa.h +++ b/src/maple_me/include/me_ssa.h @@ -23,22 +23,22 @@ #include "dominance.h" namespace maple { -class MeSSA : public maple::SSA, public AnalysisResult { +class MeSSA : public SSA, public AnalysisResult { public: - explicit MeSSA(MeFunction *func, Dominance *dom, MemPool *memPool); - ~MeSSA() {} + MeSSA(MeFunction *func, Dominance *dom, MemPool *memPool); + ~MeSSA() = default; void CollectDefBBs(std::map> &ostDefBBs); void BuildSSA(); void InsertPhiNode(); - void RenameBB(BB*); + void RenameBB(BB&); bool VerifySSA(); std::string PhaseName() const { return "ssa"; } private: - bool VerifySSAOpnd(BaseNode *node); + bool VerifySSAOpnd(BaseNode &node); MeFunction *func; Dominance *dom; }; @@ -47,7 +47,7 @@ class MeDoSSA : public MeFuncPhase { public: explicit MeDoSSA(MePhaseID id) : MeFuncPhase(id) {} - ~MeDoSSA() {} + ~MeDoSSA() = default; AnalysisResult *Run(MeFunction *ir, MeFuncResultMgr *m, ModuleResultMgr *mrm) override; std::string PhaseName() const override { diff --git a/src/maple_me/include/orig_symbol.h b/src/maple_me/include/orig_symbol.h index fe0b468cb5d01886c432e72a3a61a239d582fa3f..b066c8d5680e0f068990c74026e6c82bc4bcab0a 100644 --- a/src/maple_me/include/orig_symbol.h +++ b/src/maple_me/include/orig_symbol.h @@ -129,7 +129,7 @@ class OriginalSt { } bool IsSymbolOst() const { - return (ostType == kSymbolOst); + return ostType == kSymbolOst; } bool IsPregOst() const { @@ -144,7 +144,7 @@ class OriginalSt { this->indirectLev = idl; } - ~OriginalSt(){}; + ~OriginalSt() = default; OStIdx GetIndex() const { return index; @@ -155,13 +155,12 @@ class OriginalSt { return versionsIndex.at(version); } - MapleVector &GetVersionsIndex() { - return versionsIndex; - } - const MapleVector &GetVersionsIndex() const { return versionsIndex; } + void PushbackVersionIndex(size_t index) { + versionsIndex.push_back(index); + } size_t GetZeroVersionIndex() const { return zeroVersionIndex; @@ -191,7 +190,7 @@ class OriginalSt { return ignoreRC; } - bool IsAddressTaken() { + bool IsAddressTaken() const { return addressTaken; } @@ -203,16 +202,16 @@ class OriginalSt { epreLocalRefVar = epreLocalrefvarPara; } - PUIdx GetPuIdx() { - return puIdx; - } - PUIdx GetPuIdx() const { return puIdx; } private: - enum OSTType { kUnkonwnOst, kSymbolOst, kPregOst } ostType; + enum OSTType { + kUnkonwnOst, + kSymbolOst, + kPregOst + } ostType; OStIdx index; // index number in originalStVector MapleVector versionsIndex; // the i-th element refers the index of versionst in versionst table @@ -239,7 +238,7 @@ class OriginalSt { class OriginalStTable { public: OriginalStTable(MemPool &memPool, MIRModule &mod); - ~OriginalStTable() {} + ~OriginalStTable() = default; OriginalSt *FindOrCreateSymbolOriginalSt(MIRSymbol &mirSt, PUIdx puIdx, FieldID fld); OriginalSt *FindOrCreatePregOriginalSt(PregIdx pregIdx, PUIdx puIdx); @@ -301,13 +300,13 @@ class OriginalStTable { MapleAllocator alloc; MIRModule &mirModule; MapleVector originalStVector; // the vector that map a OriginalSt's index to its pointer - MapleUnorderedMap - mirSt2Ost; // mir symbol to original table, this only exists for no-original variables. + // mir symbol to original table, this only exists for no-original variables. + MapleUnorderedMap mirSt2Ost; MapleUnorderedMap preg2Ost; - MapleMap - pType2Ost; // mir type to virtual variables in original table. this only exists for no-original variables. - MapleMap, OStIdx> - malloc2Ost; // malloc info to virtual variables in original table. this only exists for no-original variables. + // mir type to virtual variables in original table. this only exists for no-original variables. + MapleMap pType2Ost; + // malloc info to virtual variables in original table. this only exists for no-original variables. + MapleMap, OStIdx> malloc2Ost; MapleMap thisField2Ost; // field of this_memory to virtual variables in original table. OStIdx virtuaLostUnkownMem; OStIdx virtuaLostConstMem; diff --git a/src/maple_me/include/ssa.h b/src/maple_me/include/ssa.h index a48dd90adc4f41d009dc3956444d499a27334f44..04de1cc0ed212dffd00d3cb907c4024d20ed69d5 100644 --- a/src/maple_me/include/ssa.h +++ b/src/maple_me/include/ssa.h @@ -18,6 +18,10 @@ #include "mir_module.h" #include "mir_nodes.h" +namespace { + constexpr maple::uint32 kPhiNodeOpndNum = 2; +} + namespace maple { class BB; class VersionSt; @@ -26,15 +30,16 @@ class VersionStTable; class SSATab; class PhiNode { public: - PhiNode(MapleAllocator *alloc, VersionSt *vsym) : result(vsym), phiOpnds(2, nullptr, alloc->Adapter()) { + PhiNode(MapleAllocator *alloc, VersionSt *vsym) : result(vsym), phiOpnds(kPhiNodeOpndNum, nullptr, alloc->Adapter()) { phiOpnds.pop_back(); phiOpnds.pop_back(); - }; - ~PhiNode() {} + } + + ~PhiNode() = default; void Dump(const MIRModule *mod); - VersionSt *GetResult() { + VersionSt *GetResult() const { return result; } @@ -46,7 +51,7 @@ class PhiNode { return phiOpnds; } - VersionSt *GetPhiOpnd(size_t index) { + VersionSt *GetPhiOpnd(size_t index) const { ASSERT(index < phiOpnds.size(), "out of range in PhiNode::GetPhiOpnd"); return phiOpnds.at(index); } @@ -74,36 +79,39 @@ class SSA { bbRenamed(ssaAlloc.Adapter()), ssaTab(stab) {} - virtual ~SSA() {} + virtual ~SSA() = default; - void InitRenameStack(OriginalStTable*, size_t, VersionStTable&); - VersionSt *CreateNewVersion(VersionSt *vsym, BB *defBB); - void RenamePhi(BB *bb); - void RenameDefs(StmtNode *stmt, BB *defBB); - void RenameMustDefs(const StmtNode *stmt, BB *defBB); - void RenameExpr(BaseNode *expr); - void RenameUses(StmtNode *stmt); - void RenamePhiUseInSucc(BB *bb); - void RenameMayUses(BaseNode *node); + void InitRenameStack(OriginalStTable&, size_t, VersionStTable&); + VersionSt *CreateNewVersion(VersionSt &vsym, BB &defBB); + void RenamePhi(BB &bb); + void RenameDefs(StmtNode &stmt, BB &defBB); + void RenameMustDefs(const StmtNode &stmt, BB &defBB); + void RenameExpr(BaseNode &expr); + void RenameUses(StmtNode &stmt); + void RenamePhiUseInSucc(BB &bb); + void RenameMayUses(BaseNode &node); - const MapleAllocator &GetSsaAlloc() const { + MapleAllocator &GetSSAAlloc() { return ssaAlloc; } - MapleVector*> &GetVstStacks() { + const MapleVector*> &GetVstStacks() const { return vstStacks; } - MapleStack *GetVstStack(size_t idx) { + const MapleStack *GetVstStack(size_t idx) const { ASSERT(idx < vstStacks.size(), "out of range of vstStacks"); return vstStacks.at(idx); } + void PopVersionSt(size_t idx) { + vstStacks.at(idx)->pop(); + } MapleVector &GetBBsRenamed() { return bbRenamed; } - bool GetBBRenamed(size_t idx) { + bool GetBBRenamed(size_t idx) const { ASSERT(idx < bbRenamed.size(), "BBId out of range"); return bbRenamed.at(idx); } @@ -113,16 +121,16 @@ class SSA { bbRenamed[idx] = isRenamed; } - SSATab *GetSSATab() { + SSATab *GetSSATab() const { return ssaTab; } private: MapleAllocator ssaAlloc; - MapleVector*> vstStacks; // rename stack for variable versions - MapleVector vstVersions; // maxium version for variables - MapleVector bbRenamed; // indicate bb is renamed or not + MapleVector*> vstStacks; // rename stack for variable versions + MapleVector vstVersions; // maxium version for variables + MapleVector bbRenamed; // indicate bb is renamed or not SSATab *ssaTab; }; } // namespace maple -#endif // MAPLE_ME_INCLUDE_SSA_H \ No newline at end of file +#endif // MAPLE_ME_INCLUDE_SSA_H diff --git a/src/maple_me/include/ssa_mir_nodes.h b/src/maple_me/include/ssa_mir_nodes.h index d9811ada30bd6a8ca0a4d09b96c79f1d09e7a039..746a2a9a5da5e58928c2aee5f135ae711edac1fc 100644 --- a/src/maple_me/include/ssa_mir_nodes.h +++ b/src/maple_me/include/ssa_mir_nodes.h @@ -176,21 +176,21 @@ class AccessSSANodes { CHECK_FATAL(false, "No ssaVar"); } - virtual void DumpMayDefNodes(const MIRModule *mod) const { + virtual void DumpMayDefNodes(const MIRModule &mod) const { for (auto mayDefNode : GetMayDefNodes()) { - mayDefNode.second.Dump(mod); + mayDefNode.second.Dump(&mod); } } - virtual void DumpMayUseNodes(const MIRModule *mod) const { + virtual void DumpMayUseNodes(const MIRModule &mod) const { for (std::pair mapItem : GetMayUseNodes()) { - mapItem.second.Dump(mod); + mapItem.second.Dump(&mod); } } - virtual void DumpMustDefNodes(const MIRModule *mod) const { + virtual void DumpMustDefNodes(const MIRModule &mod) const { for (MustDefNode mustDefNode : GetMustDefNodes()) { - mustDefNode.Dump(mod); + mustDefNode.Dump(&mod); } } @@ -398,19 +398,19 @@ class StmtsSSAPart { ~StmtsSSAPart() {} - AccessSSANodes *SSAPartOf(const StmtNode *s) { - return ssaPart[s->GetStmtID()]; + AccessSSANodes *SSAPartOf(const StmtNode &s) { + return ssaPart[s.GetStmtID()]; } template - void SetSSAPartOf(const StmtNode *s, T *p) { - ssaPart[s->GetStmtID()] = static_cast(p); + void SetSSAPartOf(const StmtNode &s, T *p) { + ssaPart[s.GetStmtID()] = static_cast(p); } - void SetSSAPartOf(const StmtNode *s, VersionSt *vst) { + void SetSSAPartOf(const StmtNode &s, VersionSt *vst) { VersionStPart *vStSSAPart = GetSSAPartMp()->New(); vStSSAPart->SetSSAVar(vst); - ssaPart[s->GetStmtID()] = vStSSAPart; + ssaPart[s.GetStmtID()] = vStSSAPart; } MemPool *GetSSAPartMp() { @@ -513,21 +513,21 @@ class RegreadSSANode : public RegreadNode { VersionSt *ssaVar; }; -void GenericSSAPrint(MIRModule *mod, const StmtNode *stmtNode, int32 indent, StmtsSSAPart *stmtsSsaprt); -void SSAGenericInsertMayUseNode(const StmtNode *stmtNode, VersionSt *usesym, StmtsSSAPart *stmtsSsaprt); -void SSAGenericInsertMayDefNode(const StmtNode *stmtNode, VersionSt *vst, StmtNode *s, StmtsSSAPart *stmtsSsaprt); -MapleMap *SSAGenericGetMayUseNode(const StmtNode *stmtNode, StmtsSSAPart *stmtsSsaprt); -MapleMap *SSAGenericGetMayDefNodes(const StmtNode *stmtNode, StmtsSSAPart *stmtsSsaprt); -MapleMap *SSAGenericGetMayDefsFromVersionSt(VersionSt *sym, StmtsSSAPart *ssapart); -MapleVector *SSAGenericGetMustDefNode(const StmtNode *stmtNode, StmtsSSAPart *stmtsSsaprt); -bool HasMayUseDefPart(const StmtNode *stmtNode); -bool HasMayDefPart(const StmtNode *stmtNode); -bool HasMayUsePart(const StmtNode *stmtNode); -bool HasMayUseOpnd(const BaseNode *baseNode, SSATab *func); -bool HasMayDef(const StmtNode *stmtNode, SSATab *func); -inline bool HasMallocOpnd(const BaseNode *x) { - return x->GetOpCode() == OP_malloc || x->GetOpCode() == OP_gcmalloc || x->GetOpCode() == OP_gcmallocjarray || - x->GetOpCode() == OP_alloca; +void GenericSSAPrint(MIRModule &mod, const StmtNode &stmtNode, int32 indent, StmtsSSAPart &stmtsSsaprt); +void SSAGenericInsertMayUseNode(const StmtNode &stmtNode, VersionSt &usesym, StmtsSSAPart &stmtsSsaprt); +void SSAGenericInsertMayDefNode(const StmtNode &stmtNode, VersionSt &vst, StmtNode &s, StmtsSSAPart &stmtsSsaprt); +MapleMap &SSAGenericGetMayUseNode(const StmtNode &stmtNode, StmtsSSAPart &stmtsSsaprt); +MapleMap &SSAGenericGetMayDefNodes(const StmtNode &stmtNode, StmtsSSAPart &stmtsSsaprt); +MapleMap *SSAGenericGetMayDefsFromVersionSt(VersionSt &sym, StmtsSSAPart &ssapart); +MapleVector &SSAGenericGetMustDefNode(const StmtNode &stmtNode, StmtsSSAPart &stmtsSsaprt); +bool HasMayUseDefPart(const StmtNode &stmtNode); +bool HasMayDefPart(const StmtNode &stmtNode); +bool HasMayUsePart(const StmtNode &stmtNode); +bool HasMayUseOpnd(const BaseNode &baseNode, SSATab &func); +bool HasMayDef(const StmtNode &stmtNode, SSATab &func); +inline bool HasMallocOpnd(const BaseNode &x) { + return x.GetOpCode() == OP_malloc || x.GetOpCode() == OP_gcmalloc || x.GetOpCode() == OP_gcmallocjarray || + x.GetOpCode() == OP_alloca; } } // namespace maple #endif // MAPLE_ME_INCLUDE_SSA_MIR_NODES_H diff --git a/src/maple_me/include/ssa_tab.h b/src/maple_me/include/ssa_tab.h index 1199b5c1db654639871f06d7dffd167e3a8fe982..258834da47329ee9f839fc26bb2c2d6630885838 100644 --- a/src/maple_me/include/ssa_tab.h +++ b/src/maple_me/include/ssa_tab.h @@ -34,19 +34,19 @@ class SSATab : public AnalysisResult { ~SSATab() {} - BaseNode *CreateSSAExpr(BaseNode *expr); - void CreateSSAStmt(StmtNode *stmt, const BB *curbb, bool ignoreCallassignedDefs = false); + BaseNode *CreateSSAExpr(BaseNode &expr); + void CreateSSAStmt(StmtNode &stmt, const BB &curbb, bool ignoreCallassignedDefs = false); VersionSt *GetVerSt(size_t verIdx) { return versionStTable.GetVersionStFromID(verIdx); } // following are handles to methods in originalStTable - OriginalSt *CreateSymbolOriginalSt(MIRSymbol *mirSt, PUIdx puIdx, FieldID fld) { - return originalStTable.CreateSymbolOriginalSt(*mirSt, puIdx, fld); + OriginalSt *CreateSymbolOriginalSt(MIRSymbol &mirSt, PUIdx puIdx, FieldID fld) { + return originalStTable.CreateSymbolOriginalSt(mirSt, puIdx, fld); } - OriginalSt *FindOrCreateSymbolOriginalSt(MIRSymbol *mirSt, PUIdx puIdx, FieldID fld) { - return originalStTable.FindOrCreateSymbolOriginalSt(*mirSt, puIdx, fld); + OriginalSt *FindOrCreateSymbolOriginalSt(MIRSymbol &mirSt, PUIdx puIdx, FieldID fld) { + return originalStTable.FindOrCreateSymbolOriginalSt(mirSt, puIdx, fld); } const OriginalSt *GetOriginalStFromID(OStIdx id) { @@ -59,8 +59,8 @@ class SSATab : public AnalysisResult { return ost; } - MIRSymbol *GetMIRSymbolFromOriginalSt(const OriginalSt *ost) { - return originalStTable.GetMIRSymbolFromOriginalSt(*ost); + MIRSymbol *GetMIRSymbolFromOriginalSt(const OriginalSt &ost) { + return originalStTable.GetMIRSymbolFromOriginalSt(ost); } MIRSymbol *GetMIRSymbolFromID(OStIdx id) { @@ -123,4 +123,4 @@ class SSATab : public AnalysisResult { bool wholeProgramScope; }; } // namespace maple -#endif // MAPLE_ME_INCLUDE_SSA_TAB_H \ No newline at end of file +#endif // MAPLE_ME_INCLUDE_SSA_TAB_H diff --git a/src/maple_me/include/union_find.h b/src/maple_me/include/union_find.h index 953ac11e1b6a8dc4f66aba5dd66a1cadef3f2ebb..5898bf1aa8110a3aae3c22357fe571b7a1525409 100644 --- a/src/maple_me/include/union_find.h +++ b/src/maple_me/include/union_find.h @@ -17,6 +17,7 @@ #include "mempool.h" #include "mempool_allocator.h" #include "mpl_logging.h" +#include "types_def.h" namespace maple { // This uses the Weighted Quick Union with Path Compression algorithm. diff --git a/src/maple_me/include/ver_symbol.h b/src/maple_me/include/ver_symbol.h index 5591200a07a271e8f042af38f11f8da6ec94fa40..b4a8257ede5c54471272efaff3c6d7b554b9d94a 100644 --- a/src/maple_me/include/ver_symbol.h +++ b/src/maple_me/include/ver_symbol.h @@ -31,7 +31,13 @@ class VersionStTable; class OriginalSt; class VersionSt { public: - enum DefType { kDassign, kRegassign, kPhi, kMayDef, kMustDef }; + enum DefType { + kDassign, + kRegassign, + kPhi, + kMayDef, + kMustDef + }; VersionSt(size_t index, uint32 version, OriginalSt *ost) : index(index), @@ -43,7 +49,7 @@ class VersionSt { live(false), isReturn(false) {} - ~VersionSt() {} + ~VersionSt() = default; size_t GetIndex() const { return index; @@ -56,11 +62,13 @@ class VersionSt { void SetDefBB(BB *defbb) { defBB = defbb; } + const BB *GetDefBB() const { return defBB; } - void DumpDefStmt(const MIRModule *mod); + void DumpDefStmt(const MIRModule *mod) const; + bool IsLive() const { return live; } @@ -85,7 +93,7 @@ class VersionSt { live = false; } - OStIdx GetOrigIdx() { + OStIdx GetOrigIdx() const { return ost->GetIndex(); } @@ -97,7 +105,7 @@ class VersionSt { this->ost = ost; } - maple::DassignNode *GetDassignNode() { + maple::DassignNode *GetDassignNode() const { return defStmt.dassign; } @@ -105,7 +113,7 @@ class VersionSt { defStmt.dassign = dassignNode; } - maple::RegassignNode *GetRegassignNode() { + maple::RegassignNode *GetRegassignNode() const { return defStmt.regassign; } @@ -113,7 +121,7 @@ class VersionSt { defStmt.regassign = regAssignNode; } - maple::PhiNode *GetPhi() { + maple::PhiNode *GetPhi() const { return defStmt.phi; } @@ -121,7 +129,7 @@ class VersionSt { defStmt.phi = phiNode; } - MayDefNode *GetMayDef() { + MayDefNode *GetMayDef() const { return defStmt.mayDef; } @@ -129,7 +137,7 @@ class VersionSt { defStmt.mayDef = mayDefNode; } - MustDefNode *GetMustDef() { + MustDefNode *GetMustDef() const { return defStmt.mustDef; } @@ -141,20 +149,21 @@ class VersionSt { return isReturn; } - void Dump(const MIRModule *mod, bool omitname = false) { - if (!omitname) { + void Dump(const MIRModule *mod, bool omitName = false) const { + if (!omitName) { ost->Dump(); } LogInfo::MapleLogger() << "(" << version << ")"; - }; + } + bool DefByMayDef() const { return defType == kMayDef; } private: - size_t index; // index number in versionst_table_; + size_t index; // index number in versionst_table_ int version; // starts from 0 for each symbol - OriginalSt *ost; // the index of related originalst in originalst_table; + OriginalSt *ost; // the index of related originalst in originalst_table BB *defBB; DefType defType; @@ -174,12 +183,12 @@ class VersionStTable { public: explicit VersionStTable(MemPool *vstMp) : vstAlloc(vstMp), versionStVector(vstAlloc.Adapter()) {} - ~VersionStTable() {} + ~VersionStTable() = default; VersionSt *CreateVersionSt(OriginalSt *ost, size_t version); VersionSt *FindOrCreateVersionSt(OriginalSt *ost, size_t version); - VersionSt *GetVersionStFromID(size_t id, bool checkfirst = false) { - if (checkfirst && id >= versionStVector.size()) { + VersionSt *GetVersionStFromID(size_t id, bool checkFirst = false) const { + if (checkFirst && id >= versionStVector.size()) { return nullptr; } ASSERT(id < versionStVector.size(), "symbol table index out of range"); @@ -204,7 +213,7 @@ class VersionStTable { return versionStVector.size(); } - VersionSt *GetVersionStVectorItem(size_t index) { + VersionSt *GetVersionStVectorItem(size_t index) const { CHECK_FATAL(index < versionStVector.size(), "out of range"); return versionStVector[index]; } @@ -218,11 +227,11 @@ class VersionStTable { return vstAlloc; } - void Dump(MIRModule *mod); + void Dump(MIRModule *mod) const; private: MapleAllocator vstAlloc; // this stores versionStVector - MapleVector versionStVector; // the vector that map a versionst's index to its pointer + MapleVector versionStVector; // the vector that map a versionst's index to its pointer }; -} // namespace maple +} // namespace maple #endif // MAPLE_ME_INCLUDE_VER_SYMBOL_H diff --git a/src/maple_me/src/alias_analysis_table.cpp b/src/maple_me/src/alias_analysis_table.cpp index 047fcb9a55c5ec7d9e453e9742ee3f82e8867791..4fad9010d5dfca4167fde8cf8ff41486258bb311 100644 --- a/src/maple_me/src/alias_analysis_table.cpp +++ b/src/maple_me/src/alias_analysis_table.cpp @@ -52,7 +52,7 @@ OriginalSt *AliasAnalysisTable::FindOrCreateExtraLevSymOrRegOriginalSt(OriginalS TyIdx ptyIdxOfOSt = ost.GetTyIdx(); FieldID fldIDInOSt = fld; if (ptyIdxOfOSt != ptyIdx) { - klassHierarchy.UpdateFieldID(ptyIdx, ptyIdxOfOSt, fldIDInOSt); + (void)klassHierarchy.UpdateFieldID(ptyIdx, ptyIdxOfOSt, fldIDInOSt); } MapleVector *nextLevelOsts = GetNextLevelNodes(ost); OriginalSt *nextLevOst = FindExtraLevOriginalSt(*nextLevelOsts, fldIDInOSt); @@ -76,8 +76,9 @@ OriginalSt *AliasAnalysisTable::FindOrCreateExtraLevSymOrRegOriginalSt(OriginalS ptyIdx = (ptyIdx == 0) ? ost.GetTyIdx() : ptyIdx; if (ptyIdx != 0) { // use the tyIdx info from the instruction - MIRPtrType *ptType = dynamic_cast(GlobalTables::GetTypeTable().GetTypeFromTyIdx(ptyIdx)); - if (ptType != nullptr) { + MIRType *mirType = GlobalTables::GetTypeTable().GetTypeFromTyIdx(ptyIdx); + if (mirType->GetKind() == kTypePointer) { + MIRPtrType *ptType = static_cast(mirType); TyIdxFieldAttrPair fieldPair = ptType->GetPointedTyIdxFldAttrPairWithFieldID(fld); nextLevOst->SetTyIdx(fieldPair.first); nextLevOst->SetIsFinal(fieldPair.second.GetAttr(FLDATTR_final) && !mirModule.CurFunction()->IsConstructor()); @@ -126,9 +127,9 @@ OriginalSt *AliasAnalysisTable::FindOrCreateDiffFieldOriginalSt(const OriginalSt // create a new node TyIdxFieldAttrPair nextLevFieldPair; if (parentOst->GetTyIdx() != 0) { - MIRPtrType *ptType = - dynamic_cast(GlobalTables::GetTypeTable().GetTypeFromTyIdx(parentOst->GetTyIdx())); - if (ptType != nullptr) { + MIRType *mirType = GlobalTables::GetTypeTable().GetTypeFromTyIdx(parentOst->GetTyIdx()); + if (mirType->GetKind() == kTypePointer) { + MIRPtrType *ptType = static_cast(mirType); nextLevFieldPair = ptType->GetPointedTyIdxFldAttrPairWithFieldID(fld); } } diff --git a/src/maple_me/src/alias_class.cpp b/src/maple_me/src/alias_class.cpp index 817e5dbf5c6d4c8c99082a5ed35d5aa895cd665e..ca786a0fb8511c596ddd0701ae3bd7cfe6a76ca4 100644 --- a/src/maple_me/src/alias_class.cpp +++ b/src/maple_me/src/alias_class.cpp @@ -38,13 +38,9 @@ static inline bool OriginalStIsZeroLevAndAuto(const OriginalSt &ost) { return false; } -bool AliasClass::CallHasNoSideEffectOrPrivateDefEffect(StmtNode &stmt, FuncAttrKind attrKind) { +bool AliasClass::CallHasNoSideEffectOrPrivateDefEffect(CallNode &stmt, FuncAttrKind attrKind) { ASSERT(attrKind == FUNCATTR_nosideeffect || attrKind == FUNCATTR_noprivate_defeffect, "Not supportted attrKind"); - CallNode *callStmt = dynamic_cast(&stmt); - if (callStmt == nullptr) { - return false; - } - MIRFunction *callee = GlobalTables::GetFunctionTable().GetFunctionFromPuidx(callStmt->GetPUIdx()); + MIRFunction *callee = GlobalTables::GetFunctionTable().GetFunctionFromPuidx(stmt.GetPUIdx()); bool hasAttr = false; if (callee->GetFuncAttrs().GetAttr(attrKind)) { hasAttr = true; @@ -54,11 +50,11 @@ bool AliasClass::CallHasNoSideEffectOrPrivateDefEffect(StmtNode &stmt, FuncAttrK return hasAttr; } -bool AliasClass::CallHasSideEffect(StmtNode &stmt) { +bool AliasClass::CallHasSideEffect(CallNode &stmt) { return calleeHasSideEffect ? true : !CallHasNoSideEffectOrPrivateDefEffect(stmt, FUNCATTR_nosideeffect); } -bool AliasClass::CallHasNoPrivateDefEffect(StmtNode &stmt) { +bool AliasClass::CallHasNoPrivateDefEffect(CallNode &stmt) { return calleeHasSideEffect ? false : CallHasNoSideEffectOrPrivateDefEffect(stmt, FUNCATTR_noprivate_defeffect); } @@ -98,7 +94,7 @@ AliasElem *AliasClass::FindOrCreateExtraLevAliasElem(BaseNode &expr, TyIdx tyIdx return nullptr; } OriginalSt *newOst = GetAliasAnalysisTable()->FindOrCreateExtraLevOriginalSt(ae->GetOriginalSt(), tyIdx, fieldId); - ASSERT(newOst, "null ptr check"); + CHECK_FATAL(newOst, "null ptr check"); if (newOst->GetIndex().idx == osym2Elem.size()) { osym2Elem.push_back(nullptr); ssaTab.GetVersionStTable().CreateVersionSt(newOst, kInitVersion); @@ -160,21 +156,21 @@ AliasElem *AliasClass::CreateAliasElemsExpr(BaseNode &expr) { // when a mustDef is a pointer, set its pointees' notAllDefsSeen flag to true void AliasClass::SetNotAllDefsSeenForMustDefs(const StmtNode &callas) { - MapleVector *mustDefs = SSAGenericGetMustDefNode(&callas, &ssaTab.GetStmtsSSAPart()); - for (MustDefNode mustDef : *mustDefs) { + MapleVector &mustDefs = SSAGenericGetMustDefNode(callas, ssaTab.GetStmtsSSAPart()); + for (MustDefNode mustDef : mustDefs) { AliasElem *aliasElem = FindOrCreateAliasElem(*mustDef.GetResult()->GetOrigSt()); aliasElem->SetNextLevNotAllDefsSeen(true); } } -void AliasClass::ApplyUnionForDassignCopy(const AliasElem &lhsAe, const AliasElem *rhsAe, const BaseNode *rhs) { +void AliasClass::ApplyUnionForDassignCopy(const AliasElem &lhsAe, const AliasElem *rhsAe, const BaseNode &rhs) { if (rhsAe == nullptr || rhsAe->GetOriginalSt().GetIndirectLev() > 0 || rhsAe->IsNotAllDefsSeen()) { AliasElem *ae = FindAliasElem(lhsAe.GetOriginalSt()); ae->SetNextLevNotAllDefsSeen(true); return; } - if (!IsPotentialAddress(rhs->GetPrimType()) || HasMallocOpnd(rhs) || - (rhs->GetOpCode() == OP_addrof && IsReadOnlyOst(rhsAe->GetOriginalSt()))) { + if (!IsPotentialAddress(rhs.GetPrimType()) || HasMallocOpnd(rhs) || + (rhs.GetOpCode() == OP_addrof && IsReadOnlyOst(rhsAe->GetOriginalSt()))) { return; } unionFind.Union(lhsAe.GetClassID(), rhsAe->GetClassID()); @@ -206,10 +202,10 @@ void AliasClass::ApplyUnionForCopies(StmtNode &stmt) { ASSERT(stmt.Opnd(0) != nullptr, "nullptr check"); AliasElem *rhsAe = CreateAliasElemsExpr(*stmt.Opnd(0)); // LHS - OriginalSt *ost = ssaTab.GetStmtsSSAPart().SSAPartOf(&stmt)->GetSSAVar()->GetOrigSt(); + OriginalSt *ost = ssaTab.GetStmtsSSAPart().SSAPartOf(stmt)->GetSSAVar()->GetOrigSt(); AliasElem *lhsAe = FindOrCreateAliasElem(*ost); ASSERT(lhsAe != nullptr, "aliaselem of lhs should not be null"); - ApplyUnionForDassignCopy(*lhsAe, rhsAe, stmt.Opnd(0)); + ApplyUnionForDassignCopy(*lhsAe, rhsAe, *stmt.Opnd(0)); return; } case OP_iassign: { @@ -217,7 +213,7 @@ void AliasClass::ApplyUnionForCopies(StmtNode &stmt) { AliasElem *rhsAe = CreateAliasElemsExpr(*iass.Opnd(1)); AliasElem *lhsAe = FindOrCreateExtraLevAliasElem(*iass.Opnd(0), iass.GetTyIdx(), iass.GetFieldID()); ASSERT(lhsAe != nullptr, "aliaselem of lhs should not be null"); - ApplyUnionForDassignCopy(*lhsAe, rhsAe, iass.Opnd(1)); + ApplyUnionForDassignCopy(*lhsAe, rhsAe, *iass.Opnd(1)); return; } case OP_throw: { @@ -248,8 +244,8 @@ void AliasClass::ApplyUnionForCopies(StmtNode &stmt) { case OP_interfaceicallassigned: case OP_customcallassigned: case OP_polymorphiccallassigned: { - if (CallHasSideEffect(stmt)) { - CallNode &call = static_cast(stmt); + CallNode &call = static_cast(stmt); + if (CallHasSideEffect(call)) { SetPtrOpndsNextLevNADS(1, call.NumOpnds(), call.GetNopnd(), CallHasNoPrivateDefEffect(call)); } break; @@ -452,9 +448,9 @@ bool AliasClass::AliasAccordingToType(TyIdx tyidxA, TyIdx tyidxB) { } case kTypeClass: { Klass *klassA = klassHierarchy->GetKlassFromTyIdx(mirTypeA->GetTypeIndex()); - ASSERT(klassA != nullptr, "null ptr check"); + CHECK_FATAL(klassA != nullptr, "null ptr check"); Klass *klassB = klassHierarchy->GetKlassFromTyIdx(mirTypeB->GetTypeIndex()); - ASSERT(klassB != nullptr, "null ptr check"); + CHECK_FATAL(klassB != nullptr, "null ptr check"); return (klassA == klassB || klassA->GetKlassName() == NameMangler::kJavaLangObjectStr || klassB->GetKlassName() == NameMangler::kJavaLangObjectStr || klassHierarchy->IsSuperKlass(klassA, klassB) || klassHierarchy->IsSuperKlass(klassB, klassA)); @@ -659,8 +655,8 @@ void AliasClass::InsertMayUseReturn(const StmtNode &stmt) { CollectMayUseFromNADS(mayUseOsts); // 2. collect mayUses caused by globals_affected_by_call. CollectMayUseFromGlobalsAffectedByCalls(mayUseOsts); - MapleMap *mayUseNodes = SSAGenericGetMayUseNode(&stmt, &ssaTab.GetStmtsSSAPart()); - InsertMayUseNode(mayUseOsts, *mayUseNodes); + MapleMap &mayUseNodes = SSAGenericGetMayUseNode(stmt, ssaTab.GetStmtsSSAPart()); + InsertMayUseNode(mayUseOsts, mayUseNodes); } // collect next_level_nodes of the ost of ReturnOpnd into mayUseOsts @@ -696,18 +692,18 @@ void AliasClass::InsertReturnOpndMayUse(const StmtNode &stmt) { } } // insert mayUses - MapleMap *mayUseNodes = SSAGenericGetMayUseNode(&stmt, &ssaTab.GetStmtsSSAPart()); - InsertMayUseNode(mayUseOsts, *mayUseNodes); + MapleMap &mayUseNodes = SSAGenericGetMayUseNode(stmt, ssaTab.GetStmtsSSAPart()); + InsertMayUseNode(mayUseOsts, mayUseNodes); } } } void AliasClass::InsertMayUseAll(const StmtNode &stmt) { - MapleMap *mayUseNodes = SSAGenericGetMayUseNode(&stmt, &ssaTab.GetStmtsSSAPart()); + MapleMap &mayUseNodes = SSAGenericGetMayUseNode(stmt, ssaTab.GetStmtsSSAPart()); for (AliasElem *ae : id2Elem) { if (ae->GetOriginalSt().GetIndirectLev() >= 0 && !ae->GetOriginalSt().IsPregOst()) { - mayUseNodes->insert(std::make_pair( + mayUseNodes.insert(std::make_pair( ae->GetOriginalSt().GetIndex(), MayUseNode(ssaTab.GetVersionStTable().GetVersionStFromID(ae->GetOriginalSt().GetZeroVersionIndex())))); } @@ -716,7 +712,7 @@ void AliasClass::InsertMayUseAll(const StmtNode &stmt) { void AliasClass::CollectMayDefForDassign(const StmtNode &stmt, std::set &mayDefOsts) { MayDefPartWithVersionSt *theSSAPart = - static_cast(ssaTab.GetStmtsSSAPart().SSAPartOf(&stmt)); + static_cast(ssaTab.GetStmtsSSAPart().SSAPartOf(stmt)); AliasElem *lhsAe = osym2Elem.at(theSSAPart->GetSSAVar()->GetOrigIdx().idx); ASSERT(lhsAe != nullptr, "aliaselem of lhs should not be null"); if (lhsAe->GetClassSet() != nullptr) { @@ -743,13 +739,13 @@ void AliasClass::InsertMayDefNode(std::set &mayDefOsts, MapleMap mayDefOsts; CollectMayDefForDassign(stmt, mayDefOsts); - MapleMap *mayDefNodes = SSAGenericGetMayDefNodes(&stmt, &ssaTab.GetStmtsSSAPart()); - InsertMayDefNode(mayDefOsts, *mayDefNodes, stmt, bbID); + MapleMap &mayDefNodes = SSAGenericGetMayDefNodes(stmt, ssaTab.GetStmtsSSAPart()); + InsertMayDefNode(mayDefOsts, mayDefNodes, stmt, bbID); } bool AliasClass::IsEquivalentField(TyIdx tyIdxA, FieldID fldA, TyIdx tyIdxB, FieldID fldB) { if (tyIdxA != tyIdxB) { - klassHierarchy->UpdateFieldID(tyIdxA, tyIdxB, fldA); + (void)klassHierarchy->UpdateFieldID(tyIdxA, tyIdxB, fldA); } return fldA == fldB; } @@ -772,7 +768,7 @@ void AliasClass::CollectMayDefForIassign(StmtNode &stmt, std::set & break; } } - ASSERT(lhsOst != nullptr, "AliasClass::InsertMayUseExpr: cannot find next level ost"); + CHECK_FATAL(lhsOst != nullptr, "AliasClass::InsertMayUseExpr: cannot find next level ost"); lhsAe = osym2Elem[lhsOst->GetIndex().idx]; } else { lhsAe = FindOrCreateDummyNADSAe(); @@ -806,16 +802,13 @@ void AliasClass::InsertMayDefNodeExcludeFinalOst(std::set &mayDefOs void AliasClass::InsertMayDefIassign(StmtNode &stmt, BBId bbID) { std::set mayDefOsts; CollectMayDefForIassign(stmt, mayDefOsts); - MapleMap *mayDefNodes = SSAGenericGetMayDefNodes(&stmt, &ssaTab.GetStmtsSSAPart()); - if (mayDefNodes == nullptr) { - return; - } + MapleMap &mayDefNodes = SSAGenericGetMayDefNodes(stmt, ssaTab.GetStmtsSSAPart()); if (mayDefOsts.size() == 1) { - InsertMayDefNode(mayDefOsts, *mayDefNodes, stmt, bbID); + InsertMayDefNode(mayDefOsts, mayDefNodes, stmt, bbID); } else { - InsertMayDefNodeExcludeFinalOst(mayDefOsts, *mayDefNodes, stmt, bbID); + InsertMayDefNodeExcludeFinalOst(mayDefOsts, mayDefNodes, stmt, bbID); } - ASSERT(!mayDefNodes->empty(), "AliasClass::InsertMayUseIassign(): iassign cannot have empty maydef"); + ASSERT(!mayDefNodes.empty(), "AliasClass::InsertMayUseIassign(): iassign cannot have empty maydef"); } void AliasClass::InsertMayDefUseSyncOps(StmtNode &stmt, BBId bbID) { @@ -847,7 +840,7 @@ void AliasClass::InsertMayDefUseSyncOps(StmtNode &stmt, BBId bbID) { } } // do the insertion according to aliasSet - MayDefMayUsePart *theSSAPart = static_cast(ssaTab.GetStmtsSSAPart().SSAPartOf(&stmt)); + MayDefMayUsePart *theSSAPart = static_cast(ssaTab.GetStmtsSSAPart().SSAPartOf(stmt)); for (uint elemid : aliasSet) { AliasElem *aliasElem = id2Elem[elemid]; OriginalSt &ostOfAliasAE = aliasElem->GetOriginalSt(); @@ -862,8 +855,8 @@ void AliasClass::InsertMayDefUseSyncOps(StmtNode &stmt, BBId bbID) { // collect mayDefs caused by mustDefs void AliasClass::CollectMayDefForMustDefs(const StmtNode &stmt, std::set &mayDefOsts) { - MapleVector *mustDefs = SSAGenericGetMustDefNode(&stmt, &ssaTab.GetStmtsSSAPart()); - for (MustDefNode mustDef : *mustDefs) { + MapleVector &mustDefs = SSAGenericGetMustDefNode(stmt, ssaTab.GetStmtsSSAPart()); + for (MustDefNode mustDef : mustDefs) { VersionSt *vst = mustDef.GetResult(); OriginalSt *ost = vst->GetOrigSt(); AliasElem *lhsAe = osym2Elem[ost->GetIndex().idx]; @@ -931,7 +924,7 @@ void AliasClass::InsertMayDefNodeForCall(std::set &mayDefOsts, Mapl // Four kinds of mayDefs and mayUses are inserted, which are caused by callee // opnds, not_all_def_seen_ae, globalsAffectedByCalls, and mustDefs. void AliasClass::InsertMayDefUseCall(StmtNode &stmt, BBId bbID, bool hasSideEffect, bool hasNoPrivateDefEffect) { - MayDefMayUsePart *theSSAPart = static_cast(ssaTab.GetStmtsSSAPart().SSAPartOf(&stmt)); + MayDefMayUsePart *theSSAPart = static_cast(ssaTab.GetStmtsSSAPart().SSAPartOf(stmt)); std::set mayDefUseOstsA; // 1. collect mayDefs and mayUses caused by callee-opnds CollectMayUseForCallOpnd(stmt, mayDefUseOstsA); @@ -973,7 +966,7 @@ void AliasClass::InsertMayUseNodeExcludeFinalOst(const std::set &ma // Four kinds of mayDefs and mayUses are inserted, which are caused by callee // opnds, not_all_def_seen_ae, globalsAffectedByCalls, and mustDefs. void AliasClass::InsertMayDefUseIntrncall(StmtNode &stmt, BBId bbID) { - MayDefMayUsePart *theSSAPart = static_cast(ssaTab.GetStmtsSSAPart().SSAPartOf(&stmt)); + MayDefMayUsePart *theSSAPart = static_cast(ssaTab.GetStmtsSSAPart().SSAPartOf(stmt)); IntrinsiccallNode &intrinNode = static_cast(stmt); IntrinDesc *intrinDesc = &IntrinDesc::intrinTable[intrinNode.GetIntrinsic()]; std::set mayDefUseOsts; @@ -994,7 +987,7 @@ void AliasClass::InsertMayDefUseIntrncall(StmtNode &stmt, BBId bbID) { } void AliasClass::InsertMayDefUseClinitCheck(IntrinsiccallNode &stmt, BBId bbID) { - MayDefMayUsePart *theSSAPart = static_cast(ssaTab.GetStmtsSSAPart().SSAPartOf(&stmt)); + MayDefMayUsePart *theSSAPart = static_cast(ssaTab.GetStmtsSSAPart().SSAPartOf(stmt)); for (OStIdx ostIdx : globalsMayAffectedByClinitCheck) { AliasElem *ae = osym2Elem[ostIdx.idx]; OriginalSt &ostOfAE = ae->GetOriginalSt(); @@ -1052,7 +1045,8 @@ void AliasClass::GenericInsertMayDefUse(StmtNode &stmt, BBId bbID) { case OP_customcall: case OP_polymorphiccall: case OP_icall: { - InsertMayDefUseCall(stmt, bbID, CallHasSideEffect(stmt), CallHasNoPrivateDefEffect(stmt)); + InsertMayDefUseCall(stmt, bbID, CallHasSideEffect(static_cast(stmt)), + CallHasNoPrivateDefEffect(static_cast(stmt))); return; } case OP_intrinsiccallwithtype: { diff --git a/src/maple_me/src/bb.cpp b/src/maple_me/src/bb.cpp index 84129e337fc73bc8fa31a694d36da07b7c4d730e..2f20c7dc801d3730cd39ebe80248ac04bc4fefa6 100644 --- a/src/maple_me/src/bb.cpp +++ b/src/maple_me/src/bb.cpp @@ -101,14 +101,14 @@ void BB::Dump(MIRModule *mod) { } } -void BB::DumpPhi(const MIRModule *mod) { +void BB::DumpPhi(MIRModule *mod) { for (auto phiIt = phiList.begin(); phiIt != phiList.end(); phiIt++) { (*phiIt).second.Dump(mod); } } -const PhiNode *BB::PhiofVerStInserted(VersionSt *vsym) { - auto phiit = phiList.find(vsym->GetOrigSt()); +const PhiNode *BB::PhiofVerStInserted(VersionSt &vsym) { + auto phiit = phiList.find(vsym.GetOrigSt()); return (phiit != phiList.end()) ? &(*phiit).second : nullptr; } @@ -120,7 +120,7 @@ void BB::InsertPhi(MapleAllocator *alloc, VersionSt *vsym) { phiList.insert(std::make_pair(vsym->GetOrigSt(), phiNode)); } -bool BB::IsInList(MapleVector &bblist) const { +bool BB::IsInList(const MapleVector &bblist) const { for (auto it = bblist.begin(); it != bblist.end(); it++) { if (*it == this) { return true; @@ -152,17 +152,14 @@ void BB::RemoveBBFromPred(BB *bb) { ASSERT(index != -1, "-1 is a very large number in BB::RemoveBBFromPred"); for (auto phiIt = phiList.begin(); phiIt != phiList.end(); phiIt++) { ASSERT((*phiIt).second.GetPhiOpns().size() > index, "index out of range in BB::RemoveBBFromPred"); - (*phiIt).second.GetPhiOpns().erase((*phiIt).second.GetPhiOpns().cbegin() + index); } for (auto phiIt = mevarPhiList.begin(); phiIt != mevarPhiList.end(); phiIt++) { ASSERT((*phiIt).second->GetOpnds().size() > index, "index out of range in BB::RemoveBBFromPred"); - (*phiIt).second->GetOpnds().erase((*phiIt).second->GetOpnds().cbegin() + index); } for (auto phiIt = meregPhiList.begin(); phiIt != meregPhiList.end(); phiIt++) { ASSERT((*phiIt).second->GetOpnds().size() > index, "index out of range in BB::RemoveBBFromPred"); - (*phiIt).second->GetOpnds().erase((*phiIt).second->GetOpnds().cbegin() + index); } } @@ -189,7 +186,7 @@ void BB::PrependMeStmt(MeStmt *meStmt) { // if the bb contains only one stmt other than comment, return that stmt // otherwise return nullptr -StmtNode *BB::GetTheOnlyStmtNode() { +StmtNode *BB::GetTheOnlyStmtNode() const { StmtNode *onlyStmtNode = nullptr; for (auto &stmtNode : stmtNodeList) { if (stmtNode.GetOpCode() == OP_comment) { @@ -265,7 +262,7 @@ void BB::ReplaceSuccOfCommonEntryBB(const BB *old, BB *newSucc) { return; } -void BB::FindReachableBBs(std::vector &visitedBBs) { +void BB::FindReachableBBs(std::vector &visitedBBs) const { CHECK_FATAL(GetBBId().idx < visitedBBs.size(), "out of range in BB::FindReachableBBs"); if (visitedBBs[GetBBId().idx]) { return; @@ -276,7 +273,7 @@ void BB::FindReachableBBs(std::vector &visitedBBs) { } } -void BB::FindWillExitBBs(std::vector &visitedBBs) { +void BB::FindWillExitBBs(std::vector &visitedBBs) const { CHECK_FATAL(GetBBId().idx < visitedBBs.size(), "out of range in BB::FindReachableBBs"); if (visitedBBs[GetBBId().idx]) { return; @@ -364,4 +361,4 @@ void BB::DumpMeRegPhiList(IRMap *irMap) { (*phiIt).second->Dump(irMap); } } -} // namespace maple \ No newline at end of file +} // namespace maple diff --git a/src/maple_me/src/dominance.cpp b/src/maple_me/src/dominance.cpp index 80854f3b6020bef0c55041573d600be5e279352f..ca1246a67f050549bc6be2bcfa96248e05eca4c5 100644 --- a/src/maple_me/src/dominance.cpp +++ b/src/maple_me/src/dominance.cpp @@ -17,7 +17,7 @@ /* ================= for Dominance ================= */ namespace maple { -void Dominance::PostOrderWalk(BB &bb, int32 &pid, std::vector &visitedMap) { +void Dominance::PostOrderWalk(const BB &bb, int32 &pid, std::vector &visitedMap) { ASSERT(bb.GetBBId().idx < visitedMap.size(), "index out of range in Dominance::PostOrderWalk"); if (visitedMap[bb.GetBBId().idx]) { return; @@ -62,7 +62,7 @@ BB *Dominance::Intersect(BB &bb1, const BB &bb2) { return ptrBB1; } -bool Dominance::CommonEntryBBIsPred(const BB &bb) { +bool Dominance::CommonEntryBBIsPred(const BB &bb) const { for (BB *suc : GetCommonEntryBB().GetSucc()) { if (suc == &bb) { return true; diff --git a/src/maple_me/src/irmap.cpp b/src/maple_me/src/irmap.cpp index d8e91f1dba710f54e91352bf262cc363aabd3015..28d856a9dda942c82308c268f791efd66caf3c05 100644 --- a/src/maple_me/src/irmap.cpp +++ b/src/maple_me/src/irmap.cpp @@ -51,15 +51,15 @@ void IRMap::BuildPhiMeNode(BB &bb) { OriginalSt *origst = phi.first; VersionSt *verSt = phi.second.GetResult(); if (origst->IsPregOst()) { - MeRegPhiNode *phimenode = NewInPool(); + MeRegPhiNode *phiMeNode = NewInPool(); RegMeExpr *medef = GetOrCreateRegFromVerSt(*verSt); - phimenode->UpdateLHS(*medef); - phimenode->SetDefBB(&bb); + phiMeNode->UpdateLHS(*medef); + phiMeNode->SetDefBB(&bb); // build phi operands for (VersionSt *opnd : phi.second.GetPhiOpns()) { - phimenode->GetOpnds().push_back(GetOrCreateRegFromVerSt(*opnd)); + phiMeNode->GetOpnds().push_back(GetOrCreateRegFromVerSt(*opnd)); } - bb.GetMeregphiList().insert(std::make_pair(medef->GetOstIdx(), phimenode)); + bb.GetMeregphiList().insert(std::make_pair(medef->GetOstIdx(), phiMeNode)); } else { MeVarPhiNode *phimenode = NewInPool(); VarMeExpr *medef = GetOrCreateVarFromVerSt(*verSt); @@ -107,7 +107,7 @@ VarMeExpr *IRMap::CreateNewGlobalTmp(GStrIdx strIdx, PrimType ptyp) { MIRSymbol *st = mirModule.GetMIRBuilder()->CreateSymbol((TyIdx)ptyp, strIdx, kStVar, kScGlobal, nullptr, kScopeGlobal); st->SetIsTmp(true); - OriginalSt *oSt = ssaTab.CreateSymbolOriginalSt(st, 0, 0); + OriginalSt *oSt = ssaTab.CreateSymbolOriginalSt(*st, 0, 0); VarMeExpr *varx = New(&irMapAlloc, exprID++, oSt->GetIndex(), oSt->GetZeroVersionIndex()); varx->InitBase(OP_dread, ptyp, 0); return varx; @@ -117,10 +117,10 @@ VarMeExpr *IRMap::CreateNewLocalRefVarTmp(GStrIdx strIdx, TyIdx tIdx) { MIRSymbol *st = mirModule.GetMIRBuilder()->CreateSymbol(tIdx, strIdx, kStVar, kScAuto, mirModule.CurFunction(), kScopeLocal); st->SetInstrumented(); - OriginalSt *oSt = ssaTab.CreateSymbolOriginalSt(st, mirModule.CurFunction()->GetPuidx(), 0); + OriginalSt *oSt = ssaTab.CreateSymbolOriginalSt(*st, mirModule.CurFunction()->GetPuidx(), 0); oSt->SetZeroVersionIndex(verst2MeExprTable.size()); verst2MeExprTable.push_back(nullptr); - oSt->GetVersionsIndex().push_back(oSt->GetZeroVersionIndex()); + oSt->PushbackVersionIndex(oSt->GetZeroVersionIndex()); VarMeExpr *newlocalrefvar = New(&irMapAlloc, exprID++, oSt->GetIndex(), verst2MeExprTable.size()); verst2MeExprTable.push_back(newlocalrefvar); newlocalrefvar->InitBase(OP_dread, PTY_ref, 0); @@ -315,9 +315,9 @@ IvarMeExpr *IRMap::BuildLHSIvarFromIassMeStmt(IassignMeStmt &iassignMeStmt) { void IRMap::BuildChiList(MeStmt &meStmt, MapleMap &mayDefNodes, MapleMap &outList) { for (auto it = mayDefNodes.begin(); it != mayDefNodes.end(); it++) { - MayDefNode &maydefnode = it->second; - VersionSt *opndst = maydefnode.GetOpnd(); - VersionSt *resst = maydefnode.GetResult(); + MayDefNode &maydefNode = it->second; + VersionSt *opndst = maydefNode.GetOpnd(); + VersionSt *resst = maydefNode.GetResult(); ChiMeNode *chimestmt = New(&meStmt); chimestmt->SetRHS(GetOrCreateVarFromVerSt(*opndst)); VarMeExpr *lhs = GetOrCreateVarFromVerSt(*resst); @@ -390,7 +390,7 @@ MeStmt *IRMap::BuildMeStmtWithNoSSAPart(StmtNode &stmt) { } MeStmt *IRMap::BuildMeStmt(StmtNode &stmt) { - AccessSSANodes *ssaPart = ssaTab.GetStmtsSSAPart().SSAPartOf(&stmt); + AccessSSANodes *ssaPart = ssaTab.GetStmtsSSAPart().SSAPartOf(stmt); if (ssaPart == nullptr) { return BuildMeStmtWithNoSSAPart(stmt); } @@ -525,8 +525,8 @@ MeStmt *IRMap::BuildMeStmt(StmtNode &stmt) { } } -void IRMap::BuildMuList(MapleMap &mayuselist, MapleMap &mulist) { - for (std::pair mapitem : mayuselist) { +void IRMap::BuildMuList(MapleMap &mayuseList, MapleMap &mulist) { + for (std::pair mapitem : mayuseList) { MayUseNode &mayusenode = mapitem.second; VersionSt *verSt = mayusenode.GetOpnd(); VarMeExpr *varmeexpr = GetOrCreateVarFromVerSt(*verSt); @@ -535,7 +535,7 @@ void IRMap::BuildMuList(MapleMap &mayuselist, MapleMapGetIndex()); addrofme.InitBase(mirNode.GetOpCode(), mirNode.GetPrimType(), mirNode.GetNumOpnds()); addrofme.SetFieldID(addrofnode.GetFieldID()); - retmeexpr = HashMeExpr(addrofme); + retMeExpr = HashMeExpr(addrofme); break; } case OP_dread: { @@ -559,7 +559,7 @@ MeExpr *IRMap::BuildExpr(BaseNode &mirNode) { GlobalTables::GetTypeTable().GetTypeFromTyIdx(verSt->GetOrigSt()->GetTyIdx())->GetPrimType()); varmeexpr->SetFieldID(addrofnode.GetFieldID()); } - retmeexpr = varmeexpr; + retMeExpr = varmeexpr; break; } case OP_regread: { @@ -567,7 +567,7 @@ MeExpr *IRMap::BuildExpr(BaseNode &mirNode) { VersionSt *verSt = regnode.GetSSAVar(); RegMeExpr *regmeexpr = GetOrCreateRegFromVerSt(*verSt); regmeexpr->InitBase(mirNode.GetOpCode(), mirNode.GetPrimType(), mirNode.GetNumOpnds()); - retmeexpr = regmeexpr; + retMeExpr = regmeexpr; break; } case OP_addroffunc: { @@ -575,7 +575,7 @@ MeExpr *IRMap::BuildExpr(BaseNode &mirNode) { PUIdx puidx = addfuncnode.GetPUIdx(); AddroffuncMeExpr addrfuncme(kInvalidExprID, puidx); addrfuncme.InitBase(mirNode.GetOpCode(), mirNode.GetPrimType(), mirNode.GetNumOpnds()); - retmeexpr = HashMeExpr(addrfuncme); + retMeExpr = HashMeExpr(addrfuncme); break; } case OP_gcmalloc: @@ -584,14 +584,14 @@ MeExpr *IRMap::BuildExpr(BaseNode &mirNode) { TyIdx tyidx = gcmallocnode.GetTyIdx(); GcmallocMeExpr gcmallocme(kInvalidExprID, tyidx); gcmallocme.InitBase(mirNode.GetOpCode(), mirNode.GetPrimType(), mirNode.GetNumOpnds()); - retmeexpr = HashMeExpr(gcmallocme); + retMeExpr = HashMeExpr(gcmallocme); break; } case OP_sizeoftype: { SizeoftypeNode &sizeoftypenode = static_cast(mirNode); SizeoftypeMeExpr sizemeexpr(kInvalidExprID, sizeoftypenode.GetTyIdx()); sizemeexpr.InitBase(mirNode.GetOpCode(), mirNode.GetPrimType(), mirNode.GetNumOpnds()); - retmeexpr = HashMeExpr(sizemeexpr); + retMeExpr = HashMeExpr(sizemeexpr); break; } case OP_fieldsdist: { @@ -599,7 +599,7 @@ MeExpr *IRMap::BuildExpr(BaseNode &mirNode) { FieldsDistMeExpr fieldsDistExpr(kInvalidExprID, fieldsDistNode.GetTyIdx(), fieldsDistNode.GetFiledID1(), fieldsDistNode.GetFiledID2()); fieldsDistExpr.InitBase(mirNode.GetOpCode(), mirNode.GetPrimType(), mirNode.GetNumOpnds()); - retmeexpr = HashMeExpr(fieldsDistExpr); + retMeExpr = HashMeExpr(fieldsDistExpr); break; } case OP_iread: { @@ -614,28 +614,28 @@ MeExpr *IRMap::BuildExpr(BaseNode &mirNode) { VarMeExpr *varmeexpr = GetOrCreateVarFromVerSt(*verSt); ivarmeexpr.SetMuVal(varmeexpr); } - retmeexpr = HashMeExpr(ivarmeexpr); - ASSERT(static_cast(retmeexpr)->GetMu() != nullptr, + retMeExpr = HashMeExpr(ivarmeexpr); + ASSERT(static_cast(retMeExpr)->GetMu() != nullptr, "BuildExpr: ivar node cannot have mu == nullptr"); break; } case OP_constval: { ConstvalNode &constnode = static_cast(mirNode); - retmeexpr = CreateConstMeExpr(constnode.GetPrimType(), *constnode.GetConstVal()); + retMeExpr = CreateConstMeExpr(constnode.GetPrimType(), *constnode.GetConstVal()); break; } case OP_conststr: { ConststrNode &constnode = static_cast(mirNode); ConststrMeExpr conststrmeexpr(kInvalidExprID, constnode.GetStrIdx()); conststrmeexpr.InitBase(mirNode.GetOpCode(), mirNode.GetPrimType(), mirNode.GetNumOpnds()); - retmeexpr = HashMeExpr(conststrmeexpr); + retMeExpr = HashMeExpr(conststrmeexpr); break; } case OP_conststr16: { Conststr16Node &constnode = static_cast(mirNode); Conststr16MeExpr conststrmeexpr(kInvalidExprID, constnode.GetStrIdx()); conststrmeexpr.InitBase(mirNode.GetOpCode(), mirNode.GetPrimType(), mirNode.GetNumOpnds()); - retmeexpr = HashMeExpr(conststrmeexpr); + retMeExpr = HashMeExpr(conststrmeexpr); break; } case OP_eq: @@ -653,8 +653,8 @@ MeExpr *IRMap::BuildExpr(BaseNode &mirNode) { opmeexpr.SetOpnd(1, BuildExpr(*cmpnode.Opnd(1))); opmeexpr.InitBase(mirNode.GetOpCode(), mirNode.GetPrimType(), mirNode.GetNumOpnds()); opmeexpr.SetOpndType(cmpnode.GetOpndType()); - retmeexpr = HashMeExpr(opmeexpr); - static_cast(retmeexpr)->SetOpndType(cmpnode.GetOpndType()); + retMeExpr = HashMeExpr(opmeexpr); + static_cast(retMeExpr)->SetOpndType(cmpnode.GetOpndType()); break; } case OP_ceil: @@ -666,7 +666,7 @@ MeExpr *IRMap::BuildExpr(BaseNode &mirNode) { opmeexpr.SetOpnd(0, BuildExpr(*tycvtnode.Opnd(0))); opmeexpr.InitBase(mirNode.GetOpCode(), mirNode.GetPrimType(), mirNode.GetNumOpnds()); opmeexpr.SetOpndType(tycvtnode.FromType()); - retmeexpr = HashMeExpr(opmeexpr); + retMeExpr = HashMeExpr(opmeexpr); break; } case OP_retype: { @@ -676,7 +676,7 @@ MeExpr *IRMap::BuildExpr(BaseNode &mirNode) { opmeexpr.InitBase(mirNode.GetOpCode(), mirNode.GetPrimType(), mirNode.GetNumOpnds()); opmeexpr.SetOpndType(tycvtnode.FromType()); opmeexpr.SetTyIdx(tycvtnode.GetTyIdx()); - retmeexpr = HashMeExpr(opmeexpr); + retMeExpr = HashMeExpr(opmeexpr); break; } case OP_abs: @@ -691,7 +691,7 @@ MeExpr *IRMap::BuildExpr(BaseNode &mirNode) { UnaryNode &unnode = static_cast(mirNode); opmeexpr.SetOpnd(0, BuildExpr(*unnode.Opnd(0))); opmeexpr.InitBase(mirNode.GetOpCode(), mirNode.GetPrimType(), mirNode.GetNumOpnds()); - retmeexpr = HashMeExpr(opmeexpr); + retMeExpr = HashMeExpr(opmeexpr); break; } case OP_iaddrof: { @@ -701,7 +701,7 @@ MeExpr *IRMap::BuildExpr(BaseNode &mirNode) { opmeexpr.SetFieldID(unnode.GetFieldID()); opmeexpr.SetOpnd(0, BuildExpr(*unnode.Opnd(0))); opmeexpr.InitBase(mirNode.GetOpCode(), mirNode.GetPrimType(), mirNode.GetNumOpnds()); - retmeexpr = HashMeExpr(opmeexpr); + retMeExpr = HashMeExpr(opmeexpr); break; } case OP_sext: @@ -713,7 +713,7 @@ MeExpr *IRMap::BuildExpr(BaseNode &mirNode) { opmeexpr.SetBitsOffSet(extnode.GetBitsOffset()); opmeexpr.SetBitsSize(extnode.GetBitsSize()); opmeexpr.InitBase(mirNode.GetOpCode(), mirNode.GetPrimType(), mirNode.GetNumOpnds()); - retmeexpr = HashMeExpr(opmeexpr); + retMeExpr = HashMeExpr(opmeexpr); break; } case OP_gcmallocjarray: @@ -721,9 +721,9 @@ MeExpr *IRMap::BuildExpr(BaseNode &mirNode) { OpMeExpr opmeexpr(kInvalidExprID); JarrayMallocNode &gcnode = static_cast(mirNode); opmeexpr.SetOpnd(0, BuildExpr(*gcnode.Opnd(0))); - opmeexpr.GetTyIdx() = gcnode.GetTyIdx(); + opmeexpr.SetTyIdx(gcnode.GetTyIdx()); opmeexpr.InitBase(mirNode.GetOpCode(), mirNode.GetPrimType(), mirNode.GetNumOpnds()); - retmeexpr = HashMeExpr(opmeexpr); + retMeExpr = HashMeExpr(opmeexpr); break; } case OP_resolveinterfacefunc: @@ -734,7 +734,7 @@ MeExpr *IRMap::BuildExpr(BaseNode &mirNode) { opmeexpr.SetOpnd(1, BuildExpr(*rsnode.Opnd(1))); opmeexpr.SetFieldID(rsnode.GetPuIdx()); opmeexpr.InitBase(mirNode.GetOpCode(), mirNode.GetPrimType(), mirNode.GetNumOpnds()); - retmeexpr = HashMeExpr(opmeexpr); + retMeExpr = HashMeExpr(opmeexpr); break; } case OP_sub: @@ -757,7 +757,7 @@ MeExpr *IRMap::BuildExpr(BaseNode &mirNode) { opmeexpr.SetOpnd(0, BuildExpr(*bnode.Opnd(0))); opmeexpr.SetOpnd(1, BuildExpr(*bnode.Opnd(1))); opmeexpr.InitBase(mirNode.GetOpCode(), mirNode.GetPrimType(), mirNode.GetNumOpnds()); - retmeexpr = HashMeExpr(opmeexpr); + retMeExpr = HashMeExpr(opmeexpr); break; } case OP_select: { @@ -767,7 +767,7 @@ MeExpr *IRMap::BuildExpr(BaseNode &mirNode) { opmeexpr.SetOpnd(1, BuildExpr(*bnode.Opnd(1))); opmeexpr.SetOpnd(2, BuildExpr(*bnode.Opnd(2))); opmeexpr.InitBase(mirNode.GetOpCode(), mirNode.GetPrimType(), mirNode.GetNumOpnds()); - retmeexpr = HashMeExpr(opmeexpr); + retMeExpr = HashMeExpr(opmeexpr); break; } case OP_array: { @@ -777,7 +777,7 @@ MeExpr *IRMap::BuildExpr(BaseNode &mirNode) { arrmeexpr.GetOpnds().push_back(BuildExpr(*arrnode.Opnd(i))); } arrmeexpr.InitBase(mirNode.GetOpCode(), mirNode.GetPrimType(), mirNode.GetNumOpnds()); - retmeexpr = HashMeExpr(arrmeexpr); + retMeExpr = HashMeExpr(arrmeexpr); break; } case OP_intrinsicop: { @@ -788,7 +788,7 @@ MeExpr *IRMap::BuildExpr(BaseNode &mirNode) { narymeexpr.GetOpnds().push_back(BuildExpr(*intrinnode.Opnd(i))); } narymeexpr.InitBase(mirNode.GetOpCode(), mirNode.GetPrimType(), mirNode.GetNumOpnds()); - retmeexpr = HashMeExpr(narymeexpr); + retMeExpr = HashMeExpr(narymeexpr); break; } case OP_intrinsicopwithtype: { @@ -799,30 +799,26 @@ MeExpr *IRMap::BuildExpr(BaseNode &mirNode) { narymeexpr.GetOpnds().push_back(BuildExpr(*intrinnode.Opnd(i))); } narymeexpr.InitBase(mirNode.GetOpCode(), mirNode.GetPrimType(), mirNode.GetNumOpnds()); - retmeexpr = HashMeExpr(narymeexpr); + retMeExpr = HashMeExpr(narymeexpr); break; } default: ASSERT(false, "NIY BuildExpe"); } - return retmeexpr; + return retMeExpr; } void IRMap::PutToBucket(uint32 hashidx, MeExpr &meExpr) { MeExpr *headexpr = hashTable[hashidx]; - if (headexpr == nullptr) { - hashTable[hashidx] = &meExpr; - } else { + if (headexpr != nullptr) { meExpr.SetNext(headexpr); - hashTable[hashidx] = &meExpr; } + hashTable[hashidx] = &meExpr; } -/* - Check if two IvarMeExpr are identical. - If ivar_use is the first use of the same ivar coming from an iassign - (ivar_def), then update its mu: ivar_def->mu = ivar_use->mu. - */ + // Check if two IvarMeExpr are identical. + // If ivar_use is the first use of the same ivar coming from an iassign + // (ivar_def), then update its mu: ivar_def->mu = ivar_use->mu. static bool AreIvarIdentical(IvarMeExpr &ivarUse, IvarMeExpr &ivarDef) { if (ivarDef.GetBase()->GetExprID() != ivarUse.GetBase()->GetExprID()) { return false; @@ -849,8 +845,7 @@ static bool AreIvarIdentical(IvarMeExpr &ivarUse, IvarMeExpr &ivarDef) { // this can happen due to use of placement new return false; } - for (auto xit = iass->GetChiList()->begin(); xit != iass->GetChiList()->end(); - xit++) { + for (auto xit = iass->GetChiList()->begin(); xit != iass->GetChiList()->end(); xit++) { ChiMeNode *chi = xit->second; if (chi->GetLHS()->GetExprID() == ivarUse.GetMu()->GetExprID()) { ivarDef.SetMuVal(ivarUse.GetMu()); @@ -916,39 +911,39 @@ MeExpr *IRMap::HashMeExpr(MeExpr &meExpr) { return newconstmeexpr; } case kMeOpConststr: { - ConststrMeExpr &constmeexpr = static_cast(meExpr); - ConststrMeExpr *itexpr = static_cast(hashTable[hidx]); - UStrIdx strIdx = constmeexpr.GetStrIdx(); - while (itexpr != nullptr) { - if (itexpr->GetMeOp() != kMeOpConststr) { - itexpr = static_cast(itexpr->GetNext()); + ConststrMeExpr &constMeExpr = static_cast(meExpr); + ConststrMeExpr *itExpr = static_cast(hashTable[hidx]); + UStrIdx strIdx = constMeExpr.GetStrIdx(); + while (itExpr != nullptr) { + if (itExpr->GetMeOp() != kMeOpConststr) { + itExpr = static_cast(itExpr->GetNext()); continue; } - UStrIdx itstridx = itexpr->GetStrIdx(); - if (itstridx == strIdx) { - return itexpr; + UStrIdx itStrIdx = itExpr->GetStrIdx(); + if (itStrIdx == strIdx) { + return itExpr; } - itexpr = static_cast(itexpr->GetNext()); + itExpr = static_cast(itExpr->GetNext()); } - ConststrMeExpr *newconstmeexpr = New(exprID++, strIdx); - newconstmeexpr->InitBase(meExpr.GetOp(), meExpr.GetPrimType(), meExpr.GetNumOpnds()); - PutToBucket(hidx, *newconstmeexpr); - return newconstmeexpr; + ConststrMeExpr *newConstMeExpr = New(exprID++, strIdx); + newConstMeExpr->InitBase(meExpr.GetOp(), meExpr.GetPrimType(), meExpr.GetNumOpnds()); + PutToBucket(hidx, *newConstMeExpr); + return newConstMeExpr; } case kMeOpConststr16: { - Conststr16MeExpr &constmeexpr = static_cast(meExpr); - Conststr16MeExpr *itexpr = static_cast(hashTable[hidx]); - U16StrIdx strIdx = constmeexpr.GetStrIdx(); - while (itexpr != nullptr) { - if (itexpr->GetMeOp() != kMeOpConststr16) { - itexpr = static_cast(itexpr->GetNext()); + Conststr16MeExpr &constMeExpr = static_cast(meExpr); + Conststr16MeExpr *itExpr = static_cast(hashTable[hidx]); + U16StrIdx strIdx = constMeExpr.GetStrIdx(); + while (itExpr != nullptr) { + if (itExpr->GetMeOp() != kMeOpConststr16) { + itExpr = static_cast(itExpr->GetNext()); continue; } - U16StrIdx itstridx = itexpr->GetStrIdx(); + U16StrIdx itstridx = itExpr->GetStrIdx(); if (itstridx == strIdx) { - return itexpr; + return itExpr; } - itexpr = static_cast(itexpr->GetNext()); + itExpr = static_cast(itExpr->GetNext()); } Conststr16MeExpr *newconstmeexpr = New(exprID++, strIdx); newconstmeexpr->InitBase(meExpr.GetOp(), meExpr.GetPrimType(), meExpr.GetNumOpnds()); @@ -1063,30 +1058,30 @@ MeExpr *IRMap::HashMeExpr(MeExpr &meExpr) { // replace meExpr with repexpr. meExpr must be a kid of origexpr // return repexpr's parent if replaced, otherwise return nullptr -MeExpr *IRMap::ReplaceMeExprExpr(MeExpr &origExpr, MeExpr &meExpr, MeExpr &repexpr) { +MeExpr *IRMap::ReplaceMeExprExpr(MeExpr &origExpr, MeExpr &meExpr, MeExpr &repExpr) { if (origExpr.IsLeaf()) { return &origExpr; } switch (origExpr.GetMeOp()) { case kMeOpOp: { - OpMeExpr &opmeexpr = static_cast(origExpr); - OpMeExpr newmeexpr(opmeexpr, kInvalidExprID); + OpMeExpr &opMeExpr = static_cast(origExpr); + OpMeExpr newMeExpr(opMeExpr, kInvalidExprID); bool needRehash = false; for (uint32 i = 0; i < kOpndNumOfOpMeExpr; i++) { - if (!opmeexpr.GetOpnd(i)) { + if (!opMeExpr.GetOpnd(i)) { continue; } - if (opmeexpr.GetOpnd(i) == &meExpr) { + if (opMeExpr.GetOpnd(i) == &meExpr) { needRehash = true; - newmeexpr.SetOpnd(i, &repexpr); - } else if (!opmeexpr.GetOpnd(i)->IsLeaf()) { - newmeexpr.SetOpnd(i, ReplaceMeExprExpr(*newmeexpr.GetOpnd(i), meExpr, repexpr)); - if (newmeexpr.GetOpnd(i) != opmeexpr.GetOpnd(i)) { + newMeExpr.SetOpnd(i, &repExpr); + } else if (!opMeExpr.GetOpnd(i)->IsLeaf()) { + newMeExpr.SetOpnd(i, ReplaceMeExprExpr(*newMeExpr.GetOpnd(i), meExpr, repExpr)); + if (newMeExpr.GetOpnd(i) != opMeExpr.GetOpnd(i)) { needRehash = true; } } } - return needRehash ? HashMeExpr(newmeexpr) : &origExpr; + return needRehash ? HashMeExpr(newMeExpr) : &origExpr; } case kMeOpNary: { NaryMeExpr &narymeexpr = static_cast(origExpr); @@ -1096,10 +1091,10 @@ MeExpr *IRMap::ReplaceMeExprExpr(MeExpr &origExpr, MeExpr &meExpr, MeExpr &repex for (size_t i = 0; i < opnds.size(); i++) { MeExpr *opnd = opnds[i]; if (opnd == &meExpr) { - newmeexpr.SetOpnd(i, &repexpr); + newmeexpr.SetOpnd(i, &repExpr); needRehash = true; } else if (!opnd->IsLeaf()) { - newmeexpr.SetOpnd(i, ReplaceMeExprExpr(*newmeexpr.GetOpnd(i), meExpr, repexpr)); + newmeexpr.SetOpnd(i, ReplaceMeExprExpr(*newmeexpr.GetOpnd(i), meExpr, repExpr)); if (newmeexpr.GetOpnd(i) != opnd) { needRehash = true; } @@ -1112,10 +1107,10 @@ MeExpr *IRMap::ReplaceMeExprExpr(MeExpr &origExpr, MeExpr &meExpr, MeExpr &repex IvarMeExpr newmeexpr(kInvalidExprID, ivarexpr); bool needRehash = false; if (ivarexpr.GetBase() == &meExpr) { - newmeexpr.SetBase(&repexpr); + newmeexpr.SetBase(&repExpr); needRehash = true; } else if (!ivarexpr.GetBase()->IsLeaf()) { - newmeexpr.SetBase(ReplaceMeExprExpr(*newmeexpr.GetBase(), meExpr, repexpr)); + newmeexpr.SetBase(ReplaceMeExprExpr(*newmeexpr.GetBase(), meExpr, repExpr)); if (newmeexpr.GetBase() != ivarexpr.GetBase()) { needRehash = true; } @@ -1280,17 +1275,17 @@ BB *IRMap::GetFalseBrBB(CondGotoMeStmt &condgoto) { } } -MeExpr *IRMap::CreateConstMeExpr(PrimType ptyp, MIRConst &mirconst) { - ConstMeExpr constmeexpr(kInvalidExprID, &mirconst); - constmeexpr.SetOp(OP_constval); - constmeexpr.SetPtyp(ptyp); - return HashMeExpr(constmeexpr); +MeExpr *IRMap::CreateConstMeExpr(PrimType ptyp, MIRConst &mirConst) { + ConstMeExpr constMeExpr(kInvalidExprID, &mirConst); + constMeExpr.SetOp(OP_constval); + constMeExpr.SetPtyp(ptyp); + return HashMeExpr(constMeExpr); } MeExpr *IRMap::CreateIntConstMeExpr(int64 value, PrimType ptyp) { - MIRIntConst *intconst = + MIRIntConst *intConst = mirModule.GetMemPool()->New(value, GlobalTables::GetTypeTable().GetPrimType(ptyp)); - return CreateConstMeExpr(ptyp, *intconst); + return CreateConstMeExpr(ptyp, *intConst); } MeExpr *IRMap::CreateMeExprBinary(Opcode op, PrimType ptyp, MeExpr &expr0, MeExpr &expr1) { @@ -1354,7 +1349,7 @@ IntrinsiccallMeStmt *IRMap::CreateIntrinsicCallAssignedMeStmt(MIRIntrinsicID idx } MeExpr *IRMap::CreateAddrofMeExprFromNewSymbol(MIRSymbol &st, PUIdx puidx) { - OriginalSt *baseOst = ssaTab.CreateSymbolOriginalSt(&st, puidx, 0); + OriginalSt *baseOst = ssaTab.CreateSymbolOriginalSt(st, puidx, 0); AddrofMeExpr addrofme(kInvalidExprID, baseOst->GetIndex()); addrofme.SetOp(OP_addrof); addrofme.SetPtyp(PTY_ptr); diff --git a/src/maple_me/src/irmap_emit.cpp b/src/maple_me/src/irmap_emit.cpp index eaa88d5387b3dd50b495bf39f26fd0942517b089..f22b0b09dfe89d0a5deb6d24bf6348557edb6066 100644 --- a/src/maple_me/src/irmap_emit.cpp +++ b/src/maple_me/src/irmap_emit.cpp @@ -141,8 +141,8 @@ BaseNode &OpMeExpr::EmitExpr(SSATab &ssaTab) { case OP_cmpl: case OP_cmpg: case OP_cmp: { - CompareNode *cmpNode = - ssaTab.GetModule().CurFunction()->GetCodeMempool()->New(Opcode(GetOp()), PrimType(GetPrimType())); + CompareNode *cmpNode = ssaTab.GetModule().CurFunction()->GetCodeMempool()->New( + Opcode(GetOp()), PrimType(GetPrimType())); cmpNode->SetBOpnd(&opnds[0]->EmitExpr(ssaTab), 0); cmpNode->SetBOpnd(&opnds[1]->EmitExpr(ssaTab), 1); cmpNode->SetOpndType(opndType); @@ -172,8 +172,8 @@ BaseNode &OpMeExpr::EmitExpr(SSATab &ssaTab) { return *unode; } case OP_select: { - TernaryNode *ternaryNode = - ssaTab.GetModule().CurFunction()->GetCodeMempool()->New(Opcode(GetOp()), PrimType(GetPrimType())); + TernaryNode *ternaryNode = ssaTab.GetModule().CurFunction()->GetCodeMempool()->New( + Opcode(GetOp()), PrimType(GetPrimType())); ternaryNode->SetOpnd(&opnds[0]->EmitExpr(ssaTab), 0); ternaryNode->SetOpnd(&opnds[1]->EmitExpr(ssaTab), 1); ternaryNode->SetOpnd(&opnds[2]->EmitExpr(ssaTab), 2); @@ -183,14 +183,15 @@ BaseNode &OpMeExpr::EmitExpr(SSATab &ssaTab) { case OP_cvt: case OP_floor: case OP_trunc: { - TypeCvtNode *cvtNode = - ssaTab.GetModule().CurFunction()->GetCodeMempool()->New(Opcode(GetOp()), PrimType(GetPrimType())); + TypeCvtNode *cvtNode = ssaTab.GetModule().CurFunction()->GetCodeMempool()->New( + Opcode(GetOp()), PrimType(GetPrimType())); cvtNode->SetOpnd(&opnds[0]->EmitExpr(ssaTab)); cvtNode->SetFromType(opndType); return *cvtNode; } case OP_retype: { - RetypeNode *cvtNode = ssaTab.GetModule().CurFunction()->GetCodeMempool()->New(PrimType(GetPrimType())); + RetypeNode *cvtNode = + ssaTab.GetModule().CurFunction()->GetCodeMempool()->New(PrimType(GetPrimType())); cvtNode->SetOpnd(&opnds[0]->EmitExpr(ssaTab)); cvtNode->SetFromType(opndType); cvtNode->SetTyIdx(tyIdx); @@ -301,18 +302,18 @@ StmtNode &MaydassignMeStmt::EmitStmt(SSATab &ssaTab) { return *dassignStmt; } -void MeStmt::EmitCallReturnVector(SSATab *ssaTab, CallReturnVector *nrets) { +void MeStmt::EmitCallReturnVector(SSATab &ssaTab, CallReturnVector &nrets) { MapleVector *mustDefs = GetMustDefList(); if (mustDefs == nullptr || mustDefs->empty()) { return; } MeExpr *meExpr = mustDefs->front().GetLHS(); if (meExpr->GetMeOp() == kMeOpVar) { - const OriginalSt *ost = ssaTab->GetOriginalStFromID(static_cast(meExpr)->GetOStIdx()); + const OriginalSt *ost = ssaTab.GetOriginalStFromID(static_cast(meExpr)->GetOStIdx()); MIRSymbol *symbol = ost->GetMIRSymbol(); - nrets->push_back(CallReturnPair(symbol->GetStIdx(), RegFieldPair(0, 0))); + nrets.push_back(CallReturnPair(symbol->GetStIdx(), RegFieldPair(0, 0))); } else if (meExpr->GetMeOp() == kMeOpReg) { - nrets->push_back(CallReturnPair(StIdx(), RegFieldPair(0, static_cast(meExpr)->GetRegIdx()))); + nrets.push_back(CallReturnPair(StIdx(), RegFieldPair(0, static_cast(meExpr)->GetRegIdx()))); } } @@ -339,7 +340,7 @@ StmtNode &CallMeStmt::EmitStmt(SSATab &ssaTab) { callNode->SetNumOpnds(callNode->GetNopndSize()); callNode->SetSrcPos(GetSrcPosition()); if (kOpcodeInfo.IsCallAssigned(GetOp())) { - EmitCallReturnVector(&ssaTab, &callNode->GetReturnVec()); + EmitCallReturnVector(ssaTab, callNode->GetReturnVec()); for (size_t j = 0; j < callNode->GetReturnVec().size(); j++) { CallReturnPair retPair = callNode->GetReturnVec()[j]; if (!retPair.second.IsReg()) { @@ -363,7 +364,7 @@ StmtNode &CallMeStmt::EmitStmt(SSATab &ssaTab) { icallNode->SetNumOpnds(icallNode->GetNopndSize()); icallNode->SetSrcPos(GetSrcPosition()); if (kOpcodeInfo.IsCallAssigned(GetOp())) { - EmitCallReturnVector(&ssaTab, &icallNode->GetReturnVec()); + EmitCallReturnVector(ssaTab, icallNode->GetReturnVec()); icallNode->SetRetTyIdx(TyIdx(PTY_void)); for (size_t j = 0; j < icallNode->GetReturnVec().size(); j++) { CallReturnPair retPair = icallNode->GetReturnVec()[j]; @@ -396,7 +397,7 @@ StmtNode &IcallMeStmt::EmitStmt(SSATab &ssaTab) { icallNode->SetNumOpnds(icallNode->GetNopndSize()); icallNode->SetSrcPos(GetSrcPosition()); if (kOpcodeInfo.IsCallAssigned(GetOp())) { - EmitCallReturnVector(&ssaTab, &icallNode->GetReturnVec()); + EmitCallReturnVector(ssaTab, icallNode->GetReturnVec()); icallNode->SetRetTyIdx(TyIdx(PTY_void)); for (size_t j = 0; j < icallNode->GetReturnVec().size(); j++) { CallReturnPair retPair = icallNode->GetReturnVec()[j]; @@ -431,7 +432,7 @@ StmtNode &IntrinsiccallMeStmt::EmitStmt(SSATab &ssaTab) { callNode->SetNumOpnds(callNode->GetNopndSize()); callNode->SetSrcPos(GetSrcPosition()); if (kOpcodeInfo.IsCallAssigned(GetOp())) { - EmitCallReturnVector(&ssaTab, &callNode->GetReturnVec()); + EmitCallReturnVector(ssaTab, callNode->GetReturnVec()); for (size_t j = 0; j < callNode->GetReturnVec().size(); j++) { CallReturnPair retPair = callNode->GetReturnVec()[j]; if (!retPair.second.IsReg()) { diff --git a/src/maple_me/src/me_bb_layout.cpp b/src/maple_me/src/me_bb_layout.cpp index e7d00f1b2f38a5290b02433c29a84f9d4ef9cfbd..b51d2879a70f5b4e66717361439635b6deba92a7 100644 --- a/src/maple_me/src/me_bb_layout.cpp +++ b/src/maple_me/src/me_bb_layout.cpp @@ -33,11 +33,10 @@ // the original fallthru // (3) For goto curBB see if goto target can be placed as next. // 5. do step 3 for nextBB until all bbs are laid out - namespace maple { static void CreateGoto(BB &bb, MeFunction &func, BB &fallthru) { if (fallthru.GetBBLabel() == 0) { - func.CreateBBLabel(&fallthru); + func.CreateBBLabel(fallthru); } if (func.GetIRMap() != nullptr) { GotoNode stmt(OP_goto); @@ -286,7 +285,7 @@ start_: newTargetBB = brTargetBB->GetSucc(1); } if (newTargetBB->GetBBLabel() == 0) { - func.CreateBBLabel(newTargetBB); + func.CreateBBLabel(*newTargetBB); } LabelIdx newTargetLabel = newTargetBB->GetBBLabel(); if (func.GetIRMap() != nullptr) { @@ -447,8 +446,8 @@ AnalysisResult *MeDoBBLayout::Run(MeFunction *func, MeFuncResultMgr *m, ModuleRe } ASSERT(!(isTry && bbLayout->GetTryOutstanding()), "cannot emit another try if last try has not been ended"); if (nextBB->GetAttributes(kBBAttrIsTryEnd)) { - ASSERT(func->GetEndTryBB2TryBB()[nextBB] == nextBB || - bbLayout->IsBBLaidOut(func->GetEndTryBB2TryBB()[nextBB]->GetBBId()), + ASSERT(func->GetTryBBFromEndTryBB(nextBB) == nextBB || + bbLayout->IsBBLaidOut(func->GetTryBBFromEndTryBB(nextBB)->GetBBId()), "cannot emit endtry bb before its corresponding try bb"); } } @@ -461,7 +460,7 @@ AnalysisResult *MeDoBBLayout::Run(MeFunction *func, MeFuncResultMgr *m, ModuleRe if (brTargetBB != fallthru && fallthru->GetPred().size() > 1 && bbLayout->BBCanBeMoved(*brTargetBB, *bb)) { // flip the sense of the condgoto and lay out brTargetBB right here if (fallthru->GetBBLabel() == 0) { - func->CreateBBLabel(fallthru); + func->CreateBBLabel(*fallthru); } if (func->GetIRMap() != nullptr) { CondGotoMeStmt &condGotoMeStmt = static_cast(bb->GetMeStmts().back()); @@ -490,7 +489,7 @@ AnalysisResult *MeDoBBLayout::Run(MeFunction *func, MeFuncResultMgr *m, ModuleRe newFallthru->SetKind(kBBGoto); bbLayout->SetNewBBInLayout(); if (fallthru->GetBBLabel() == 0) { - func->CreateBBLabel(fallthru); + func->CreateBBLabel(*fallthru); } if (func->GetIRMap() != nullptr) { GotoNode stmt(OP_goto); diff --git a/src/maple_me/src/me_cfg.cpp b/src/maple_me/src/me_cfg.cpp index b00671d45c92778c7c9cfece2fab64cf7b9e104c..963fb05682ae4009ca42d7ba6917ce6ab3fb5b44 100644 --- a/src/maple_me/src/me_cfg.cpp +++ b/src/maple_me/src/me_cfg.cpp @@ -110,9 +110,10 @@ void MeCFG::BuildMirCFG() { } /* deal try blocks, add catch handler to try's succ */ if (bb->GetAttributes(kBBAttrIsTry)) { - ASSERT((func.GetBBTryNodeMap().find(bb) != func.GetBBTryNodeMap().end()), "try bb without try"); - StmtNode *currTry = func.GetBBTryNodeMap()[bb]; - TryNode *tryNode = static_cast(currTry); + auto it = func.GetBBTryNodeMap().find(bb); + CHECK_FATAL(it != func.GetBBTryNodeMap().end(), "try bb without try"); + StmtNode *currTry = it->second; + const TryNode *tryNode = static_cast(currTry); bool hasFinallyHandler = false; /* add exception handler bb */ for (size_t j = 0; j < tryNode->GetOffsetsCount(); j++) { @@ -163,9 +164,9 @@ void MeCFG::BuildMirCFG() { } } -bool MeCFG::FindExprUse(BaseNode &expr, StIdx stIdx) { +bool MeCFG::FindExprUse(const BaseNode &expr, StIdx stIdx) const { if (expr.GetOpCode() == OP_addrof || expr.GetOpCode() == OP_dread) { - AddrofNode &addofNode = static_cast(expr); + const AddrofNode &addofNode = static_cast(expr); return addofNode.GetStIdx() == stIdx; } else if (expr.GetOpCode() == OP_iread) { return FindExprUse(*expr.Opnd(0), stIdx); @@ -179,7 +180,7 @@ bool MeCFG::FindExprUse(BaseNode &expr, StIdx stIdx) { return false; } -bool MeCFG::FindUse(StmtNode &stmt, StIdx stID) { +bool MeCFG::FindUse(const StmtNode &stmt, StIdx stID) const { Opcode opcode = stmt.GetOpCode(); switch (opcode) { case OP_call: @@ -217,18 +218,18 @@ bool MeCFG::FindUse(StmtNode &stmt, StIdx stID) { break; } case OP_dassign: { - DassignNode &dNode = static_cast(stmt); + const DassignNode &dNode = static_cast(stmt); return FindExprUse(*dNode.GetRHS(), stID); } case OP_regassign: { - RegassignNode &rNode = static_cast(stmt); + const RegassignNode &rNode = static_cast(stmt); if (rNode.GetRegIdx() < 0) { return false; } return FindExprUse(*rNode.Opnd(0), stID); } case OP_iassign: { - IassignNode &iNode = static_cast(stmt); + const IassignNode &iNode = static_cast(stmt); if (FindExprUse(*iNode.Opnd(0), stID)) { return true; } else { @@ -248,16 +249,16 @@ bool MeCFG::FindUse(StmtNode &stmt, StIdx stID) { return false; } -bool MeCFG::FindDef(StmtNode &stmt, StIdx stid) { +bool MeCFG::FindDef(const StmtNode &stmt, StIdx stid) const { if (stmt.GetOpCode() != OP_dassign && !kOpcodeInfo.IsCallAssigned(stmt.GetOpCode())) { return false; } if (stmt.GetOpCode() == OP_dassign) { - DassignNode &dassStmt = static_cast(stmt); + const DassignNode &dassStmt = static_cast(stmt); return dassStmt.GetStIdx() == stid; } else { - CallNode &cnode = static_cast(stmt); - CallReturnVector &nrets = cnode.GetReturnVec(); + const CallNode &cnode = static_cast(stmt); + const CallReturnVector &nrets = cnode.GetReturnVec(); if (nrets.size() != 0) { ASSERT(nrets.size() == 1, "Single Ret value for now."); StIdx stidx = nrets[0].first; @@ -271,7 +272,7 @@ bool MeCFG::FindDef(StmtNode &stmt, StIdx stid) { } // Return true if there is no use or def of sym betweent from to to. -bool MeCFG::HasNoOccBetween(StmtNode &from, StmtNode &to, StIdx stIdx) { +bool MeCFG::HasNoOccBetween(StmtNode &from, const StmtNode &to, StIdx stIdx) const { for (StmtNode *stmt = &from; stmt && stmt != &to; stmt = stmt->GetNext()) { if (FindUse(*stmt, stIdx) || FindDef(*stmt, stIdx)) { return false; @@ -384,7 +385,7 @@ void MeCFG::FixMirCFG() { if (HasNoOccBetween(*bb->GetStmtNodes().begin().d(), *nextStmt, sym->GetStIdx())) { continue; } - BB *newBB = func.SplitBB(bb, &splitPoint); + BB *newBB = func.SplitBB(*bb, splitPoint); // because SplitBB will insert a bb, we need update bIt & eIt auto newBBIt = std::find(func.cbegin(), func.cend(), bb); bIt = build_filter_iterator( @@ -430,7 +431,7 @@ void MeCFG::FixMirCFG() { splitPoint = splitPoint->GetPrev(); } CHECK_FATAL(splitPoint != nullptr, "null ptr check"); - BB *newBB = func.SplitBB(bb, splitPoint); + BB *newBB = func.SplitBB(*bb, *splitPoint); // because SplitBB will insert a bb, we need update bIt & eIt auto newBBIt = std::find(func.cbegin(), func.cend(), bb); bIt = build_filter_iterator( @@ -471,10 +472,10 @@ void MeCFG::ConvertPhis2IdentityAssigns(BB &meBB) { dread2->SetSSAVar((*phiIt).second.GetPhiOpnd(0)); DassignNode *dassign = func.GetMIRModule().GetMIRBuilder()->CreateStmtDassign(st, 0, dread2); func.GetMeSSATab()->GetStmtsSSAPart().SetSSAPartOf( - dassign, func.GetMeSSATab()->GetStmtsSSAPart().GetSSAPartMp()->New( + *dassign, func.GetMeSSATab()->GetStmtsSSAPart().GetSSAPartMp()->New( &func.GetMeSSATab()->GetStmtsSSAPart().GetSSAPartAlloc())); MayDefPartWithVersionSt *theSSAPart = - static_cast(func.GetMeSSATab()->GetStmtsSSAPart().SSAPartOf(dassign)); + static_cast(func.GetMeSSATab()->GetStmtsSSAPart().SSAPartOf(*dassign)); theSSAPart->SetSSAVar((*phiIt).second.GetResult()); meBB.PrependStmtNode(dassign); } @@ -560,13 +561,13 @@ void MeCFG::UnreachCodeAnalysis(bool updatePhi) { // move entrytry tag to previous bb with try if ((*it)->GetAttributes(kBBAttrIsTry) && !(*it)->GetAttributes(kBBAttrIsTryEnd)) { (*it)->SetAttributes(kBBAttrIsTryEnd); - func.GetEndTryBB2TryBB()[*it] = func.GetEndTryBB2TryBB()[bb]; + func.SetTryBBByOtherEndTryBB(*it, bb); } break; } } } - func.DeleteBasicBlock(bb); + func.DeleteBasicBlock(*bb); // remove the bb from its succ's pred_ list for (auto it = bb->GetSucc().begin(); it != bb->GetSucc().end(); it++) { BB *sucBB = *it; @@ -635,7 +636,7 @@ void MeCFG::WontExitAnalysis() { // CFG Verify // Check bb-vec and bb-list are strictly consistent. -void MeCFG::Verify() { +void MeCFG::Verify() const { // Check every bb in bb-list. auto eIt = func.valid_end(); for (auto bIt = func.valid_begin(); bIt != eIt; ++bIt) { @@ -672,7 +673,7 @@ void MeCFG::Verify() { } // check that all the target labels in jump statements are defined -void MeCFG::VerifyLabels(void) { +void MeCFG::VerifyLabels() { auto eIt = func.valid_end(); for (auto bIt = func.valid_begin(); bIt != eIt; ++bIt) { BB *mirBB = *bIt; @@ -750,12 +751,12 @@ static void ReplaceFilename(std::string &fileName) { } } -static bool ContainsConststr(const BaseNode *x) { - if (x->GetOpCode() == OP_conststr || x->GetOpCode() == OP_conststr16) { +static bool ContainsConststr(const BaseNode &x) { + if (x.GetOpCode() == OP_conststr || x.GetOpCode() == OP_conststr16) { return true; } - for (size_t i = 0; i < x->NumOpnds(); i++) - if (ContainsConststr(x->Opnd(i))) { + for (size_t i = 0; i < x.NumOpnds(); i++) + if (ContainsConststr(*x.Opnd(i))) { return true; } return false; @@ -837,7 +838,7 @@ void MeCFG::DumpToFile(const std::string &prefix, bool dumpInStrs) { if (stmt.GetOpCode() == OP_comment) { continue; } - if (ContainsConststr(&stmt)) { + if (ContainsConststr(stmt)) { continue; } stmt.Dump(func.GetMIRModule(), 1); diff --git a/src/maple_me/src/me_dominance.cpp b/src/maple_me/src/me_dominance.cpp index 90d9f2165edda3ffd2603b792e63ed3e015399da..f60f2d3e0d1e0f6d1b10d32ba5cc1156b593f82d 100644 --- a/src/maple_me/src/me_dominance.cpp +++ b/src/maple_me/src/me_dominance.cpp @@ -21,7 +21,6 @@ // For some backward data-flow problems, such as LiveOut, // the reverse CFG(The CFG with its edges reversed) is always useful, // so we also generates the above two structures on the reverse CFG. - namespace maple { AnalysisResult *MeDoDominance::Run(MeFunction *func, MeFuncResultMgr *m, ModuleResultMgr *mrm) { MemPool *memPool = NewMemPool(); @@ -41,7 +40,7 @@ AnalysisResult *MeDoDominance::Run(MeFunction *func, MeFuncResultMgr *m, ModuleR dom->ComputePdomChildren(); num = 0; dom->ComputePdtPreorder(*func->GetCommonExitBB(), num); - dom->GetPdtPreOrder().resize(num); + dom->ResizePdtPreOrder(num); dom->ComputePdtDfn(); if (DEBUGFUNC(func)) { LogInfo::MapleLogger() << "-----------------Dump dominance info and postdominance info---------\n"; diff --git a/src/maple_me/src/me_function.cpp b/src/maple_me/src/me_function.cpp index 405cb8ee11da4ab3b988258a66126dd854dec889..18f2d06d76bf08b94efa0e5a9dc988637c19eeee 100644 --- a/src/maple_me/src/me_function.cpp +++ b/src/maple_me/src/me_function.cpp @@ -434,11 +434,11 @@ BB *MeFunction::NewBasicBlock() { } // new a basic block and insert before position -BB *MeFunction::InsertNewBasicBlock(BB *position) { +BB *MeFunction::InsertNewBasicBlock(BB &position) { BB *newbb = memPool->New(&alloc, &versAlloc, BBId(nextBBId++)); - auto bIt = std::find(begin(), end(), position); - auto idx = position->GetBBId().idx; + auto bIt = std::find(begin(), end(), &position); + auto idx = position.GetBBId().idx; auto newIt = bbVec.insert(bIt, newbb); auto eIt = end(); // update bb's idx @@ -451,10 +451,10 @@ BB *MeFunction::InsertNewBasicBlock(BB *position) { return newbb; } -void MeFunction::DeleteBasicBlock(const BB *bb) { - ASSERT(bbVec[bb->GetBBId().idx] == bb, "runtime check error"); +void MeFunction::DeleteBasicBlock(const BB &bb) { + ASSERT(bbVec[bb.GetBBId().idx] == &bb, "runtime check error"); /* update first_bb_ and last_bb if needed */ - bbVec.at(bb->GetBBId().idx) = nullptr; + bbVec.at(bb.GetBBId().idx) = nullptr; } /* get next bb in bbVec */ @@ -482,28 +482,27 @@ BB *MeFunction::PrevBB(const BB *bb) { } /* clone stmtnode in orig bb to newBB */ -void MeFunction::CloneBasicBlock(BB *newBB, BB *orig) { - if (orig == nullptr || orig->IsEmpty()) { +void MeFunction::CloneBasicBlock(BB &newBB, BB &orig) { + if (orig.IsEmpty()) { return; } - for (auto &stmt : orig->GetStmtNodes()) { + for (auto &stmt : orig.GetStmtNodes()) { StmtNode *newStmt = static_cast(stmt.CloneTree(mirModule.GetCurFuncCodeMPAllocator())); - ASSERT(newStmt != nullptr, "null ptr check"); newStmt->SetNext(nullptr); newStmt->SetPrev(nullptr); - newBB->AddStmtNode(newStmt); + newBB.AddStmtNode(newStmt); if (meSSATab != nullptr) { - meSSATab->CreateSSAStmt(newStmt, newBB); + meSSATab->CreateSSAStmt(*newStmt, newBB); } } } /* Split BB at split_point */ -BB *MeFunction::SplitBB(BB *bb, StmtNode *splitPoint, BB *newBB) { +BB *MeFunction::SplitBB(BB &bb, StmtNode &splitPoint, BB *newBB) { if (newBB == nullptr){ newBB = memPool->New(&alloc, &versAlloc, BBId(nextBBId++)); } - StmtNode *newBBStart = splitPoint->GetNext(); + StmtNode *newBBStart = splitPoint.GetNext(); // Fix Stmt in BB. if (newBBStart != nullptr) { newBBStart->SetPrev(nullptr); @@ -511,18 +510,18 @@ BB *MeFunction::SplitBB(BB *bb, StmtNode *splitPoint, BB *newBB) { StmtNode *nextStmt = stmt->GetNext(); newBB->AddStmtNode(stmt); if (meSSATab != nullptr) { - meSSATab->CreateSSAStmt(stmt, newBB); + meSSATab->CreateSSAStmt(*stmt, *newBB); } stmt = nextStmt; } } - bb->SetLast(splitPoint); - splitPoint->SetNext(nullptr); + bb.SetLast(&splitPoint); + splitPoint.SetNext(nullptr); // Fix BB in CFG - newBB->SetKind(bb->GetKind()); - bb->SetKind(kBBFallthru); - auto bIt = std::find(begin(), end(), bb); - auto idx = bb->GetBBId().idx; + newBB->SetKind(bb.GetKind()); + bb.SetKind(kBBFallthru); + auto bIt = std::find(begin(), end(), &bb); + auto idx = bb.GetBBId().idx; auto newIt = bbVec.insert(++bIt, newBB); auto eIt = end(); // update bb's idx @@ -535,38 +534,38 @@ BB *MeFunction::SplitBB(BB *bb, StmtNode *splitPoint, BB *newBB) { // Special Case: commonExitBB is orig bb's succ auto *commonExitBB = *common_exit(); for (size_t i = 0; i < commonExitBB->GetPred().size(); i++) { - if (commonExitBB->GetPred(i) == bb) { + if (commonExitBB->GetPred(i) == &bb) { commonExitBB->SetPred(i, newBB); break; } } - for (size_t i = 0; i < bb->GetSucc().size(); i++) { - BB *succ = bb->GetSucc(i); - succ->ReplacePred(bb, newBB); + for (size_t i = 0; i < bb.GetSucc().size(); i++) { + BB *succ = bb.GetSucc(i); + succ->ReplacePred(&bb, newBB); } - bb->GetSucc().clear(); - bb->GetSucc().push_back(newBB); - newBB->GetPred().push_back(bb); + bb.GetSucc().clear(); + bb.GetSucc().push_back(newBB); + newBB->GetPred().push_back(&bb); // Setup flags newBB->CopyFlagsAfterSplit(bb); if (newBB->GetAttributes(kBBAttrIsTryEnd)) { - endTryBB2TryBB[newBB] = endTryBB2TryBB[bb]; - endTryBB2TryBB[bb] = nullptr; - bb->ClearAttributes(kBBAttrIsTryEnd); + endTryBB2TryBB[newBB] = endTryBB2TryBB[&bb]; + endTryBB2TryBB[&bb] = nullptr; + bb.ClearAttributes(kBBAttrIsTryEnd); } - bb->ClearAttributes(kBBAttrIsExit); + bb.ClearAttributes(kBBAttrIsExit); return newBB; } /* create label for bb */ -void MeFunction::CreateBBLabel(BB *bb) { - if (bb->GetBBLabel() != 0) { +void MeFunction::CreateBBLabel(BB &bb) { + if (bb.GetBBLabel() != 0) { return; } LabelIdx label = mirModule.CurFunction()->GetLabelTab()->CreateLabelWithPrefix('m'); mirModule.CurFunction()->GetLabelTab()->AddToStringLabelMap(label); - bb->SetBBLabel(label); - labelBBIdMap.insert(std::make_pair(label, bb)); + bb.SetBBLabel(label); + labelBBIdMap.insert(std::make_pair(label, &bb)); } // Recognize the following kind of simple pattern and remove corresponding EH edges diff --git a/src/maple_me/src/me_ir.cpp b/src/maple_me/src/me_ir.cpp index adbcd834a030e1c924672c428f75440c073d38e6..d219db2b2413dfd8f6b73a9fff627f366aab0a80 100644 --- a/src/maple_me/src/me_ir.cpp +++ b/src/maple_me/src/me_ir.cpp @@ -20,7 +20,6 @@ #include "mir_function.h" namespace maple { - constexpr int32_t kDefaultPrintIndentNum = 5; bool MeExpr::IsTheSameWorkcand(const MeExpr &expr) const { @@ -66,7 +65,7 @@ void MeExpr::UpdateDepth() { } } ASSERT(maxDepth < UINT8_MAX, "runtime check error"); - depth = (uint8)maxDepth + 1; + depth = static_cast(maxDepth + 1); } // get the definition of this @@ -251,18 +250,18 @@ MeExpr &MeExpr::GetAddrExprBase() { } bool NaryMeExpr::IsUseSameSymbol(const MeExpr &expr) const { - auto *naryMeExpr = dynamic_cast(&expr); - if (naryMeExpr == nullptr) { + if (expr.GetMeOp() != kMeOpNary) { return false; } - if (expr.GetOp() != GetOp() || naryMeExpr->GetIntrinsic() != intrinsic || naryMeExpr->tyIdx != tyIdx) { + auto &naryMeExpr = static_cast(expr); + if (expr.GetOp() != GetOp() || naryMeExpr.GetIntrinsic() != intrinsic || naryMeExpr.tyIdx != tyIdx) { return false; } - if (opnds.size() != naryMeExpr->GetOpnds().size()) { + if (opnds.size() != naryMeExpr.GetOpnds().size()) { return false; } for (size_t i = 0; i < opnds.size(); i++) { - if (!opnds[i]->IsUseSameSymbol(*naryMeExpr->GetOpnd(i))) { + if (!opnds[i]->IsUseSameSymbol(*naryMeExpr.GetOpnd(i))) { return false; } } @@ -277,21 +276,21 @@ bool OpMeExpr::IsIdentical(const OpMeExpr &meexpr) { meexpr.bitsSize != bitsSize || meexpr.tyIdx != tyIdx || meexpr.fieldID != fieldID) { return false; } - CHECK_FATAL(meexpr.opnds[0], "at least opnds[0] shouldn't be empty"); - CHECK_FATAL(opnds[0], "at least opnds[0] shouldn't be empty"); + CHECK_FATAL(meexpr.opnds[0] != nullptr, "at least opnds[0] shouldn't be empty"); + CHECK_FATAL(opnds[0] != nullptr, "at least opnds[0] shouldn't be empty"); if (meexpr.opnds[0]->GetExprID() != opnds[0]->GetExprID()) { return false; } - if ((meexpr.opnds[1] && !opnds[1]) || (!meexpr.opnds[1] && opnds[1])) { + if ((meexpr.opnds[1] != nullptr && opnds[1] == nullptr) || (meexpr.opnds[1] == nullptr && opnds[1] != nullptr)) { return false; } - if ((meexpr.opnds[1] && opnds[1] && meexpr.opnds[1]->GetExprID() != opnds[1]->GetExprID())) { + if (meexpr.opnds[1] != nullptr && opnds[1] != nullptr && meexpr.opnds[1]->GetExprID() != opnds[1]->GetExprID()) { return false; } - if ((meexpr.opnds[2] && !opnds[2]) || (!meexpr.opnds[2] && opnds[2])) { + if ((meexpr.opnds[2] != nullptr && opnds[2] == nullptr) || (meexpr.opnds[2] == nullptr && opnds[2] != nullptr)) { return false; } - if ((meexpr.opnds[2] && opnds[2] && meexpr.opnds[2]->GetExprID() != opnds[2]->GetExprID())) { + if (meexpr.opnds[2] != nullptr && opnds[2] != nullptr && meexpr.opnds[2]->GetExprID() != opnds[2]->GetExprID()) { return false; } return true; @@ -318,11 +317,11 @@ bool IvarMeExpr::IsUseSameSymbol(const MeExpr &expr) const { if (expr.GetExprID() == GetExprID()) { return true; } - auto *ivarMeExpr = dynamic_cast(&expr); - if (ivarMeExpr == nullptr) { + if (expr.GetMeOp() != kMeOpIvar) { return false; } - if (base->IsUseSameSymbol(*ivarMeExpr->base) && fieldID == ivarMeExpr->fieldID) { + auto &ivarMeExpr = static_cast(expr); + if (base->IsUseSameSymbol(*ivarMeExpr.base) && fieldID == ivarMeExpr.fieldID) { return true; } return false; @@ -381,11 +380,11 @@ BB *VarMeExpr::GetDefByBBMeStmt(Dominance &dominance, MeStmtPtr &defMeStmt) { } bool VarMeExpr::IsUseSameSymbol(const MeExpr &expr) const { - auto *varMeExpr = dynamic_cast(&expr); - if (varMeExpr == nullptr) { + if (expr.GetMeOp() != kMeOpVar) { return false; } - return ostIdx == varMeExpr->ostIdx; + auto &varMeExpr = static_cast(expr); + return ostIdx == varMeExpr.ostIdx; } bool VarMeExpr::IsPureLocal(SSATab &tab, const MIRFunction &irFunc) const { @@ -400,11 +399,11 @@ bool VarMeExpr::IsZeroVersion(SSATab &ssatab) const { } bool RegMeExpr::IsUseSameSymbol(const MeExpr &expr) const { - auto *regMeExpr = dynamic_cast(&expr); - if (regMeExpr == nullptr) { + if (expr.GetMeOp() != kMeOpReg) { return false; } - return ostIdx == regMeExpr->ostIdx; + auto ®MeExpr = static_cast(expr); + return ostIdx == regMeExpr.ostIdx; } BB *RegMeExpr::DefByBB() { @@ -428,31 +427,31 @@ BB *RegMeExpr::DefByBB() { } bool AddrofMeExpr::IsUseSameSymbol(const MeExpr &expr) const { - auto *varMeExpr = dynamic_cast(&expr); - if (varMeExpr == nullptr) { + if (expr.GetMeOp() != kMeOpAddrof) { return false; } - return ostIdx == varMeExpr->ostIdx; + const auto &varMeExpr = static_cast(expr); + return ostIdx == varMeExpr.ostIdx; } bool OpMeExpr::IsUseSameSymbol(const MeExpr &expr) const { if (expr.GetOp() != GetOp()) { return false; } - auto *opmeexpr = dynamic_cast(&expr); - if (opmeexpr == nullptr) { + if (expr.GetMeOp() != kMeOpOp) { return false; } + auto &opMeExpr = static_cast(expr); for (uint32 i = 0; i < kOpndNumOfOpMeExpr; i++) { if (opnds[i]) { - if (!opmeexpr->opnds[i]) { + if (!opMeExpr.opnds[i]) { return false; } - if (!opnds[i]->IsUseSameSymbol(*opmeexpr->opnds[i])) { + if (!opnds[i]->IsUseSameSymbol(*opMeExpr.opnds[i])) { return false; } } else { - if (opmeexpr->opnds[i]) { + if (opMeExpr.opnds[i]) { return false; } } @@ -671,7 +670,6 @@ void NaryMeExpr::Dump(IRMap *irMap, int32 indent) const { MeExpr *DassignMeStmt::GetLHSRef(SSATab &ssatab, bool excludelocalrefvar) { VarMeExpr *l = GetVarLHS(); - ASSERT(l != nullptr, "null ptr check"); if (l->GetPrimType() != PTY_ref) { return nullptr; } @@ -687,7 +685,6 @@ MeExpr *DassignMeStmt::GetLHSRef(SSATab &ssatab, bool excludelocalrefvar) { MeExpr *MaydassignMeStmt::GetLHSRef(SSATab &ssatab, bool excludelocalrefvar) { VarMeExpr *l = GetVarLHS(); - ASSERT(l != nullptr, "null ptr check"); if (l->GetPrimType() != PTY_ref) { return nullptr; } @@ -707,7 +704,7 @@ MeExpr *IassignMeStmt::GetLHSRef(SSATab &ssatab, bool excludelocalrefvar) { MIRType *ptype = static_cast(baseType)->GetPointedType(); MIRStructType *structType = dynamic_cast(ptype); if (structType == nullptr) { - if (dynamic_cast(ptype)) { + if (ptype->GetKind() == kTypePointer) { if (lhsVar->GetFieldID() == 0) { if (static_cast(ptype)->GetPrimType() != PTY_ref) { return nullptr; @@ -743,10 +740,10 @@ VarMeExpr *AssignedPart::GetAssignedPartLHSRef(SSATab &ssatab, bool excludelocal return nullptr; } MeExpr *assignedLHS = mustDefList.front().GetLHS(); - auto *theLHS = dynamic_cast(assignedLHS); - if (theLHS == nullptr) { + if (assignedLHS->GetMeOp() != kMeOpVar) { return nullptr; } + auto *theLHS = static_cast(assignedLHS); if (theLHS->GetPrimType() != PTY_ref) { return nullptr; } @@ -835,20 +832,20 @@ void ChiMeNode::Dump(IRMap *irMap) const { LogInfo::MapleLogger() << "mx" << merhs->GetExprID() << "}"; } -void DumpMuList(IRMap *irMap, const MapleMap &mulist, int32 indent) { - if (mulist.empty()) { +void DumpMuList(IRMap *irMap, const MapleMap &muList, int32 indent) { + if (muList.empty()) { return; } int count = 0; LogInfo::MapleLogger() << "---- MULIST: { "; - for (auto it = mulist.begin();;) { + for (auto it = muList.begin();;) { if (!DumpOptions::GetSimpleDump()) { (*it).second->Dump(irMap); } else { LogInfo::MapleLogger() << "mx" << (*it).second->GetExprID(); } it++; - if (it == mulist.end()) { + if (it == muList.end()) { break; } else { LogInfo::MapleLogger() << ", "; @@ -861,16 +858,16 @@ void DumpMuList(IRMap *irMap, const MapleMap &mulist, int32 LogInfo::MapleLogger() << " }\n"; } -void DumpChiList(IRMap *irMap, const MapleMap &chilist) { - if (chilist.empty()) { +void DumpChiList(IRMap *irMap, const MapleMap &chiList) { + if (chiList.empty()) { return; } int count = 0; LogInfo::MapleLogger() << "---- CHILIST: { "; - for (auto it = chilist.begin();;) { + for (auto it = chiList.begin();;) { it->second->Dump(irMap); it++; - if (it == chilist.end()) { + if (it == chiList.end()) { break; } else { LogInfo::MapleLogger() << ", "; @@ -1185,38 +1182,37 @@ bool MeExpr::PointsToSomethingThatNeedsIncRef() { return false; } -MapleMap *GenericGetChiListFromVarMeExprInner(VarMeExpr *expr, +MapleMap *GenericGetChiListFromVarMeExprInner(VarMeExpr &expr, std::unordered_set &visited) { - if (expr == nullptr || expr->GetDefBy() == kDefByNo || visited.find(expr) != visited.end()) { + if (expr.GetDefBy() == kDefByNo || visited.find(&expr) != visited.end()) { return nullptr; } - visited.insert(expr); - if (expr->GetDefBy() == kDefByPhi) { - MeVarPhiNode &phime = expr->GetDefPhi(); + visited.insert(&expr); + if (expr.GetDefBy() == kDefByPhi) { + MeVarPhiNode &phime = expr.GetDefPhi(); MapleVector &phiopnds = phime.GetOpnds(); for (auto it = phiopnds.begin(); it != phiopnds.end(); it++) { VarMeExpr *meexpr = *it; - MapleMap *chiList = GenericGetChiListFromVarMeExprInner(meexpr, visited); + MapleMap *chiList = GenericGetChiListFromVarMeExprInner(*meexpr, visited); if (chiList != nullptr) { return chiList; } } - } else if (expr->GetDefBy() == kDefByChi) { - return expr->GetDefChi().GetBase()->GetChiList(); + } else if (expr.GetDefBy() == kDefByChi) { + return expr.GetDefChi().GetBase()->GetChiList(); } else { - // NYI + // not yet implemented return nullptr; } return nullptr; } -MapleMap *GenericGetChiListFromVarMeExpr(VarMeExpr *expr) { +MapleMap *GenericGetChiListFromVarMeExpr(VarMeExpr &expr) { std::unordered_set visited; return GenericGetChiListFromVarMeExprInner(expr, visited); } -void MeStmt::SetCallReturn(MeExpr &curexpr) { - ASSERT(GetMustDefList() != nullptr, "null ptr check"); +void CallMeStmt::SetCallReturn(MeExpr &curexpr) { MustDefMeNode &mustDefMeNode = GetMustDefList()->front(); mustDefMeNode.UpdateLHS(curexpr); } diff --git a/src/maple_me/src/me_irmap.cpp b/src/maple_me/src/me_irmap.cpp index 80a6a3b14236f7f2cd7bf34cf91d5109fb6a8713..fc0f573a9afa2d1c2c5b8abfa3143d25f255d644 100644 --- a/src/maple_me/src/me_irmap.cpp +++ b/src/maple_me/src/me_irmap.cpp @@ -89,19 +89,19 @@ void MeIRMap::EmitBB(BB &bb, BlockNode &curblk) { AnalysisResult *MeDoIRMap::Run(MeFunction *func, MeFuncResultMgr *m, ModuleResultMgr *mrm) { Dominance *dom = static_cast(m->GetAnalysisResult(MeFuncPhase_DOMINANCE, func)); - ASSERT(dom, "dominance phase has problem"); + ASSERT(dom != nullptr, "dominance phase has problem"); MemPool *irMapMemPool = NewMemPool(); - MeIRMap *irmap = irMapMemPool->New(*func, *dom, *irMapMemPool, *NewMemPool()); - func->SetIRMap(irmap); + MeIRMap *irMap = irMapMemPool->New(*func, *dom, *irMapMemPool, *NewMemPool()); + func->SetIRMap(irMap); #if DEBUG - g_irmap = irmap; + g_irmap = irMap; #endif std::vector bbIRMapProcessed(func->NumBBs(), false); - irmap->BuildBB(*func->GetCommonEntryBB(), bbIRMapProcessed); + irMap->BuildBB(*func->GetCommonEntryBB(), bbIRMapProcessed); if (DEBUGFUNC(func)) { - irmap->Dump(); + irMap->Dump(); } - irmap->GetTempAlloc().SetMemPool(nullptr); + irMap->GetTempAlloc().SetMemPool(nullptr); // delete input IR code for current function MIRFunction *mirFunc = func->GetMirFunc(); mempoolctrler.DeleteMemPool(mirFunc->GetCodeMempool()); @@ -122,6 +122,6 @@ AnalysisResult *MeDoIRMap::Run(MeFunction *func, MeFuncResultMgr *m, ModuleResul } #endif mempoolctrler.DeleteMemPool(func->GetMeSSATab()->GetVersionStTable().GetVSTAlloc().GetMemPool()); - return irmap; + return irMap; } } // namespace maple diff --git a/src/maple_me/src/me_phase_manager.cpp b/src/maple_me/src/me_phase_manager.cpp index 98e85a03af5a08c53c09ad03ee973d7624cc729d..ef22e8e4fb463537c63df768d73e353f473d8d20 100644 --- a/src/maple_me/src/me_phase_manager.cpp +++ b/src/maple_me/src/me_phase_manager.cpp @@ -33,14 +33,12 @@ namespace maple { void MeFuncPhaseManager::RunFuncPhase(MeFunction *func, MeFuncPhase *phase) { - { - // 1. check options.enable(phase.id()) - // 2. options.tracebeforePhase(phase.id()) dumpIR before - if (!MeOption::quiet) { - LogInfo::MapleLogger() << "---Run Phase [ " << phase->PhaseName() << " ]---\n"; - } - // 3. tracetime(phase.id()) + // 1. check options.enable(phase.id()) + // 2. options.tracebeforePhase(phase.id()) dumpIR before + if (!MeOption::quiet) { + LogInfo::MapleLogger() << "---Run Phase [ " << phase->PhaseName() << " ]---\n"; } + // 3. tracetime(phase.id()) // 4. run: skip mplme phase except "emit" if no cfg in MeFunction AnalysisResult *r = nullptr; MePhaseID phaseID = phase->GetPhaseId(); @@ -74,14 +72,14 @@ void MeFuncPhaseManager::RegisterFuncPhases() { #undef FUNCAPHASE } -void MeFuncPhaseManager::AddPhasesNoDefault(std::vector &phases) { +void MeFuncPhaseManager::AddPhasesNoDefault(const std::vector &phases) { for (size_t i = 0; i < phases.size(); i++) { PhaseManager::AddPhase(phases[i].c_str()); } ASSERT(phases.size() == GetPhaseSequence()->size(), "invalid phase name"); } -void MeFuncPhaseManager::AddPhases(std::unordered_set &skipPhases) { +void MeFuncPhaseManager::AddPhases(const std::unordered_set &skipPhases) { auto addPhase = [&](const std::string &phase) { std::unordered_set::const_iterator it = skipPhases.find(phase); if (it == skipPhases.end()) { @@ -111,21 +109,21 @@ void MeFuncPhaseManager::IPACleanUp(MeFunction *func) { mempoolctrler.DeleteMemPool(func->GetMemPool()); } -void MeFuncPhaseManager::Run(MIRFunction *mirfunc, uint64 rangenum, const std::string &meinput) { +void MeFuncPhaseManager::Run(MIRFunction *mirFunc, uint64 rangeNum, const std::string &meInput) { if (!MeOption::quiet) - LogInfo::MapleLogger() << ">>>>>>>>>>>>>>>>>>>>>>>>>>>>> Optimizing Function < " << mirfunc->GetName() - << " id=" << mirfunc->GetPuidxOrigin() << " >---\n"; + LogInfo::MapleLogger() << ">>>>>>>>>>>>>>>>>>>>>>>>>>>>> Optimizing Function < " << mirFunc->GetName() + << " id=" << mirFunc->GetPuidxOrigin() << " >---\n"; MemPool *funcMP = mempoolctrler.NewMemPool("maple_me per-function mempool"); MemPool *versMP = mempoolctrler.NewMemPool("first verst mempool"); - MeFunction func(&mirModule, mirfunc, funcMP, versMP, meinput); + MeFunction func(&mirModule, mirFunc, funcMP, versMP, meInput); func.PartialInit(false); #if DEBUG g_mirmodule = &mirModule; g_func = &func; #endif - func.Prepare(rangenum); + func.Prepare(rangeNum); if (ipa) { - mirfunc->SetMeFunc(&func); + mirFunc->SetMeFunc(&func); } std::string phaseName = ""; MeFuncPhase *changeCFGPhase = nullptr; @@ -167,9 +165,9 @@ void MeFuncPhaseManager::Run(MIRFunction *mirfunc, uint64 rangenum, const std::s } // do all the phases start over MemPool *versMemPool = mempoolctrler.NewMemPool("second verst mempool"); - MeFunction function(&mirModule, mirfunc, funcMP, versMemPool, meinput); + MeFunction function(&mirModule, mirFunc, funcMP, versMemPool, meInput); function.PartialInit(true); - function.Prepare(rangenum); + function.Prepare(rangeNum); for (auto it = PhaseSequenceBegin(); it != PhaseSequenceEnd(); it++) { PhaseID id = GetPhaseId(it); MeFuncPhase *p = static_cast(GetPhase(id)); diff --git a/src/maple_me/src/me_rc_lowering.cpp b/src/maple_me/src/me_rc_lowering.cpp index 81df30d771308319f937dafb72c5daf13a936e36..0ade9fbfa94634159e7b1af1a7809585b7c1bd60 100644 --- a/src/maple_me/src/me_rc_lowering.cpp +++ b/src/maple_me/src/me_rc_lowering.cpp @@ -35,15 +35,22 @@ static inline void CheckRemove(MeStmt *stmt, const Opcode op) { } void RCLowering::Prepare() { - MIRFunction *mirfunction = func.GetMirFunc(); - ASSERT(mirfunction->GetModule()->CurFunction() == mirfunction, "unexpected CurFunction"); + MIRFunction *mirFunction = func.GetMirFunc(); + ASSERT(mirFunction->GetModule()->CurFunction() == mirFunction, "unexpected CurFunction"); if (DEBUGFUNC((&func))) { - LogInfo::MapleLogger() << "Handling function " << mirfunction->GetName() << std::endl; + LogInfo::MapleLogger() << "Handling function " << mirFunction->GetName() << std::endl; } } void RCLowering::PreRCLower() { // preparation steps before going through basicblocks + MarkLocalRefVar(); + + MarkAllRefOpnds(); + CreateCleanupIntrinsics(); +} + +void RCLowering::MarkLocalRefVar() { MIRFunction *mirfunction = func.GetMirFunc(); size_t bsize = mirfunction->GetSymTab()->GetSymbolTableSize(); for (size_t i = 0; i < bsize; ++i) { @@ -52,7 +59,9 @@ void RCLowering::PreRCLower() { sym->SetLocalRefVar(); } } +} +void RCLowering::MarkAllRefOpnds() { auto eIt = func.valid_end(); for (auto bIt = func.valid_begin(); bIt != eIt; ++bIt) { for (auto &stmt : (*bIt)->GetMeStmts()) { @@ -63,7 +72,7 @@ void RCLowering::PreRCLower() { if (lhsRef->GetMeOp() == kMeOpVar) { VarMeExpr *var = static_cast(lhsRef); cleanUpVars[var->GetOStIdx()] = var; - ssaTab.UpdateVarOstMap(var->GetOStIdx(), varOstMap); + ssaTab.UpdateVarOstMap(var->GetOStIdx(), varOStMap); } stmt.EnableNeedDecref(); MeExpr *rhs = stmt.GetRHS(); @@ -77,7 +86,6 @@ void RCLowering::PreRCLower() { } } } - CreateCleanupIntrinsics(); } void RCLowering::CreateCleanupIntrinsics() { @@ -88,7 +96,7 @@ void RCLowering::CreateCleanupIntrinsics() { } std::vector opnds; for (auto item : cleanUpVars) { - if (!varOstMap[item.first]->IsLocal() || varOstMap[item.first]->IsFormal()) { + if (!varOStMap[item.first]->IsLocal() || varOStMap[item.first]->IsFormal()) { continue; } opnds.push_back(item.second); @@ -100,12 +108,12 @@ void RCLowering::CreateCleanupIntrinsics() { // move to MeFunction::CreateVarMeExprFromSym as func has ssaTab and irMap VarMeExpr *RCLowering::CreateVarMeExprFromSym(MIRSymbol &sym) const { - OriginalSt *ost = ssaTab.FindOrCreateSymbolOriginalSt(&sym, func.GetMirFunc()->GetPuidx(), 0); + OriginalSt *ost = ssaTab.FindOrCreateSymbolOriginalSt(sym, func.GetMirFunc()->GetPuidx(), 0); return irMap.GetOrCreateZeroVersionVarMeExpr(*ost); } // note that RCInstrinsic creation will check the ref assignment and reuse lhs if possible -IntrinsiccallMeStmt *RCLowering::CreateRCIntrinsic(MIRIntrinsicID intrnID, MeStmt &stmt, std::vector opnds, +IntrinsiccallMeStmt *RCLowering::CreateRCIntrinsic(MIRIntrinsicID intrnID, MeStmt &stmt, std::vector &opnds, bool assigned) { IntrinsiccallMeStmt *intrn = nullptr; if (assigned) { @@ -137,9 +145,8 @@ IntrinsiccallMeStmt *RCLowering::GetVarRHSHandleStmt(MeStmt &stmt) { } // load global into temp and update rhs to temp std::vector opnds; - MIRIntrinsicID rcCallID = INTRN_UNDEFINED; bool isVolatile = var->IsVolatile(ssaTab); - rcCallID = isVolatile ? PrepareVolatileCall(stmt, INTRN_MCCLoadRefSVol) : INTRN_MCCLoadRefS; + MIRIntrinsicID rcCallID = isVolatile ? PrepareVolatileCall(stmt, INTRN_MCCLoadRefSVol) : INTRN_MCCLoadRefS; opnds.push_back(irMap.CreateAddrofMeExpr(*var)); // rhs is not special, skip if (rcCallID == INTRN_UNDEFINED) { @@ -156,8 +163,7 @@ IntrinsiccallMeStmt *RCLowering::GetIvarRHSHandleStmt(MeStmt &stmt) { } // load global into temp and update rhs to temp std::vector opnds; - MIRIntrinsicID rcCallId = INTRN_UNDEFINED; - rcCallId = ivar->IsVolatile() ? PrepareVolatileCall(stmt, INTRN_MCCLoadRefVol) : INTRN_MCCLoadRef; + MIRIntrinsicID rcCallId = ivar->IsVolatile() ? PrepareVolatileCall(stmt, INTRN_MCCLoadRefVol) : INTRN_MCCLoadRef; opnds.push_back(&ivar->GetBase()->GetAddrExprBase()); opnds.push_back(irMap.CreateAddrofMeExpr(*ivar)); // rhs is not special, skip @@ -174,7 +180,7 @@ void RCLowering::HandleAssignMeStmtRHS(MeStmt &stmt) { return; } MeExpr *rhs = stmt.GetRHS(); - ASSERT(rhs != nullptr, "rhs is nullptr in RCLowering::HandleAssignMeStmtRHS"); + CHECK_FATAL(rhs != nullptr, "rhs is nullptr in RCLowering::HandleAssignMeStmtRHS"); IntrinsiccallMeStmt *loadCall = nullptr; std::vector opnds; if (rhs->GetMeOp() == kMeOpVar) { @@ -207,11 +213,7 @@ void RCLowering::HandleCallAssignedMeStmt(MeStmt &stmt, MeExpr *pendingDec) { CHECK_FATAL(bb != nullptr, "bb null ptr check"); if (mustDefs->empty()) { // introduce a ret and decref on it as callee has +1 return ref - RegMeExpr *curTmp = irMap.CreateRegMeExpr(PTY_ref); - stmt.GetMustDefList()->push_back(MustDefMeNode(curTmp, &stmt)); - IntrinsiccallMeStmt *decrefCall = CreateRCIntrinsic(INTRN_MCCDecRef, stmt, std::vector({ curTmp })); - decrefCall->GetOriExprInRcLowering().push_back(curTmp); - bb->InsertMeStmtAfter(&stmt, decrefCall); + IntroduceRegRetIntoCallAssigned(stmt); return; } @@ -233,24 +235,38 @@ void RCLowering::HandleCallAssignedMeStmt(MeStmt &stmt, MeExpr *pendingDec) { return; } - MeStmt *backup = irMap.CreateRegassignMeStmt(*irMap.CreateRegMeExpr(PTY_ref), *pendingDec, *bb); - IntrinsiccallMeStmt *decrefCall = CreateRCIntrinsic( - INTRN_MCCDecRef, stmt, std::vector({ static_cast(backup)->GetRegLHS() })); + CHECK_FATAL(pendingDec != nullptr, "pendingDec null ptr check"); + HandleRetOfCallAssignedMeStmt(stmt, *pendingDec); +} + +void RCLowering::IntroduceRegRetIntoCallAssigned(MeStmt &stmt) { + RegMeExpr *curTmp = irMap.CreateRegMeExpr(PTY_ref); + stmt.GetMustDefList()->push_back(MustDefMeNode(curTmp, &stmt)); + std::vector opnds = { curTmp }; + IntrinsiccallMeStmt *decrefCall = CreateRCIntrinsic(INTRN_MCCDecRef, stmt, opnds); + decrefCall->GetOriExprInRcLowering().push_back(curTmp); + stmt.GetBB()->InsertMeStmtAfter(&stmt, decrefCall); +} + +void RCLowering::HandleRetOfCallAssignedMeStmt(MeStmt &stmt, MeExpr &pendingDec) { + BB *bb = stmt.GetBB(); + CHECK_FATAL(bb != nullptr, "bb null ptr check"); + RegassignMeStmt *backup = irMap.CreateRegassignMeStmt(*irMap.CreateRegMeExpr(PTY_ref), pendingDec, *bb); + std::vector opnds = { backup->GetRegLHS() }; + IntrinsiccallMeStmt *decrefCall = CreateRCIntrinsic(INTRN_MCCDecRef, stmt, opnds); decrefCall->GetOriExprInRcLowering().push_back(backup->GetRegLHS()); if (!dynamic_cast(&stmt)) { bb->InsertMeStmtBefore(&stmt, backup); bb->InsertMeStmtAfter(&stmt, decrefCall); } else { - /** + /* * simple optimization for callassign * instead of change callassign {dassign} to backup; callassign {dassign}; decref * callassign {regassign}; backup; dassign (regread); decref */ - CallMeStmt &callStmt = static_cast(stmt); RegMeExpr *curTmp = irMap.CreateRegMeExpr(PTY_ref); - MeStmt *regToVar = irMap.CreateDassignMeStmt(*lhs, *curTmp, *bb); - ASSERT(!callStmt.GetMustDefList()->empty(), "container check"); - callStmt.GetMustDefList()->front().UpdateLHS(*curTmp); + MeStmt *regToVar = irMap.CreateDassignMeStmt(*stmt.GetAssignedLHS(), *curTmp, *bb); + stmt.GetMustDefList()->front().UpdateLHS(*curTmp); bb->InsertMeStmtAfter(&stmt, decrefCall); bb->InsertMeStmtAfter(&stmt, regToVar); bb->InsertMeStmtAfter(&stmt, backup); @@ -292,7 +308,7 @@ void RCLowering::PreprocessAssignMeStmt(MeStmt &stmt) { } gcMallocObjects.insert(lhs); if (lsym->GetAttr(ATTR_rcunowned)) { - /** + /* * if new obj is assigned to unowned refvar, we need a localrefvar * to decref at exit * introduce new localrefvar = lhs after current stmt @@ -307,56 +323,75 @@ void RCLowering::HandleAssignMeStmtRegLHS(MeStmt &stmt) { if (!stmt.NeedIncref()) { return; } - IntrinsiccallMeStmt *incCall = CreateRCIntrinsic(INTRN_MCCIncRef, stmt, std::vector({ stmt.GetLHS() })); + std::vector opnds = { stmt.GetLHS() }; + IntrinsiccallMeStmt *incCall = CreateRCIntrinsic(INTRN_MCCIncRef, stmt, opnds); incCall->GetOriExprInRcLowering().push_back(stmt.GetLHS()); stmt.GetBB()->InsertMeStmtAfter(&stmt, incCall); } void RCLowering::HandleAssignMeStmtVarLHS(MeStmt &stmt, MeExpr *pendingDec) { MIRSymbol *lsym = ssaTab.GetMIRSymbolFromID(stmt.GetVarLHS()->GetOStIdx()); + if (lsym->IsGlobal()) { + // decref could be optimized away after if null check + HandleAssignToGlobalVar(stmt); + } else { + // local assign, backup old value and insert Inc and Dec after + HandleAssignToLocalVar(stmt, pendingDec); + } + assignedPtrSym.insert(lsym); +} + +void RCLowering::HandleAssignToGlobalVar(MeStmt &stmt) { MeExpr *lhs = stmt.GetLHS(); CHECK_FATAL(lhs != nullptr, "null ptr check"); MeExpr *rhs = stmt.GetRHS(); CHECK_FATAL(rhs != nullptr, "null ptr check"); - bool incWithLHS = stmt.NeedIncref(); - bool decWithLHS = stmt.NeedDecref(); - bool incDecFirst = RCFirst(*rhs); BB *bb = stmt.GetBB(); - if (lsym->IsGlobal()) { - // decref could be optimized away after if null check - IntrinsiccallMeStmt *writeRefCall = CreateRCIntrinsic(SelectWriteBarrier(stmt), stmt, - std::vector({irMap.CreateAddrofMeExpr(*lhs), rhs})); - writeRefCall->GetOriExprInRcLowering().push_back(lhs); - bb->ReplaceMeStmt(&stmt, writeRefCall); - } else { - // local assign, backup old value and insert Inc and Dec after - if (decWithLHS) { - if (incDecFirst) { - // temp is not needed - if (incWithLHS) { - MeStmt *incCall = CreateRCIntrinsic(INTRN_MCCIncRef, stmt, std::vector({ rhs })); - bb->InsertMeStmtBefore(&stmt, incCall); - incWithLHS = false; - } - IntrinsiccallMeStmt *decCall = CreateRCIntrinsic(INTRN_MCCDecRef, stmt, std::vector({ pendingDec })); - decCall->GetOriExprInRcLowering().push_back(pendingDec); - bb->InsertMeStmtBefore(&stmt, decCall); - } else { - MeStmt *backup = irMap.CreateRegassignMeStmt(*irMap.CreateRegMeExpr(PTY_ref), *pendingDec, *bb); - bb->InsertMeStmtBefore(&stmt, backup); - IntrinsiccallMeStmt *decCall = CreateRCIntrinsic(INTRN_MCCDecRef, stmt, - std::vector({ static_cast(backup)->GetLHS() })); - decCall->GetOriExprInRcLowering().push_back(backup->GetLHS()); - bb->InsertMeStmtAfter(&stmt, decCall); + CHECK_FATAL(bb != nullptr, "bb null ptr check"); + + std::vector opnds = { irMap.CreateAddrofMeExpr(*lhs), rhs }; + IntrinsiccallMeStmt *writeRefCall = CreateRCIntrinsic(SelectWriteBarrier(stmt), stmt, opnds); + writeRefCall->GetOriExprInRcLowering().push_back(lhs); + bb->ReplaceMeStmt(&stmt, writeRefCall); +} + +void RCLowering::HandleAssignToLocalVar(MeStmt &stmt, MeExpr *pendingDec) { + MeExpr *lhs = stmt.GetLHS(); + CHECK_FATAL(lhs != nullptr, "null ptr check"); + MeExpr *rhs = stmt.GetRHS(); + CHECK_FATAL(rhs != nullptr, "null ptr check"); + BB *bb = stmt.GetBB(); + CHECK_FATAL(bb != nullptr, "bb null ptr check"); + bool incWithLHS = stmt.NeedIncref(); + + if (stmt.NeedDecref()) { + if (RCFirst(*rhs)) { + // temp is not needed + if (incWithLHS) { + std::vector opnds = { rhs }; + IntrinsiccallMeStmt *incCall = CreateRCIntrinsic(INTRN_MCCIncRef, stmt, opnds); + bb->InsertMeStmtBefore(&stmt, incCall); + incWithLHS = false; } - } - if (incWithLHS) { - IntrinsiccallMeStmt *incCall = CreateRCIntrinsic(INTRN_MCCIncRef, stmt, std::vector({ lhs })); - incCall->GetOriExprInRcLowering().push_back(lhs); - bb->InsertMeStmtAfter(&stmt, incCall); + std::vector opnds = { pendingDec }; + IntrinsiccallMeStmt *decCall = CreateRCIntrinsic(INTRN_MCCDecRef, stmt, opnds); + decCall->GetOriExprInRcLowering().push_back(pendingDec); + bb->InsertMeStmtBefore(&stmt, decCall); + } else { + RegassignMeStmt *backup = irMap.CreateRegassignMeStmt(*irMap.CreateRegMeExpr(PTY_ref), *pendingDec, *bb); + bb->InsertMeStmtBefore(&stmt, backup); + std::vector opnds = { backup->GetLHS() }; + IntrinsiccallMeStmt *decCall = CreateRCIntrinsic(INTRN_MCCDecRef, stmt, opnds); + decCall->GetOriExprInRcLowering().push_back(backup->GetLHS()); + bb->InsertMeStmtAfter(&stmt, decCall); } } - assignedPtrSym.insert(lsym); + if (incWithLHS) { + std::vector opnds = { lhs }; + IntrinsiccallMeStmt *incCall = CreateRCIntrinsic(INTRN_MCCIncRef, stmt, opnds); + incCall->GetOriExprInRcLowering().push_back(lhs); + bb->InsertMeStmtAfter(&stmt, incCall); + } } bool RCLowering::IsInitialized(IvarMeExpr &ivar) { @@ -402,9 +437,9 @@ void RCLowering::HandleAssignMeStmtIvarLHS(MeStmt &stmt) { } MeExpr *rhsInner = stmt.GetRHS(); MIRIntrinsicID intrinsicID = SelectWriteBarrier(stmt); - IntrinsiccallMeStmt *writeRefCall = CreateRCIntrinsic( - intrinsicID, stmt, - std::vector({ &lhsInner->GetBase()->GetAddrExprBase(), irMap.CreateAddrofMeExpr(*lhsInner), rhsInner })); + std::vector opnds = + { &lhsInner->GetBase()->GetAddrExprBase(), irMap.CreateAddrofMeExpr(*lhsInner), rhsInner }; + IntrinsiccallMeStmt *writeRefCall = CreateRCIntrinsic(intrinsicID, stmt, opnds); writeRefCall->GetOriExprInRcLowering().push_back(lhsInner); stmt.GetBB()->ReplaceMeStmt(&stmt, writeRefCall); } @@ -426,7 +461,7 @@ void RCLowering::HandleAssignMeStmt(MeStmt &stmt, MeExpr *pendingDec) { } } -/** +/* * align with order in rcinsertion, otherwise missing weak volatile * note that we are generating INTRN_MCCWriteNoRC so write_barrier is supported, * otherwise iassign would be enough. @@ -441,7 +476,7 @@ MIRIntrinsicID RCLowering::SelectWriteBarrier(MeStmt &stmt) { if (lhs->IsVolatile(ssaTab)) { if (meOp == kMeOpVar) { return PrepareVolatileCall(stmt, incWithLHS ? (decWithLHS ? INTRN_MCCWriteSVol : INTRN_MCCWriteSVolNoDec) - : (decWithLHS ? INTRN_MCCWriteSVolNoInc : INTRN_MCCWriteSVolNoRC)); + : (decWithLHS ? INTRN_MCCWriteSVolNoInc : INTRN_MCCWriteSVolNoRC)); } else { if (static_cast(lhs)->IsRCWeak()) { return PrepareVolatileCall(stmt, INTRN_MCCWriteVolWeak); @@ -468,11 +503,11 @@ void RCLowering::RCLower() { if (bIt == func.common_entry() || bIt == func.common_exit()) { continue; } - BBLower(*bIt); + BBLower(**bIt); } } -/** +/* * if a var me expr is initialized by constructor, record it's initialized map * if a field id is not in initialized map, means the field has not been assigned a value * dec ref is not necessary in it's first assignment. @@ -500,12 +535,12 @@ void RCLowering::InitializedObjectFields(MeStmt &stmt) { } } -void RCLowering::BBLower(BB *bb) { +void RCLowering::BBLower(BB &bb) { MeExpr *pendingDec = nullptr; gcMallocObjects.clear(); initializedFields.clear(); - needSpecialHandleException = bb->GetAttributes(kBBAttrIsCatch); - for (auto &stmt : bb->GetMeStmts()) { + needSpecialHandleException = bb.GetAttributes(kBBAttrIsCatch); + for (auto &stmt : bb.GetMeStmts()) { pendingDec = stmt.GetLHSRef(ssaTab, false); Opcode opcode = stmt.GetOp(); if (opcode == OP_return) { @@ -530,11 +565,11 @@ void RCLowering::BBLower(BB *bb) { ost->SetTyIdx(GlobalTables::GetTypeTable().GetPrimType(PTY_ref)->GetTypeIndex()); RegMeExpr *regreadExpr = irMap.CreateRegMeExprVersion(*ost); regreadExpr->SetPtyp(PTY_ref); - MeStmt *firstMeStmt = to_ptr(bb->GetMeStmts().begin()); - IntrinsiccallMeStmt *decRefcall = CreateRCIntrinsic(INTRN_MCCDecRef, *firstMeStmt, - std::vector({ regreadExpr })); + MeStmt *firstMeStmt = to_ptr(bb.GetMeStmts().begin()); + std::vector opnds = { regreadExpr }; + IntrinsiccallMeStmt *decRefcall = CreateRCIntrinsic(INTRN_MCCDecRef, *firstMeStmt, opnds); decRefcall->GetOriExprInRcLowering().push_back(regreadExpr); - bb->InsertMeStmtAfter(firstMeStmt, decRefcall); + bb.InsertMeStmtAfter(firstMeStmt, decRefcall); } } @@ -559,85 +594,109 @@ void RCLowering::HandleReturnVar(RetMeStmt &ret) { return; } if (sym != nullptr && sym->IsGlobal() && !sym->IsFinal()) { - IntrinsiccallMeStmt *loadCall = - CreateRCIntrinsic(INTRN_MCCLoadRefS, ret, std::vector({ irMap.CreateAddrofMeExpr(*retVar) }), true); - loadCall->GetOriExprInRcLowering().push_back(retVar); - ret.GetBB()->InsertMeStmtBefore(&ret, loadCall); - ret.SetOpnd(0, loadCall->GetMustDefList()->front().GetLHS()); + HandleReturnGlobal(ret); } else if (assignedPtrSym.count(sym) > 0 && sym->GetStorageClass() == kScAuto && sym->GetAttr(ATTR_localrefvar)) { - /** + /* * must be regreadAtReturn * checking localrefvar because some objects are meta */ - IntrinsiccallMeStmt *cleanup = FindCleanupIntrinsic(ret); - if (cleanup == nullptr) { - IntrinsiccallMeStmt *incCall = CreateRCIntrinsic(INTRN_MCCIncRef, ret, std::vector({ retVar })); - incCall->GetOriExprInRcLowering().push_back(retVar); - ret.GetBB()->InsertMeStmtBefore(&ret, incCall); - } else { - // remove argument from intrinsiccall MPL_CLEANUP_LOCALREFVARS (dread ref %Reg1_R5678, ... - MapleVector *opnds = &cleanup->GetOpnds(); - for (auto iter = opnds->begin(); iter != opnds->end(); iter++) { - if (*iter == retVar || static_cast(*iter)->GetOStIdx() == retVar->GetOStIdx()) { - opnds->erase(iter); - opnds->push_back(retVar); // pin it to end of std::vector - cleanup->SetIntrinsic(INTRN_MPL_CLEANUP_LOCALREFVARS_SKIP); - break; - } - } - } + HandleReturnRegread(ret); } else { // if returning formal, incref unless placementRC is used and formal is NOT reassigned - IntrinsiccallMeStmt *increfStmt = CreateRCIntrinsic(INTRN_MCCIncRef, ret, std::vector({ retVar }), true); - ret.SetOpnd(0, increfStmt->GetMustDefList()->front().GetLHS()); - increfStmt->GetOriExprInRcLowering().push_back(retVar); - ret.SetOpnd(0, increfStmt->GetMustDefList()->front().GetLHS()); - IntrinsiccallMeStmt *cleanup = FindCleanupIntrinsic(ret); - if (cleanup == nullptr) { - ret.GetBB()->InsertMeStmtBefore(&ret, increfStmt); - } else { - ret.GetBB()->InsertMeStmtAfter(cleanup, increfStmt); + HandleReturnFormal(ret); + } +} + +void RCLowering::HandleReturnGlobal(RetMeStmt &ret) { + BB *bb = ret.GetBB(); + CHECK_FATAL(bb != nullptr, "bb null ptr check"); + VarMeExpr *retVar = static_cast(ret.GetOpnd(0)); + CHECK_FATAL(retVar != nullptr, "retVal null ptr check"); + std::vector opnds = { irMap.CreateAddrofMeExpr(*retVar) }; + IntrinsiccallMeStmt *loadCall = CreateRCIntrinsic(INTRN_MCCLoadRefS, ret, opnds, true); + loadCall->GetOriExprInRcLowering().push_back(retVar); + bb->InsertMeStmtBefore(&ret, loadCall); + ret.SetOpnd(0, loadCall->GetMustDefList()->front().GetLHS()); +} + +void RCLowering::HandleReturnRegread(RetMeStmt &ret) { + BB *bb = ret.GetBB(); + CHECK_FATAL(bb != nullptr, "bb null ptr check"); + VarMeExpr *retVar = static_cast(ret.GetOpnd(0)); + CHECK_FATAL(retVar != nullptr, "retVal null ptr check"); + IntrinsiccallMeStmt *cleanup = FindCleanupIntrinsic(ret); + if (cleanup == nullptr) { + std::vector opnds = { retVar }; + IntrinsiccallMeStmt *incCall = CreateRCIntrinsic(INTRN_MCCIncRef, ret, opnds); + incCall->GetOriExprInRcLowering().push_back(retVar); + bb->InsertMeStmtBefore(&ret, incCall); + } else { + // remove argument from intrinsiccall MPL_CLEANUP_LOCALREFVARS (dread ref %Reg1_R5678, ... + MapleVector *opnds = &cleanup->GetOpnds(); + for (auto iter = opnds->begin(); iter != opnds->end(); iter++) { + if (*iter == retVar || static_cast(*iter)->GetOStIdx() == retVar->GetOStIdx()) { + opnds->erase(iter); + opnds->push_back(retVar); // pin it to end of std::vector + cleanup->SetIntrinsic(INTRN_MPL_CLEANUP_LOCALREFVARS_SKIP); + break; + } } } } +void RCLowering::HandleReturnFormal(RetMeStmt &ret) { + BB *bb = ret.GetBB(); + CHECK_FATAL(bb != nullptr, "bb null ptr check"); + VarMeExpr *retVar = static_cast(ret.GetOpnd(0)); + CHECK_FATAL(retVar != nullptr, "retVal null ptr check"); + std::vector opnds = { retVar }; + IntrinsiccallMeStmt *increfStmt = CreateRCIntrinsic(INTRN_MCCIncRef, ret, opnds, true); + increfStmt->GetOriExprInRcLowering().push_back(retVar); + ret.SetOpnd(0, increfStmt->GetMustDefList()->front().GetLHS()); + IntrinsiccallMeStmt *cleanup = FindCleanupIntrinsic(ret); + if (cleanup == nullptr) { + bb->InsertMeStmtBefore(&ret, increfStmt); + } else { + bb->InsertMeStmtAfter(cleanup, increfStmt); + } +} + void RCLowering::HandleReturnIvar(RetMeStmt &ret) { // insert calls IvarMeExpr *retIvar = static_cast(ret.GetOpnd(0)); if (retIvar->IsVolatile()) { - IntrinsiccallMeStmt *loadCall = CreateRCIntrinsic( - PrepareVolatileCall(ret, INTRN_MCCLoadRefVol), ret, - std::vector({ &retIvar->GetBase()->GetAddrExprBase(), irMap.CreateAddrofMeExpr(*retIvar) }), true); + std::vector opnds = { &retIvar->GetBase()->GetAddrExprBase(), irMap.CreateAddrofMeExpr(*retIvar) }; + IntrinsiccallMeStmt *loadCall = CreateRCIntrinsic(PrepareVolatileCall(ret, INTRN_MCCLoadRefVol), ret, opnds, true); ret.GetBB()->InsertMeStmtBefore(&ret, loadCall); ret.SetOpnd(0, loadCall->GetMustDefList()->front().GetLHS()); loadCall->GetOriExprInRcLowering().push_back(retIvar); } else { - MeStmt *loadCall = CreateRCIntrinsic( - INTRN_MCCLoadRef, ret, - std::vector({ &retIvar->GetBase()->GetAddrExprBase(), irMap.CreateAddrofMeExpr(*retIvar) }), true); + std::vector opnds = { &retIvar->GetBase()->GetAddrExprBase(), irMap.CreateAddrofMeExpr(*retIvar) }; + MeStmt *loadCall = CreateRCIntrinsic(INTRN_MCCLoadRef, ret, opnds, true); ret.GetBB()->InsertMeStmtBefore(&ret, loadCall); ret.SetOpnd(0, loadCall->GetMustDefList()->front().GetLHS()); } } void RCLowering::HandleReturnReg(RetMeStmt &ret) { - /** + /* * if the register with ref value is defined by callassigned or gcmalloc * return incref should have been delegated and not needed. */ - RegMeExpr *retreg = static_cast(ret.GetOpnd(0)); - if (retreg->GetDefBy() == kDefByMustDef) { + RegMeExpr *regRet = static_cast(ret.GetOpnd(0)); + if (regRet->GetDefBy() == kDefByMustDef) { return; } - if (retreg->GetDefBy() == kDefByStmt && retreg->GetDefStmt()->GetOp() == OP_regassign) { - MeExpr *rhs = retreg->GetDefStmt()->GetRHS(); + if (regRet->GetDefBy() == kDefByStmt && regRet->GetDefStmt()->GetOp() == OP_regassign) { + MeExpr *rhs = regRet->GetDefStmt()->GetRHS(); ASSERT(rhs != nullptr, "null ptr check"); if (rhs->GetOp() == OP_gcmalloc || rhs->GetOp() == OP_gcmallocjarray) { return; } } - IntrinsiccallMeStmt *incCall = CreateRCIntrinsic(INTRN_MCCIncRef, ret, std::vector({ retreg }), true); - incCall->GetOriExprInRcLowering().push_back(retreg); + std::vector opnds = { regRet }; + IntrinsiccallMeStmt *incCall = CreateRCIntrinsic(INTRN_MCCIncRef, ret, opnds, true); + incCall->GetOriExprInRcLowering().push_back(regRet); ret.SetOpnd(0, incCall->GetMustDefList()->front().GetLHS()); ret.GetBB()->InsertMeStmtBefore(&ret, incCall); } @@ -668,9 +727,10 @@ void RCLowering::HandleReturnWithCleanup() { } else { // incref by default RegMeExpr *tmpReg = irMap.CreateRegMeExpr(PTY_ref); - MeStmt *temp = irMap.CreateRegassignMeStmt(*tmpReg, *retVal, *stmt->GetBB()); + RegassignMeStmt *temp = irMap.CreateRegassignMeStmt(*tmpReg, *retVal, *stmt->GetBB()); stmt->GetBB()->InsertMeStmtBefore(stmt, temp); - IntrinsiccallMeStmt *incCall = CreateRCIntrinsic(INTRN_MCCIncRef, *stmt, std::vector({ tmpReg })); + std::vector opnds = { tmpReg }; + IntrinsiccallMeStmt *incCall = CreateRCIntrinsic(INTRN_MCCIncRef, *stmt, opnds); incCall->GetOriExprInRcLowering().push_back(tmpReg); stmt->GetBB()->InsertMeStmtBefore(stmt, incCall); ret->SetOpnd(0, tmpReg); @@ -679,7 +739,7 @@ void RCLowering::HandleReturnWithCleanup() { } void RCLowering::HandleReturnNeedBackup() { - /** + /* * any return value expression containing ivar has to be saved in a * temp with the temp being returned */ @@ -710,7 +770,7 @@ void RCLowering::HandleReturnStmt() { } void RCLowering::HandleArguments() { - /** + /* * handle arguments, if the formal gets modified * insert incref at entry and decref before all returns */ @@ -726,7 +786,8 @@ void RCLowering::HandleArguments() { CHECK_FATAL(argVar != nullptr, "null ptr check"); IntrinsiccallMeStmt *incCall = nullptr; if (firstMestmt != nullptr) { - incCall = CreateRCIntrinsic(INTRN_MCCIncRef, *firstMestmt, std::vector({ argVar })); + std::vector opnds = { argVar }; + incCall = CreateRCIntrinsic(INTRN_MCCIncRef, *firstMestmt, opnds); incCall->GetOriExprInRcLowering().push_back(argVar); firstBB->InsertMeStmtBefore(firstMestmt, incCall); } @@ -736,7 +797,8 @@ void RCLowering::HandleArguments() { sym->SetLocalRefVar(); for (auto *stmt : rets) { - IntrinsiccallMeStmt *decrefCall = CreateRCIntrinsic(INTRN_MCCDecRef, *stmt, std::vector({ argVar })); + std::vector opnds = { argVar }; + IntrinsiccallMeStmt *decrefCall = CreateRCIntrinsic(INTRN_MCCDecRef, *stmt, opnds); decrefCall->GetOriExprInRcLowering().push_back(argVar); stmt->GetBB()->InsertMeStmtBefore(stmt, decrefCall); } @@ -763,7 +825,7 @@ OriginalSt *RCLowering::RetrieveOSt(const std::string &name, bool isLocalrefvar) if (isLocalrefvar) { backupSym->SetLocalRefVar(); } - OriginalSt *ost = ssaTab.FindOrCreateSymbolOriginalSt(backupSym, func.GetMirFunc()->GetPuidx(), 0); + OriginalSt *ost = ssaTab.FindOrCreateSymbolOriginalSt(*backupSym, func.GetMirFunc()->GetPuidx(), 0); return ost; } @@ -774,7 +836,7 @@ VarMeExpr *RCLowering::CreateNewTmpVarMeExpr(bool isLocalrefvar) { if (ost->GetZeroVersionIndex() == 0) { ost->SetZeroVersionIndex(irMap.GetVerst2MeExprTableSize()); irMap.PushBackVerst2MeExprTable(nullptr); - ost->GetVersionsIndex().push_back(ost->GetZeroVersionIndex()); + ost->PushbackVersionIndex(ost->GetZeroVersionIndex()); } irMap.SetExprID(irMap.GetExprID() + 1); VarMeExpr *varMeExpr = irMap.New(&irMap.GetIRMapAlloc(), irMap.GetExprID(), ost->GetIndex(), @@ -782,7 +844,7 @@ VarMeExpr *RCLowering::CreateNewTmpVarMeExpr(bool isLocalrefvar) { varMeExpr->InitBase(OP_dread, PTY_ref, 0); varMeExpr->SetFieldID(0); irMap.PushBackVerst2MeExprTable(varMeExpr); - ost->GetVersionsIndex().push_back(varMeExpr->GetVstIdx()); + ost->PushbackVersionIndex(varMeExpr->GetVstIdx()); if (isLocalrefvar) { tmpLocalRefVars.insert(varMeExpr); } diff --git a/src/maple_me/src/me_ssa.cpp b/src/maple_me/src/me_ssa.cpp index e56fed09a60b66f8ac6004fc83f593926d5d08ca..0d5e7f70e4a9e4adcd164c4ce919ad5c1994f393 100644 --- a/src/maple_me/src/me_ssa.cpp +++ b/src/maple_me/src/me_ssa.cpp @@ -49,12 +49,12 @@ namespace maple { void MeSSA::BuildSSA() { InsertPhiNode(); - InitRenameStack(&func->GetMeSSATab()->GetOriginalStTable(), func->GetAllBBs().size(), + InitRenameStack(func->GetMeSSATab()->GetOriginalStTable(), func->GetAllBBs().size(), func->GetMeSSATab()->GetVersionStTable()); // recurse down dominator tree in pre-order traversal const MapleSet &children = dom->GetDomChildren(func->GetCommonEntryBB()->GetBBId().idx); for (const BBId &child : children) { - RenameBB(func->GetBBFromID(child)); + RenameBB(*func->GetBBFromID(child)); } } @@ -63,10 +63,10 @@ void MeSSA::CollectDefBBs(std::map> &ostDefBBs) { for (auto bIt = func->valid_begin(); bIt != eIt; ++bIt) { auto *bb = *bIt; for (auto &stmt : bb->GetStmtNodes()) { - if (HasMayDefPart(&stmt)) { - MapleMap *mayDefs = SSAGenericGetMayDefNodes(&stmt, &GetSSATab()->GetStmtsSSAPart()); + if (HasMayDefPart(stmt)) { + MapleMap &mayDefs = SSAGenericGetMayDefNodes(stmt, GetSSATab()->GetStmtsSSAPart()); MapleMap::iterator iter; - for (iter = mayDefs->begin(); iter != mayDefs->end(); ++iter) { + for (iter = mayDefs.begin(); iter != mayDefs.end(); ++iter) { const OriginalSt *ost = func->GetMeSSATab()->GetOriginalStFromID(iter->first); if (ost && (!ost->IsFinal() || func->GetMirFunc()->IsConstructor())) { ostDefBBs[iter->first].insert(bb->GetBBId()); @@ -78,7 +78,7 @@ void MeSSA::CollectDefBBs(std::map> &ostDefBBs) { } } if (stmt.GetOpCode() == OP_dassign || stmt.GetOpCode() == OP_maydassign) { - VersionSt *vst = GetSSATab()->GetStmtsSSAPart().SSAPartOf(&stmt)->GetSSAVar(); + VersionSt *vst = GetSSATab()->GetStmtsSSAPart().SSAPartOf(stmt)->GetSSAVar(); OriginalSt *ost = vst->GetOrigSt(); if (ost && (!ost->IsFinal() || func->GetMirFunc()->IsConstructor())) { ostDefBBs[vst->GetOrigIdx()].insert(bb->GetBBId()); @@ -86,9 +86,9 @@ void MeSSA::CollectDefBBs(std::map> &ostDefBBs) { } } if (kOpcodeInfo.IsCallAssigned(stmt.GetOpCode())) { // Needs to handle mustDef in callassigned stmt - MapleVector *mustDefs = SSAGenericGetMustDefNode(&stmt, &GetSSATab()->GetStmtsSSAPart()); + MapleVector &mustDefs = SSAGenericGetMustDefNode(stmt, GetSSATab()->GetStmtsSSAPart()); MapleVector::iterator iter; - for (iter = mustDefs->begin(); iter != mustDefs->end(); ++iter) { + for (iter = mustDefs.begin(); iter != mustDefs.end(); ++iter) { OriginalSt *ost = iter->GetResult()->GetOrigSt(); if (ost && (!ost->IsFinal() || func->GetMirFunc()->IsConstructor())) { ostDefBBs[ost->GetIndex()].insert(bb->GetBBId()); @@ -106,7 +106,7 @@ void MeSSA::InsertPhiNode() { for (size_t i = 1; i < otable->Size(); i++) { const OriginalSt *ost = otable->GetOriginalStFromID(OStIdx(i)); VersionSt *vst = func->GetMeSSATab()->GetVersionStTable().GetVersionStFromID(ost->GetZeroVersionIndex(), true); - ASSERT(vst != nullptr, "null ptr check"); + CHECK_FATAL(vst != nullptr, "null ptr check"); if (ost2DefBBs[ost->GetIndex()].empty()) { continue; } @@ -115,8 +115,7 @@ void MeSSA::InsertPhiNode() { continue; } std::deque *workList = new std::deque(); - for (auto it = ost2DefBBs[ost->GetIndex()].begin(); it != ost2DefBBs[ost->GetIndex()].end(); - it++) { + for (auto it = ost2DefBBs[ost->GetIndex()].begin(); it != ost2DefBBs[ost->GetIndex()].end(); it++) { BB *defBb = func->GetAllBBs()[(*it).idx]; if (defBb != nullptr) { workList->push_back(defBb); @@ -129,7 +128,7 @@ void MeSSA::InsertPhiNode() { for (auto &bbID : dfs) { BB *dfBB = func->GetBBFromID(bbID); CHECK_FATAL(dfBB != nullptr, "null ptr check"); - if (!dfBB->PhiofVerStInserted(vst)) { + if (!dfBB->PhiofVerStInserted(*vst)) { workList->push_back(dfBB); dfBB->InsertPhi(&func->GetAlloc(), vst); if (DEBUGFUNC(func)) { @@ -147,12 +146,12 @@ void MeSSA::InsertPhiNode() { MeSSA::MeSSA(MeFunction *func, Dominance *dom, MemPool *memPool) : SSA(memPool, func->GetMeSSATab()), AnalysisResult(memPool), func(func), dom(dom) {} -void MeSSA::RenameBB(BB *bb) { - if (GetBBRenamed(bb->GetBBId().idx)) { +void MeSSA::RenameBB(BB &bb) { + if (GetBBRenamed(bb.GetBBId().idx)) { return; } - SetBBRenamed(bb->GetBBId().idx, true); + SetBBRenamed(bb.GetBBId().idx, true); // record stack size for variable versions before processing rename. It is used for stack pop up. std::vector oriStackSize; @@ -161,41 +160,41 @@ void MeSSA::RenameBB(BB *bb) { oriStackSize[i] = GetVstStack(i)->size(); } RenamePhi(bb); - for (auto &stmt : bb->GetStmtNodes()) { - RenameUses(&stmt); - RenameDefs(&stmt, bb); - RenameMustDefs(&stmt, bb); + for (auto &stmt : bb.GetStmtNodes()) { + RenameUses(stmt); + RenameDefs(stmt, bb); + RenameMustDefs(stmt, bb); } RenamePhiUseInSucc(bb); // Rename child in Dominator Tree. - ASSERT(bb->GetBBId().idx < dom->GetDomChildrenSize(), "index out of range in MeSSA::RenameBB"); - const MapleSet &children = dom->GetDomChildren(bb->GetBBId().idx); + ASSERT(bb.GetBBId().idx < dom->GetDomChildrenSize(), "index out of range in MeSSA::RenameBB"); + const MapleSet &children = dom->GetDomChildren(bb.GetBBId().idx); for (const BBId &child : children) { - RenameBB(func->GetBBFromID(child)); + RenameBB(*func->GetBBFromID(child)); } for (size_t i = 1; i < GetVstStacks().size(); i++) { while (GetVstStack(i)->size() > oriStackSize[i]) { - GetVstStack(i)->pop(); + PopVersionSt(i); } } } -bool MeSSA::VerifySSAOpnd(BaseNode *node) { - Opcode op = node->GetOpCode(); +bool MeSSA::VerifySSAOpnd(BaseNode &node) { + Opcode op = node.GetOpCode(); size_t vtableSize = func->GetMeSSATab()->GetVersionStTable().GetVersionStVectorSize(); if (op == OP_dread || op == OP_addrof) { - AddrofSSANode *addrofSSANode = static_cast(node); - VersionSt *verSt = addrofSSANode->GetSSAVar(); + AddrofSSANode &addrofSSANode = static_cast(node); + VersionSt *verSt = addrofSSANode.GetSSAVar(); CHECK_FATAL(verSt->GetIndex() < vtableSize, "runtime check error"); return true; } else if (op == OP_regread) { - RegreadSSANode *regNode = static_cast(node); - VersionSt *verSt = regNode->GetSSAVar(); + RegreadSSANode ®Node = static_cast(node); + VersionSt *verSt = regNode.GetSSAVar(); CHECK_FATAL(verSt->GetIndex() < vtableSize, "runtime check error"); return true; } - for (size_t i = 0; i < node->NumOpnds(); i++) { - VerifySSAOpnd(node->Opnd(i)); + for (size_t i = 0; i < node.NumOpnds(); i++) { + VerifySSAOpnd(*node.Opnd(i)); } return true; } @@ -213,11 +212,11 @@ bool MeSSA::VerifySSA() { for (auto &stmt : bb->GetStmtNodes()) { opcode = stmt.GetOpCode(); if (opcode == OP_dassign || opcode == OP_regassign) { - VersionSt *verSt = func->GetMeSSATab()->GetStmtsSSAPart().SSAPartOf(&stmt)->GetSSAVar(); + VersionSt *verSt = func->GetMeSSATab()->GetStmtsSSAPart().SSAPartOf(stmt)->GetSSAVar(); CHECK_FATAL(verSt != nullptr && verSt->GetIndex() < vtableSize, "runtime check error"); } for (size_t i = 0; i < stmt.NumOpnds(); i++) { - CHECK_FATAL(VerifySSAOpnd(stmt.Opnd(i)), "runtime check error"); + CHECK_FATAL(VerifySSAOpnd(*stmt.Opnd(i)), "runtime check error"); } } } diff --git a/src/maple_me/src/me_ssa_tab.cpp b/src/maple_me/src/me_ssa_tab.cpp index 08795ad6cdfe022f8d1711486267f37736d0b7fb..d2c177468ab15e187627ab7767eabcb66696443b 100644 --- a/src/maple_me/src/me_ssa_tab.cpp +++ b/src/maple_me/src/me_ssa_tab.cpp @@ -36,7 +36,7 @@ AnalysisResult *MeDoSSATab::Run(MeFunction *func, MeFuncResultMgr *m, ModuleResu for (auto bIt = func->valid_begin(); bIt != eIt; ++bIt) { auto *bb = *bIt; for (auto &stmt : bb->GetStmtNodes()) { - ssaTab->CreateSSAStmt(&stmt, bb); // this adds the SSANodes for exprs + ssaTab->CreateSSAStmt(stmt, *bb); // this adds the SSANodes for exprs } } if (DEBUGFUNC(func)) { diff --git a/src/maple_me/src/ssa.cpp b/src/maple_me/src/ssa.cpp index 0bfb21b77d332364b4d72e395644f978023b7848..636d76bfb3d329a93bee36ce152a3b4a853672ad 100644 --- a/src/maple_me/src/ssa.cpp +++ b/src/maple_me/src/ssa.cpp @@ -19,13 +19,13 @@ #include "ver_symbol.h" namespace maple { -void SSA::InitRenameStack(OriginalStTable *otable, size_t bbsize, VersionStTable &versttab) { - vstStacks.resize(otable->Size()); - vstVersions.resize(otable->Size(), 0); +void SSA::InitRenameStack(OriginalStTable &otable, size_t bbsize, VersionStTable &versttab) { + vstStacks.resize(otable.Size()); + vstVersions.resize(otable.Size(), 0); bbRenamed.resize(bbsize, false); - for (size_t i = 1; i < otable->Size(); i++) { + for (size_t i = 1; i < otable.Size(); i++) { MapleStack *vstack = ssaAlloc.GetMemPool()->New>(ssaAlloc.Adapter()); - const OriginalSt *ost = otable->GetOriginalStFromID(OStIdx(i)); + const OriginalSt *ost = otable.GetOriginalStFromID(OStIdx(i)); VersionSt *temp = (ost->GetIndirectLev() >= 0) ? versttab.GetVersionStFromID(ost->GetZeroVersionIndex(), true) : &versttab.GetDummyVersionSt(); vstack->push(temp); @@ -33,57 +33,57 @@ void SSA::InitRenameStack(OriginalStTable *otable, size_t bbsize, VersionStTable } } -VersionSt *SSA::CreateNewVersion(VersionSt *vsym, BB *defBB) { - CHECK_FATAL(vsym->GetVersion() == 0, "rename before?"); +VersionSt *SSA::CreateNewVersion(VersionSt &vsym, BB &defBB) { + CHECK_FATAL(vsym.GetVersion() == 0, "rename before?"); // volatile variables will keep zero version. - if (vsym->GetOrigSt()->IsVolatile()) { - return vsym; + if (vsym.GetOrigSt()->IsVolatile()) { + return &vsym; } - ASSERT(vsym->GetOrigIdx().idx < vstVersions.size(), "index out of range in SSA::CreateNewVersion"); - VersionSt *newVersionSym = ssaTab->GetVersionStTable().CreateVSymbol(vsym, ++vstVersions[vsym->GetOrigIdx().idx]); - vstStacks[vsym->GetOrigIdx().idx]->push(newVersionSym); - newVersionSym->SetDefBB(defBB); + ASSERT(vsym.GetOrigIdx().idx < vstVersions.size(), "index out of range in SSA::CreateNewVersion"); + VersionSt *newVersionSym = ssaTab->GetVersionStTable().CreateVSymbol(&vsym, ++vstVersions[vsym.GetOrigIdx().idx]); + vstStacks[vsym.GetOrigIdx().idx]->push(newVersionSym); + newVersionSym->SetDefBB(&defBB); return newVersionSym; } -void SSA::RenamePhi(BB *bb) { +void SSA::RenamePhi(BB &bb) { MapleMap::iterator phiIt; - for (phiIt = bb->GetPhiList().begin(); phiIt != bb->GetPhiList().end(); phiIt++) { + for (phiIt = bb.GetPhiList().begin(); phiIt != bb.GetPhiList().end(); phiIt++) { VersionSt *vsym = (*phiIt).second.GetResult(); // It shows that this BB has been renamed. if (vsym->GetVersion() > 0) { return; } - VersionSt *newVersionSym = CreateNewVersion(vsym, bb); + VersionSt *newVersionSym = CreateNewVersion(*vsym, bb); (*phiIt).second.SetResult(newVersionSym); newVersionSym->SetDefType(VersionSt::kPhi); newVersionSym->SetPhi(&(*phiIt).second); } } -void SSA::RenameDefs(StmtNode *stmt, BB *defBB) { - Opcode opcode = stmt->GetOpCode(); +void SSA::RenameDefs(StmtNode &stmt, BB &defBB) { + Opcode opcode = stmt.GetOpCode(); switch (opcode) { case OP_regassign: { - RegassignNode *regNode = static_cast(stmt); - if (regNode->GetRegIdx() < 0) { + RegassignNode ®Node = static_cast(stmt); + if (regNode.GetRegIdx() < 0) { return; } VersionSt *theSSAPart = ssaTab->GetStmtsSSAPart().SSAPartOf(stmt)->GetSSAVar(); - VersionSt *newVersionSym = CreateNewVersion(theSSAPart, defBB); + VersionSt *newVersionSym = CreateNewVersion(*theSSAPart, defBB); newVersionSym->SetDefType(VersionSt::kRegassign); - newVersionSym->SetRegassignNode(regNode); + newVersionSym->SetRegassignNode(®Node); ssaTab->GetStmtsSSAPart().SetSSAPartOf(stmt, newVersionSym); return; } case OP_dassign: { - DassignNode *dnode = static_cast(stmt); - MayDefPartWithVersionSt *thessapart = + DassignNode &dnode = static_cast(stmt); + MayDefPartWithVersionSt *theSSAPart = static_cast(ssaTab->GetStmtsSSAPart().SSAPartOf(stmt)); - VersionSt *newVersionSym = CreateNewVersion(thessapart->GetSSAVar(), defBB); - thessapart->SetSSAVar(newVersionSym); + VersionSt *newVersionSym = CreateNewVersion(*theSSAPart->GetSSAVar(), defBB); + theSSAPart->SetSSAVar(newVersionSym); newVersionSym->SetDefType(VersionSt::kDassign); - newVersionSym->SetDassignNode(dnode); + newVersionSym->SetDassignNode(&dnode); } // intentional fall though case OP_call: @@ -114,16 +114,16 @@ void SSA::RenameDefs(StmtNode *stmt, BB *defBB) { case OP_syncexit: case OP_maydassign: case OP_iassign: { - MapleMap *mayDefList = SSAGenericGetMayDefNodes(stmt, &ssaTab->GetStmtsSSAPart()); - for (auto it = mayDefList->begin(); it != mayDefList->end(); it++) { - MayDefNode &maydef = it->second; - VersionSt *vsym = maydef.GetResult(); + MapleMap &mayDefList = SSAGenericGetMayDefNodes(stmt, ssaTab->GetStmtsSSAPart()); + for (auto it = mayDefList.begin(); it != mayDefList.end(); it++) { + MayDefNode &mayDef = it->second; + VersionSt *vsym = mayDef.GetResult(); ASSERT(vsym->GetOrigIdx().idx < vstStacks.size(), "index out of range in SSA::RenameMayDefs"); - maydef.SetOpnd(vstStacks[vsym->GetOrigIdx().idx]->top()); - VersionSt *newVersionSym = CreateNewVersion(vsym, defBB); - maydef.SetResult(newVersionSym); + mayDef.SetOpnd(vstStacks[vsym->GetOrigIdx().idx]->top()); + VersionSt *newVersionSym = CreateNewVersion(*vsym, defBB); + mayDef.SetResult(newVersionSym); newVersionSym->SetDefType(VersionSt::kMayDef); - newVersionSym->SetMayDef(&maydef); + newVersionSym->SetMayDef(&mayDef); } return; } @@ -132,8 +132,8 @@ void SSA::RenameDefs(StmtNode *stmt, BB *defBB) { } } -void SSA::RenameMustDefs(const StmtNode *stmt, BB *defBB) { - Opcode opcode = stmt->GetOpCode(); +void SSA::RenameMustDefs(const StmtNode &stmt, BB &defBB) { + Opcode opcode = stmt.GetOpCode(); switch (opcode) { case OP_callassigned: case OP_virtualcallassigned: @@ -147,10 +147,10 @@ void SSA::RenameMustDefs(const StmtNode *stmt, BB *defBB) { case OP_intrinsiccallassigned: case OP_xintrinsiccallassigned: case OP_intrinsiccallwithtypeassigned: { - MapleVector *mustDefs = SSAGenericGetMustDefNode(stmt, &ssaTab->GetStmtsSSAPart()); - MapleVector::iterator it = mustDefs->begin(); - for (; it != mustDefs->end(); it++) { - VersionSt *newVersionSym = CreateNewVersion((*it).GetResult(), defBB); + MapleVector &mustDefs = SSAGenericGetMustDefNode(stmt, ssaTab->GetStmtsSSAPart()); + MapleVector::iterator it = mustDefs.begin(); + for (; it != mustDefs.end(); it++) { + VersionSt *newVersionSym = CreateNewVersion(*(*it).GetResult(), defBB); (*it).SetResult(newVersionSym); newVersionSym->SetDefType(VersionSt::kMustDef); newVersionSym->SetMustDef(&(*it)); @@ -162,19 +162,19 @@ void SSA::RenameMustDefs(const StmtNode *stmt, BB *defBB) { } } -void SSA::RenameMayUses(BaseNode *node) { - if (node->GetOpCode() == OP_iread) { - IreadSSANode *iread = static_cast(node); - VersionSt *vsym = iread->GetMayUse().GetOpnd(); +void SSA::RenameMayUses(BaseNode &node) { + if (node.GetOpCode() == OP_iread) { + IreadSSANode &iread = static_cast(node); + VersionSt *vsym = iread.GetMayUse().GetOpnd(); CHECK_FATAL(vsym != nullptr, "SSA::RenameMayUses: iread has no mayUse opnd"); ASSERT(vsym->GetOrigIdx().idx < vstStacks.size(), "index out of range in SSA::RenameMayUses"); - iread->GetMayUse().SetOpnd(vstStacks[vsym->GetOrigIdx().idx]->top()); + iread.GetMayUse().SetOpnd(vstStacks[vsym->GetOrigIdx().idx]->top()); return; } - MapleMap *mayUseList = - SSAGenericGetMayUseNode(static_cast(node), &ssaTab->GetStmtsSSAPart()); - MapleMap::iterator it = mayUseList->begin(); - for (; it != mayUseList->end(); it++) { + MapleMap &mayUseList = + SSAGenericGetMayUseNode(static_cast(node), ssaTab->GetStmtsSSAPart()); + MapleMap::iterator it = mayUseList.begin(); + for (; it != mayUseList.end(); it++) { MayUseNode &mayuse = it->second; VersionSt *vsym = mayuse.GetOpnd(); ASSERT(vsym->GetOrigIdx().idx < vstStacks.size(), "index out of range in SSA::RenameMayUses"); @@ -182,46 +182,46 @@ void SSA::RenameMayUses(BaseNode *node) { } } -void SSA::RenameExpr(BaseNode *expr) { - if (expr->GetOpCode() == OP_addrof || expr->GetOpCode() == OP_dread) { - AddrofSSANode *addrofNode = static_cast(expr); - VersionSt *vsym = addrofNode->GetSSAVar(); +void SSA::RenameExpr(BaseNode &expr) { + if (expr.GetOpCode() == OP_addrof || expr.GetOpCode() == OP_dread) { + AddrofSSANode &addrofNode = static_cast(expr); + VersionSt *vsym = addrofNode.GetSSAVar(); ASSERT(vsym->GetOrigIdx().idx < vstStacks.size(), "index out of range in SSA::RenameExpr"); - addrofNode->SetSSAVar(vstStacks[vsym->GetOrigIdx().idx]->top()); + addrofNode.SetSSAVar(vstStacks[vsym->GetOrigIdx().idx]->top()); return; - } else if (expr->GetOpCode() == OP_regread) { - RegreadSSANode *regNode = static_cast(expr); - if (regNode->GetRegIdx() < 0) { + } else if (expr.GetOpCode() == OP_regread) { + RegreadSSANode ®Node = static_cast(expr); + if (regNode.GetRegIdx() < 0) { return; } - VersionSt *vsym = regNode->GetSSAVar(); + VersionSt *vsym = regNode.GetSSAVar(); ASSERT(vsym->GetOrigIdx().idx < vstStacks.size(), "index out of range in SSA::RenameExpr"); - regNode->SetSSAVar(vstStacks[vsym->GetOrigIdx().idx]->top()); + regNode.SetSSAVar(vstStacks[vsym->GetOrigIdx().idx]->top()); return; - } else if (expr->GetOpCode() == OP_iread) { + } else if (expr.GetOpCode() == OP_iread) { RenameMayUses(expr); - RenameExpr(expr->Opnd(0)); + RenameExpr(*expr.Opnd(0)); } else { - for (size_t i = 0; i < expr->NumOpnds(); i++) { - RenameExpr(expr->Opnd(i)); + for (size_t i = 0; i < expr.NumOpnds(); i++) { + RenameExpr(*expr.Opnd(i)); } } } -void SSA::RenameUses(StmtNode *stmt) { - Opcode opcode = stmt->GetOpCode(); +void SSA::RenameUses(StmtNode &stmt) { + Opcode opcode = stmt.GetOpCode(); switch (opcode) { case OP_brfalse: case OP_brtrue: { - RenameExpr(stmt->Opnd(0)); + RenameExpr(*stmt.Opnd(0)); break; } case OP_return: { - NaryStmtNode *retnode = static_cast(stmt); - BaseNode *retValue = retnode->NumOpnds() == 0 ? nullptr : retnode->Opnd(0); + NaryStmtNode &retNode = static_cast(stmt); + BaseNode *retValue = retNode.NumOpnds() == 0 ? nullptr : retNode.Opnd(0); RenameMayUses(stmt); if (retValue != nullptr) { - RenameExpr(retValue); + RenameExpr(*retValue); } break; } @@ -252,30 +252,30 @@ void SSA::RenameUses(StmtNode *stmt) { case OP_syncenter: case OP_syncexit: { RenameMayUses(stmt); - for (size_t i = 0; i < stmt->NumOpnds(); i++) { - BaseNode *argExpr = stmt->Opnd(i); - RenameExpr(argExpr); + for (size_t i = 0; i < stmt.NumOpnds(); i++) { + BaseNode *argExpr = stmt.Opnd(i); + RenameExpr(*argExpr); } break; } case OP_maydassign: case OP_dassign: { - DassignNode *dnode = static_cast(stmt); - RenameExpr(dnode->GetRHS()); + DassignNode &dnode = static_cast(stmt); + RenameExpr(*dnode.GetRHS()); break; } case OP_regassign: { - RegassignNode *rnode = static_cast(stmt); - if (rnode->GetRegIdx() < 0) { + RegassignNode &rnode = static_cast(stmt); + if (rnode.GetRegIdx() < 0) { return; } - RenameExpr(rnode->Opnd(0)); + RenameExpr(*rnode.Opnd(0)); break; } case OP_iassign: { - IassignNode *inode = static_cast(stmt); - RenameExpr(inode->Opnd(0)); - RenameExpr(inode->GetRHS()); + IassignNode &inode = static_cast(stmt); + RenameExpr(*inode.Opnd(0)); + RenameExpr(*inode.GetRHS()); break; } case OP_throw: @@ -285,8 +285,8 @@ void SSA::RenameUses(StmtNode *stmt) { case OP_eval: case OP_free: case OP_switch: { - BaseNode *argExpr = stmt->Opnd(0); - RenameExpr(argExpr); + BaseNode *argExpr = stmt.Opnd(0); + RenameExpr(*argExpr); break; } case OP_gosub: @@ -314,20 +314,19 @@ void SSA::RenameUses(StmtNode *stmt) { } } -void SSA::RenamePhiUseInSucc(BB *bb) { - for (BB *succBB : bb->GetSucc()) { +void SSA::RenamePhiUseInSucc(BB &bb) { + for (BB *succBB : bb.GetSucc()) { // find index of bb in succ_bb->pred[] size_t index = 0; while (index < succBB->GetPred().size()) { - if (succBB->GetPred(index) == bb) { + if (succBB->GetPred(index) == &bb) { break; } index++; } CHECK_FATAL(index < succBB->GetPred().size(), "RenamePhiUseInSucc: cannot find corresponding pred"); // rename the phiOpnds[index] in all the phis in succ_bb - for (auto phiIt = succBB->GetPhiList().begin(); - phiIt != succBB->GetPhiList().end(); phiIt++) { + for (auto phiIt = succBB->GetPhiList().begin(); phiIt != succBB->GetPhiList().end(); phiIt++) { PhiNode &phiNode = phiIt->second; ASSERT(phiNode.GetPhiOpnd(index)->GetOrigIdx().idx < vstStacks.size(), "out of range SSA::RenamePhiUseInSucc"); phiNode.SetPhiOpnd(index, vstStacks.at(phiNode.GetPhiOpnd(index)->GetOrigIdx().idx)->top()); diff --git a/src/maple_me/src/ssa_mir_nodes.cpp b/src/maple_me/src/ssa_mir_nodes.cpp index 663bc9d11c0cd0c5ae953e807e1f5ecf1e984a95..e0581f99eaaaee5aedc73d3761f92e2e4cdc36b5 100644 --- a/src/maple_me/src/ssa_mir_nodes.cpp +++ b/src/maple_me/src/ssa_mir_nodes.cpp @@ -19,38 +19,38 @@ #include "ssa_tab.h" namespace maple { -bool HasMayUseDefPart(const StmtNode *stmtNode) { - Opcode op = stmtNode->GetOpCode(); +bool HasMayUseDefPart(const StmtNode &stmtNode) { + Opcode op = stmtNode.GetOpCode(); return kOpcodeInfo.IsCall(op) || op == OP_syncenter || op == OP_syncexit; } -bool HasMayDefPart(const StmtNode *stmtNode) { - Opcode op = stmtNode->GetOpCode(); +bool HasMayDefPart(const StmtNode &stmtNode) { + Opcode op = stmtNode.GetOpCode(); return op == OP_iassign || op == OP_dassign || op == OP_maydassign || HasMayUseDefPart(stmtNode); } -bool HasMayUsePart(const StmtNode *stmtNode) { - Opcode op = stmtNode->GetOpCode(); +bool HasMayUsePart(const StmtNode &stmtNode) { + Opcode op = stmtNode.GetOpCode(); return op == OP_iread || op == OP_throw || op == OP_gosub || op == OP_retsub || op == OP_return || HasMayUseDefPart(stmtNode); } -void GenericSSAPrint(MIRModule *mod, const StmtNode *stmtNode, int32 indent, StmtsSSAPart *stmtsSsaprt) { - stmtNode->Dump(*mod, indent); +void GenericSSAPrint(MIRModule &mod, const StmtNode &stmtNode, int32 indent, StmtsSSAPart &stmtsSsaprt) { + stmtNode.Dump(mod, indent); // print SSAPart - Opcode op = stmtNode->GetOpCode(); - AccessSSANodes *ssaPart = stmtsSsaprt->SSAPartOf(stmtNode); + Opcode op = stmtNode.GetOpCode(); + AccessSSANodes *ssaPart = stmtsSsaprt.SSAPartOf(stmtNode); switch (op) { case OP_maydassign: case OP_dassign: { - mod->GetOut() << " "; - ssaPart->GetSSAVar()->Dump(mod); + mod.GetOut() << " "; + ssaPart->GetSSAVar()->Dump(&mod); ssaPart->DumpMayDefNodes(mod); return; } case OP_regassign: { - mod->GetOut() << " "; - ssaPart->GetSSAVar()->Dump(mod); + mod.GetOut() << " "; + ssaPart->GetSSAVar()->Dump(&mod); return; } case OP_iassign: { @@ -61,7 +61,7 @@ void GenericSSAPrint(MIRModule *mod, const StmtNode *stmtNode, int32 indent, Stm case OP_retsub: case OP_return: { ssaPart->DumpMayUseNodes(mod); - mod->GetOut() << std::endl; + mod.GetOut() << std::endl; return; } default: { @@ -71,7 +71,7 @@ void GenericSSAPrint(MIRModule *mod, const StmtNode *stmtNode, int32 indent, Stm ssaPart->DumpMayDefNodes(mod); } else if (HasMayUseDefPart(stmtNode)) { ssaPart->DumpMayUseNodes(mod); - mod->GetOut() << std::endl; + mod.GetOut() << std::endl; ssaPart->DumpMayDefNodes(mod); } return; @@ -79,88 +79,78 @@ void GenericSSAPrint(MIRModule *mod, const StmtNode *stmtNode, int32 indent, Stm } } -void SSAGenericInsertMayUseNode(const StmtNode *stmtNode, VersionSt *mayuse, StmtsSSAPart *stmtsSsaprt) { - MapleMap *mayUseNodes = SSAGenericGetMayUseNode(stmtNode, stmtsSsaprt); - if (mayUseNodes == nullptr) { - return; - } - mayUseNodes->insert(std::make_pair(mayuse->GetOrigSt()->GetIndex(), MayUseNode(mayuse))); +void SSAGenericInsertMayUseNode(const StmtNode &stmtNode, VersionSt &mayUse, StmtsSSAPart &stmtsSsaprt) { + MapleMap &mayUseNodes = SSAGenericGetMayUseNode(stmtNode, stmtsSsaprt); + mayUseNodes.insert(std::make_pair(mayUse.GetOrigSt()->GetIndex(), MayUseNode(&mayUse))); } -MapleMap *SSAGenericGetMayUseNode(const StmtNode *stmtNode, StmtsSSAPart *stmtsSsaprt) { - return &(stmtsSsaprt->SSAPartOf(stmtNode)->GetMayUseNodes()); +MapleMap &SSAGenericGetMayUseNode(const StmtNode &stmtNode, StmtsSSAPart &stmtsSsaprt) { + return stmtsSsaprt.SSAPartOf(stmtNode)->GetMayUseNodes(); } -void SSAGenericInsertMayDefNode(const StmtNode *stmtNode, VersionSt *vst, StmtNode *s, StmtsSSAPart *stmtsSsaprt) { - MapleMap *mayDefNodes = SSAGenericGetMayDefNodes(stmtNode, stmtsSsaprt); - if (mayDefNodes == nullptr) { - return; - } - mayDefNodes->insert(std::make_pair(vst->GetOrigSt()->GetIndex(), MayDefNode(vst, s))); +void SSAGenericInsertMayDefNode(const StmtNode &stmtNode, VersionSt &vst, StmtNode &s, StmtsSSAPart &stmtsSsaprt) { + MapleMap &mayDefNodes = SSAGenericGetMayDefNodes(stmtNode, stmtsSsaprt); + mayDefNodes.insert(std::make_pair(vst.GetOrigSt()->GetIndex(), MayDefNode(&vst, &s))); } -MapleMap *SSAGenericGetMayDefNodes(const StmtNode *stmtNode, StmtsSSAPart *stmtsSsaprt) { - if (stmtNode == nullptr) { - return nullptr; - } - return &(stmtsSsaprt->SSAPartOf(stmtNode)->GetMayDefNodes()); +MapleMap &SSAGenericGetMayDefNodes(const StmtNode &stmtNode, StmtsSSAPart &stmtsSsaprt) { + return stmtsSsaprt.SSAPartOf(stmtNode)->GetMayDefNodes(); } -static MapleMap *SSAGenericGetMayDefsFromVersionSt(VersionSt *vst, StmtsSSAPart *ssapart, +static MapleMap *SSAGenericGetMayDefsFromVersionSt(VersionSt &vst, StmtsSSAPart &ssapart, std::unordered_set &visited) { - if (vst == nullptr || vst->IsInitVersion() || visited.find(vst) != visited.end()) { + if (vst.IsInitVersion() || visited.find(&vst) != visited.end()) { return nullptr; } - visited.insert(vst); - if (vst->GetDefType() == VersionSt::kPhi) { - PhiNode *phi = vst->GetPhi(); + visited.insert(&vst); + if (vst.GetDefType() == VersionSt::kPhi) { + PhiNode *phi = vst.GetPhi(); for (size_t i = 0; i < phi->GetPhiOpns().size(); i++) { VersionSt *vsym = phi->GetPhiOpnd(i); - MapleMap *mayDefs = SSAGenericGetMayDefsFromVersionSt(vsym, ssapart, visited); + MapleMap *mayDefs = SSAGenericGetMayDefsFromVersionSt(*vsym, ssapart, visited); if (mayDefs != nullptr) { return mayDefs; } } - } else if (vst->GetDefType() == VersionSt::kMayDef) { - MayDefNode *maydef = vst->GetMayDef(); - return SSAGenericGetMayDefNodes(maydef->GetStmt(), ssapart); + } else if (vst.GetDefType() == VersionSt::kMayDef) { + MayDefNode *maydef = vst.GetMayDef(); + return &SSAGenericGetMayDefNodes(*maydef->GetStmt(), ssapart); } return nullptr; } -MapleMap *SSAGenericGetMayDefsFromVersionSt(VersionSt *sym, StmtsSSAPart *ssapart) { +MapleMap *SSAGenericGetMayDefsFromVersionSt(VersionSt &sym, StmtsSSAPart &ssapart) { std::unordered_set visited; return SSAGenericGetMayDefsFromVersionSt(sym, ssapart, visited); } -MapleVector *SSAGenericGetMustDefNode(const StmtNode *stmtNode, StmtsSSAPart *stmtsSsaprt) { - return &(stmtsSsaprt->SSAPartOf(stmtNode)->GetMustDefNodes()); +MapleVector &SSAGenericGetMustDefNode(const StmtNode &stmtNode, StmtsSSAPart &stmtsSsaprt) { + return stmtsSsaprt.SSAPartOf(stmtNode)->GetMustDefNodes(); } -bool HasMayUseOpnd(const BaseNode *baseNode, SSATab *func) { - const StmtNode *stmtNode = static_cast(baseNode); +bool HasMayUseOpnd(const BaseNode &baseNode, SSATab &func) { + const StmtNode &stmtNode = static_cast(baseNode); if (HasMayUsePart(stmtNode)) { - MapleMap *mayUses = SSAGenericGetMayUseNode(stmtNode, &func->GetStmtsSSAPart()); - if (!mayUses->empty()) { + MapleMap &mayUses = SSAGenericGetMayUseNode(stmtNode, func.GetStmtsSSAPart()); + if (!mayUses.empty()) { return true; } } - for (size_t i = 0; i < baseNode->NumOpnds(); i++) { - if (HasMayUseOpnd(baseNode->Opnd(i), func)) { + for (size_t i = 0; i < baseNode.NumOpnds(); i++) { + if (HasMayUseOpnd(*baseNode.Opnd(i), func)) { return true; } } return false; } -bool HasMayDef(const StmtNode *stmtNode, SSATab *func) { +bool HasMayDef(const StmtNode &stmtNode, SSATab &func) { if (HasMayDefPart(stmtNode)) { - MapleMap *mayDefs = SSAGenericGetMayDefNodes(stmtNode, &func->GetStmtsSSAPart()); - CHECK_FATAL(mayDefs, "should have maydefs here"); - if (!mayDefs->empty()) { + MapleMap &mayDefs = SSAGenericGetMayDefNodes(stmtNode, func.GetStmtsSSAPart()); + if (!mayDefs.empty()) { return true; } } return false; } -} // namespace maple \ No newline at end of file +} // namespace maple diff --git a/src/maple_me/src/ssa_tab.cpp b/src/maple_me/src/ssa_tab.cpp index bff26a3558de7861320f4b810ff4c368e324c74c..6f3ca44b2585da0f36ac78027ca12394ac49e6fd 100644 --- a/src/maple_me/src/ssa_tab.cpp +++ b/src/maple_me/src/ssa_tab.cpp @@ -25,73 +25,73 @@ // stored in class SSATab's StmtsSSAPart, which has an array of pointers indexed // by the stmtID field of each statement node. namespace maple { -BaseNode *SSATab::CreateSSAExpr(BaseNode *expr) { - if (expr->GetOpCode() == OP_addrof || expr->GetOpCode() == OP_dread) { - AddrofNode *addrofNode = static_cast(expr); - AddrofSSANode *ssaNode = mirModule.CurFunction()->GetCodeMemPool()->New(addrofNode); +BaseNode *SSATab::CreateSSAExpr(BaseNode &expr) { + if (expr.GetOpCode() == OP_addrof || expr.GetOpCode() == OP_dread) { + AddrofNode &addrofNode = static_cast(expr); + AddrofSSANode *ssaNode = mirModule.CurFunction()->GetCodeMemPool()->New(&addrofNode); MIRSymbol *st = mirModule.CurFunction()->GetLocalOrGlobalSymbol(ssaNode->GetStIdx()); - OriginalSt *ost = FindOrCreateSymbolOriginalSt(st, mirModule.CurFunction()->GetPuidx(), ssaNode->GetFieldID()); + OriginalSt *ost = FindOrCreateSymbolOriginalSt(*st, mirModule.CurFunction()->GetPuidx(), ssaNode->GetFieldID()); VersionSt *vst = versionStTable.FindOrCreateVersionSt(ost, kInitVersion); ssaNode->SetSSAVar(vst); return ssaNode; - } else if (expr->GetOpCode() == OP_regread) { - RegreadNode *rreadNode = static_cast(expr); - RegreadSSANode *ssaNode = mirModule.CurFunction()->GetCodeMemPool()->New(rreadNode); + } else if (expr.GetOpCode() == OP_regread) { + RegreadNode &rreadNode = static_cast(expr); + RegreadSSANode *ssaNode = mirModule.CurFunction()->GetCodeMemPool()->New(&rreadNode); OriginalSt *ost = originalStTable.FindOrCreatePregOriginalSt(ssaNode->GetRegIdx(), mirModule.CurFunction()->GetPuidx()); VersionSt *vst = versionStTable.FindOrCreateVersionSt(ost, kInitVersion); ssaNode->SetSSAVar(vst); return ssaNode; - } else if (expr->GetOpCode() == OP_iread) { - IreadNode *ireadNode = static_cast(expr); + } else if (expr.GetOpCode() == OP_iread) { + IreadNode &ireadNode = static_cast(expr); IreadSSANode *ssaNode = mirModule.CurFunction()->GetCodeMempool()->New( - mirModule.CurFuncCodeMemPoolAllocator(), ireadNode); - BaseNode *newOpnd = CreateSSAExpr(expr->Opnd(0)); + mirModule.CurFuncCodeMemPoolAllocator(), &ireadNode); + BaseNode *newOpnd = CreateSSAExpr(*expr.Opnd(0)); if (newOpnd != nullptr) { ssaNode->SetOpnd(newOpnd, 0); } return ssaNode; } else { - for (size_t i = 0; i < expr->NumOpnds(); i++) { - BaseNode *newOpnd = CreateSSAExpr(expr->Opnd(i)); + for (size_t i = 0; i < expr.NumOpnds(); i++) { + BaseNode *newOpnd = CreateSSAExpr(*expr.Opnd(i)); if (newOpnd != nullptr) { - expr->SetOpnd(newOpnd, i); + expr.SetOpnd(newOpnd, i); } } return nullptr; } } -void SSATab::CreateSSAStmt(StmtNode *stmt, const BB *curbb, bool ignoreCallassignedDefs) { - for (size_t i = 0; i < stmt->NumOpnds(); i++) { - BaseNode *newOpnd = CreateSSAExpr(stmt->Opnd(i)); +void SSATab::CreateSSAStmt(StmtNode &stmt, const BB &curbb, bool ignoreCallassignedDefs) { + for (size_t i = 0; i < stmt.NumOpnds(); i++) { + BaseNode *newOpnd = CreateSSAExpr(*stmt.Opnd(i)); if (newOpnd != nullptr) { - stmt->SetOpnd(newOpnd, i); + stmt.SetOpnd(newOpnd, i); } } - switch (stmt->GetOpCode()) { + switch (stmt.GetOpCode()) { case OP_maydassign: case OP_dassign: { MayDefPartWithVersionSt *theSSAPart = stmtsSSAPart.GetSSAPartMp()->New(&stmtsSSAPart.GetSSAPartAlloc()); stmtsSSAPart.SetSSAPartOf(stmt, theSSAPart); - DassignNode *dnode = static_cast(stmt); - MIRSymbol *st = mirModule.CurFunction()->GetLocalOrGlobalSymbol(dnode->GetStIdx()); + DassignNode &dnode = static_cast(stmt); + MIRSymbol *st = mirModule.CurFunction()->GetLocalOrGlobalSymbol(dnode.GetStIdx()); CHECK_FATAL(st != nullptr, "null ptr check"); - OriginalSt *ost = FindOrCreateSymbolOriginalSt(st, mirModule.CurFunction()->GetPuidx(), dnode->GetFieldID()); + OriginalSt *ost = FindOrCreateSymbolOriginalSt(*st, mirModule.CurFunction()->GetPuidx(), dnode.GetFieldID()); VersionSt *vst = versionStTable.FindOrCreateVersionSt(ost, kInitVersion); theSSAPart->SetSSAVar(vst); // if the rhs may throw exception, we insert MayDef of the lhs var - if (stmt->GetOpCode() == OP_maydassign) { - theSSAPart->InsertMayDefNode(theSSAPart->GetSSAVar(), dnode); + if (stmt.GetOpCode() == OP_maydassign) { + theSSAPart->InsertMayDefNode(theSSAPart->GetSSAVar(), &dnode); } return; } case OP_regassign: { - RegassignNode *regNode = static_cast(stmt); + RegassignNode ®Node = static_cast(stmt); OriginalSt *ost = - originalStTable.FindOrCreatePregOriginalSt(regNode->GetRegIdx(), mirModule.CurFunction()->GetPuidx()); + originalStTable.FindOrCreatePregOriginalSt(regNode.GetRegIdx(), mirModule.CurFunction()->GetPuidx()); VersionSt *vst = versionStTable.FindOrCreateVersionSt(ost, kInitVersion); stmtsSSAPart.SetSSAPartOf(stmt, vst); return; @@ -111,12 +111,12 @@ void SSATab::CreateSSAStmt(StmtNode *stmt, const BB *curbb, bool ignoreCallassig stmtsSSAPart.SetSSAPartOf(stmt, stmtsSSAPart.GetSSAPartMp()->New(&stmtsSSAPart.GetSSAPartAlloc())); return; default: { - if (kOpcodeInfo.IsCallAssigned(stmt->GetOpCode())) { + if (kOpcodeInfo.IsCallAssigned(stmt.GetOpCode())) { MayDefMayUseMustDefPart *theSSAPart = stmtsSSAPart.GetSSAPartMp()->New(&stmtsSSAPart.GetSSAPartAlloc()); stmtsSSAPart.SetSSAPartOf(stmt, theSSAPart); // insert the mustdefs - CallReturnVector *nrets = static_cast(stmt)->GetCallReturnVector(); + CallReturnVector *nrets = static_cast(stmt).GetCallReturnVector(); CHECK_FATAL(nrets != nullptr, "CreateSSAStmt: failed to retrieve call return vector"); if (nrets->empty()) { return; @@ -127,15 +127,15 @@ void SSATab::CreateSSAStmt(StmtNode *stmt, const BB *curbb, bool ignoreCallassig MIRSymbolTable *symtab = mirModule.CurFunction()->GetSymTab(); MIRSymbol *st = symtab->GetSymbolFromStIdx(stidx.Idx()); OriginalSt *ost = - FindOrCreateSymbolOriginalSt(st, mirModule.CurFunction()->GetPuidx(), retPair.second.GetFieldID()); + FindOrCreateSymbolOriginalSt(*st, mirModule.CurFunction()->GetPuidx(), retPair.second.GetFieldID()); VersionSt *vst = versionStTable.FindOrCreateVersionSt(ost, kInitVersion); - theSSAPart->InsertMustDefNode(vst, stmt); + theSSAPart->InsertMustDefNode(vst, &stmt); } else { ASSERT(false, "NYI"); } } return; - } else if (kOpcodeInfo.IsCall(stmt->GetOpCode())) { + } else if (kOpcodeInfo.IsCall(stmt.GetOpCode())) { stmtsSSAPart.SetSSAPartOf(stmt, stmtsSSAPart.GetSSAPartMp()->New(&stmtsSSAPart.GetSSAPartAlloc())); return; diff --git a/src/maple_me/src/ver_symbol.cpp b/src/maple_me/src/ver_symbol.cpp index cc421560dfce61a0f269bd236214985f25d76253..ccfa6eda746ddbad1e04ee8e3a13d56f80af1273 100644 --- a/src/maple_me/src/ver_symbol.cpp +++ b/src/maple_me/src/ver_symbol.cpp @@ -18,7 +18,7 @@ #include "ssa_mir_nodes.h" namespace maple { -void VersionSt::DumpDefStmt(const MIRModule *mod) { +void VersionSt::DumpDefStmt(const MIRModule *mod) const { if (version <= 0) { return; } @@ -35,16 +35,19 @@ void VersionSt::DumpDefStmt(const MIRModule *mod) { case kMustDef: defStmt.mustDef->Dump(mod); return; + case kRegassign: + defStmt.dassign->Dump(*mod, 0); default: - ASSERT(false, "NYI"); + ASSERT(false, "not yet implement"); } } VersionSt *VersionStTable::CreateVersionSt(OriginalSt *ost, size_t version) { + ASSERT(ost != nullptr, "nullptr check"); ASSERT(ost->GetVersionsIndex().size() == version, "ssa version need to be created incrementally!"); VersionSt *vst = vstAlloc.GetMemPool()->New(versionStVector.size(), version, ost); versionStVector.push_back(vst); - ost->GetVersionsIndex().push_back(vst->GetIndex()); + ost->PushbackVersionIndex(vst->GetIndex()); if (version == kInitVersion) { ost->SetZeroVersionIndex(vst->GetIndex()); } @@ -54,18 +57,21 @@ VersionSt *VersionStTable::CreateVersionSt(OriginalSt *ost, size_t version) { VersionSt *VersionStTable::FindOrCreateVersionSt(OriginalSt *ost, size_t version) { // this version already exists... + ASSERT(ost != nullptr, "nullptr check"); if (ost->GetVersionsIndex().size() > version) { - ASSERT(versionStVector.size() > ost->GetVersionIndex(version), "versionStVector out of range"); - return versionStVector.at(ost->GetVersionIndex(version)); + size_t versionIndex = ost->GetVersionIndex(version); + ASSERT(versionStVector.size() > versionIndex, "versionStVector out of range"); + return versionStVector.at(versionIndex); } else { - return (CreateVersionSt(ost, version)); + return CreateVersionSt(ost, version); } } -void VersionStTable::Dump(MIRModule *mod) { +void VersionStTable::Dump(MIRModule *mod) const { + ASSERT(mod != nullptr, "nullptr check"); LogInfo::MapleLogger() << "=======version st table entries=======\n"; for (size_t i = 1; i < versionStVector.size(); i++) { - VersionSt *vst = versionStVector[i]; + const VersionSt *vst = versionStVector[i]; vst->Dump(mod); if (vst->GetVersion() > 0) { LogInfo::MapleLogger() << " defined BB" << vst->GetDefBB()->GetBBId().idx << ": "; diff --git a/src/maple_util/include/option_parser.h b/src/maple_util/include/option_parser.h index b26d3c311f79610fb5a463786da121b22c617d5a..13b1120656bb9de41ca16bc73cfcab44723bfa0b 100644 --- a/src/maple_util/include/option_parser.h +++ b/src/maple_util/include/option_parser.h @@ -20,7 +20,6 @@ #include "error_code.h" namespace mapleOption { - enum ArgStatus { kArgNone, kArgOk, kArgIllegal }; enum BuildType { kBuildTypeAll, kBuildTypeDebug, kBuildTypeRelease }; @@ -252,11 +251,10 @@ class OptionParser { std::vector &inputOption, const std::string &exeName); const bool CheckOpt(const std::string option, std::string &lastKey, bool &isLastMatch, std::vector &inputOption, const std::string &exeName); - void InsertOption(const char *opt, Descriptor usage); + void InsertOption(const std::string &opt, Descriptor usage); const bool CheckSpecialOption(const std::string &option, std::string &key, std::string &value); }; - } // namespace mapleOption #endif // MAPLE_UTIL_INCLUDE_OPTION_PARSER_H diff --git a/src/mpl2mpl/include/native_stub_func.h b/src/mpl2mpl/include/native_stub_func.h index 5961445262c618e2b049d39ecfc40bebecd7b16d..6c8b64dbdee95e06c3623ff935dca83b14a24a3e 100644 --- a/src/mpl2mpl/include/native_stub_func.h +++ b/src/mpl2mpl/include/native_stub_func.h @@ -41,6 +41,7 @@ class NativeFuncProperty { NativeFuncProperty() { jniType = kJniTypeNormal; } + ~NativeFuncProperty() = default; private: std::string javaFunc; diff --git a/src/mpl2mpl/src/class_hierarchy.cpp b/src/mpl2mpl/src/class_hierarchy.cpp index 17e1900a910132b923174c513647cdf3db83339d..a5dcdc93f6091bb1b98757086b83d13656417610 100644 --- a/src/mpl2mpl/src/class_hierarchy.cpp +++ b/src/mpl2mpl/src/class_hierarchy.cpp @@ -57,8 +57,8 @@ Klass::Klass(MIRStructType *type, MapleAllocator *alc) isPrivateInnerAndNoSubClassFlag(false), hasNativeMethods(false), needDecoupling(true) { - ASSERT((type != nullptr) && (type->GetKind() == kTypeClass || type->GetKind() == kTypeInterface), - "runtime check error"); + ASSERT(type != nullptr, "type is nullptr in Klass::Klass!"); + ASSERT(type->GetKind() == kTypeClass || type->GetKind() == kTypeInterface, "runtime check error"); } void Klass::DumpKlassMethods() const { @@ -227,9 +227,9 @@ void Klass::CountVirtMethTopDown(const KlassHierarchy *kh) { superAndImplClasses->push_back(superKlass); } // Initialize strIdx2CandidateMap based on the superclass methods - for (Klass * const &superAndImplClasse : *superAndImplClasses) { - ASSERT(superAndImplClasse, "Not a valid super class of interface"); - for (auto const &pair : superAndImplClasse->strIdx2CandidateMap) { + for (Klass * const &superAndImplClass : *superAndImplClasses) { + ASSERT(superAndImplClass, "Not a valid super class of interface"); + for (auto const &pair : superAndImplClass->strIdx2CandidateMap) { stridx = pair.first; pvec = pair.second; ASSERT(pvec->size() == 1, "Expect exactly one method definition from parent class"); @@ -245,7 +245,8 @@ void Klass::CountVirtMethTopDown(const KlassHierarchy *kh) { // Interfaces implemented methods override, need to determine the inherit relation. // class method can override interface method, interface method can override its parent's methods vec = strIdx2CandidateMap[stridx]; - ASSERT(vec && vec->size() == 1, "Expect exactly one method definition from parent class"); + ASSERT(vec != nullptr, "nullptr check!"); + ASSERT(vec->size() == 1, "Expect exactly one method definition from parent class"); Klass *parentKlass = kh->GetKlassFromFunc((*vec)[0]); Klass *childKlass = kh->GetKlassFromFunc((*pvec)[0]); CHECK_FATAL(childKlass != nullptr, "childKlass is null in Klass::CountVirtMethTopDown"); @@ -266,7 +267,8 @@ void Klass::CountVirtMethTopDown(const KlassHierarchy *kh) { if (strIdx2CandidateMap.find(stridx) != strIdx2CandidateMap.end()) { // Override the method coming from parent vec = strIdx2CandidateMap[stridx]; - ASSERT(vec && vec->size() == 1, "Expect exactly one method definition from parent class"); + ASSERT(vec != nullptr, "nullptr check!"); + ASSERT(vec->size() == 1, "Expect exactly one method definition from parent class"); (*vec)[0] = method; } else { // Newly declared and defined @@ -528,7 +530,7 @@ void KlassHierarchy::AddKlassRelationAndMethods() { } else { // Class MIRClassType *ctype = klass->GetMIRClassType(); - ASSERT(ctype, "null ptr check"); + ASSERT(ctype != nullptr, "null ptr check"); // Add interface relationship for (TyIdx const &intfTyIdx : ctype->GetInerfaceImplemented()) { Klass *intfKlass = GetKlassFromTyIdx(intfTyIdx); diff --git a/src/mpl2mpl/src/class_init.cpp b/src/mpl2mpl/src/class_init.cpp index 4c976b9573a35fe4d06b017133d819798a6b9659..454633ee367699543fb85b790441d7fc1178f769 100644 --- a/src/mpl2mpl/src/class_init.cpp +++ b/src/mpl2mpl/src/class_init.cpp @@ -121,7 +121,8 @@ void ClassInit::ProcessFunc(MIRFunction *func) { CHECK_FATAL(intrinsicCall->GetTyIdx().GetIdx() < GlobalTables::GetTypeTable().GetTypeTable().size(), "index out of range"); MIRType *classType = GlobalTables::GetTypeTable().GetTypeTable()[intrinsicCall->GetTyIdx().GetIdx()]; - CHECK_FATAL(classType && classType->GetNameStrIdx() != 0, "symbol name is null for type index %d", + ASSERT(classType != nullptr, "null ptr check!"); + CHECK_FATAL(classType->GetNameStrIdx() != 0, "symbol name is null for type index %d", intrinsicCall->GetTyIdx().GetIdx()); const std::string &className = GlobalTables::GetStrTable().GetStringFromStrIdx(classType->GetNameStrIdx()); Klass *klass = klassHierarchy->GetKlassFromName(className); diff --git a/src/mpl2mpl/src/gen_check_cast.cpp b/src/mpl2mpl/src/gen_check_cast.cpp index 3278642b52f6fce3631e93855907576d73708d82..ff8748ff54f276a33a49a90ef7099ee938ef85b7 100644 --- a/src/mpl2mpl/src/gen_check_cast.cpp +++ b/src/mpl2mpl/src/gen_check_cast.cpp @@ -203,8 +203,8 @@ void CheckCastGenerator::GenCheckCast(BaseNode *stmt) { } BaseNode *opnd = callNode->Opnd(0); ASSERT(opnd->GetOpCode() == OP_dread || opnd->GetOpCode() == OP_regread || opnd->GetOpCode() == OP_iread || - opnd->GetOpCode() == OP_retype, - "unknown calltype! check it!"); + opnd->GetOpCode() == OP_retype, "unknown calltype! check it!"); + MIRType *fromType = nullptr; if (opnd->GetOpCode() == OP_dread) { fromType = GlobalTables::GetTypeTable().GetTypeFromTyIdx( @@ -241,9 +241,10 @@ void CheckCastGenerator::GenCheckCast(BaseNode *stmt) { fromType = GlobalTables::GetTypeTable().GetTypeTable()[PTY_ptr]; } } - ASSERT((fromType->GetPrimType() == maple::PTY_ptr || fromType->GetPrimType() == maple::PTY_ref) && - (GlobalTables::GetTypeTable().GetTypeFromTyIdx(callNode->GetTyIdx())->GetPrimType() == maple::PTY_ptr || - GlobalTables::GetTypeTable().GetTypeFromTyIdx(callNode->GetTyIdx())->GetPrimType() == maple::PTY_ref), + ASSERT((fromType->GetPrimType() == maple::PTY_ptr || fromType->GetPrimType() == maple::PTY_ref), + "unknown fromType! check it!"); + ASSERT(GlobalTables::GetTypeTable().GetTypeFromTyIdx(callNode->GetTyIdx())->GetPrimType() == maple::PTY_ptr || + GlobalTables::GetTypeTable().GetTypeFromTyIdx(callNode->GetTyIdx())->GetPrimType() == maple::PTY_ref, "unknown fromType! check it!"); const size_t callNodeNretSize1 = callNode->GetReturnVec().size(); CHECK_FATAL(callNodeNretSize1 > 0, "container check"); diff --git a/src/mpl2mpl/src/java_eh_lower.cpp b/src/mpl2mpl/src/java_eh_lower.cpp index 237fafb084c59d544f47c8a0d6cafbfbf0420968..7c15e820f03fd17fc1745c8df5712b3674490295 100644 --- a/src/mpl2mpl/src/java_eh_lower.cpp +++ b/src/mpl2mpl/src/java_eh_lower.cpp @@ -94,6 +94,7 @@ BaseNode *JavaEHLowerer::DoLowerDiv(BinaryNode *expr, BlockNode *blknode) { } BaseNode *JavaEHLowerer::DoLowerExpr(BaseNode *expr, BlockNode *curblk) { + ASSERT(expr != nullptr, "null ptr check!"); for (size_t i = 0; i < expr->NumOpnds(); i++) { expr->SetOpnd(DoLowerExpr(expr->Opnd(i), curblk), i); } diff --git a/src/mpl2mpl/src/muid_replacement.cpp b/src/mpl2mpl/src/muid_replacement.cpp index 28cdcd3141f83ec62852c579e7ff478e168e86c5..5a3b391ffdfb5ff544cd9d149b7dd0b587be9e81 100644 --- a/src/mpl2mpl/src/muid_replacement.cpp +++ b/src/mpl2mpl/src/muid_replacement.cpp @@ -109,7 +109,7 @@ void MUIDReplacement::CollectFuncAndDataFromKlasses() { if (vMethodPair != nullptr) { MIRSymbol *funcSymbol = GlobalTables::GetGsymTable().GetSymbolFromStidx(vMethodPair->first.Idx()); MIRFunction *mirFunc = funcSymbol->GetFunction(); - if (mirFunc && mirFunc->GetBody() == nullptr && !mirFunc->IsAbstract()) { + if (mirFunc != nullptr && mirFunc->GetBody() == nullptr && !mirFunc->IsAbstract()) { AddUndefFunc(mirFunc); } } diff --git a/src/mpl2mpl/src/reflection_analysis.cpp b/src/mpl2mpl/src/reflection_analysis.cpp index cd3e7ddfc3cc74c7df9c06a0df46bbce5ecea415..a405115e817ae13f4e648bb631559caa72363f18 100644 --- a/src/mpl2mpl/src/reflection_analysis.cpp +++ b/src/mpl2mpl/src/reflection_analysis.cpp @@ -475,7 +475,7 @@ static bool IsSameType(TyIdx tyIdx1, TyIdx tyIdx2) { MIRSymbol *ReflectionAnalysis::GetSymbol(GStrIdx strIdx, TyIdx tyIdx) { MIRSymbol *st = GlobalTables::GetGsymTable().GetSymbolFromStrIdx(strIdx); - if (st && st->GetSKind() == kStVar && IsSameType(st->GetTyIdx(), tyIdx)) { + if (st != nullptr && st->GetSKind() == kStVar && IsSameType(st->GetTyIdx(), tyIdx)) { return st; } return nullptr; @@ -856,8 +856,10 @@ MIRSymbol *ReflectionAnalysis::GenFieldsMetaData(const Klass *klass) { mirBuilder.AddAddrofFieldConst(*fieldsInfoType, *newconst, fieldID++, *gvarSt); } else { // Offset of the instance field, we fill the index of fields here and let CG to fill in. + MIRClassType *mirClassType = klass->GetMIRClassType(); + ASSERT(mirClassType != nullptr, "GetMIRClassType() returns null"); FieldID fldID = mirBuilder.GetStructFieldIDFromNameAndTypeParentFirstFoundInChild( - klass->GetMIRClassType(), originFieldname.c_str(), fieldP.second.first); + *mirClassType, originFieldname.c_str(), fieldP.second.first); mirBuilder.AddIntFieldConst(*fieldsInfoType, *newconst, fieldID++, fldID); } // @modifier