diff --git a/src/bin/jbc2mpl b/src/bin/jbc2mpl index 4620037a8a26ea73005b3f7961ef254711b5cdee..aa9b65aaf34fd4c10eb49a27d9a9b00905e2c709 100755 Binary files a/src/bin/jbc2mpl and b/src/bin/jbc2mpl differ diff --git a/src/bin/maple b/src/bin/maple index 841a8e918b45ff8e7682c27f1a89c626129f3630..145d66c0e9f1b5bd01dbbd2df886e36cb5c477ff 100755 Binary files a/src/bin/maple and b/src/bin/maple differ diff --git a/src/bin/mplcg b/src/bin/mplcg index ce80bbb770a861804e8bf5d123518a810ae46a21..093b6a0f72bda4b0f6e2aa06f12ecc878f515018 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 258d971bac8e5b937eb0e8e73b04d2c03d1e45da..28c0f2b1e7fb1eb096e5a4b026ded1b21976a85b 100644 Binary files a/src/deplibs/libmaple_driverutil.a and b/src/deplibs/libmaple_driverutil.a differ diff --git a/src/deplibs/libmplphase.a b/src/deplibs/libmplphase.a index 15308b0c21471021b6d88163dfb6b1700b9fb8ac..623121759376ac61c5a1b5d4aa0aeaeac8e64dc9 100644 Binary files a/src/deplibs/libmplphase.a and b/src/deplibs/libmplphase.a differ diff --git a/src/deplibs/libmplutil.a b/src/deplibs/libmplutil.a index f10aef3f805b53f7b4fe1fd262fc947f54090437..3fe193a96da64a6f346f8975d31437e23f154f25 100644 Binary files a/src/deplibs/libmplutil.a and b/src/deplibs/libmplutil.a differ diff --git a/src/maple_driver/include/compiler.h b/src/maple_driver/include/compiler.h index fc6122033eef2060675e8f46d3ca72b8c6d40209..313827e2a0e4e3b0e264272189ac6fff86b6ff4d 100644 --- a/src/maple_driver/include/compiler.h +++ b/src/maple_driver/include/compiler.h @@ -24,11 +24,11 @@ #include "mir_parser.h" namespace maple { -static const std::string kBinNameJbc2mpl = "jbc2mpl"; -static const std::string kBinNameMe = "me"; -static const std::string kBinNameMpl2mpl = "mpl2mpl"; -static const std::string kBinNameMplcg = "mplcg"; -static const std::string kBinNameMapleComb = "maplecomb"; +extern const std::string kBinNameJbc2mpl; +extern const std::string kBinNameMe; +extern const std::string kBinNameMpl2mpl; +extern const std::string kBinNameMplcg; +extern const std::string kBinNameMapleComb; class Compiler { public: @@ -40,19 +40,19 @@ class Compiler { virtual void GetTmpFilesToDelete(const MplOptions &mplOptions, std::vector &tempFiles) const {} - virtual const std::unordered_set GetFinalOutputs(const MplOptions &mplOptions) const { + virtual std::unordered_set GetFinalOutputs(const MplOptions &mplOptions) const { return std::unordered_set(); } virtual void PrintCommand(const MplOptions &options) const {} protected: - virtual const std::string GetBinPath(const MplOptions &mplOptions) const; - virtual const std::string GetBinName() const { + virtual std::string GetBinPath(const MplOptions &mplOptions) const; + virtual std::string GetBinName() const { return ""; } - virtual const std::string GetInputFileName(const MplOptions &options) const { + virtual std::string GetInputFileName(const MplOptions &options) const { std::ostringstream ss; for (auto const &inputFile : options.GetSplitsInputFiles()) { ss << " " << inputFile; @@ -60,17 +60,17 @@ class Compiler { return ss.str(); } - virtual const DefaultOption GetDefaultOptions(const MplOptions &options) { + virtual DefaultOption GetDefaultOptions(const MplOptions &options) { return DefaultOption(); } - virtual const std::string AppendSpecialOption(const MplOptions &options, const std::string &optionStr) const { + virtual std::string AppendSpecialOption(const MplOptions &options, const std::string &optionStr) const { return optionStr; } - virtual const std::string AppendOptimization(const MplOptions &options, const std::string &optionStr) const; + virtual std::string AppendOptimization(const MplOptions &options, const std::string &optionStr) const; - virtual const std::vector GetBinNames() const { + virtual std::vector GetBinNames() const { return std::vector(); } @@ -78,7 +78,7 @@ class Compiler { private: const std::string name; - const std::string MakeOption(const MplOptions &options); + std::string MakeOption(const MplOptions &options); void AppendDefaultOptions(std::map &finalOptions, const std::map &defaultOptions) const; void AppendUserOptions(std::map &finalOptions, @@ -87,8 +87,8 @@ class Compiler { const std::string &connectSymbol) const; void AppendExtraOptions(std::map &finalOptions, const std::map> &extraOptions) const; - const std::map MakeDefaultOptions(const MplOptions &options); - const int Exe(const MplOptions &mplOptions, const std::string &options) const; + std::map MakeDefaultOptions(const MplOptions &options); + int Exe(const MplOptions &mplOptions, const std::string &options) const; const std::string &GetName() const { return name; } @@ -101,11 +101,11 @@ class Jbc2MplCompiler : public Compiler { ~Jbc2MplCompiler() = default; private: - const std::string GetBinName() const override; - const DefaultOption GetDefaultOptions(const MplOptions &options) override; + std::string GetBinName() const override; + DefaultOption GetDefaultOptions(const MplOptions &options) override; void GetTmpFilesToDelete(const MplOptions &mplOptions, std::vector &tempFiles) const override; - const std::unordered_set GetFinalOutputs(const MplOptions &mplOptions) const override; - const std::vector GetBinNames() const override; + std::unordered_set GetFinalOutputs(const MplOptions &mplOptions) const override; + std::vector GetBinNames() const override; }; class MapleCombCompiler : public Compiler { @@ -116,11 +116,11 @@ class MapleCombCompiler : public Compiler { ErrorCode Compile(const MplOptions &options, MIRModulePtr &theModule) override; void PrintCommand(const MplOptions &options) const override; - const std::string GetInputFileName(const MplOptions &options) const override; + std::string GetInputFileName(const MplOptions &options) const override; private: std::string realRunningExe; - const std::unordered_set GetFinalOutputs(const MplOptions &mplOptions) const override; + std::unordered_set GetFinalOutputs(const MplOptions &mplOptions) const override; MeOption *MakeMeOptions(const MplOptions &options, MemPool &optmp); Options *MakeMpl2MplOptions(const MplOptions &options, MemPool &optmp); }; @@ -133,10 +133,10 @@ class MplcgCompiler : public Compiler { private: - const std::string GetInputFileName(const MplOptions &options) const override; - const DefaultOption GetDefaultOptions(const MplOptions &options) override; - const std::string GetBinName() const override; - const std::vector GetBinNames() const override; + std::string GetInputFileName(const MplOptions &options) const override; + DefaultOption GetDefaultOptions(const MplOptions &options) override; + std::string GetBinName() const override; + std::vector GetBinNames() const override; }; } // namespace maple diff --git a/src/maple_driver/include/compiler_selector.h b/src/maple_driver/include/compiler_selector.h index 1655a749395e2024fe89bfac63ff85079f7d6da8..57eae416b9cc592a9a0f0e8bfc0c17b7f019adef 100644 --- a/src/maple_driver/include/compiler_selector.h +++ b/src/maple_driver/include/compiler_selector.h @@ -27,8 +27,8 @@ class CompilerSelector { virtual ~CompilerSelector() = default; - virtual const ErrorCode Select(const SupportedCompilers &supportedCompilers, const MplOptions &mplOptions, - std::vector &selected) const { + virtual ErrorCode Select(const SupportedCompilers &supportedCompilers, const MplOptions &mplOptions, + std::vector &selected) const { return ErrorCode::kErrorToolNotFound; } }; @@ -39,8 +39,8 @@ class CompilerSelectorImpl : public CompilerSelector { ~CompilerSelectorImpl() = default; - const ErrorCode Select(const SupportedCompilers &supportedCompilers, const MplOptions &mplOptions, - std::vector &selected) const override; + ErrorCode Select(const SupportedCompilers &supportedCompilers, const MplOptions &mplOptions, + std::vector &selected) const override; private: Compiler *FindCompiler(const SupportedCompilers &compilers, const std::string &name) const; diff --git a/src/maple_driver/include/file_utils.h b/src/maple_driver/include/file_utils.h index ecd0f7679f52763351c3f00e1ad7b615a1676e28..31ad7dd478ac12ac050761e990ee1b3de8cffd5a 100644 --- a/src/maple_driver/include/file_utils.h +++ b/src/maple_driver/include/file_utils.h @@ -16,28 +16,22 @@ #define MAPLE_DRIVER_INCLUDE_FILE_UTILS_H #include -namespace FileSeperator { -const char kFileSeperatorLinuxStyleChar = '/'; -const char kFileSeperatorWindowsStyleChar = '\\'; -const char kFileSeperatorChar = kFileSeperatorLinuxStyleChar; -const std::string kFileSeperatorLinuxStyleStr = std::string(1, kFileSeperatorLinuxStyleChar); -const std::string kFileSeperatorWindowsStyleStr = std::string(1, kFileSeperatorWindowsStyleChar); -const std::string kFileSeperatorStr = kFileSeperatorLinuxStyleStr; -} // namespace FileSeperator - namespace maple { +extern const std::string kFileSeperatorStr; +extern const char kFileSeperatorChar; // Use char[] since getenv receives char* as parameter -static constexpr char kMapleRoot[] = "MAPLE_ROOT"; +constexpr char kMapleRoot[] = "MAPLE_ROOT"; + class FileUtils { public: - const static std::string GetFileName(const std::string &filePath, const bool isWithExtension); - const static std::string GetFileExtension(const std::string &filePath); - const static std::string GetFileFolder(const std::string &filePath); - const static std::string ConvertPathIfNeeded(const std::string &src); - const static int Remove(const std::string &filePath); - const static std::string AppendMapleRootIfNeeded(bool needRootPath, const std::string &path, - const std::string &defaultRoot = - ("." + FileSeperator::kFileSeperatorStr)); + static std::string GetFileName(const std::string &filePath, bool isWithExtension); + static std::string GetFileExtension(const std::string &filePath); + static std::string GetFileFolder(const std::string &filePath); + static std::string ConvertPathIfNeeded(const std::string &src); + static int Remove(const std::string &filePath); + static std::string AppendMapleRootIfNeeded(bool needRootPath, const std::string &path, + const std::string &defaultRoot = + ("." + kFileSeperatorStr)); }; } // namespace maple #endif // MAPLE_DRIVER_INCLUDE_FILE_UTILS_H diff --git a/src/maple_driver/include/mpl_options.h b/src/maple_driver/include/mpl_options.h index 5bf29c68ce004ba05b10c3ed5580027b4f03f86a..97a05ae6c38e9e04e8523dbb3f139e5c662a56d0 100644 --- a/src/maple_driver/include/mpl_options.h +++ b/src/maple_driver/include/mpl_options.h @@ -128,7 +128,7 @@ class MplOptions { ~MplOptions() = default; int Parse(int argc, char **argv); - const std::string OptimizationLevelStr() const; + std::string OptimizationLevelStr() const; const std::map> &GetOptions() const { return options; diff --git a/src/maple_driver/include/usages.h b/src/maple_driver/include/usages.h index 5395ae04f4abce4b088feadceed48dc5e6355672..5e1fe9b220ae752a8cc801257edb93dfdc1e68de 100644 --- a/src/maple_driver/include/usages.h +++ b/src/maple_driver/include/usages.h @@ -81,792 +81,5 @@ enum OptionIndex : uint64 { }; enum EnabledIndex { kDisable, kEnable }; - -const static mapleOption::Descriptor USAGES[] = { - // index, type , shortOption , longOption, connector, isCanAppend, delimiter, enableBuildType, checkPolicy, help, - // extra - { kUnknown, - 0, - nullptr, - nullptr, - nullptr, - false, - nullptr, - mapleOption::BuildType::kBuildTypeAll, - mapleOption::ArgCheckPolicy::kArgCheckPolicyNone, - "USAGE: maple [options]\n\n Options:", - "all", - { { nullptr } } }, - { kHelp, - 0, - "h", - "help", - nullptr, - false, - nullptr, - mapleOption::BuildType::kBuildTypeAll, - mapleOption::ArgCheckPolicy::kArgCheckPolicyOptional, - " -h --help [command] \tPrint usage and exit.\n", - "all", - { { nullptr } } }, - { kVersion, - 0, - nullptr, - "version", - nullptr, - false, - nullptr, - mapleOption::BuildType::kBuildTypeAll, - mapleOption::ArgCheckPolicy::kArgCheckPolicyOptional, - " --version [command] \tPrint version and exit.\n", - "all", - { { nullptr } } }, - { kInFile, - 0, - nullptr, - "infile", - nullptr, - false, - nullptr, - mapleOption::BuildType::kBuildTypeAll, - mapleOption::ArgCheckPolicy::kArgCheckPolicyRequired, - " --infile file1,file2,file3 \tInput files.\n", - "all", - { { nullptr } } }, - { kInMplt, - 0, - nullptr, - "mplt", - "=", - true, - ",", - mapleOption::BuildType::kBuildTypeAll, - mapleOption::ArgCheckPolicy::kArgCheckPolicyRequired, - " --mplt=file1,file2,file3 \tImport mplt files.\n", - "all", - { { "jbc2mpl", "-mplt", " ", nullptr }, - // End - { nullptr, nullptr, nullptr, nullptr } } }, - { kOptimization0, - 0, - "O0", - nullptr, - nullptr, - false, - nullptr, - mapleOption::BuildType::kBuildTypeAll, - mapleOption::ArgCheckPolicy::kArgCheckPolicyNone, - " -O0 \tNo optimization.\n", - "all", - { { nullptr } } }, - { kMeOpt, - 0, - nullptr, - "me-opt", - nullptr, - false, - nullptr, - mapleOption::BuildType::kBuildTypeAll, - mapleOption::ArgCheckPolicy::kArgCheckPolicyNone, - " --me-opt \tSet options for me\n", - "all", - { { nullptr } } }, - { kMpl2MplOpt, - 0, - nullptr, - "mpl2mpl-opt", - nullptr, - false, - nullptr, - mapleOption::BuildType::kBuildTypeAll, - mapleOption::ArgCheckPolicy::kArgCheckPolicyNone, - " --mpl2mpl-opt \tSet options for mpl2mpl\n", - "all", - { { nullptr } } }, - { kSaveTemps, - 0, - nullptr, - "save-temps", - nullptr, - false, - nullptr, - mapleOption::BuildType::kBuildTypeAll, - mapleOption::ArgCheckPolicy::kArgCheckPolicyNone, - " --save-temps \tDo not delete intermediate files.\n" - " \t--save-temps Save all intermediate files.\n" - " \t--save-temps=file1,file2,file3 Save the\n" - " \ttarget files.\n", - "all", - { { nullptr } } }, - { kRun, - 0, - nullptr, - "run", - nullptr, - false, - nullptr, - mapleOption::BuildType::kBuildTypeDebug, - mapleOption::ArgCheckPolicy::kArgCheckPolicyRequired, - " --run=cmd1:cmd2 \tThe name of executables that are going\n" - " \tto execute. IN SEQUENCE.\n" - " \tSeparated by \":\".Available exe names:\n" - " \tjbc2mpl, me, mpl2mpl, mplcg\n" - " \tInput file must match the tool can\n" - " \thandle\n", - "all", - { { nullptr } } }, - { kOption, - 0, - nullptr, - "option", - nullptr, - false, - nullptr, - mapleOption::BuildType::kBuildTypeDebug, - mapleOption::ArgCheckPolicy::kArgCheckPolicyRequired, - " --option=\"opt1:opt2\" \tOptions for each executable,\n" - " \tseparated by \":\".\n" - " \tThe sequence must match the sequence in\n" - " \t--run.\n", - "all", - { { nullptr } } }, - { kCombTimePhases, - 0, - "time-phases", - nullptr, - nullptr, - false, - nullptr, - mapleOption::BuildType::kBuildTypeAll, - mapleOption::ArgCheckPolicy::kArgCheckPolicyNone, - " -time-phases \tTiming phases and print percentages\n", - "all", - { { nullptr } } }, - { kGenMeMpl, - 0, - nullptr, - "genmempl", - nullptr, - false, - nullptr, - mapleOption::BuildType::kBuildTypeAll, - mapleOption::ArgCheckPolicy::kArgCheckPolicyNone, - " --genmempl \tGenerate me.mpl file\n", - "all", - { { nullptr } } }, - { kGenVtableImpl, - 0, - nullptr, - "genVtableImpl", - nullptr, - false, - nullptr, - mapleOption::BuildType::kBuildTypeAll, - mapleOption::ArgCheckPolicy::kArgCheckPolicyNone, - " --genVtableImpl \tGenerate VtableImpl.mpl file\n", - "all", - { { nullptr } } }, - { kVerify, - 0, - nullptr, - "verify", - nullptr, - false, - nullptr, - mapleOption::BuildType::kBuildTypeAll, - mapleOption::ArgCheckPolicy::kArgCheckPolicyNone, - " --verify \tVerify mpl file\n", - "all", - { { nullptr } } }, - { kAllDebug, - 0, - nullptr, - "debug", - nullptr, - false, - nullptr, - mapleOption::BuildType::kBuildTypeAll, - mapleOption::ArgCheckPolicy::kArgCheckPolicyNone, - " --debug \tPrint debug info.\n", - "all", - { { nullptr } } }, - // jbc2mpl - { kUseStringFactory, - 0, - nullptr, - "use-string-factory", - nullptr, - false, - nullptr, - mapleOption::BuildType::kBuildTypeAll, - mapleOption::ArgCheckPolicy::kArgCheckPolicyNone, - " -use-string-factory \tReplace String. by StringFactory call\n", - "jbc2mpl", - { { nullptr } } }, - { kJbc2mplOutMpl, - 0, - "o", - "out", - nullptr, - false, - nullptr, - mapleOption::BuildType::kBuildTypeDebug, - mapleOption::ArgCheckPolicy::kArgCheckPolicyRequired, - " -o, -out=output.mpl \toutput mpl name\n", - "jbc2mpl", - { { nullptr } } }, - // me - { kMeHelp, - 0, - "h-me", - "help-me", - nullptr, - false, - nullptr, - mapleOption::BuildType::kBuildTypeAll, - mapleOption::ArgCheckPolicy::kArgCheckPolicyOptional, - " -h-me --help-me \tPrint usage and exit.Available command names:\n" - " \tme\n", - "all", - { { nullptr } } }, - { kMeRange, - 0, - nullptr, - "range", - nullptr, - false, - nullptr, - mapleOption::BuildType::kBuildTypeAll, - mapleOption::ArgCheckPolicy::kArgCheckPolicyRequired, - " --range \tOptimize only functions in the range [NUM0, NUM1]\n" - " \t--range=NUM0,NUM1\n", - "me", - { { nullptr } } }, - { kMeDumpPhases, - 0, - nullptr, - "dump-phases", - nullptr, - false, - nullptr, - mapleOption::BuildType::kBuildTypeAll, - mapleOption::ArgCheckPolicy::kArgCheckPolicyRequired, - " --dump-phases \tEnable debug trace for specified phases in the comma separated list\n" - " \t--dump-phases=PHASENAME,...\n", - "me", - { { nullptr } } }, - { kMeSkipPhases, - 0, - nullptr, - "skip-phases", - nullptr, - false, - nullptr, - mapleOption::BuildType::kBuildTypeAll, - mapleOption::ArgCheckPolicy::kArgCheckPolicyRequired, - " --skip-phases \tSkip the phases specified in the comma separated list\n" - " \t--skip-phases=PHASENAME,...\n", - "me", - { { nullptr } } }, - { kMeDumpFunc, - 0, - nullptr, - "dump-func", - nullptr, - false, - nullptr, - mapleOption::BuildType::kBuildTypeAll, - mapleOption::ArgCheckPolicy::kArgCheckPolicyRequired, - " --dump-func \tDump/trace only for functions whose names contain FUNCNAME as substring\n" - " \t(can only specify once)\n" - " \t--dump-func=FUNCNAME\n", - "me", - { { nullptr } } }, - { kMeQuiet, - 0, - nullptr, - "quiet", - nullptr, - false, - nullptr, - mapleOption::BuildType::kBuildTypeAll, - mapleOption::ArgCheckPolicy::kArgCheckPolicyNone, - " --quiet \tDisable brief trace messages with phase/function names\n", - "me", - { { nullptr } } }, - { kMeNoDot, - 0, - nullptr, - "nodot", - nullptr, - false, - nullptr, - mapleOption::BuildType::kBuildTypeAll, - mapleOption::ArgCheckPolicy::kArgCheckPolicyNone, - " --nodot \tDisable dot file generation from cfg\n", - "me", - { { nullptr } } }, - { kSetCalleeHasSideEffect, - 0, - nullptr, - "setCalleeHasSideEffect", - nullptr, - false, - nullptr, - mapleOption::BuildType::kBuildTypeAll, - mapleOption::ArgCheckPolicy::kArgCheckPolicyNone, - " --setCalleeHasSideEffect \tSet all the callees have side effect\n", - "me", - { { nullptr } } }, - { kNoSteensgaard, - 0, - nullptr, - "noSteensgaard", - nullptr, - false, - nullptr, - mapleOption::BuildType::kBuildTypeAll, - mapleOption::ArgCheckPolicy::kArgCheckPolicyNone, - " --noSteensgaard \tDisable Steensgaard-style alias analysis\n", - "me", - { { nullptr } } }, - { kNoTBAA, - 0, - nullptr, - "noTBAA", - nullptr, - false, - nullptr, - mapleOption::BuildType::kBuildTypeAll, - mapleOption::ArgCheckPolicy::kArgCheckPolicyNone, - " --noTBAA \tDisable type-based alias analysis\n", - "me", - { { nullptr } } }, - { kAliasAnalysisLevel, - 0, - nullptr, - "aliasAnalysisLevel", - nullptr, - false, - nullptr, - mapleOption::BuildType::kBuildTypeAll, - mapleOption::ArgCheckPolicy::kArgCheckPolicyRequired, - " --aliasAnalysisLevel \tSet level of alias analysis. \n" - " \t0: most conservative;\n" - " \t1: Steensgaard-style alias analysis; 2: type-based alias analysis;\n" - " \t3: Steensgaard-style and type-based alias analysis\n" - " \t--aliasAnalysisLevel=NUM\n", - "me", - { { nullptr } } }, - { kStmtNum, - 0, - nullptr, - "stmtnum", - nullptr, - false, - nullptr, - mapleOption::BuildType::kBuildTypeAll, - mapleOption::ArgCheckPolicy::kArgCheckPolicyNone, - " --stmtnum \tPrint MeStmt index number in IR dump\n", - "me", - { { nullptr } } }, - { kMeDumpAfter, - 0, - nullptr, - "dump-after", - nullptr, - false, - nullptr, - mapleOption::BuildType::kBuildTypeAll, - mapleOption::ArgCheckPolicy::kArgCheckPolicyNone, - " --dump-after \tDo extra IR dump after the specified phase in me\n", - "me", - { { nullptr } } }, - { kLessThrowAlias, - 0, - nullptr, - "lessthrowalias", - nullptr, - false, - nullptr, - mapleOption::BuildType::kBuildTypeAll, - mapleOption::ArgCheckPolicy::kArgCheckPolicyNone, - " --lessthrowalias \tHandle aliases at java throw statements more accurately\n", - "me", - { { nullptr } } }, - { kFinalFieldAlias, - 0, - nullptr, - "finalfieldalias", - nullptr, - false, - nullptr, - mapleOption::BuildType::kBuildTypeAll, - mapleOption::ArgCheckPolicy::kArgCheckPolicyNone, - " --finalfieldalias \tRegard final fields as having alias like other fields\n", - "me", - { { nullptr } } }, - { kRegReadAtReturn, - 0, - nullptr, - "regreadatreturn", - nullptr, - false, - nullptr, - mapleOption::BuildType::kBuildTypeAll, - mapleOption::ArgCheckPolicy::kArgCheckPolicyNone, - " --regreadatreturn \tAllow register promotion to promote the operand of return statements\n", - "me", - { { nullptr } } }, - // mpl2mpl - { kMpl2MplHelp, - 0, - "h-mpl2mpl", - "help-mpl2mpl", - nullptr, - false, - nullptr, - mapleOption::BuildType::kBuildTypeAll, - mapleOption::ArgCheckPolicy::kArgCheckPolicyOptional, - " -h-mpl2mpl --help-mpl2mpl \tPrint usage and exit.Available command names:\n" - " \tmpl2mpl\n", - "all", - { { nullptr } } }, - { kMpl2MplDumpPhase, - 0, - nullptr, - "dump-phase", - nullptr, - false, - nullptr, - mapleOption::BuildType::kBuildTypeAll, - mapleOption::ArgCheckPolicy::kArgCheckPolicyRequired, - " --dump-phase \tEnable debug trace for specified phase (can only specify once)\n" - " \t--dump-phase=PHASENAME\n", - "mpl2mpl", - { { nullptr } } }, - { kMpl2MplSkipPhase, - 0, - nullptr, - "skip-phase", - nullptr, - false, - nullptr, - mapleOption::BuildType::kBuildTypeAll, - mapleOption::ArgCheckPolicy::kArgCheckPolicyRequired, - " --skip-phase \tSkip the phase when adding it to phase manager\n" - " \t--skip-phase=PHASENAME\n", - "mpl2mpl", - { { nullptr } } }, - { kMpl2MplSkipFrom, - 0, - nullptr, - "skip-from", - nullptr, - false, - nullptr, - mapleOption::BuildType::kBuildTypeAll, - mapleOption::ArgCheckPolicy::kArgCheckPolicyRequired, - " --skip-from \tSkip all remaining phases including PHASENAME\n" - " \t--skip-from=PHASENAME\n", - "mpl2mpl", - { { nullptr } } }, - { kMpl2MplSkipAfter, - 0, - nullptr, - "skip-after", - nullptr, - false, - nullptr, - mapleOption::BuildType::kBuildTypeAll, - mapleOption::ArgCheckPolicy::kArgCheckPolicyRequired, - " --skip-after \tSkip all remaining phases after PHASENAME\n" - " \t--skip-after=PHASENAME\n", - "mpl2mpl", - { { nullptr } } }, - { kMpl2MplDumpFunc, - 0, - nullptr, - "dump-func", - nullptr, - false, - nullptr, - mapleOption::BuildType::kBuildTypeAll, - mapleOption::ArgCheckPolicy::kArgCheckPolicyRequired, - " --dump-func \tDump/trace only for functions whose names contain FUNCNAME as substring\n" - " \t(can only specify once)\n" - " \t--dump-func=FUNCNAME\n", - "mpl2mpl", - { { nullptr } } }, - { kMpl2MplQuiet, - 0, - nullptr, - "quiet", - nullptr, - false, - nullptr, - mapleOption::BuildType::kBuildTypeAll, - mapleOption::ArgCheckPolicy::kArgCheckPolicyNone, - " --quiet \tDisable brief trace messages with phase/function names\n", - "mpl2mpl", - { { nullptr } } }, - { kMpl2MplMapleLinker, - 0, - nullptr, - "maplelinker", - nullptr, - false, - nullptr, - mapleOption::BuildType::kBuildTypeAll, - mapleOption::ArgCheckPolicy::kArgCheckPolicyNone, - " --maplelinker \tGenerate MUID symbol tables and references\n", - "mpl2mpl", - { { nullptr } } }, - { kMpl2MplStubJniFunc, - 0, - nullptr, - "regnativefunc", - nullptr, - false, - nullptr, - mapleOption::BuildType::kBuildTypeAll, - mapleOption::ArgCheckPolicy::kArgCheckPolicyNone, - " --regnativefunc \tGenerate native stub function to support JNI registration and calling\n", - "mpl2mpl", - { { nullptr } } }, - { kNativeWrapper, - kEnable, - nullptr, - "nativewrapper", - nullptr, - false, - nullptr, - mapleOption::BuildType::kBuildTypeAll, - mapleOption::ArgCheckPolicy::kArgCheckPolicyNone, - " --nativewrapper \tGenerate native wrappers [default]\n", - "mpl2mpl", - { { nullptr } } }, - { kNativeWrapper, - kDisable, - nullptr, - "no-nativewrapper", - nullptr, - false, - nullptr, - mapleOption::BuildType::kBuildTypeAll, - mapleOption::ArgCheckPolicy::kArgCheckPolicyNone, - " --no-nativewrapper\n", - "mpl2mpl", - { { nullptr } } }, - { kRegNativeDynamicOnly, - 0, - nullptr, - "regnative-dynamic-only", - nullptr, - false, - nullptr, - mapleOption::BuildType::kBuildTypeAll, - mapleOption::ArgCheckPolicy::kArgCheckPolicyNone, - " --regnative-dynamic-only \tOnly Generate dynamic register code, Report Fatal Msg if no implemented\n", - "mpl2mpl", - { { nullptr } } }, - { kRegNativeStaticBindingList, - 0, - nullptr, - "static-binding-list", - nullptr, - false, - nullptr, - mapleOption::BuildType::kBuildTypeAll, - mapleOption::ArgCheckPolicy::kArgCheckPolicyRequired, - " --static-bindig-list \tOnly Generate static binding function in file configure list\n" - " \t--static-bindig-list=file\n", - "mpl2mpl", - { { nullptr } } }, - { kMpl2MplDumpBefore, - 0, - nullptr, - "dump-before", - nullptr, - false, - nullptr, - mapleOption::BuildType::kBuildTypeAll, - mapleOption::ArgCheckPolicy::kArgCheckPolicyNone, - " --dump-before \tDo extra IR dump before the specified phase\n", - "mpl2mpl", - { { nullptr } } }, - { kMpl2MplDumpAfter, - 0, - nullptr, - "dump-after", - nullptr, - false, - nullptr, - mapleOption::BuildType::kBuildTypeAll, - mapleOption::ArgCheckPolicy::kArgCheckPolicyNone, - " --dump-after \tDo extra IR dump after the specified phase\n", - "mpl2mpl", - { { nullptr } } }, - { kMplnkDumpMuid, - 0, - nullptr, - "dump-muid", - nullptr, - false, - nullptr, - mapleOption::BuildType::kBuildTypeAll, - mapleOption::ArgCheckPolicy::kArgCheckPolicyNone, - " --dump-muid \tDump MUID def information into a .muid file\n", - "mpl2mpl", - { { nullptr } } }, - { kEmitVtableImpl, - 0, - nullptr, - "emitVtableImpl", - nullptr, - false, - nullptr, - mapleOption::BuildType::kBuildTypeAll, - mapleOption::ArgCheckPolicy::kArgCheckPolicyNone, - " --emitVtableImpl \tgenerate VtableImpl file\n", - "mpl2mpl", - { { nullptr } } }, -#if MIR_JAVA - { kMpl2MplSkipVirtual, - 0, - nullptr, - "skipvirtual", - nullptr, - false, - nullptr, - mapleOption::BuildType::kBuildTypeAll, - mapleOption::ArgCheckPolicy::kArgCheckPolicyNone, - " --skipvirtual\n", - "mpl2mpl", - { { nullptr } } }, -#endif - // mplcg - { kPie, - kEnable, - nullptr, - "pie", - nullptr, - false, - nullptr, - mapleOption::BuildType::kBuildTypeAll, - mapleOption::ArgCheckPolicy::kArgCheckPolicyNone, - " --pie \tGenerate position-independent executable\n", - "mplcg", - { { nullptr } } }, - { kPie, - kDisable, - nullptr, - "no-pie", - nullptr, - false, - nullptr, - mapleOption::BuildType::kBuildTypeAll, - mapleOption::ArgCheckPolicy::kArgCheckPolicyNone, - " --no-pie\n", - "mplcg", - { { nullptr } } }, - { kPic, - kEnable, - nullptr, - "fpic", - nullptr, - false, - nullptr, - mapleOption::BuildType::kBuildTypeAll, - mapleOption::ArgCheckPolicy::kArgCheckPolicyNone, - " --fpic \tGenerate position-independent shared library\n", - "mplcg", - { { nullptr } } }, - { kPic, - kDisable, - nullptr, - "no-fpic", - nullptr, - false, - nullptr, - mapleOption::BuildType::kBuildTypeAll, - mapleOption::ArgCheckPolicy::kArgCheckPolicyNone, - " --no-fpic\n", - "mplcg", - { { nullptr } } }, - { kVerbose, - kEnable, - nullptr, - "verbose-asm", - nullptr, - false, - nullptr, - mapleOption::BuildType::kBuildTypeAll, - mapleOption::ArgCheckPolicy::kArgCheckPolicyNone, - " --verbose-asm \tAdd comments to asm output\n", - "mplcg", - { { nullptr } } }, - { kVerbose, - kDisable, - nullptr, - "no-verbose-asm", - nullptr, - false, - nullptr, - mapleOption::BuildType::kBuildTypeAll, - mapleOption::ArgCheckPolicy::kArgCheckPolicyNone, - " --no-verbose-asm\n", - "mplcg", - { { nullptr } } }, - { kCGMapleLinker, - kEnable, - nullptr, - "maplelinker", - nullptr, - false, - nullptr, - mapleOption::BuildType::kBuildTypeAll, - mapleOption::ArgCheckPolicy::kArgCheckPolicyNone, - " --maplelinker \tGenerate the MapleLinker .s format\n", - "mplcg", - { { nullptr } } }, - { kCGQuiet, - kEnable, - nullptr, - "quiet", - nullptr, - false, - nullptr, - mapleOption::BuildType::kBuildTypeAll, - mapleOption::ArgCheckPolicy::kArgCheckPolicyNone, - " --quiet \tBe quiet (don't output debug messages)\n", - "mplcg", - { { nullptr } } }, - { kCGQuiet, - kDisable, - nullptr, - "no-quiet", - nullptr, - false, - nullptr, - mapleOption::BuildType::kBuildTypeAll, - mapleOption::ArgCheckPolicy::kArgCheckPolicyNone, - " --no-quiet\n", - "mplcg", - { { nullptr } } }, - - { kUnknown, - 0, - nullptr, - nullptr, - nullptr, - false, - nullptr, - mapleOption::BuildType::kBuildTypeAll, - mapleOption::ArgCheckPolicy::kArgCheckPolicyNone, - nullptr, - "", - { { nullptr } } } -}; } // namespace maple #endif // MAPLE_DRIVER_INCLUDE_USAGES_H diff --git a/src/maple_driver/src/compiler.cpp b/src/maple_driver/src/compiler.cpp index cdc5b3face7726c771d84c965e5d24f8e1e180f1..0b40e0042f8886d66f63dad385cf72d4d2b01e76 100644 --- a/src/maple_driver/src/compiler.cpp +++ b/src/maple_driver/src/compiler.cpp @@ -20,20 +20,27 @@ namespace maple { using namespace mapleOption; -const int Compiler::Exe(const MplOptions &mplOptions, const std::string &options) const { + +const std::string kBinNameJbc2mpl = "jbc2mpl"; +const std::string kBinNameMe = "me"; +const std::string kBinNameMpl2mpl = "mpl2mpl"; +const std::string kBinNameMplcg = "mplcg"; +const std::string kBinNameMapleComb = "maplecomb"; + +int Compiler::Exe(const MplOptions &mplOptions, const std::string &options) const { std::ostringstream ostrStream; ostrStream << GetBinPath(mplOptions) << GetBinName(); std::string binPath = FileUtils::ConvertPathIfNeeded(ostrStream.str()); return SafeExe::Exe(binPath, options); } -const std::string Compiler::GetBinPath(const MplOptions &mplOptions) const { +std::string Compiler::GetBinPath(const MplOptions &mplOptions) const { #ifdef MAPLE_PRODUCT_EXECUTABLE // build flag -DMAPLE_PRODUCT_EXECUTABLE std::string binPath = std::string(MAPLE_PRODUCT_EXECUTABLE); if (binPath.empty()) { binPath = mplOptions.exeFolder; } else { - binPath = binPath + FileSeperator::kFileSeperatorChar; + binPath = binPath + kFileSeperatorChar; } #else std::string binPath = mplOptions.GetExeFolder(); @@ -57,7 +64,7 @@ ErrorCode Compiler::Compile(const MplOptions &options, MIRModulePtr &theModule) return ErrorCode::kErrorNoError; } -const std::string Compiler::MakeOption(const MplOptions &options) { +std::string Compiler::MakeOption(const MplOptions &options) { std::map finalOptions; auto defaultOptions = MakeDefaultOptions(options); AppendDefaultOptions(finalOptions, defaultOptions); @@ -116,7 +123,7 @@ void Compiler::AppendExtraOptions(std::map &finalOptions } } -const std::map Compiler::MakeDefaultOptions(const MplOptions &options) { +std::map Compiler::MakeDefaultOptions(const MplOptions &options) { auto rawDefaultOptions = GetDefaultOptions(options); std::map defaultOptions; if (rawDefaultOptions.mplOptions != nullptr) { @@ -148,7 +155,7 @@ const bool Compiler::CanAppendOptimization(const std::string &optionStr) const { return false; } -const std::string Compiler::AppendOptimization(const MplOptions &options, const std::string &optionStr) const { +std::string Compiler::AppendOptimization(const MplOptions &options, const std::string &optionStr) const { if (!CanAppendOptimization(optionStr)) { return optionStr; } diff --git a/src/maple_driver/src/compiler_selector.cpp b/src/maple_driver/src/compiler_selector.cpp index 79fdb58a728be5fd8cb61bb4920de00f676e3866..a9c9c206ef03500f03b2ff83937075183def0e67 100644 --- a/src/maple_driver/src/compiler_selector.cpp +++ b/src/maple_driver/src/compiler_selector.cpp @@ -40,8 +40,8 @@ const ErrorCode CompilerSelectorImpl::InsertCompilerIfNeeded(std::vector &selected) const { +ErrorCode CompilerSelectorImpl::Select(const SupportedCompilers &supportedCompilers, const MplOptions &mplOptions, + std::vector &selected) const { bool combPhases = false; if (!mplOptions.GetRunningExes().empty()) { for (auto runningExe : mplOptions.GetRunningExes()) { diff --git a/src/maple_driver/src/file_utils.cpp b/src/maple_driver/src/file_utils.cpp index 08d56430211e0914614626f3efd994dfe2b2bf4f..8c6305d7d02f397b5c3d7874f4835be7273493fc 100644 --- a/src/maple_driver/src/file_utils.cpp +++ b/src/maple_driver/src/file_utils.cpp @@ -16,37 +16,48 @@ #include #include "string_utils.h" +namespace { +const char kFileSeperatorLinuxStyleChar = '/'; +const char kFileSeperatorWindowsStyleChar = '\\'; +const std::string kFileSeperatorLinuxStyleStr = std::string(1, kFileSeperatorLinuxStyleChar); +const std::string kFileSeperatorWindowsStyleStr = std::string(1, kFileSeperatorWindowsStyleChar); +} // namespace + namespace maple { -const std::string FileUtils::GetFileName(const std::string &filePath, const bool isWithExtension) { - std::string fullFileName = StringUtils::GetStrAfterLast(filePath, FileSeperator::kFileSeperatorStr); +const char kFileSeperatorChar = kFileSeperatorLinuxStyleChar; + +const std::string kFileSeperatorStr = kFileSeperatorLinuxStyleStr; + +std::string FileUtils::GetFileName(const std::string &filePath, bool isWithExtension) { + std::string fullFileName = StringUtils::GetStrAfterLast(filePath, kFileSeperatorStr); if (isWithExtension) { return fullFileName; } return StringUtils::GetStrBeforeLast(fullFileName, "."); } -const std::string FileUtils::GetFileExtension(const std::string &filePath) { +std::string FileUtils::GetFileExtension(const std::string &filePath) { return StringUtils::GetStrAfterLast(filePath, ".", true); } -const std::string FileUtils::GetFileFolder(const std::string &filePath) { - std::string folder = StringUtils::GetStrBeforeLast(filePath, FileSeperator::kFileSeperatorStr, true); - return folder.empty() ? ("." + FileSeperator::kFileSeperatorStr) : (folder + FileSeperator::kFileSeperatorStr); +std::string FileUtils::GetFileFolder(const std::string &filePath) { + std::string folder = StringUtils::GetStrBeforeLast(filePath, kFileSeperatorStr, true); + return folder.empty() ? ("." + kFileSeperatorStr) : (folder + kFileSeperatorStr); } -const std::string FileUtils::ConvertPathIfNeeded(const std::string &src) { +std::string FileUtils::ConvertPathIfNeeded(const std::string &src) { std::string ret = src; - ret = StringUtils::Replace(ret, FileSeperator::kFileSeperatorWindowsStyleStr, - FileSeperator::kFileSeperatorLinuxStyleStr); + ret = StringUtils::Replace(ret, kFileSeperatorWindowsStyleStr, + kFileSeperatorLinuxStyleStr); return ret; } -const int FileUtils::Remove(const std::string &filePath) { +int FileUtils::Remove(const std::string &filePath) { return remove(filePath.c_str()); } -const std::string FileUtils::AppendMapleRootIfNeeded(bool needRootPath, const std::string &path, - const std::string &defaultRoot) { +std::string FileUtils::AppendMapleRootIfNeeded(bool needRootPath, const std::string &path, + const std::string &defaultRoot) { if (!needRootPath) { return path; } @@ -54,7 +65,7 @@ const std::string FileUtils::AppendMapleRootIfNeeded(bool needRootPath, const st if (getenv(kMapleRoot) == nullptr) { ostrStream << defaultRoot << path; } else { - ostrStream << getenv(kMapleRoot) << FileSeperator::kFileSeperatorStr << path; + ostrStream << getenv(kMapleRoot) << kFileSeperatorStr << path; } return ostrStream.str(); } diff --git a/src/maple_driver/src/jbc2mpl_compiler.cpp b/src/maple_driver/src/jbc2mpl_compiler.cpp index db0d0c942cdfe752400f5e5dde9d0b77c8c4e613..ad0c84b2969d7e4bef0f3527d96649a9750d4b70 100644 --- a/src/maple_driver/src/jbc2mpl_compiler.cpp +++ b/src/maple_driver/src/jbc2mpl_compiler.cpp @@ -17,17 +17,17 @@ #include "default_options.def" namespace maple { -const std::string Jbc2MplCompiler::GetBinName() const { +std::string Jbc2MplCompiler::GetBinName() const { return kBinNameJbc2mpl; } -const std::vector Jbc2MplCompiler::GetBinNames() const { +std::vector Jbc2MplCompiler::GetBinNames() const { auto binNames = std::vector(); binNames.push_back(kBinNameJbc2mpl); return binNames; } -const DefaultOption Jbc2MplCompiler::GetDefaultOptions(const MplOptions &options) { +DefaultOption Jbc2MplCompiler::GetDefaultOptions(const MplOptions &options) { DefaultOption defaultOptions = { nullptr, 0 }; return defaultOptions; } @@ -36,7 +36,7 @@ void Jbc2MplCompiler::GetTmpFilesToDelete(const MplOptions &mplOptions, std::vec tempFiles.push_back(mplOptions.GetOutputFolder() + mplOptions.GetOutputName() + ".mpl"); } -const std::unordered_set Jbc2MplCompiler::GetFinalOutputs(const MplOptions &mplOptions) const { +std::unordered_set Jbc2MplCompiler::GetFinalOutputs(const MplOptions &mplOptions) const { auto finalOutputs = std::unordered_set(); finalOutputs.insert(mplOptions.GetOutputFolder() + mplOptions.GetOutputName() + ".mpl"); return finalOutputs; diff --git a/src/maple_driver/src/maple_comb_compiler.cpp b/src/maple_driver/src/maple_comb_compiler.cpp index 05ac07fedcf4561ce2914197d8874b711dbddf2e..e08ce349cfbec52eec312c732fb3a7c8c731fabb 100644 --- a/src/maple_driver/src/maple_comb_compiler.cpp +++ b/src/maple_driver/src/maple_comb_compiler.cpp @@ -23,7 +23,7 @@ namespace maple { using namespace mapleOption; -const std::string MapleCombCompiler::GetInputFileName(const MplOptions &options) const { +std::string MapleCombCompiler::GetInputFileName(const MplOptions &options) const { if (options.GetInputFileType() == InputFileType::kVtableImplMpl) { return options.GetOutputFolder() + options.GetOutputName() + ".VtableImpl.mpl"; } else { @@ -32,7 +32,7 @@ const std::string MapleCombCompiler::GetInputFileName(const MplOptions &options) } -const std::unordered_set MapleCombCompiler::GetFinalOutputs(const MplOptions &mplOptions) const { +std::unordered_set MapleCombCompiler::GetFinalOutputs(const MplOptions &mplOptions) const { auto finalOutputs = std::unordered_set(); finalOutputs.insert(mplOptions.GetOutputFolder() + mplOptions.GetOutputName() + ".VtableImpl.mpl"); return finalOutputs; diff --git a/src/maple_driver/src/mpl_options.cpp b/src/maple_driver/src/mpl_options.cpp index d739aab91483a4d5b9042048d20b2fd300b98ae8..f847d04ec1a73fbe3a7a176b41e3194d5203682d 100644 --- a/src/maple_driver/src/mpl_options.cpp +++ b/src/maple_driver/src/mpl_options.cpp @@ -25,9 +25,799 @@ #include "version.h" #include "default_options.def" -using namespace mapleOption; +namespace { +using namespace maple; +const mapleOption::Descriptor USAGES[] = { + // index, type , shortOption , longOption, connector, isCanAppend, delimiter, enableBuildType, checkPolicy, help, + // extra + { kUnknown, + 0, + nullptr, + nullptr, + nullptr, + false, + nullptr, + mapleOption::BuildType::kBuildTypeAll, + mapleOption::ArgCheckPolicy::kArgCheckPolicyNone, + "USAGE: maple [options]\n\n Options:", + "all", + { { nullptr } } }, + { kHelp, + 0, + "h", + "help", + nullptr, + false, + nullptr, + mapleOption::BuildType::kBuildTypeAll, + mapleOption::ArgCheckPolicy::kArgCheckPolicyOptional, + " -h --help [command] \tPrint usage and exit.\n", + "all", + { { nullptr } } }, + { kVersion, + 0, + nullptr, + "version", + nullptr, + false, + nullptr, + mapleOption::BuildType::kBuildTypeAll, + mapleOption::ArgCheckPolicy::kArgCheckPolicyOptional, + " --version [command] \tPrint version and exit.\n", + "all", + { { nullptr } } }, + { kInFile, + 0, + nullptr, + "infile", + nullptr, + false, + nullptr, + mapleOption::BuildType::kBuildTypeAll, + mapleOption::ArgCheckPolicy::kArgCheckPolicyRequired, + " --infile file1,file2,file3 \tInput files.\n", + "all", + { { nullptr } } }, + { kInMplt, + 0, + nullptr, + "mplt", + "=", + true, + ",", + mapleOption::BuildType::kBuildTypeAll, + mapleOption::ArgCheckPolicy::kArgCheckPolicyRequired, + " --mplt=file1,file2,file3 \tImport mplt files.\n", + "all", + { { "jbc2mpl", "-mplt", " ", nullptr }, + // End + { nullptr, nullptr, nullptr, nullptr } } }, + { kOptimization0, + 0, + "O0", + nullptr, + nullptr, + false, + nullptr, + mapleOption::BuildType::kBuildTypeAll, + mapleOption::ArgCheckPolicy::kArgCheckPolicyNone, + " -O0 \tNo optimization.\n", + "all", + { { nullptr } } }, + { kMeOpt, + 0, + nullptr, + "me-opt", + nullptr, + false, + nullptr, + mapleOption::BuildType::kBuildTypeAll, + mapleOption::ArgCheckPolicy::kArgCheckPolicyNone, + " --me-opt \tSet options for me\n", + "all", + { { nullptr } } }, + { kMpl2MplOpt, + 0, + nullptr, + "mpl2mpl-opt", + nullptr, + false, + nullptr, + mapleOption::BuildType::kBuildTypeAll, + mapleOption::ArgCheckPolicy::kArgCheckPolicyNone, + " --mpl2mpl-opt \tSet options for mpl2mpl\n", + "all", + { { nullptr } } }, + { kSaveTemps, + 0, + nullptr, + "save-temps", + nullptr, + false, + nullptr, + mapleOption::BuildType::kBuildTypeAll, + mapleOption::ArgCheckPolicy::kArgCheckPolicyNone, + " --save-temps \tDo not delete intermediate files.\n" + " \t--save-temps Save all intermediate files.\n" + " \t--save-temps=file1,file2,file3 Save the\n" + " \ttarget files.\n", + "all", + { { nullptr } } }, + { kRun, + 0, + nullptr, + "run", + nullptr, + false, + nullptr, + mapleOption::BuildType::kBuildTypeDebug, + mapleOption::ArgCheckPolicy::kArgCheckPolicyRequired, + " --run=cmd1:cmd2 \tThe name of executables that are going\n" + " \tto execute. IN SEQUENCE.\n" + " \tSeparated by \":\".Available exe names:\n" + " \tjbc2mpl, me, mpl2mpl, mplcg\n" + " \tInput file must match the tool can\n" + " \thandle\n", + "all", + { { nullptr } } }, + { kOption, + 0, + nullptr, + "option", + nullptr, + false, + nullptr, + mapleOption::BuildType::kBuildTypeDebug, + mapleOption::ArgCheckPolicy::kArgCheckPolicyRequired, + " --option=\"opt1:opt2\" \tOptions for each executable,\n" + " \tseparated by \":\".\n" + " \tThe sequence must match the sequence in\n" + " \t--run.\n", + "all", + { { nullptr } } }, + { kCombTimePhases, + 0, + "time-phases", + nullptr, + nullptr, + false, + nullptr, + mapleOption::BuildType::kBuildTypeAll, + mapleOption::ArgCheckPolicy::kArgCheckPolicyNone, + " -time-phases \tTiming phases and print percentages\n", + "all", + { { nullptr } } }, + { kGenMeMpl, + 0, + nullptr, + "genmempl", + nullptr, + false, + nullptr, + mapleOption::BuildType::kBuildTypeAll, + mapleOption::ArgCheckPolicy::kArgCheckPolicyNone, + " --genmempl \tGenerate me.mpl file\n", + "all", + { { nullptr } } }, + { kGenVtableImpl, + 0, + nullptr, + "genVtableImpl", + nullptr, + false, + nullptr, + mapleOption::BuildType::kBuildTypeAll, + mapleOption::ArgCheckPolicy::kArgCheckPolicyNone, + " --genVtableImpl \tGenerate VtableImpl.mpl file\n", + "all", + { { nullptr } } }, + { kVerify, + 0, + nullptr, + "verify", + nullptr, + false, + nullptr, + mapleOption::BuildType::kBuildTypeAll, + mapleOption::ArgCheckPolicy::kArgCheckPolicyNone, + " --verify \tVerify mpl file\n", + "all", + { { nullptr } } }, + { kAllDebug, + 0, + nullptr, + "debug", + nullptr, + false, + nullptr, + mapleOption::BuildType::kBuildTypeAll, + mapleOption::ArgCheckPolicy::kArgCheckPolicyNone, + " --debug \tPrint debug info.\n", + "all", + { { nullptr } } }, + // jbc2mpl + { kUseStringFactory, + 0, + nullptr, + "use-string-factory", + nullptr, + false, + nullptr, + mapleOption::BuildType::kBuildTypeAll, + mapleOption::ArgCheckPolicy::kArgCheckPolicyNone, + " -use-string-factory \tReplace String. by StringFactory call\n", + "jbc2mpl", + { { nullptr } } }, + { kJbc2mplOutMpl, + 0, + "o", + "out", + nullptr, + false, + nullptr, + mapleOption::BuildType::kBuildTypeDebug, + mapleOption::ArgCheckPolicy::kArgCheckPolicyRequired, + " -o, -out=output.mpl \toutput mpl name\n", + "jbc2mpl", + { { nullptr } } }, + // me + { kMeHelp, + 0, + "h-me", + "help-me", + nullptr, + false, + nullptr, + mapleOption::BuildType::kBuildTypeAll, + mapleOption::ArgCheckPolicy::kArgCheckPolicyOptional, + " -h-me --help-me \tPrint usage and exit.Available command names:\n" + " \tme\n", + "all", + { { nullptr } } }, + { kMeRange, + 0, + nullptr, + "range", + nullptr, + false, + nullptr, + mapleOption::BuildType::kBuildTypeAll, + mapleOption::ArgCheckPolicy::kArgCheckPolicyRequired, + " --range \tOptimize only functions in the range [NUM0, NUM1]\n" + " \t--range=NUM0,NUM1\n", + "me", + { { nullptr } } }, + { kMeDumpPhases, + 0, + nullptr, + "dump-phases", + nullptr, + false, + nullptr, + mapleOption::BuildType::kBuildTypeAll, + mapleOption::ArgCheckPolicy::kArgCheckPolicyRequired, + " --dump-phases \tEnable debug trace for specified phases in the comma separated list\n" + " \t--dump-phases=PHASENAME,...\n", + "me", + { { nullptr } } }, + { kMeSkipPhases, + 0, + nullptr, + "skip-phases", + nullptr, + false, + nullptr, + mapleOption::BuildType::kBuildTypeAll, + mapleOption::ArgCheckPolicy::kArgCheckPolicyRequired, + " --skip-phases \tSkip the phases specified in the comma separated list\n" + " \t--skip-phases=PHASENAME,...\n", + "me", + { { nullptr } } }, + { kMeDumpFunc, + 0, + nullptr, + "dump-func", + nullptr, + false, + nullptr, + mapleOption::BuildType::kBuildTypeAll, + mapleOption::ArgCheckPolicy::kArgCheckPolicyRequired, + " --dump-func \tDump/trace only for functions whose names contain FUNCNAME as substring\n" + " \t(can only specify once)\n" + " \t--dump-func=FUNCNAME\n", + "me", + { { nullptr } } }, + { kMeQuiet, + 0, + nullptr, + "quiet", + nullptr, + false, + nullptr, + mapleOption::BuildType::kBuildTypeAll, + mapleOption::ArgCheckPolicy::kArgCheckPolicyNone, + " --quiet \tDisable brief trace messages with phase/function names\n", + "me", + { { nullptr } } }, + { kMeNoDot, + 0, + nullptr, + "nodot", + nullptr, + false, + nullptr, + mapleOption::BuildType::kBuildTypeAll, + mapleOption::ArgCheckPolicy::kArgCheckPolicyNone, + " --nodot \tDisable dot file generation from cfg\n", + "me", + { { nullptr } } }, + { kSetCalleeHasSideEffect, + 0, + nullptr, + "setCalleeHasSideEffect", + nullptr, + false, + nullptr, + mapleOption::BuildType::kBuildTypeAll, + mapleOption::ArgCheckPolicy::kArgCheckPolicyNone, + " --setCalleeHasSideEffect \tSet all the callees have side effect\n", + "me", + { { nullptr } } }, + { kNoSteensgaard, + 0, + nullptr, + "noSteensgaard", + nullptr, + false, + nullptr, + mapleOption::BuildType::kBuildTypeAll, + mapleOption::ArgCheckPolicy::kArgCheckPolicyNone, + " --noSteensgaard \tDisable Steensgaard-style alias analysis\n", + "me", + { { nullptr } } }, + { kNoTBAA, + 0, + nullptr, + "noTBAA", + nullptr, + false, + nullptr, + mapleOption::BuildType::kBuildTypeAll, + mapleOption::ArgCheckPolicy::kArgCheckPolicyNone, + " --noTBAA \tDisable type-based alias analysis\n", + "me", + { { nullptr } } }, + { kAliasAnalysisLevel, + 0, + nullptr, + "aliasAnalysisLevel", + nullptr, + false, + nullptr, + mapleOption::BuildType::kBuildTypeAll, + mapleOption::ArgCheckPolicy::kArgCheckPolicyRequired, + " --aliasAnalysisLevel \tSet level of alias analysis. \n" + " \t0: most conservative;\n" + " \t1: Steensgaard-style alias analysis; 2: type-based alias analysis;\n" + " \t3: Steensgaard-style and type-based alias analysis\n" + " \t--aliasAnalysisLevel=NUM\n", + "me", + { { nullptr } } }, + { kStmtNum, + 0, + nullptr, + "stmtnum", + nullptr, + false, + nullptr, + mapleOption::BuildType::kBuildTypeAll, + mapleOption::ArgCheckPolicy::kArgCheckPolicyNone, + " --stmtnum \tPrint MeStmt index number in IR dump\n", + "me", + { { nullptr } } }, + { kMeDumpAfter, + 0, + nullptr, + "dump-after", + nullptr, + false, + nullptr, + mapleOption::BuildType::kBuildTypeAll, + mapleOption::ArgCheckPolicy::kArgCheckPolicyNone, + " --dump-after \tDo extra IR dump after the specified phase in me\n", + "me", + { { nullptr } } }, + { kLessThrowAlias, + 0, + nullptr, + "lessthrowalias", + nullptr, + false, + nullptr, + mapleOption::BuildType::kBuildTypeAll, + mapleOption::ArgCheckPolicy::kArgCheckPolicyNone, + " --lessthrowalias \tHandle aliases at java throw statements more accurately\n", + "me", + { { nullptr } } }, + { kFinalFieldAlias, + 0, + nullptr, + "finalfieldalias", + nullptr, + false, + nullptr, + mapleOption::BuildType::kBuildTypeAll, + mapleOption::ArgCheckPolicy::kArgCheckPolicyNone, + " --finalfieldalias \tRegard final fields as having alias like other fields\n", + "me", + { { nullptr } } }, + { kRegReadAtReturn, + 0, + nullptr, + "regreadatreturn", + nullptr, + false, + nullptr, + mapleOption::BuildType::kBuildTypeAll, + mapleOption::ArgCheckPolicy::kArgCheckPolicyNone, + " --regreadatreturn \tAllow register promotion to promote the operand of return statements\n", + "me", + { { nullptr } } }, + // mpl2mpl + { kMpl2MplHelp, + 0, + "h-mpl2mpl", + "help-mpl2mpl", + nullptr, + false, + nullptr, + mapleOption::BuildType::kBuildTypeAll, + mapleOption::ArgCheckPolicy::kArgCheckPolicyOptional, + " -h-mpl2mpl --help-mpl2mpl \tPrint usage and exit.Available command names:\n" + " \tmpl2mpl\n", + "all", + { { nullptr } } }, + { kMpl2MplDumpPhase, + 0, + nullptr, + "dump-phase", + nullptr, + false, + nullptr, + mapleOption::BuildType::kBuildTypeAll, + mapleOption::ArgCheckPolicy::kArgCheckPolicyRequired, + " --dump-phase \tEnable debug trace for specified phase (can only specify once)\n" + " \t--dump-phase=PHASENAME\n", + "mpl2mpl", + { { nullptr } } }, + { kMpl2MplSkipPhase, + 0, + nullptr, + "skip-phase", + nullptr, + false, + nullptr, + mapleOption::BuildType::kBuildTypeAll, + mapleOption::ArgCheckPolicy::kArgCheckPolicyRequired, + " --skip-phase \tSkip the phase when adding it to phase manager\n" + " \t--skip-phase=PHASENAME\n", + "mpl2mpl", + { { nullptr } } }, + { kMpl2MplSkipFrom, + 0, + nullptr, + "skip-from", + nullptr, + false, + nullptr, + mapleOption::BuildType::kBuildTypeAll, + mapleOption::ArgCheckPolicy::kArgCheckPolicyRequired, + " --skip-from \tSkip all remaining phases including PHASENAME\n" + " \t--skip-from=PHASENAME\n", + "mpl2mpl", + { { nullptr } } }, + { kMpl2MplSkipAfter, + 0, + nullptr, + "skip-after", + nullptr, + false, + nullptr, + mapleOption::BuildType::kBuildTypeAll, + mapleOption::ArgCheckPolicy::kArgCheckPolicyRequired, + " --skip-after \tSkip all remaining phases after PHASENAME\n" + " \t--skip-after=PHASENAME\n", + "mpl2mpl", + { { nullptr } } }, + { kMpl2MplDumpFunc, + 0, + nullptr, + "dump-func", + nullptr, + false, + nullptr, + mapleOption::BuildType::kBuildTypeAll, + mapleOption::ArgCheckPolicy::kArgCheckPolicyRequired, + " --dump-func \tDump/trace only for functions whose names contain FUNCNAME as substring\n" + " \t(can only specify once)\n" + " \t--dump-func=FUNCNAME\n", + "mpl2mpl", + { { nullptr } } }, + { kMpl2MplQuiet, + 0, + nullptr, + "quiet", + nullptr, + false, + nullptr, + mapleOption::BuildType::kBuildTypeAll, + mapleOption::ArgCheckPolicy::kArgCheckPolicyNone, + " --quiet \tDisable brief trace messages with phase/function names\n", + "mpl2mpl", + { { nullptr } } }, + { kMpl2MplMapleLinker, + 0, + nullptr, + "maplelinker", + nullptr, + false, + nullptr, + mapleOption::BuildType::kBuildTypeAll, + mapleOption::ArgCheckPolicy::kArgCheckPolicyNone, + " --maplelinker \tGenerate MUID symbol tables and references\n", + "mpl2mpl", + { { nullptr } } }, + { kMpl2MplStubJniFunc, + 0, + nullptr, + "regnativefunc", + nullptr, + false, + nullptr, + mapleOption::BuildType::kBuildTypeAll, + mapleOption::ArgCheckPolicy::kArgCheckPolicyNone, + " --regnativefunc \tGenerate native stub function to support JNI registration and calling\n", + "mpl2mpl", + { { nullptr } } }, + { kNativeWrapper, + kEnable, + nullptr, + "nativewrapper", + nullptr, + false, + nullptr, + mapleOption::BuildType::kBuildTypeAll, + mapleOption::ArgCheckPolicy::kArgCheckPolicyNone, + " --nativewrapper \tGenerate native wrappers [default]\n", + "mpl2mpl", + { { nullptr } } }, + { kNativeWrapper, + kDisable, + nullptr, + "no-nativewrapper", + nullptr, + false, + nullptr, + mapleOption::BuildType::kBuildTypeAll, + mapleOption::ArgCheckPolicy::kArgCheckPolicyNone, + " --no-nativewrapper\n", + "mpl2mpl", + { { nullptr } } }, + { kRegNativeDynamicOnly, + 0, + nullptr, + "regnative-dynamic-only", + nullptr, + false, + nullptr, + mapleOption::BuildType::kBuildTypeAll, + mapleOption::ArgCheckPolicy::kArgCheckPolicyNone, + " --regnative-dynamic-only \tOnly Generate dynamic register code, Report Fatal Msg if no implemented\n", + "mpl2mpl", + { { nullptr } } }, + { kRegNativeStaticBindingList, + 0, + nullptr, + "static-binding-list", + nullptr, + false, + nullptr, + mapleOption::BuildType::kBuildTypeAll, + mapleOption::ArgCheckPolicy::kArgCheckPolicyRequired, + " --static-bindig-list \tOnly Generate static binding function in file configure list\n" + " \t--static-bindig-list=file\n", + "mpl2mpl", + { { nullptr } } }, + { kMpl2MplDumpBefore, + 0, + nullptr, + "dump-before", + nullptr, + false, + nullptr, + mapleOption::BuildType::kBuildTypeAll, + mapleOption::ArgCheckPolicy::kArgCheckPolicyNone, + " --dump-before \tDo extra IR dump before the specified phase\n", + "mpl2mpl", + { { nullptr } } }, + { kMpl2MplDumpAfter, + 0, + nullptr, + "dump-after", + nullptr, + false, + nullptr, + mapleOption::BuildType::kBuildTypeAll, + mapleOption::ArgCheckPolicy::kArgCheckPolicyNone, + " --dump-after \tDo extra IR dump after the specified phase\n", + "mpl2mpl", + { { nullptr } } }, + { kMplnkDumpMuid, + 0, + nullptr, + "dump-muid", + nullptr, + false, + nullptr, + mapleOption::BuildType::kBuildTypeAll, + mapleOption::ArgCheckPolicy::kArgCheckPolicyNone, + " --dump-muid \tDump MUID def information into a .muid file\n", + "mpl2mpl", + { { nullptr } } }, + { kEmitVtableImpl, + 0, + nullptr, + "emitVtableImpl", + nullptr, + false, + nullptr, + mapleOption::BuildType::kBuildTypeAll, + mapleOption::ArgCheckPolicy::kArgCheckPolicyNone, + " --emitVtableImpl \tgenerate VtableImpl file\n", + "mpl2mpl", + { { nullptr } } }, +#if MIR_JAVA + { kMpl2MplSkipVirtual, + 0, + nullptr, + "skipvirtual", + nullptr, + false, + nullptr, + mapleOption::BuildType::kBuildTypeAll, + mapleOption::ArgCheckPolicy::kArgCheckPolicyNone, + " --skipvirtual\n", + "mpl2mpl", + { { nullptr } } }, +#endif + // mplcg + { kPie, + kEnable, + nullptr, + "pie", + nullptr, + false, + nullptr, + mapleOption::BuildType::kBuildTypeAll, + mapleOption::ArgCheckPolicy::kArgCheckPolicyNone, + " --pie \tGenerate position-independent executable\n", + "mplcg", + { { nullptr } } }, + { kPie, + kDisable, + nullptr, + "no-pie", + nullptr, + false, + nullptr, + mapleOption::BuildType::kBuildTypeAll, + mapleOption::ArgCheckPolicy::kArgCheckPolicyNone, + " --no-pie\n", + "mplcg", + { { nullptr } } }, + { kPic, + kEnable, + nullptr, + "fpic", + nullptr, + false, + nullptr, + mapleOption::BuildType::kBuildTypeAll, + mapleOption::ArgCheckPolicy::kArgCheckPolicyNone, + " --fpic \tGenerate position-independent shared library\n", + "mplcg", + { { nullptr } } }, + { kPic, + kDisable, + nullptr, + "no-fpic", + nullptr, + false, + nullptr, + mapleOption::BuildType::kBuildTypeAll, + mapleOption::ArgCheckPolicy::kArgCheckPolicyNone, + " --no-fpic\n", + "mplcg", + { { nullptr } } }, + { kVerbose, + kEnable, + nullptr, + "verbose-asm", + nullptr, + false, + nullptr, + mapleOption::BuildType::kBuildTypeAll, + mapleOption::ArgCheckPolicy::kArgCheckPolicyNone, + " --verbose-asm \tAdd comments to asm output\n", + "mplcg", + { { nullptr } } }, + { kVerbose, + kDisable, + nullptr, + "no-verbose-asm", + nullptr, + false, + nullptr, + mapleOption::BuildType::kBuildTypeAll, + mapleOption::ArgCheckPolicy::kArgCheckPolicyNone, + " --no-verbose-asm\n", + "mplcg", + { { nullptr } } }, + { kCGMapleLinker, + kEnable, + nullptr, + "maplelinker", + nullptr, + false, + nullptr, + mapleOption::BuildType::kBuildTypeAll, + mapleOption::ArgCheckPolicy::kArgCheckPolicyNone, + " --maplelinker \tGenerate the MapleLinker .s format\n", + "mplcg", + { { nullptr } } }, + { kCGQuiet, + kEnable, + nullptr, + "quiet", + nullptr, + false, + nullptr, + mapleOption::BuildType::kBuildTypeAll, + mapleOption::ArgCheckPolicy::kArgCheckPolicyNone, + " --quiet \tBe quiet (don't output debug messages)\n", + "mplcg", + { { nullptr } } }, + { kCGQuiet, + kDisable, + nullptr, + "no-quiet", + nullptr, + false, + nullptr, + mapleOption::BuildType::kBuildTypeAll, + mapleOption::ArgCheckPolicy::kArgCheckPolicyNone, + " --no-quiet\n", + "mplcg", + { { nullptr } } }, + + { kUnknown, + 0, + nullptr, + nullptr, + nullptr, + false, + nullptr, + mapleOption::BuildType::kBuildTypeAll, + mapleOption::ArgCheckPolicy::kArgCheckPolicyNone, + nullptr, + "", + { { nullptr } } } +}; +} // namepsace namespace maple { +using namespace mapleOption; + const std::string kMapleDriverVersion = "mapledriver " + std::to_string(Version::kMajorMplVersion) + "." + std::to_string(Version::kMinorCompilerVersion) + " 20190712"; int MplOptions::Parse(int argc, char **argv) { @@ -300,7 +1090,7 @@ bool MplOptions::Init(const std::string &inputFile) { return true; } -const std::string MplOptions::OptimizationLevelStr() const { +std::string MplOptions::OptimizationLevelStr() const { switch (this->optimizationLevel) { case OptimizationLevel::kO0: { return "-O0"; diff --git a/src/maple_driver/src/mplcg_compiler.cpp b/src/maple_driver/src/mplcg_compiler.cpp index 19174f0f6c9cbb1fe5f3d346d32177cc86163de0..cf91afc60ebff09c48e2862f0872accda4586073 100644 --- a/src/maple_driver/src/mplcg_compiler.cpp +++ b/src/maple_driver/src/mplcg_compiler.cpp @@ -19,7 +19,7 @@ using namespace maple; -const DefaultOption MplcgCompiler::GetDefaultOptions(const MplOptions &options) { +DefaultOption MplcgCompiler::GetDefaultOptions(const MplOptions &options) { DefaultOption defaultOptions = { nullptr, 0 }; if (options.GetOptimizationLevel() == kO0 && options.HasSetDefaultLevel()) { defaultOptions.mplOptions = kMplcgDefaultOptionsO0; @@ -28,17 +28,17 @@ const DefaultOption MplcgCompiler::GetDefaultOptions(const MplOptions &options) return defaultOptions; } -const std::string MplcgCompiler::GetBinName() const { +std::string MplcgCompiler::GetBinName() const { return kBinNameMplcg; } -const std::vector MplcgCompiler::GetBinNames() const { +std::vector MplcgCompiler::GetBinNames() const { auto binNames = std::vector(); binNames.push_back(kBinNameMplcg); return binNames; } -const std::string MplcgCompiler::GetInputFileName(const MplOptions &options) const { +std::string MplcgCompiler::GetInputFileName(const MplOptions &options) const { std::string::size_type idx = options.GetOutputName().find(".VtableImpl"); std::string outputName = options.GetOutputName(); if (idx != std::string::npos) { diff --git a/src/maple_ir/include/types_def.h b/src/maple_ir/include/types_def.h index c957440cdfe52847be622d2b13f988ec29095728..6a876c1dd30fcdd4bcb9cfa0d56cb709f39f999b 100644 --- a/src/maple_ir/include/types_def.h +++ b/src/maple_ir/include/types_def.h @@ -51,7 +51,7 @@ class StIdx { // scope nesting level + symbol table index u.scopeIdx.idx = i; } - ~StIdx() {} + ~StIdx() = default; uint32 Idx() const { return u.scopeIdx.idx; @@ -104,171 +104,63 @@ using PregIdx = int32; using PregIdx16 = int16; using ExprIdx = int32; using FieldID = int32; -class TyIdx { // global type table index - public: - TyIdx() : idx(0) {} - - explicit TyIdx(uint32 i) : idx(i) {} - TyIdx(const TyIdx&) = default; - TyIdx &operator=(const TyIdx&) = default; - - ~TyIdx() {} - - bool operator==(const TyIdx &x) const { - return idx == x.idx; - } - - bool operator!=(const TyIdx &x) const { - return !(*this == x); - } - - bool operator==(const uint32 id) const { - return idx == id; - } - - bool operator!=(const uint32 id) const { - return !(*this == id); - } - - bool operator<(const TyIdx &x) const { - return idx < x.idx; - } - - uint32 GetIdx() const { - return idx; - } - - void SetIdx(uint32 i) { - idx = i; - } - - private: - uint32 idx; -}; - -const TyIdx kInitTyIdx = TyIdx(0); -const TyIdx kNoneTyIdx = TyIdx(UINT32_MAX); -class GStrIdx { // global string table index - public: - GStrIdx() { - idx = 0; - } - - explicit GStrIdx(uint32 i) : idx(i) {} - - ~GStrIdx() {} - - bool operator==(const GStrIdx &x) const { - return idx == x.idx; - } - - bool operator!=(const GStrIdx &x) const { - return !(*this == x); - } - - bool operator==(const uint32 id) const { - return idx == id; - } - bool operator!=(const uint32 id) const { - return !(*this == id); - } - - bool operator<(const GStrIdx &x) const { - return idx < x.idx; - } - - uint32 GetIdx() const { - return idx; - } - - void SetIdx(uint32 i) { - idx = i; - } - - private: - uint32 idx; -}; - -class UStrIdx { // user string table index (from the conststr opcode) +// T is integer, category is Idx kind. +// this template is for instantiating some kinds of Idx Class such as TyIdx, GStrIdx, UStrIdx, U16StrIdx +template +class IdxTemplate { public: - UStrIdx() : idx(0) {} - - explicit UStrIdx(uint32 i) : idx(i) {} - - ~UStrIdx() {} + IdxTemplate() = default; + explicit IdxTemplate(T i) : idx(i) {} + IdxTemplate(const IdxTemplate&) = default; + IdxTemplate &operator=(const IdxTemplate&) = default; + ~IdxTemplate() = default; - bool operator==(const UStrIdx &x) const { + bool operator==(const IdxTemplate &x) const { return idx == x.idx; } - bool operator!=(const UStrIdx &x) const { + bool operator!=(const IdxTemplate &x) const { return !(*this == x); } - bool operator==(const uint32 id) const { + bool operator==(T id) const { return idx == id; } - bool operator!=(const uint32 id) const { + bool operator!=(T id) const { return !(*this == id); } - bool operator<(const UStrIdx &x) const { + bool operator<(const IdxTemplate &x) const { return idx < x.idx; } - uint32 GetIdx() const { + T GetIdx() const { return idx; } - void SetIdx(uint32 i) { + void SetIdx(T i) { idx = i; } private: - uint32 idx; + T idx = 0; }; -class U16StrIdx { // user string table index (from the conststr opcode) - public: - U16StrIdx() : idx(0) {} - - explicit U16StrIdx(uint32 i) : idx(i) {} - - ~U16StrIdx() {} +struct TyIdxCategory {}; +struct GStrIdxCategory {}; +struct UStrIdxCategory {}; +struct U16StrIdxCategory {}; - bool operator==(const U16StrIdx &x) const { - return idx == x.idx; - } +using TyIdx = IdxTemplate; // global type table index +using GStrIdx = IdxTemplate; // global string table index +using UStrIdx = IdxTemplate; // user string table index (from the conststr opcode) +using U16StrIdx = IdxTemplate; // user string table index (from the conststr opcode) - bool operator!=(const U16StrIdx &x) const { - return !(*this == x); - } - - bool operator==(const uint32 id) const { - return idx == id; - } - - bool operator!=(const uint32 id) const { - return !(*this == id); - } - - bool operator<(const U16StrIdx &x) const { - return idx < x.idx; - } - - uint32 GetIdx() const { - return idx; - } - - void SetIdx(uint32 i) { - idx = i; - } +const TyIdx kInitTyIdx = TyIdx(0); +const TyIdx kNoneTyIdx = TyIdx(UINT32_MAX); - private: - uint32 idx; -}; constexpr int kOperandNumUnary = 1; constexpr int kOperandNumBinary = 2; constexpr int kOperandNumTernary = 3; diff --git a/src/maple_me/include/bb.h b/src/maple_me/include/bb.h index e16acd5f8109e8d53b193b016bfea95ebe17050c..9eb8abe39294986d258bc62132289ecf4bd65cd7 100644 --- a/src/maple_me/include/bb.h +++ b/src/maple_me/include/bb.h @@ -14,6 +14,7 @@ */ #ifndef MAPLE_ME_INCLUDE_BB_H #define MAPLE_ME_INCLUDE_BB_H +#include "mpl_number.h" #include "ptr_list_ref.h" #include "ssa.h" @@ -51,25 +52,8 @@ enum BBAttr { kBBIsInLoopForEA // For EA use }; -struct BBId { - size_t idx = 0; - - BBId() = default; - - explicit BBId(size_t i) : idx(i) {} - - bool operator==(const BBId &x) const { - return idx == x.idx; - } - - bool operator!=(const BBId &x) const { - return idx != x.idx; - } - - bool operator<(const BBId &x) const { - return idx < x.idx; - } -}; +class BB; +using BBId = utils::Index; struct OStIdx { size_t idx = 0; @@ -197,7 +181,7 @@ class BB { } uint32 UintID() const { - return static_cast(id.idx); + return static_cast(id); } StmtNode *GetTheOnlyStmtNode() const; @@ -460,7 +444,7 @@ namespace std { template <> struct hash { size_t operator()(const maple::BBId &x) const { - return x.idx; + return x; } }; diff --git a/src/maple_me/include/me_alias_class.h b/src/maple_me/include/me_alias_class.h index 13bae9171ab4f94d8e484c63acc53c55a2ba5b63..1723f2d65d07155a7cd9f52d63a11eaa390588ea 100644 --- a/src/maple_me/include/me_alias_class.h +++ b/src/maple_me/include/me_alias_class.h @@ -24,18 +24,16 @@ class MeAliasClass : public AliasClass { MeAliasClass(MemPool &memPool, MIRModule &mod, SSATab &ssaTab, MeFunction &func, bool lessAliasAtThrow, bool finalFieldHasAlias, bool ignoreIPA, bool debug, bool setCalleeHasSideEffect, KlassHierarchy *kh) : AliasClass(memPool, mod, ssaTab, lessAliasAtThrow, finalFieldHasAlias, ignoreIPA, setCalleeHasSideEffect, kh), - func(func) {} + func(func), enabledDebug(debug) {} virtual ~MeAliasClass() = default; void DoAliasAnalysis(); - std::string PhaseName() const { - return "aliasclass"; - } private: MeFunction &func; + bool enabledDebug; BB *GetBB(BBId id) override { - if (func.GetAllBBs().size() < id.idx) { + if (func.GetAllBBs().size() < id) { return nullptr; } return func.GetBBFromID(id); diff --git a/src/maple_me/include/me_bb_layout.h b/src/maple_me/include/me_bb_layout.h index dd66a2a395830df0379118f3e9e75f16a86efe6b..cadec2c4e01e7f83a75b62f5a907f9e4ac707246 100644 --- a/src/maple_me/include/me_bb_layout.h +++ b/src/maple_me/include/me_bb_layout.h @@ -20,7 +20,7 @@ namespace maple { class BBLayout : public AnalysisResult { public: - BBLayout(MemPool &memPool, MeFunction &f) + BBLayout(MemPool &memPool, MeFunction &f, bool enabledDebug) : AnalysisResult(&memPool), func(f), layoutAlloc(&memPool), @@ -28,21 +28,22 @@ class BBLayout : public AnalysisResult { curBBId(0), bbCreated(false), laidOut(func.GetAllBBs().size(), false, layoutAlloc.Adapter()), - tryOutstanding(false) { - laidOut[func.GetCommonEntryBB()->GetBBId().idx] = true; - laidOut[func.GetCommonExitBB()->GetBBId().idx] = true; + tryOutstanding(false), + enabledDebug(enabledDebug) { + laidOut[func.GetCommonEntryBB()->GetBBId()] = true; + laidOut[func.GetCommonExitBB()->GetBBId()] = true; } virtual ~BBLayout() = default; BB *NextBB() { // return the next BB following strictly program input order - curBBId.idx++; - while (curBBId.idx < func.GetAllBBs().size()) { + curBBId++; + while (curBBId < func.GetAllBBs().size()) { BB *nextBB = func.GetBBFromID(curBBId); - if (nextBB != nullptr && !laidOut[nextBB->GetBBId().idx]) { + if (nextBB != nullptr && !laidOut[nextBB->GetBBId()]) { return nextBB; } - curBBId.idx++; + curBBId++; } return nullptr; } @@ -78,16 +79,13 @@ class BBLayout : public AnalysisResult { } bool IsBBLaidOut(BBId bbid) const { - return laidOut.at(bbid.idx); + return laidOut.at(bbid); } void AddLaidOut(bool val) { return laidOut.push_back(val); } - std::string PhaseName() const { - return "bblayout"; - } private: MeFunction &func; MapleAllocator layoutAlloc; @@ -97,6 +95,7 @@ class BBLayout : public AnalysisResult { // related analysis result MapleVector laidOut; // indexed by bbid to tell if has been laid out bool tryOutstanding; // true if a try laid out but not its endtry + bool enabledDebug; }; class MeDoBBLayout : public MeFuncPhase { diff --git a/src/maple_me/include/me_function.h b/src/maple_me/include/me_function.h index 5e075099f4de17f21a77ef8b356e1b30d891fb1d..41b458521c9c3770b3973d543f19c338fa6a1df5 100644 --- a/src/maple_me/include/me_function.h +++ b/src/maple_me/include/me_function.h @@ -341,8 +341,8 @@ class MeFunction : public FuncEmit { } BB *GetBBFromID(BBId bbID) { - ASSERT(bbID.idx < bbVec.size(), "array index out of range"); - return bbVec.at(bbID.idx); + ASSERT(bbID < bbVec.size(), "array index out of range"); + return bbVec.at(bbID); } SSATab *GetMeSSATab() { diff --git a/src/maple_me/include/me_irmap.h b/src/maple_me/include/me_irmap.h index 19e3f294c5802b90f41e34b070c37c01c958f346..a7300ae0a03e95b76c5534e38f0b6c41730dc264 100644 --- a/src/maple_me/include/me_irmap.h +++ b/src/maple_me/include/me_irmap.h @@ -47,9 +47,6 @@ class MeIRMap : public IRMap { return func; } - std::string PhaseName() const { - return "irmap"; - } private: MeFunction &func; }; diff --git a/src/maple_me/include/me_rc_lowering.h b/src/maple_me/include/me_rc_lowering.h index 8cc45dcbc323bf9952cb1bccda423d7860d96983..8fd461d224f756951eb110e9567b1c3ebcd1c706 100644 --- a/src/maple_me/include/me_rc_lowering.h +++ b/src/maple_me/include/me_rc_lowering.h @@ -23,12 +23,13 @@ namespace maple { class RCLowering { public: - RCLowering(MeFunction &f, KlassHierarchy &kh) + RCLowering(MeFunction &f, KlassHierarchy &kh, bool enabledDebug) : func(f), mirModule(f.GetMIRModule()), irMap(*f.GetIRMap()), ssaTab(*f.GetMeSSATab()), - klassHierarchy(kh) {} + klassHierarchy(kh), + enabledDebug(enabledDebug) {} virtual ~RCLowering() = default; @@ -55,9 +56,7 @@ class RCLowering { std::map varOStMap{}; // used to store initialized map, help to optimize dec ref in first assignment std::unordered_map*> initializedFields{}; - std::string PhaseName() const { - return "rclowering"; - } + bool enabledDebug; void MarkLocalRefVar(); void MarkAllRefOpnds(); void BBLower(BB &bb); diff --git a/src/maple_me/include/me_ssa.h b/src/maple_me/include/me_ssa.h index ae9ddc4baa452ddbe527ca41c975ee46e7e990da..276d899226951b5b72c11d7990d26bfea832a700 100644 --- a/src/maple_me/include/me_ssa.h +++ b/src/maple_me/include/me_ssa.h @@ -25,7 +25,7 @@ namespace maple { class MeSSA : public SSA, public AnalysisResult { public: - MeSSA(MeFunction *func, Dominance *dom, MemPool *memPool); + MeSSA(MeFunction *func, Dominance *dom, MemPool *memPool, bool enabledDebug); ~MeSSA() = default; void BuildSSA(); @@ -38,9 +38,7 @@ class MeSSA : public SSA, public AnalysisResult { void CollectDefBBs(std::map> &ostDefBBs); void InsertPhiNode(); void RenameBB(BB&); - std::string PhaseName() const { - return "ssa"; - } + bool enabledDebug; }; class MeDoSSA : public MeFuncPhase { diff --git a/src/maple_me/src/bb.cpp b/src/maple_me/src/bb.cpp index aecb151c49d8b9c683c391831c95c9615c086e0f..fc4b72dc69b015072447b46f00e2ffd3830b5c7a 100644 --- a/src/maple_me/src/bb.cpp +++ b/src/maple_me/src/bb.cpp @@ -73,16 +73,16 @@ void BB::DumpBBAttribute(MIRModule *mod) { } void BB::DumpHeader(MIRModule *mod) { - mod->GetOut() << "============BB id:" << GetBBId().idx << " " << StrAttribute() << " ["; + mod->GetOut() << "============BB id:" << GetBBId() << " " << StrAttribute() << " ["; DumpBBAttribute(mod); mod->GetOut() << "]===============\n"; mod->GetOut() << "preds: "; for (const auto &predElement : pred) { - mod->GetOut() << predElement->GetBBId().idx << " "; + mod->GetOut() << predElement->GetBBId() << " "; } mod->GetOut() << "\nsuccs: "; for (const auto &succElement : succ) { - mod->GetOut() << succElement->GetBBId().idx << " "; + mod->GetOut() << succElement->GetBBId() << " "; } mod->GetOut() << "\n"; if (bbLabel != 0) { @@ -256,22 +256,22 @@ void BB::ReplaceSuccOfCommonEntryBB(const BB *old, BB *newSucc) { } void BB::FindReachableBBs(std::vector &visitedBBs) const { - CHECK_FATAL(GetBBId().idx < visitedBBs.size(), "out of range in BB::FindReachableBBs"); - if (visitedBBs[GetBBId().idx]) { + CHECK_FATAL(GetBBId() < visitedBBs.size(), "out of range in BB::FindReachableBBs"); + if (visitedBBs[GetBBId()]) { return; } - visitedBBs[GetBBId().idx] = true; + visitedBBs[GetBBId()] = true; for (auto it = succ.begin(); it != succ.end(); ++it) { (*it)->FindReachableBBs(visitedBBs); } } void BB::FindWillExitBBs(std::vector &visitedBBs) const { - CHECK_FATAL(GetBBId().idx < visitedBBs.size(), "out of range in BB::FindReachableBBs"); - if (visitedBBs[GetBBId().idx]) { + CHECK_FATAL(GetBBId() < visitedBBs.size(), "out of range in BB::FindReachableBBs"); + if (visitedBBs[GetBBId()]) { return; } - visitedBBs[GetBBId().idx] = true; + visitedBBs[GetBBId()] = true; for (auto it = pred.begin(); it != pred.end(); ++it) { (*it)->FindWillExitBBs(visitedBBs); } diff --git a/src/maple_me/src/dominance.cpp b/src/maple_me/src/dominance.cpp index 091a64b53c86c038a6ce044768c375f9989f765a..977c0edb23424e93a693e07d9e8f78dcf0a3b572 100644 --- a/src/maple_me/src/dominance.cpp +++ b/src/maple_me/src/dominance.cpp @@ -18,16 +18,16 @@ /* ================= for Dominance ================= */ namespace maple { 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]) { + ASSERT(bb.GetBBId() < visitedMap.size(), "index out of range in Dominance::PostOrderWalk"); + if (visitedMap[bb.GetBBId()]) { return; } - visitedMap[bb.GetBBId().idx] = true; + visitedMap[bb.GetBBId()] = true; for (BB *suc : bb.GetSucc()) { PostOrderWalk(*suc, pid, visitedMap); } - ASSERT(bb.GetBBId().idx < postOrderIDVec.size(), "index out of range in Dominance::PostOrderWalk"); - postOrderIDVec[bb.GetBBId().idx] = pid++; + ASSERT(bb.GetBBId() < postOrderIDVec.size(), "index out of range in Dominance::PostOrderWalk"); + postOrderIDVec[bb.GetBBId()] = pid++; return; } @@ -52,11 +52,11 @@ BB *Dominance::Intersect(BB &bb1, const BB &bb2) { auto *ptrBB1 = &bb1; auto *ptrBB2 = &bb2; while (ptrBB1 != ptrBB2) { - while (postOrderIDVec[ptrBB1->GetBBId().idx] < postOrderIDVec[ptrBB2->GetBBId().idx]) { - ptrBB1 = doms[ptrBB1->GetBBId().idx]; + while (postOrderIDVec[ptrBB1->GetBBId()] < postOrderIDVec[ptrBB2->GetBBId()]) { + ptrBB1 = doms[ptrBB1->GetBBId()]; } - while (postOrderIDVec[ptrBB2->GetBBId().idx] < postOrderIDVec[ptrBB1->GetBBId().idx]) { - ptrBB2 = doms[ptrBB2->GetBBId().idx]; + while (postOrderIDVec[ptrBB2->GetBBId()] < postOrderIDVec[ptrBB1->GetBBId()]) { + ptrBB2 = doms[ptrBB2->GetBBId()]; } } return ptrBB1; @@ -73,7 +73,7 @@ bool Dominance::CommonEntryBBIsPred(const BB &bb) const { // Figure 3 in "A Simple, Fast Dominance Algorithm" by Keith Cooper et al. void Dominance::ComputeDominance() { - doms.at(commonEntryBB.GetBBId().idx) = &commonEntryBB; + doms.at(commonEntryBB.GetBBId()) = &commonEntryBB; bool changed = false; do { changed = false; @@ -86,19 +86,19 @@ void Dominance::ComputeDominance() { pre = bb->GetPred(0); } size_t j = 1; - while ((doms[pre->GetBBId().idx] == nullptr || pre == bb) && j < bb->GetPred().size()) { + while ((doms[pre->GetBBId()] == nullptr || pre == bb) && j < bb->GetPred().size()) { pre = bb->GetPred(j); j++; } BB *newIDom = pre; for (; j < bb->GetPred().size(); j++) { pre = bb->GetPred(j); - if (doms[pre->GetBBId().idx] != nullptr && pre != bb) { + if (doms[pre->GetBBId()] != nullptr && pre != bb) { newIDom = Intersect(*pre, *newIDom); } } - if (doms[bb->GetBBId().idx] != newIDom) { - doms[bb->GetBBId().idx] = newIDom; + if (doms[bb->GetBBId()] != newIDom) { + doms[bb->GetBBId()] = newIDom; changed = true; } } @@ -116,9 +116,9 @@ void Dominance::ComputeDomFrontiers() { } for (BB *pre : bb->GetPred()) { BB *runner = pre; - while (runner != doms[bb->GetBBId().idx] && runner != &commonEntryBB) { - domFrontier[runner->GetBBId().idx].insert(bb->GetBBId()); - runner = doms[runner->GetBBId().idx]; + while (runner != doms[bb->GetBBId()] && runner != &commonEntryBB) { + domFrontier[runner->GetBBId()].insert(bb->GetBBId()); + runner = doms[runner->GetBBId()]; } } } @@ -129,28 +129,28 @@ void Dominance::ComputeDomChildren() { if (bb == nullptr) { continue; } - if (doms[bb->GetBBId().idx] == nullptr) { + if (doms[bb->GetBBId()] == nullptr) { continue; } - BB *parent = doms[bb->GetBBId().idx]; + BB *parent = doms[bb->GetBBId()]; if (parent == bb) { continue; } - domChildren[parent->GetBBId().idx].insert(bb->GetBBId()); + domChildren[parent->GetBBId()].insert(bb->GetBBId()); } } void Dominance::ComputeDtPreorder(const BB &bb, size_t &num) { CHECK_FATAL(num < dtPreOrder.size(), "index out of range in Dominance::ComputeDtPreorder"); dtPreOrder[num++] = bb.GetBBId(); - for (BBId k : domChildren[bb.GetBBId().idx]) { - ComputeDtPreorder(*bbVec[k.idx], num); + for (BBId k : domChildren[bb.GetBBId()]) { + ComputeDtPreorder(*bbVec[k], num); } } void Dominance::ComputeDtDfn() { for (uint32 i = 0; i < dtPreOrder.size(); i++) { - dtDfn[dtPreOrder[i].idx] = i; + dtDfn[dtPreOrder[i]] = i; } } @@ -159,8 +159,8 @@ bool Dominance::Dominate(const BB &bb1, BB &bb2) { if (&bb1 == &bb2) { return true; } - CHECK_FATAL(bb2.GetBBId().idx < doms.size(), "index out of range in Dominance::Dominate "); - if (doms[bb2.GetBBId().idx] == nullptr) { + CHECK_FATAL(bb2.GetBBId() < doms.size(), "index out of range in Dominance::Dominate "); + if (doms[bb2.GetBBId()] == nullptr) { return false; } BB *immediateDom = &bb2; @@ -168,7 +168,7 @@ bool Dominance::Dominate(const BB &bb1, BB &bb2) { if (immediateDom == nullptr) { return false; } - immediateDom = doms[immediateDom->GetBBId().idx]; + immediateDom = doms[immediateDom->GetBBId()]; if (immediateDom == &bb1) { return true; } @@ -178,19 +178,19 @@ bool Dominance::Dominate(const BB &bb1, BB &bb2) { /* ================= for PostDominance ================= */ void Dominance::PdomPostOrderWalk(BB &bb, int32 &pid, std::vector &visitedMap) { - ASSERT(bb.GetBBId().idx < visitedMap.size(), "index out of range in Dominance::PdomPostOrderWalk"); - if (bbVec[bb.GetBBId().idx] == nullptr) { + ASSERT(bb.GetBBId() < visitedMap.size(), "index out of range in Dominance::PdomPostOrderWalk"); + if (bbVec[bb.GetBBId()] == nullptr) { return; } - if (visitedMap[bb.GetBBId().idx]) { + if (visitedMap[bb.GetBBId()]) { return; } - visitedMap[bb.GetBBId().idx] = true; + visitedMap[bb.GetBBId()] = true; for (BB *pre : bb.GetPred()) { PdomPostOrderWalk(*pre, pid, visitedMap); } - CHECK_FATAL(bb.GetBBId().idx < pdomPostOrderIDVec.size(), "index out of range in Dominance::PdomPostOrderWalk"); - pdomPostOrderIDVec[bb.GetBBId().idx] = pid++; + CHECK_FATAL(bb.GetBBId() < pdomPostOrderIDVec.size(), "index out of range in Dominance::PdomPostOrderWalk"); + pdomPostOrderIDVec[bb.GetBBId()] = pid++; return; } @@ -215,11 +215,11 @@ BB *Dominance::PdomIntersect(BB &bb1, const BB &bb2) { auto *ptrBB1 = &bb1; auto *ptrBB2 = &bb2; while (ptrBB1 != ptrBB2) { - while (pdomPostOrderIDVec[ptrBB1->GetBBId().idx] < pdomPostOrderIDVec[ptrBB2->GetBBId().idx]) { - ptrBB1 = pdoms[ptrBB1->GetBBId().idx]; + while (pdomPostOrderIDVec[ptrBB1->GetBBId()] < pdomPostOrderIDVec[ptrBB2->GetBBId()]) { + ptrBB1 = pdoms[ptrBB1->GetBBId()]; } - while (pdomPostOrderIDVec[ptrBB2->GetBBId().idx] < pdomPostOrderIDVec[ptrBB1->GetBBId().idx]) { - ptrBB2 = pdoms[ptrBB2->GetBBId().idx]; + while (pdomPostOrderIDVec[ptrBB2->GetBBId()] < pdomPostOrderIDVec[ptrBB1->GetBBId()]) { + ptrBB2 = pdoms[ptrBB2->GetBBId()]; } } return ptrBB1; @@ -227,7 +227,7 @@ BB *Dominance::PdomIntersect(BB &bb1, const BB &bb2) { // Figure 3 in "A Simple, Fast Dominance Algorithm" by Keith Cooper et al. void Dominance::ComputePostDominance() { - pdoms.at(commonExitBB.GetBBId().idx) = &commonExitBB; + pdoms.at(commonExitBB.GetBBId()) = &commonExitBB; bool changed = false; do { changed = false; @@ -240,23 +240,23 @@ void Dominance::ComputePostDominance() { suc = bb->GetSucc(0); } size_t j = 1; - while ((pdoms[suc->GetBBId().idx] == nullptr || suc == bb) && j < bb->GetSucc().size()) { + while ((pdoms[suc->GetBBId()] == nullptr || suc == bb) && j < bb->GetSucc().size()) { suc = bb->GetSucc(j); j++; } - if (pdoms[suc->GetBBId().idx] == nullptr) { + if (pdoms[suc->GetBBId()] == nullptr) { suc = &commonExitBB; } BB *newIDom = suc; for (; j < bb->GetSucc().size(); j++) { suc = bb->GetSucc(j); - if (pdoms[suc->GetBBId().idx] != nullptr && suc != bb) { + if (pdoms[suc->GetBBId()] != nullptr && suc != bb) { newIDom = PdomIntersect(*suc, *newIDom); } } - if (pdoms[bb->GetBBId().idx] != newIDom) { - pdoms[bb->GetBBId().idx] = newIDom; - ASSERT(pdoms[newIDom->GetBBId().idx] != nullptr, "null ptr check"); + if (pdoms[bb->GetBBId()] != newIDom) { + pdoms[bb->GetBBId()] = newIDom; + ASSERT(pdoms[newIDom->GetBBId()] != nullptr, "null ptr check"); changed = true; } } @@ -274,10 +274,10 @@ void Dominance::ComputePdomFrontiers() { } for (BB *suc : bb->GetSucc()) { BB *runner = suc; - while (runner != pdoms[bb->GetBBId().idx] && runner != &commonEntryBB) { - pdomFrontier[runner->GetBBId().idx].insert(bb->GetBBId()); - ASSERT(pdoms[runner->GetBBId().idx] != nullptr, "ComputePdomFrontiers: pdoms[] is nullptr"); - runner = pdoms[runner->GetBBId().idx]; + while (runner != pdoms[bb->GetBBId()] && runner != &commonEntryBB) { + pdomFrontier[runner->GetBBId()].insert(bb->GetBBId()); + ASSERT(pdoms[runner->GetBBId()] != nullptr, "ComputePdomFrontiers: pdoms[] is nullptr"); + runner = pdoms[runner->GetBBId()]; } } } @@ -285,28 +285,28 @@ void Dominance::ComputePdomFrontiers() { void Dominance::ComputePdomChildren() { for (const BB *bb : bbVec) { - if (bb == nullptr || pdoms[bb->GetBBId().idx] == nullptr) { + if (bb == nullptr || pdoms[bb->GetBBId()] == nullptr) { continue; } - const BB *parent = pdoms[bb->GetBBId().idx]; + const BB *parent = pdoms[bb->GetBBId()]; if (parent == bb) { continue; } - pdomChildren[parent->GetBBId().idx].insert(bb->GetBBId()); + pdomChildren[parent->GetBBId()].insert(bb->GetBBId()); } } void Dominance::ComputePdtPreorder(const BB &bb, size_t &num) { ASSERT(num < pdtPreOrder.size(), "index out of range in Dominance::ComputePdtPreOrder"); pdtPreOrder[num++] = bb.GetBBId(); - for (BBId k : pdomChildren[bb.GetBBId().idx]) { - ComputePdtPreorder(*bbVec[k.idx], num); + for (BBId k : pdomChildren[bb.GetBBId()]) { + ComputePdtPreorder(*bbVec[k], num); } } void Dominance::ComputePdtDfn() { for (uint32 i = 0; i < pdtPreOrder.size(); i++) { - pdtDfn[pdtPreOrder[i].idx] = i; + pdtDfn[pdtPreOrder[i]] = i; } } @@ -315,8 +315,8 @@ bool Dominance::PostDominate(const BB &bb1, BB &bb2) { if (&bb1 == &bb2) { return true; } - CHECK_FATAL(bb2.GetBBId().idx < pdoms.size(), "index out of range in Dominance::PostDominate"); - if (pdoms[bb2.GetBBId().idx] == nullptr) { + CHECK_FATAL(bb2.GetBBId() < pdoms.size(), "index out of range in Dominance::PostDominate"); + if (pdoms[bb2.GetBBId()] == nullptr) { return false; } BB *impdom = &bb2; @@ -324,7 +324,7 @@ bool Dominance::PostDominate(const BB &bb1, BB &bb2) { if (impdom == nullptr) { return false; } - impdom = pdoms[impdom->GetBBId().idx]; + impdom = pdoms[impdom->GetBBId()]; if (impdom == &bb1) { return true; } @@ -335,22 +335,22 @@ bool Dominance::PostDominate(const BB &bb1, BB &bb2) { void Dominance::DumpDoms() { for (size_t i = 0; i < reversePostOrder.size(); i++) { BB *bb = reversePostOrder[i]; - LogInfo::MapleLogger() << "postorder no " << postOrderIDVec[bb->GetBBId().idx]; - LogInfo::MapleLogger() << " is bb:" << bb->GetBBId().idx; - LogInfo::MapleLogger() << " im_dom is bb:" << doms[bb->GetBBId().idx]->GetBBId().idx; + LogInfo::MapleLogger() << "postorder no " << postOrderIDVec[bb->GetBBId()]; + LogInfo::MapleLogger() << " is bb:" << bb->GetBBId(); + LogInfo::MapleLogger() << " im_dom is bb:" << doms[bb->GetBBId()]->GetBBId(); LogInfo::MapleLogger() << " domfrontier: ["; - for (BBId id : domFrontier[bb->GetBBId().idx]) { - LogInfo::MapleLogger() << id.idx << " "; + for (BBId id : domFrontier[bb->GetBBId()]) { + LogInfo::MapleLogger() << id << " "; } LogInfo::MapleLogger() << "] domchildren: ["; - for (BBId id : domChildren[bb->GetBBId().idx]) { - LogInfo::MapleLogger() << id.idx << " "; + for (BBId id : domChildren[bb->GetBBId()]) { + LogInfo::MapleLogger() << id << " "; } LogInfo::MapleLogger() << "]\n"; } LogInfo::MapleLogger() << "\npreorder traversal of dominator tree:"; for (BBId id : dtPreOrder) { - LogInfo::MapleLogger() << id.idx << " "; + LogInfo::MapleLogger() << id << " "; } LogInfo::MapleLogger() << "\n\n"; } @@ -358,23 +358,23 @@ void Dominance::DumpDoms() { void Dominance::DumpPdoms() { for (size_t i = 0; i < pdomReversePostOrder.size(); i++) { BB *bb = pdomReversePostOrder[i]; - LogInfo::MapleLogger() << "pdom_postorder no " << pdomPostOrderIDVec[bb->GetBBId().idx]; - LogInfo::MapleLogger() << " is bb:" << bb->GetBBId().idx; - LogInfo::MapleLogger() << " im_pdom is bb:" << pdoms[bb->GetBBId().idx]->GetBBId().idx; + LogInfo::MapleLogger() << "pdom_postorder no " << pdomPostOrderIDVec[bb->GetBBId()]; + LogInfo::MapleLogger() << " is bb:" << bb->GetBBId(); + LogInfo::MapleLogger() << " im_pdom is bb:" << pdoms[bb->GetBBId()]->GetBBId(); LogInfo::MapleLogger() << " pdomfrontier: ["; - for (BBId id : pdomFrontier[bb->GetBBId().idx]) { - LogInfo::MapleLogger() << id.idx << " "; + for (BBId id : pdomFrontier[bb->GetBBId()]) { + LogInfo::MapleLogger() << id << " "; } LogInfo::MapleLogger() << "] pdomchildren: ["; - for (BBId id : pdomChildren[bb->GetBBId().idx]) { - LogInfo::MapleLogger() << id.idx << " "; + for (BBId id : pdomChildren[bb->GetBBId()]) { + LogInfo::MapleLogger() << id << " "; } LogInfo::MapleLogger() << "]\n"; } LogInfo::MapleLogger() << "\n"; LogInfo::MapleLogger() << "preorder traversal of post-dominator tree:"; for (BBId id : pdtPreOrder) { - LogInfo::MapleLogger() << id.idx << " "; + LogInfo::MapleLogger() << id << " "; } LogInfo::MapleLogger() << "\n\n"; } diff --git a/src/maple_me/src/irmap.cpp b/src/maple_me/src/irmap.cpp index 7fea26371fe42e5e6e8022be70f3cde2601cff94..367d266faf98313b646ac07ea032baf8e28980d8 100644 --- a/src/maple_me/src/irmap.cpp +++ b/src/maple_me/src/irmap.cpp @@ -26,10 +26,10 @@ using MeStmtFactory = FunctionFactory &bbIRMapProcessed) { BBId bbid = bb.GetBBId(); - if (bbIRMapProcessed[bbid.idx]) { + if (bbIRMapProcessed[bbid]) { return; } - bbIRMapProcessed[bbid.idx] = true; + bbIRMapProcessed[bbid] = true; curBB = &bb; SetCurFunction(bb); // iterate phi list to update the definition by phi @@ -41,8 +41,8 @@ void IRMap::BuildBB(BB &bb, std::vector &bbIRMapProcessed) { } } // travesal bb's dominated tree - ASSERT(bbid.idx < dom.GetDomChildrenSize(), " index out of range in IRMap::BuildBB"); - const MapleSet &domChildren = dom.GetDomChildren(bbid.idx); + ASSERT(bbid < dom.GetDomChildrenSize(), " index out of range in IRMap::BuildBB"); + const MapleSet &domChildren = dom.GetDomChildren(bbid); for (auto bbit = domChildren.begin(); bbit != domChildren.end(); bbit++) { BBId childbbid = *bbit; BuildBB(*GetBB(childbbid), bbIRMapProcessed); diff --git a/src/maple_me/src/me_alias_class.cpp b/src/maple_me/src/me_alias_class.cpp index 92faf25d9c3978ead009d5c89ea786ea3de65bcc..6ab01df3fd4216911f0a8ce8d1495248b1669a42 100644 --- a/src/maple_me/src/me_alias_class.cpp +++ b/src/maple_me/src/me_alias_class.cpp @@ -50,7 +50,7 @@ void MeAliasClass::DoAliasAnalysis() { } } CreateAssignSets(); - if (DEBUGFUNC((&func))) { + if (enabledDebug) { DumpAssignSets(); } ReinitUnionFind(); @@ -65,11 +65,11 @@ void MeAliasClass::DoAliasAnalysis() { ReconstructAliasGroups(); } CreateClassSets(); - if (DEBUGFUNC((&func))) { + if (enabledDebug) { DumpClassSets(); } // pass 2 through the program statements - if (DEBUGFUNC((&func))) { + if (enabledDebug) { LogInfo::MapleLogger() << "\n============ Alias Classification Pass 2 ============" << '\n'; } diff --git a/src/maple_me/src/me_bb_layout.cpp b/src/maple_me/src/me_bb_layout.cpp index 6747c87e599f692b15e0c368fd23ba0930507123..64e603d5185fd76cd10c910b1e14a6df90b3c135 100644 --- a/src/maple_me/src/me_bb_layout.cpp +++ b/src/maple_me/src/me_bb_layout.cpp @@ -170,7 +170,7 @@ bool BBLayout::BBCanBeMoved(const BB &fromBB, const BB &toAfterBB) const { if (fromBB.GetPred().size() > 1) { return false; } - if (laidOut[fromBB.GetBBId().idx]) { + if (laidOut[fromBB.GetBBId()]) { return false; } if (fromBB.GetAttributes(kBBAttrArtificial) || @@ -299,20 +299,20 @@ void BBLayout::OptimizeBranchTarget(BB &bb) { // update CFG bb.ReplaceSucc(brTargetBB, newTargetBB); bb.RemoveBBFromVector(brTargetBB->GetPred()); - if (brTargetBB->GetPred().empty() && !laidOut[brTargetBB->GetBBId().idx]) { - laidOut[brTargetBB->GetBBId().idx] = true; + if (brTargetBB->GetPred().empty() && !laidOut[brTargetBB->GetBBId()]) { + laidOut[brTargetBB->GetBBId()] = true; brTargetBB->RemoveBBFromVector(newTargetBB->GetPred()); } } while (true); } void BBLayout::AddBB(BB &bb) { - CHECK_FATAL(bb.GetBBId().idx < laidOut.size(), "index out of range in BBLayout::AddBB"); - ASSERT(!laidOut[bb.GetBBId().idx], "AddBB: bb already laid out"); + CHECK_FATAL(bb.GetBBId() < laidOut.size(), "index out of range in BBLayout::AddBB"); + ASSERT(!laidOut[bb.GetBBId()], "AddBB: bb already laid out"); layoutBBs.push_back(&bb); - laidOut[bb.GetBBId().idx] = true; - if (DEBUGFUNC((&func))) { - LogInfo::MapleLogger() << "bb id " << bb.GetBBId().idx << " kind is " << bb.StrAttribute(); + laidOut[bb.GetBBId()] = true; + if (enabledDebug) { + LogInfo::MapleLogger() << "bb id " << bb.GetBBId() << " kind is " << bb.StrAttribute(); } bool isTry = false; if (func.GetIRMap() != nullptr) { @@ -323,17 +323,17 @@ void BBLayout::AddBB(BB &bb) { if (isTry) { ASSERT(!tryOutstanding, "BBLayout::AddBB: cannot lay out another try without ending the last one"); tryOutstanding = true; - if (DEBUGFUNC((&func))) { + if (enabledDebug) { LogInfo::MapleLogger() << " try"; } } if (bb.GetAttributes(kBBAttrIsTryEnd) && func.GetMIRModule().IsJavaModule()) { tryOutstanding = false; - if (DEBUGFUNC((&func))) { + if (enabledDebug) { LogInfo::MapleLogger() << " endtry"; } } - if (DEBUGFUNC((&func))) { + if (enabledDebug) { LogInfo::MapleLogger() << '\n'; } return; @@ -356,7 +356,7 @@ BB *BBLayout::GetFallThruBBSkippingEmpty(BB &bb) { return fallthru; } } - laidOut[fallthru->GetBBId().idx] = true; + laidOut[fallthru->GetBBId()] = true; fallthru->RemoveBBFromPred(&bb); BB *oldFallthru = fallthru; fallthru = oldFallthru->GetSucc().front(); @@ -402,7 +402,7 @@ void BBLayout::ResolveUnconditionalFallThru(BB &bb, BB &nextBB) { AnalysisResult *MeDoBBLayout::Run(MeFunction *func, MeFuncResultMgr *funcResMgr, ModuleResultMgr *moduleResMgr) { // mempool used in analysisresult MemPool *layoutMp = NewMemPool(); - BBLayout *bbLayout = layoutMp->New(*layoutMp, *func); + BBLayout *bbLayout = layoutMp->New(*layoutMp, *func, DEBUGFUNC(func)); // assume common_entry_bb is always bb 0 ASSERT(func->front() == func->GetCommonEntryBB(), "assume bb[0] is the commont entry bb"); BB *bb = func->GetFirstBB(); diff --git a/src/maple_me/src/me_cfg.cpp b/src/maple_me/src/me_cfg.cpp index dd3667fcc167d4be5a31f45639a6f2b299d36837..3eb03f0583aeb0b64ec3209c9e2cb44152f42ab6 100644 --- a/src/maple_me/src/me_cfg.cpp +++ b/src/maple_me/src/me_cfg.cpp @@ -547,7 +547,7 @@ void MeCFG::UnreachCodeAnalysis(bool updatePhi) { continue; } auto *bb = *bIt; - uint32 idx = bb->GetBBId().idx; + BBId idx = bb->GetBBId(); if (!visitedBBs[idx] && !bb->GetAttributes(kBBAttrIsEntry)) { bb->SetAttributes(kBBAttrWontExit); /* avoid redundant pred before adding to common_exit_bb's pred list */ @@ -561,7 +561,7 @@ void MeCFG::UnreachCodeAnalysis(bool updatePhi) { func.GetCommonExitBB()->GetPred().push_back(bb); } if (!MeOption::quiet) { - LogInfo::MapleLogger() << "#### BB " << bb->GetBBId().idx << " deleted because unreachable\n"; + LogInfo::MapleLogger() << "#### BB " << bb->GetBBId() << " deleted because unreachable\n"; } if (bb->GetAttributes(kBBAttrIsTryEnd)) { // unreachable bb has try end info @@ -620,7 +620,7 @@ void MeCFG::WontExitAnalysis() { continue; } auto *bb = *bIt; - uint32 idx = bb->GetBBId().idx; + BBId idx = bb->GetBBId(); if (!visitedBBs[idx]) { bb->SetAttributes(kBBAttrWontExit); if (!MeOption::quiet) { @@ -655,7 +655,7 @@ void MeCFG::Verify() const { continue; } auto *bb = *bIt; - ASSERT(bb->GetBBId().idx < func.GetAllBBs().size(), "CFG Error!"); + ASSERT(bb->GetBBId() < func.GetAllBBs().size(), "CFG Error!"); ASSERT(func.GetBBFromID(bb->GetBBId()) == bb, "CFG Error!"); if (bb->IsEmpty()) { continue; @@ -734,15 +734,15 @@ void MeCFG::Dump() const { continue; } BBId id = bb->GetBBId(); - if (visitedMap[id.idx] == true) { + if (visitedMap[static_cast(id)] == true) { continue; } - LogInfo::MapleLogger() << id.idx << " "; - visitedMap[id.idx] = true; + LogInfo::MapleLogger() << id << " "; + visitedMap[static_cast(id)] = true; auto it = bb->GetSucc().begin(); while (it != bb->GetSucc().end()) { BB *kidBB = *it; - if (!visitedMap[kidBB->GetBBId().idx]) { + if (!visitedMap[static_cast(kidBB->GetBBId())]) { qu.push(kidBB); } it++; @@ -798,9 +798,9 @@ void MeCFG::DumpToFileInStrs(std::ofstream &cfgFile) const { continue; } if (bb->GetKind() == kBBCondGoto) { - cfgFile << "BB" << bb->GetBBId().idx << "[shape=diamond,label= \" BB" << bb->GetBBId().idx << ":\n{ "; + cfgFile << "BB" << bb->GetBBId() << "[shape=diamond,label= \" BB" << bb->GetBBId() << ":\n{ "; } else { - cfgFile << "BB" << bb->GetBBId().idx << "[shape=box,label= \" BB" << bb->GetBBId().idx << ":\n{ "; + cfgFile << "BB" << bb->GetBBId() << "[shape=box,label= \" BB" << bb->GetBBId() << ":\n{ "; } if (bb->GetBBLabel() != 0) { cfgFile << "@" << func.GetMirFunc()->GetLabelName(bb->GetBBLabel()) << ":\n"; @@ -842,14 +842,14 @@ void MeCFG::DumpToFile(const std::string &prefix, bool dumpInStrs) const { if (bIt == func.common_exit()) { /* specical case for common_exit_bb */ for (auto it = bb->GetPred().begin(); it != bb->GetPred().end(); it++) { - cfgFile << "BB" << (*it)->GetBBId().idx << " -> " - << "BB" << bb->GetBBId().idx << "[style=dotted];\n"; + cfgFile << "BB" << (*it)->GetBBId() << " -> " + << "BB" << bb->GetBBId() << "[style=dotted];\n"; } continue; } for (auto it = bb->GetSucc().begin(); it != bb->GetSucc().end(); it++) { - cfgFile << "BB" << bb->GetBBId().idx << " -> " - << "BB" << (*it)->GetBBId().idx; + cfgFile << "BB" << bb->GetBBId() << " -> " + << "BB" << (*it)->GetBBId(); if (bb == func.GetCommonEntryBB()) { cfgFile << "[style=dotted];\n"; continue; diff --git a/src/maple_me/src/me_function.cpp b/src/maple_me/src/me_function.cpp index 309836adaf301aa3d6710d5545e02f7791299f8b..3a4b1112ae31c8f2fe40ad811bc4e7f6afa8cea3 100644 --- a/src/maple_me/src/me_function.cpp +++ b/src/maple_me/src/me_function.cpp @@ -437,7 +437,7 @@ BB *MeFunction::InsertNewBasicBlock(const BB &position) { BB *newBB = memPool->New(&alloc, &versAlloc, BBId(nextBBId++)); auto bIt = std::find(begin(), end(), &position); - auto idx = position.GetBBId().idx; + auto idx = position.GetBBId(); auto newIt = bbVec.insert(bIt, newBB); auto eIt = end(); // update bb's idx @@ -451,9 +451,9 @@ BB *MeFunction::InsertNewBasicBlock(const BB &position) { } void MeFunction::DeleteBasicBlock(const BB &bb) { - ASSERT(bbVec[bb.GetBBId().idx] == &bb, "runtime check error"); + ASSERT(bbVec[bb.GetBBId()] == &bb, "runtime check error"); /* update first_bb_ and last_bb if needed */ - bbVec.at(bb.GetBBId().idx) = nullptr; + bbVec.at(bb.GetBBId()) = nullptr; } /* get next bb in bbVec */ @@ -525,7 +525,7 @@ BB &MeFunction::SplitBB(BB &bb, StmtNode &splitPoint, BB *newBB) { newBB->SetKind(bb.GetKind()); bb.SetKind(kBBFallthru); auto bIt = std::find(begin(), end(), &bb); - auto idx = bb.GetBBId().idx; + auto idx = bb.GetBBId(); auto newIt = bbVec.insert(++bIt, newBB); auto eIt = end(); // update bb's idx diff --git a/src/maple_me/src/me_rc_lowering.cpp b/src/maple_me/src/me_rc_lowering.cpp index 0053f4fa86bcdffed842bb41969733ad9d516a72..677ba7fa4477bcbf24d808affde8808856673619 100644 --- a/src/maple_me/src/me_rc_lowering.cpp +++ b/src/maple_me/src/me_rc_lowering.cpp @@ -37,7 +37,7 @@ static inline void CheckRemove(MeStmt *stmt, const Opcode op) { void RCLowering::Prepare() { MIRFunction *mirFunction = func.GetMirFunc(); ASSERT(mirFunction->GetModule()->CurFunction() == mirFunction, "unexpected CurFunction"); - if (DEBUGFUNC((&func))) { + if (enabledDebug) { LogInfo::MapleLogger() << "Handling function " << mirFunction->GetName() << '\n'; } } @@ -794,7 +794,7 @@ void RCLowering::PostRCLower() { } void RCLowering::Finish() { - if (DEBUGFUNC((&func))) { + if (enabledDebug) { LogInfo::MapleLogger() << "\n============== After RC LOWERING =============" << '\n'; func.Dump(false); } @@ -842,7 +842,7 @@ AnalysisResult *MeDoRCLowering::Run(MeFunction *func, MeFuncResultMgr *funcResMg func->SetIRMap(hmap); } CHECK_FATAL(func->GetMeSSATab() != nullptr, "ssatab has problem"); - RCLowering rcLowering(*func, *kh); + RCLowering rcLowering(*func, *kh, DEBUGFUNC(func)); rcLowering.Prepare(); rcLowering.PreRCLower(); diff --git a/src/maple_me/src/me_ssa.cpp b/src/maple_me/src/me_ssa.cpp index 99a5124d9a97ad553197f38164f6db11d89c0355..71a2766efd83216efb65b30ed1c1cf4557ffe0c9 100644 --- a/src/maple_me/src/me_ssa.cpp +++ b/src/maple_me/src/me_ssa.cpp @@ -52,7 +52,7 @@ void MeSSA::BuildSSA() { 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); + const MapleSet &children = dom->GetDomChildren(func->GetCommonEntryBB()->GetBBId()); for (const BBId &child : children) { RenameBB(*func->GetBBFromID(child)); } @@ -116,7 +116,7 @@ void MeSSA::InsertPhiNode() { } std::deque *workList = new std::deque(); for (auto it = ost2DefBBs[ost->GetIndex()].begin(); it != ost2DefBBs[ost->GetIndex()].end(); it++) { - BB *defBB = func->GetAllBBs()[(*it).idx]; + BB *defBB = func->GetAllBBs()[*it]; if (defBB != nullptr) { workList->push_back(defBB); } @@ -124,17 +124,17 @@ void MeSSA::InsertPhiNode() { while (!workList->empty()) { BB *defBB = workList->front(); workList->pop_front(); - MapleSet &dfs = dom->GetDomFrontier(defBB->GetBBId().idx); + MapleSet &dfs = dom->GetDomFrontier(defBB->GetBBId()); for (auto &bbID : dfs) { BB *dfBB = func->GetBBFromID(bbID); CHECK_FATAL(dfBB != nullptr, "null ptr check"); if (dfBB->PhiofVerStInserted(*vst) == nullptr) { workList->push_back(dfBB); dfBB->InsertPhi(&func->GetAlloc(), vst); - if (DEBUGFUNC(func)) { + if (enabledDebug) { ost->Dump(); - LogInfo::MapleLogger() << " Defined In: BB" << defBB->GetBBId().idx << " Insert Phi Here: BB" - << dfBB->GetBBId().idx << '\n'; + LogInfo::MapleLogger() << " Defined In: BB" << defBB->GetBBId() << " Insert Phi Here: BB" + << dfBB->GetBBId() << '\n'; } } } @@ -143,15 +143,15 @@ void MeSSA::InsertPhiNode() { } } -MeSSA::MeSSA(MeFunction *func, Dominance *dom, MemPool *memPool) - : SSA(*memPool, *func->GetMeSSATab()), AnalysisResult(memPool), func(func), dom(dom) {} +MeSSA::MeSSA(MeFunction *func, Dominance *dom, MemPool *memPool, bool enabledDebug) + : SSA(*memPool, *func->GetMeSSATab()), AnalysisResult(memPool), func(func), dom(dom), enabledDebug(enabledDebug) {} void MeSSA::RenameBB(BB &bb) { - if (GetBBRenamed(bb.GetBBId().idx)) { + if (GetBBRenamed(bb.GetBBId())) { return; } - SetBBRenamed(bb.GetBBId().idx, true); + SetBBRenamed(bb.GetBBId(), true); // record stack size for variable versions before processing rename. It is used for stack pop up. std::vector oriStackSize; @@ -167,8 +167,8 @@ void MeSSA::RenameBB(BB &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() < dom->GetDomChildrenSize(), "index out of range in MeSSA::RenameBB"); + const MapleSet &children = dom->GetDomChildren(bb.GetBBId()); for (const BBId &child : children) { RenameBB(*func->GetBBFromID(child)); } @@ -225,7 +225,7 @@ AnalysisResult *MeDoSSA::Run(MeFunction *func, MeFuncResultMgr *funcResMgr, Modu auto *ssaTab = static_cast(funcResMgr->GetAnalysisResult(MeFuncPhase_SSATAB, func)); CHECK_FATAL(ssaTab != nullptr, "ssaTab phase has problem"); MemPool *ssaMp = NewMemPool(); - MeSSA *ssa = ssaMp->New(func, dom, ssaMp); + MeSSA *ssa = ssaMp->New(func, dom, ssaMp, DEBUGFUNC(func)); ssa->BuildSSA(); ssa->VerifySSA(); if (DEBUGFUNC(func)) { diff --git a/src/maple_me/src/me_ssa_update.cpp b/src/maple_me/src/me_ssa_update.cpp index ebf5bc928ec2fa312e4e83bb83837126d720b0b4..2b6bce433575901d63fc59cdb9fff5a6de1d3ed4 100644 --- a/src/maple_me/src/me_ssa_update.cpp +++ b/src/maple_me/src/me_ssa_update.cpp @@ -24,12 +24,12 @@ namespace maple { // accumulate the BBs that are in the iterated dominance frontiers of bb in // the set dfSet, visiting each BB only once void MeSSAUpdate::GetIterDomFrontier(const BB &bb, MapleSet &dfSet, std::vector &visitedMap) { - CHECK_FATAL(bb.GetBBId().idx < visitedMap.size(), "index out of range in MeSSAUpdate::GetIterDomFrontier"); - if (visitedMap[bb.GetBBId().idx]) { + CHECK_FATAL(bb.GetBBId() < visitedMap.size(), "index out of range in MeSSAUpdate::GetIterDomFrontier"); + if (visitedMap[bb.GetBBId()]) { return; } - visitedMap[bb.GetBBId().idx] = true; - for (BBId frontierBBId : dom.GetDomFrontier(bb.GetBBId().idx)) { + visitedMap[bb.GetBBId()] = true; + for (BBId frontierBBId : dom.GetDomFrontier(bb.GetBBId())) { dfSet.insert(frontierBBId); BB *frontierBB = func.GetBBFromID(frontierBBId); GetIterDomFrontier(*frontierBB, dfSet, visitedMap); @@ -243,7 +243,7 @@ void MeSSAUpdate::RenameBB(BB &bb) { RenameStmts(bb); RenamePhiOpndsInSucc(bb); // recurse down dominator tree in pre-order traversal - const MapleSet &children = dom.GetDomChildren(bb.GetBBId().idx); + const MapleSet &children = dom.GetDomChildren(bb.GetBBId()); for (const BBId &child : children) { RenameBB(*func.GetBBFromID(child)); } @@ -267,7 +267,7 @@ void MeSSAUpdate::Run() { renameStack->push(zeroVersVar); } // recurse down dominator tree in pre-order traversal - const MapleSet &children = dom.GetDomChildren(func.GetCommonEntryBB()->GetBBId().idx); + const MapleSet &children = dom.GetDomChildren(func.GetCommonEntryBB()->GetBBId()); for (const BBId &child : children) { RenameBB(*func.GetBBFromID(child)); } diff --git a/src/maple_me/src/ver_symbol.cpp b/src/maple_me/src/ver_symbol.cpp index 47cb2123c128fc98984cc04340af4b6f021dff86..760c5fea50be24e5ad39491064bc1a95cb7b1de2 100644 --- a/src/maple_me/src/ver_symbol.cpp +++ b/src/maple_me/src/ver_symbol.cpp @@ -75,7 +75,7 @@ void VersionStTable::Dump(MIRModule *mod) const { const VersionSt *vst = versionStVector[i]; vst->Dump(mod); if (vst->GetVersion() > 0) { - LogInfo::MapleLogger() << " defined BB" << vst->GetDefBB()->GetBBId().idx << ": "; + LogInfo::MapleLogger() << " defined BB" << vst->GetDefBB()->GetBBId() << ": "; vst->DumpDefStmt(mod); } else { LogInfo::MapleLogger() << '\n'; diff --git a/src/maple_util/include/mpl_number.h b/src/maple_util/include/mpl_number.h new file mode 100644 index 0000000000000000000000000000000000000000..d1838e79997aa649468606959a287c14f292fd48 --- /dev/null +++ b/src/maple_util/include/mpl_number.h @@ -0,0 +1,252 @@ +/* + * Copyright (c) [2019] Huawei Technologies Co.,Ltd.All rights reserved. + * + * OpenArkCompiler is licensed under the Mulan PSL v1. + * You can use this software according to the terms and conditions of the Mulan PSL v1. + * You may obtain a copy of Mulan PSL v1 at: + * + * http://license.coscl.org.cn/MulanPSL + * + * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER + * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR + * FIT FOR A PARTICULAR PURPOSE. + * See the Mulan PSL v1 for more details. + */ +#ifndef MAPLE_UTIL_INCLUDE_MPL_NUMBER_H +#define MAPLE_UTIL_INCLUDE_MPL_NUMBER_H +#include + +namespace maple { namespace utils { + +template +class Number { + public: + using element_type = T; + + Number() = default; + + explicit Number(element_type data) : val(data) {} + + template ::value>> + explicit Number(U data) : val(static_cast(data)) {} + + Number(const Number &num) : val(num.val) {} + + Number(Number &&num) noexcept : val(std::move(num.val)) {} + + ~Number() = default; + + // As the implicit T cast is enabled, disable it to avoid implicit cast for `Number num = Number()` + // which should be two types and should not be able to neither convert to each other nor compare with each other. + Number &operator=(element_type data) = delete; + + Number &operator=(const Number &num) noexcept { + if (this != &num) { + val = num.val; + } + return *this; + } + + Number &operator=(Number &&num) noexcept { + if (this != &num) { + val = std::move(num.val); + } + return *this; + } + + void reset(element_type data) noexcept { + val = data; + } + + void swap(Number &other) noexcept { + std::swap(val, other.val); + } + + element_type get() const noexcept { + return val; + } + + operator bool() const = delete; + + operator element_type() const noexcept { + return val; + } + + template ::value>> + explicit operator U() const noexcept { + return static_cast(val); + } + + Number &operator+=(const T &data) noexcept { + val += data; + } + + Number &operator+=(const Number &num) noexcept { + val += num.val; + } + + Number &operator-=(const T &data) noexcept { + val -= data; + } + + Number &operator-=(const Number &num) noexcept { + val -= num.val; + } + + Number &operator++() noexcept { + ++val; + return *this; + } + + Number operator++(int) { + auto tmp = val; + this->operator++(); + return Number(tmp); + } + + Number &operator--() noexcept { + --val; + return *this; + } + + Number operator--(int) { + auto tmp = val; + this->operator--; + return Number(tmp); + } + + private: + element_type val = 0; +}; + +template +inline bool operator==(const Number &lhs, const Number &rhs) { + return lhs.get() == rhs.get(); +} + +template +inline bool operator!=(const Number &lhs, const Number &rhs) { + return !(lhs == rhs); +} + +template +inline bool operator<(const Number &lhs, const Number &rhs) { + return lhs.get() < rhs.get(); +} + +template +inline bool operator<=(const Number &lhs, const Number &rhs) { + return lhs.get() <= rhs.get(); +} + +template +inline bool operator>(const Number &lhs, const Number &rhs) { + return !(lhs <= rhs); +} + +template +inline bool operator>=(const Number &lhs, const Number &rhs) { + return !(lhs < rhs); +} + +template +inline Number operator+(const Number &lhs, const Number &rhs) { + return Number(lhs.get() + rhs.get()); +} + +template +inline Number operator-(const Number &lhs, const Number &rhs) { + return Number(lhs.get() + rhs.get()); +} + +template ::value>> +inline bool operator==(const Number &lhs, const U &rhs) { + return lhs.get() == rhs; +} + +template ::value>> +inline bool operator==(const U &lhs, const Number &rhs) { + return lhs == rhs.get(); +} + +template ::value>> +inline bool operator!=(const Number &lhs, const U &rhs) { + return !(lhs == rhs); +} + +template ::value>> +inline bool operator!=(const U &lhs, const Number &rhs) { + return !(lhs == rhs); +} + +template ::value>> +inline bool operator<(const Number &lhs, const U &rhs) { + return lhs.get() < rhs; +} + +template ::value>> +inline bool operator<(const U &lhs, const Number &rhs) { + return lhs < rhs.get(); +} + +template ::value>> +inline bool operator<=(const Number &lhs, const U &rhs) { + return lhs.get() <= rhs; +} + +template ::value>> +inline bool operator<=(const U &lhs, const Number &rhs) { + return lhs <= rhs.get(); +} + +template ::value>> +inline bool operator>(const Number &lhs, const U &rhs) { + return !(lhs <= rhs); +} + +template ::value>> +inline bool operator>(const U &lhs, const Number &rhs) { + return !(lhs <= rhs); +} + +template ::value>> +inline bool operator>=(const Number &lhs, const U &rhs) { + return !(lhs < rhs); +} + +template ::value>> +inline bool operator>=(const U &lhs, const Number &rhs) { + return !(lhs < rhs); +} + +template ::value>> +inline Number operator+(const Number &lhs, const U &rhs) { + return Number(lhs.get() + rhs); +} + +template ::value>> +inline Number operator+(const U &lhs, const Number &rhs) { + return Number(lhs + rhs.get()); +} + +template ::value>> +inline Number operator-(const Number &lhs, const U &rhs) { + return Number(lhs.get() + rhs); +} + +template ::value>> +inline Number operator-(const U &lhs, const Number &rhs) { + return Number(lhs + rhs.get()); +} + +template +inline OS &operator<<(OS &os, const Number &num) { + os << num.get(); + return os; +} + +template +using Index = Number; + +}} +#endif //MAPLE_UTIL_INCLUDE_NUMBER_H diff --git a/src/mpl2mpl/include/reflection_analysis.h b/src/mpl2mpl/include/reflection_analysis.h index f1bc1e012b28d8c96f2703546143dad303fd0eed..ee44f5b50d6bb80b8e747a3ce0d2b8c8fbf2da8f 100644 --- a/src/mpl2mpl/include/reflection_analysis.h +++ b/src/mpl2mpl/include/reflection_analysis.h @@ -22,7 +22,6 @@ namespace maple { #define METADATA_KLASS_FIELDID (static_cast(ClassProperty::kShadow) + 1) static constexpr bool kRADebug = false; static constexpr int64 kTBDValue = 0xABCD; -static constexpr int kMaxOptimiseThreshold = 6; static constexpr uint32 kMethodFieldHashSize = 1022; static constexpr uint16 kHashConflictFlag = 1023; @@ -90,8 +89,9 @@ static constexpr char kReflectionAccessibleobjectPrefixStr[] = "Ljava_2Flang_2Fr static constexpr int kAnonymousClassIndex = 5; static constexpr char kAnonymousClassSuffix[] = "30"; -static constexpr char kAnonymousClassPrefix[] = "`IC"; -static constexpr char kInnerClassPrefix[] = "`EC"; +static constexpr char kAnonymousClassPrefix[] = "Lark/annotation/InnerClass;"; +static constexpr char kInnerClassPrefix[] = "Lark/annotation/EnclosingClass;"; +static constexpr char kArkAnnotationEnclosingClassStr[] = "Lark_2Fannotation_2FEnclosingClass_3B"; // maple field index definition enum struct ClassRO : uint32 { @@ -178,46 +178,6 @@ static constexpr uint64 kMethodMetaCompact = 0x00000004; static constexpr uint64 kMethodAbstract = 0x00000010; static constexpr uint64 kFieldReadOnly = 0x00000001; -#define CASE_CONDITION(ARRAYNAME, ELEM) \ - case kValueInt: \ - ARRAYNAME += std::to_string(ELEM->GetI32Val()); \ - oss.str(); \ - break; \ - case kValueLong: \ - ARRAYNAME += std::to_string(ELEM->GetI64Val()); \ - break; \ - case kValueDouble: \ - oss << tmp << std::setiosflags(std::ios::scientific) << std::setprecision(16) << ELEM->GetDoubleVal(); \ - ARRAYNAME += oss.str(); \ - break; \ - case kValueFloat: \ - oss << tmp << std::setiosflags(std::ios::scientific) << std::setprecision(7) << ELEM->GetFloatVal(); \ - ARRAYNAME += oss.str(); \ - break; \ - case kValueString: { \ - stridx.SetIdx(ELEM->GetU64Val()); \ - std::string s = GlobalTables::GetStrTable().GetStringFromStrIdx(stridx); \ - DelimeterConvert(s); \ - ReflectionAnalysis::CompressHighFrequencyStr(s); \ - ARRAYNAME += s; \ - break; \ - } \ - case kValueEnum: \ - stridx.SetIdx(ELEM->GetU64Val()); \ - ARRAYNAME += GlobalTables::GetStrTable().GetStringFromStrIdx(stridx); \ - break; \ - case kValueBoolean: \ - ARRAYNAME += std::to_string(ELEM->GetU64Val()); \ - break; \ - case kValueByte: \ - ARRAYNAME += std::to_string(ELEM->GetI32Val()); \ - break; \ - case kValueShort: \ - ARRAYNAME += std::to_string(ELEM->GetI32Val()); \ - break; \ - case kValueChar: \ - ARRAYNAME += std::to_string(ELEM->GetU64Val()); \ - break; class ReflectionAnalysis : public AnalysisResult { public: ReflectionAnalysis(MIRModule *mod, MemPool *memPool, KlassHierarchy *kh, MIRBuilder &builder) @@ -246,7 +206,6 @@ class ReflectionAnalysis : public AnalysisResult { MIRBuilder &mirBuilder; MapleVector classTab; int isLibcore; - std::map highFrequencyStrMap; std::string reflectionMuidStr; static const char *klassPtrName; static TyIdx classMetadataTyIdx; @@ -312,10 +271,9 @@ class ReflectionAnalysis : public AnalysisResult { MIRSymbol *CreateSymbol(GStrIdx strIdx, TyIdx tyIdx); MIRSymbol *GetSymbol(GStrIdx strIdx, TyIdx tyIdx); void GenClassMetaData(Klass &klass); - std::string GetAnnoValueWithoutArray(const MIRPragmaElement &annoElem); - void CompressHighFrequencyStr(std::string &s); - std::string GetArrayValue(MapleVector subElemVector, bool isSN = false); - std::string GetAnnotationValue(MapleVector subElemVector, GStrIdx typeStrIdx); + std::string GetAnnoValueNoArray(const MIRPragmaElement &annoElem); + std::string GetArrayValue(const MapleVector &subElemVector); + std::string GetAnnotationValue(const MapleVector &subElemVector, GStrIdx typeStrIdx); MIRSymbol *GenSuperClassMetaData(const Klass &klass, std::list superClassList); void GenFieldOffsetData(const Klass &klass, std::vector> &fieldOffsetVector); MIRSymbol *GenFieldsMetaData(const Klass &klass); @@ -341,11 +299,13 @@ class ReflectionAnalysis : public AnalysisResult { void GeneAnnotation(std::map &idxNumMap, std::string &annoArr, MIRClassType &classType, PragmaKind paragKind, const std::string ¶gName, TyIdx fieldTypeIdx, std::map *paramNumArray = nullptr, int *paramIndex = nullptr); + void AppendValueByType(std::string &annoArr, const MIRPragmaElement &elem); void SetAnnoFieldConst(const MIRStructType &metadataRoType, MIRAggConst &newConst, uint32 fieldID, std::map &idxNumMap, const std::string &annoArr); bool IsAnonymousClass(const std::string &annotationString); bool IsPrivateClass(MIRClassType &classType); bool IsStaticClass(MIRClassType &classType); + int8 JudgePara(MIRClassType &ctype); void CheckPrivateInnerAndNoSubClass(Klass &clazz, const std::string &annoArr); void ConvertMapleClassName(const std::string &mplClassName, std::string &javaDsp); @@ -356,6 +316,10 @@ class ReflectionAnalysis : public AnalysisResult { MIRSymbol *GetClinitFuncSymbol(const Klass &klass); int SolveAnnotation(MIRClassType &classType, MIRFunction &func); uint32 GetTypeNameIdxFromType(MIRType &type, const Klass &klass, const std::string &fieldName); + static constexpr char annoDelimiterPrefix = '`'; + static constexpr char annoDelimiter = '!'; + static constexpr char annoArrayStartDelimiter = '{'; + static constexpr char annoArrayEndDelimiter = '}'; }; class DoReflectionAnalysis : public ModulePhase { diff --git a/src/mpl2mpl/src/reflection_analysis.cpp b/src/mpl2mpl/src/reflection_analysis.cpp index 4f04d3ce48856abd58c589032b6e78c23e0208f5..b81a2f0b50b72f2a9a8ab32283492860eeca9734 100644 --- a/src/mpl2mpl/src/reflection_analysis.cpp +++ b/src/mpl2mpl/src/reflection_analysis.cpp @@ -44,7 +44,7 @@ std::string ReflectionAnalysis::strTabBothHot = std::string(1, '\0'); std::string ReflectionAnalysis::strTabRunHot = std::string(1, '\0'); bool ReflectionAnalysis::strTabInited = false; int ReflectionAnalysis::GetDeflateStringIdx(const std::string &subStr) { - return FindOrInsertReflectString("0!" + subStr); + return FindOrInsertReflectString("1!" + subStr); } uint32 ReflectionAnalysis::FirstFindOrInsertRepeatString(const std::string &str, bool isHot, uint8 hotType) { @@ -216,10 +216,6 @@ static bool IsFinalize(const std::string &funcName, const std::string &signature return funcName == "finalize" && signature == "()V"; } -static bool NeedFourBytes(PragmaValueType type) { - return type == kValueInt || type == kValueByte || type == kValueShort; -} - static std::string GetSignatureFromFullName(const std::string &fullname) { size_t pos = fullname.find("|"); if (pos != std::string::npos) { @@ -306,6 +302,8 @@ uint32 ReflectionAnalysis::GetTypeNameIdxFromType(MIRType &type, const Klass &kl void ReflectionAnalysis::CheckPrivateInnerAndNoSubClass(Klass &clazz, const std::string &annoArr) { // LMain_24A_3B `EC!`VL!24!LMain_3B!`IC!`AF!4!2!name!23!A! + uint32_t idx = ReflectionAnalysis::FindOrInsertReflectString(kInnerClassPrefix); + std::string target = annoDelimiterPrefix + std::to_string(idx) + annoDelimiter; size_t pos = annoArr.find(kInnerClassPrefix, 0); if (pos == std::string::npos) { return; @@ -407,25 +405,6 @@ uint16 GetFieldHash(std::vector> &fieldV, FieldPair return 0; } -static void DelimeterConvert(std::string &str) { - constexpr size_t nextPos = 2; - size_t loc = str.find("`"); - while (loc != std::string::npos) { - str.replace(loc, 1, "``"); - loc = str.find("`", loc + nextPos); - } - loc = str.find("!"); - while (loc != std::string::npos) { - str.replace(loc, 1, "`!"); - loc = str.find("!", loc + nextPos); - } - loc = str.find("|"); - while (loc != std::string::npos) { - str.replace(loc, 1, "`|"); - loc = str.find("|", loc + nextPos); - } -} - bool ReflectionAnalysis::RootClassDefined() { if (isLibcore < 0) { // Check whether this module defines root classes including Class/Object/Fields/Methods. @@ -491,12 +470,6 @@ MIRSymbol *ReflectionAnalysis::CreateSymbol(GStrIdx strIdx, TyIdx tyIdx) { return st; } -void ReflectionAnalysis::CompressHighFrequencyStr(std::string &s) { - if (highFrequencyStrMap.find(s) != highFrequencyStrMap.end()) { - s = ReflectionAnalysis::highFrequencyStrMap[s]; - } -} - bool ReflectionAnalysis::VtableFunc(const MIRFunction &func) const { return (func.GetAttr(FUNCATTR_virtual) && !func.GetAttr(FUNCATTR_private) && !func.GetAttr(FUNCATTR_static)); } @@ -933,175 +906,220 @@ MIRSymbol *ReflectionAnalysis::GenFieldsMetaData(const Klass &klass) { void ReflectionAnalysis::ConvertMapleClassName(const std::string &mplClassName, std::string &javaDsp) { // Convert classname end with _3B, 3 is strlen("_3B") unsigned int len = strlen(kClassSuffix); - if (mplClassName.size() > len && mplClassName.rfind(kClassSuffix, mplClassName.size() - len) != std::string::npos && - false) { + if (mplClassName.size() > len && mplClassName.rfind(kClassSuffix, mplClassName.size() - len) != std::string::npos) { NameMangler::DecodeMapleNameToJavaDescriptor(mplClassName, javaDsp); - if (highFrequencyStrMap.find(javaDsp) == highFrequencyStrMap.end()) { - uint32 idx = ReflectionAnalysis::FindOrInsertReflectString(javaDsp); - javaDsp = "`" + std::to_string(idx); - } } else { javaDsp = mplClassName; } } -std::string ReflectionAnalysis::GetAnnotationValue(MapleVector subelemVector, GStrIdx typestridx) { - std::string annoArray, tmp; - GStrIdx strIdx; - annoArray += '['; - annoArray += std::to_string(subelemVector.size()); - annoArray += '!'; +void ReflectionAnalysis::AppendValueByType(std::string &annoArr, const MIRPragmaElement &elem) { + std::ostringstream oss; + std::string tmp; + switch(elem.GetType()) { + case kValueInt: + case kValueByte: + case kValueShort: + annoArr += std::to_string(elem.GetI32Val()); + break; + case kValueLong: + annoArr += std::to_string(elem.GetI64Val()); + break; + case kValueDouble: + oss << tmp << std::setiosflags(std::ios::scientific) << std::setprecision(16) << elem.GetDoubleVal(); + annoArr += oss.str(); + break; + case kValueFloat: + oss << tmp << std::setiosflags(std::ios::scientific) << std::setprecision(7) << elem.GetFloatVal(); + annoArr += oss.str(); + break; + case kValueBoolean: + case kValueChar: + annoArr += std::to_string(elem.GetU64Val()); + break; + default: { // kValueString kValueEnum kValueType + GStrIdx strIdx; + strIdx.SetIdx(elem.GetU64Val()); + std::string s = GlobalTables::GetStrTable().GetStringFromStrIdx(strIdx); + uint32 idx = ReflectionAnalysis::FindOrInsertReflectString(s); + annoArr += annoDelimiterPrefix; + annoArr += std::to_string(idx); + } + } +} + +#define COMMON_CASE \ +case kValueInt: \ +case kValueLong: \ +case kValueDouble: \ +case kValueFloat: \ +case kValueString: \ +case kValueBoolean:\ +case kValueByte: \ +case kValueShort: \ +case kValueChar: \ +case kValueEnum: \ +case kValueType: + +std::string ReflectionAnalysis::GetAnnotationValue(const MapleVector &subelemVector, + GStrIdx typeStrIdx) { + std::string annoArray; + annoArray += (annoArrayStartDelimiter + std::to_string(subelemVector.size()) + annoDelimiter); std::string javaDscp; - ConvertMapleClassName(GlobalTables::GetStrTable().GetStringFromStrIdx(typestridx), javaDscp); + ConvertMapleClassName(GlobalTables::GetStrTable().GetStringFromStrIdx(typeStrIdx), javaDscp); + uint32_t idx = ReflectionAnalysis::FindOrInsertReflectString(javaDscp); + javaDscp = annoDelimiterPrefix + std::to_string(idx); annoArray += javaDscp; for (MIRPragmaElement *arrayElem : subelemVector) { - annoArray += '!'; - std::ostringstream oss3; - annoArray += GlobalTables::GetStrTable().GetStringFromStrIdx(arrayElem->GetNameStrIdx()); - annoArray += '!'; - annoArray += std::to_string(arrayElem->GetType()); - annoArray += '!'; - if (NeedFourBytes(arrayElem->GetType())) { - annoArray += std::to_string(arrayElem->GetI32Val()); - } else if (arrayElem->GetType() == kValueLong) { - annoArray += std::to_string(arrayElem->GetI64Val()); - } else if (arrayElem->GetType() == kValueDouble) { - oss3 << tmp << std::setiosflags(std::ios::scientific) << std::setprecision(16) << arrayElem->GetDoubleVal(); - annoArray += oss3.str(); - } else if (arrayElem->GetType() == kValueFloat) { - oss3 << tmp << std::setiosflags(std::ios::scientific) << std::setprecision(7) << arrayElem->GetFloatVal(); - annoArray += oss3.str(); - } else if (arrayElem->GetType() == kValueString || arrayElem->GetType() == kValueEnum) { - strIdx.SetIdx(arrayElem->GetU64Val()); - std::string t = GlobalTables::GetStrTable().GetStringFromStrIdx(strIdx); - DelimeterConvert(t); - CompressHighFrequencyStr(t); - annoArray += t; - } else if (arrayElem->GetType() == kValueBoolean || arrayElem->GetType() == kValueChar) { - annoArray += std::to_string(arrayElem->GetU64Val()); - } else if (arrayElem->GetType() == kValueType) { - strIdx.SetIdx(arrayElem->GetU64Val()); - std::string javaDsp; - ConvertMapleClassName(GlobalTables::GetStrTable().GetStringFromStrIdx(strIdx), javaDsp); - annoArray += javaDsp; - } else if (arrayElem->GetType() == kValueAnnotation) { - annoArray += GetAnnotationValue(arrayElem->GetSubElemVec(), arrayElem->GetTypeStrIdx()); - } else if (arrayElem->GetType() == kValueArray) { - annoArray += GetArrayValue(arrayElem->GetSubElemVec()); - } else { - annoArray += std::to_string(arrayElem->GetU64Val()); - annoArray += '!'; - annoArray += GlobalTables::GetStrTable().GetStringFromStrIdx(arrayElem->GetNameStrIdx()); - strIdx.SetIdx(arrayElem->GetU64Val()); - annoArray += GlobalTables::GetStrTable().GetStringFromStrIdx(strIdx); - annoArray += '!'; - } + annoArray += annoDelimiter; + idx = FindOrInsertReflectString(GlobalTables::GetStrTable().GetStringFromStrIdx(arrayElem->GetNameStrIdx())); + annoArray += (annoDelimiterPrefix + std::to_string(idx) + annoDelimiter + std::to_string(arrayElem->GetType())); + annoArray += annoDelimiter; + annoArray += GetAnnoValueNoArray(*arrayElem); } - annoArray += ']'; + annoArray += annoArrayEndDelimiter; return annoArray; } -std::string ReflectionAnalysis::GetArrayValue(MapleVector subelemVector, bool isSN) { +std::string ReflectionAnalysis::GetArrayValue(const MapleVector &subelemVector) { std::string annoArray; GStrIdx strIdx; - annoArray += '['; - annoArray += std::to_string(subelemVector.size()); - annoArray += '!'; + annoArray += (annoArrayStartDelimiter + std::to_string(subelemVector.size()) + annoDelimiter); if (!subelemVector.empty()) { annoArray += std::to_string(subelemVector[0]->GetType()); - annoArray += '!'; + annoArray += annoDelimiter; } for (MIRPragmaElement *arrayElem : subelemVector) { - std::ostringstream oss3; std::string javaDsp; ConvertMapleClassName(GlobalTables::GetStrTable().GetStringFromStrIdx(arrayElem->GetTypeStrIdx()), javaDsp); std::string typeStr = javaDsp; - CompressHighFrequencyStr(typeStr); - annoArray += typeStr; - annoArray += '!'; - std::string type; - MapleVector subsubelemVector = arrayElem->GetSubElemVec(); - if (arrayElem->GetType() == kValueAnnotation) { - std::ostringstream oss4; - oss4 << type << subsubelemVector.size(); - annoArray += oss4.str(); - annoArray += '!'; - for (MIRPragmaElement *annoElem : subsubelemVector) { - ASSERT(annoElem != nullptr, "null ptr check!"); - annoArray += GlobalTables::GetStrTable().GetStringFromStrIdx(annoElem->GetNameStrIdx()); - annoArray += '!'; - annoArray += std::to_string(annoElem->GetType()); - annoArray += '!'; - annoArray += GetAnnoValueWithoutArray(*annoElem); - annoArray += '!'; + uint32_t idx = ReflectionAnalysis::FindOrInsertReflectString(typeStr); + annoArray += (annoDelimiterPrefix + std::to_string(idx) + annoDelimiter); + MapleVector arrayElemVector = arrayElem->GetSubElemVec(); + switch (arrayElem->GetType()) { + COMMON_CASE + AppendValueByType(annoArray, *arrayElem); + break; + case kValueAnnotation: { + annoArray += std::to_string(arrayElemVector.size()); + annoArray += annoDelimiter; + for (MIRPragmaElement *annoElem : arrayElemVector) { + std::string tt = GlobalTables::GetStrTable().GetStringFromStrIdx(annoElem->GetNameStrIdx()); + idx = ReflectionAnalysis::FindOrInsertReflectString(tt); + tt = annoDelimiterPrefix + std::to_string(idx) + annoDelimiter + std::to_string(annoElem->GetType()) + + annoDelimiter + GetAnnoValueNoArray(*annoElem) + annoDelimiter; + annoArray += tt; + } + break; } - } else if (NeedFourBytes(arrayElem->GetType())) { - oss3 << type << arrayElem->GetI32Val(); - annoArray += oss3.str(); - } else if (arrayElem->GetType() == kValueLong) { - oss3 << type << arrayElem->GetI64Val(); - annoArray += oss3.str(); - } else if (arrayElem->GetType() == kValueDouble) { - oss3 << type << std::setiosflags(std::ios::scientific) << std::setprecision(16) << arrayElem->GetDoubleVal(); - annoArray += oss3.str(); - } else if (arrayElem->GetType() == kValueFloat) { - oss3 << type << std::setiosflags(std::ios::scientific) << std::setprecision(7) << arrayElem->GetFloatVal(); - annoArray += oss3.str(); - } else if (arrayElem->GetType() == kValueString || arrayElem->GetType() == kValueEnum) { - strIdx.SetIdx(arrayElem->GetU64Val()); - std::string t = GlobalTables::GetStrTable().GetStringFromStrIdx(strIdx); - DelimeterConvert(t); - CompressHighFrequencyStr(t); - if (arrayElem->GetType() == kValueString && isSN && t.size() > kMaxOptimiseThreshold) { - uint32 idx = ReflectionAnalysis::FindOrInsertReflectString(t); - t = "`" + std::to_string(idx); + default: { + annoArray += (std::to_string(arrayElem->GetU64Val()) + annoDelimiter); + annoArray += GlobalTables::GetStrTable().GetStringFromStrIdx(arrayElem->GetNameStrIdx()); + strIdx.SetIdx(arrayElem->GetU64Val()); + annoArray += (GlobalTables::GetStrTable().GetStringFromStrIdx(strIdx) + annoDelimiter); } - annoArray += t; - } else if (arrayElem->GetType() == kValueBoolean || arrayElem->GetType() == kValueChar) { - oss3 << type << arrayElem->GetU64Val(); - annoArray += oss3.str(); - } else if (arrayElem->GetType() == kValueType) { - strIdx.SetIdx(arrayElem->GetU64Val()); - std::string javaDspInner; - ConvertMapleClassName(GlobalTables::GetStrTable().GetStringFromStrIdx(strIdx), javaDspInner); - annoArray += javaDspInner; - } else { - oss3 << type << arrayElem->GetU64Val(); - annoArray += oss3.str(); - annoArray += '!'; - annoArray += GlobalTables::GetStrTable().GetStringFromStrIdx(arrayElem->GetNameStrIdx()); - strIdx.SetIdx(arrayElem->GetU64Val()); - annoArray += GlobalTables::GetStrTable().GetStringFromStrIdx(strIdx); - annoArray += '!'; } } - annoArray += ']'; + annoArray += annoArrayEndDelimiter; return annoArray; } -std::string ReflectionAnalysis::GetAnnoValueWithoutArray(const MIRPragmaElement &annoElem) { - std::ostringstream oss; - std::string tmp, annoArray; - GStrIdx stridx; - if (NeedFourBytes(annoElem.GetType())) { - annoArray += std::to_string(annoElem.GetI32Val()); - } else if (annoElem.GetType() == kValueFloat) { - annoArray += std::to_string(annoElem.GetFloatVal()); - } else if (annoElem.GetType() == kValueDouble) { - annoArray += std::to_string(annoElem.GetDoubleVal()); - } else if (annoElem.GetType() == kValueLong) { - annoArray += std::to_string(annoElem.GetI64Val()); - } else if (annoElem.GetType() == kValueBoolean || annoElem.GetType() == kValueChar) { - annoArray += std::to_string(annoElem.GetU64Val()); - } else if (annoElem.GetType() == kValueArray) { - annoArray += GetArrayValue(annoElem.GetSubElemVec()); - } else { - stridx.SetIdx(annoElem.GetU64Val()); - annoArray += GlobalTables::GetStrTable().GetStringFromStrIdx(stridx); +std::string ReflectionAnalysis::GetAnnoValueNoArray(const MIRPragmaElement &annoElem) { + std::string annoArray; + switch (annoElem.GetType()) { + COMMON_CASE + AppendValueByType(annoArray, annoElem); + break; + case kValueArray: + annoArray += GetArrayValue(annoElem.GetSubElemVec()); + break; + case kValueAnnotation : + annoArray += GetAnnotationValue(annoElem.GetSubElemVec(), annoElem.GetTypeStrIdx()); + break; + default: { + GStrIdx strIdx; + strIdx.SetIdx(annoElem.GetU64Val()); + std::string javaDescriptor; + ConvertMapleClassName(GlobalTables::GetStrTable().GetStringFromStrIdx(strIdx), javaDescriptor); + uint32_t idx = ReflectionAnalysis::FindOrInsertReflectString(javaDescriptor); + annoArray += annoDelimiterPrefix; + annoArray += std::to_string(idx); + } } return annoArray; } +void ReflectionAnalysis::GeneAnnotation(std::map &idxNumMap, std::string &annoArr, MIRClassType &classType, + PragmaKind paragKind, const std::string ¶gName, TyIdx fieldTypeIdx, + std::map *paramnumArray, int *paramIndex) { + int annoNum = 0; + std::string cmpString = ""; + for (MIRPragma *prag : classType.GetPragmaVec()) { + cmpString = paragKind == kPragmaVar ? NameMangler::DecodeName(GlobalTables::GetStrTable().GetStringFromStrIdx( + prag->GetStrIdx())) : GlobalTables::GetStrTable().GetStringFromStrIdx(prag->GetStrIdx()); + bool validTypeFlag = false; + if (prag->GetTyIdxEx() == fieldTypeIdx || fieldTypeIdx == invalidIdx) { + validTypeFlag = true; + } + if (prag->GetKind() == paragKind && paragName == cmpString && validTypeFlag) { + const MapleVector &elemVector = prag->GetElementVector(); + MIRSymbol *classInfo = GlobalTables::GetGsymTable().GetSymbolFromStrIdx( + GlobalTables::GetTypeTable().GetTypeFromTyIdx(prag->GetTyIdx())->GetNameStrIdx()); + if (classInfo != nullptr && !RtRetentionPolicyCheck(*classInfo)) { + continue; + } + annoNum++; + idxNumMap[annoNum - 1] = 0; + GStrIdx gindex = GlobalTables::GetTypeTable().GetTypeFromTyIdx(prag->GetTyIdx())->GetNameStrIdx(); + std::string pregTypeString = GlobalTables::GetStrTable().GetStringFromStrIdx(gindex); + std::string klassJavaDescriptor; + ConvertMapleClassName(pregTypeString, klassJavaDescriptor); + uint32 idx = ReflectionAnalysis::FindOrInsertReflectString(klassJavaDescriptor); + annoArr += annoDelimiterPrefix; + annoArr += std::to_string(idx); + annoArr += annoDelimiter; + if (paramnumArray != nullptr) { + int8 x = JudgePara(classType); + CHECK_FATAL(paramIndex != nullptr, "null ptr check"); + if (x && paragName.find(kInitFuntionStr) != std::string::npos) { + (*paramnumArray)[(*paramIndex)++] = prag->GetParamNum() + x; + } else { + (*paramnumArray)[(*paramIndex)++] = prag->GetParamNum(); + } + } + for (MIRPragmaElement *elem : elemVector) { + idxNumMap[annoNum - 1]++; + std::string convertTmp = + NameMangler::DecodeName(GlobalTables::GetStrTable().GetStringFromStrIdx(elem->GetNameStrIdx())); + idx = ReflectionAnalysis::FindOrInsertReflectString(convertTmp); + annoArr += (annoDelimiterPrefix + std::to_string(idx) + annoDelimiter + + std::to_string(elem->GetType()) + annoDelimiter); + annoArr += GetAnnoValueNoArray(*elem); + annoArr += annoDelimiter; + } + } + } +} + +uint32 ReflectionAnalysis::GetAnnoCstrIndex(std::map &idxNumMap, const std::string &annoArr) { + size_t annoNum = idxNumMap.size(); + uint32 signatureIdx = 0; + if (annoNum == 0) { + std::string subStr = "0!0"; + signatureIdx = FindOrInsertReflectString(subStr); + } else { + std::string subStr = std::to_string(annoNum); + subStr += annoDelimiter; + std::for_each(idxNumMap.begin(), idxNumMap.end(), [&subStr](const std::pair p) { + subStr += std::to_string(p.second); + subStr += annoDelimiter; + }); + subStr += annoArr; + signatureIdx = GetDeflateStringIdx(subStr); + } + return signatureIdx; +} + int64 ReflectionAnalysis::BKDRHash(const std::string &strname, uint32 seed) { const char *name = strname.c_str(); int64 hash = 0; @@ -1370,97 +1388,24 @@ void ReflectionAnalysis::SetAnnoFieldConst(const MIRStructType &metadataRoType, } } - -void ReflectionAnalysis::GeneAnnotation(std::map &idxNumMap, std::string &annoArr, MIRClassType &classType, - PragmaKind paragKind, const std::string ¶gName, TyIdx fieldTypeIdx, - std::map *paramnumArray, int *paramIndex) { - int annoNum = 0; - std::string cmpString = ""; +int8 ReflectionAnalysis::JudgePara(MIRClassType &classType) { for (MIRPragma *prag : classType.GetPragmaVec()) { - if (paragKind == kPragmaVar) { - cmpString = NameMangler::DecodeName(GlobalTables::GetStrTable().GetStringFromStrIdx(prag->GetStrIdx())); - } else { - cmpString = GlobalTables::GetStrTable().GetStringFromStrIdx(prag->GetStrIdx()); - } - bool validTypeFlag = false; - if (prag->GetTyIdxEx() == fieldTypeIdx || fieldTypeIdx == invalidIdx) { - validTypeFlag = true; - } - if (prag->GetKind() == paragKind && paragName == cmpString && validTypeFlag) { - MapleVector elemVector = prag->GetElementVector(); - MIRSymbol *clInfo = GlobalTables::GetGsymTable().GetSymbolFromStrIdx( - GlobalTables::GetTypeTable().GetTypeFromTyIdx(prag->GetTyIdx())->GetNameStrIdx()); - if (clInfo != nullptr) { - if (!RtRetentionPolicyCheck(*clInfo)) { - continue; - } - } - annoNum++; - idxNumMap[annoNum - 1] = 0; - GStrIdx gindex = GlobalTables::GetTypeTable().GetTypeFromTyIdx(prag->GetTyIdx())->GetNameStrIdx(); - std::string pregTypeString = GlobalTables::GetStrTable().GetStringFromStrIdx(gindex); - std::string klassJavaDescriptor; - ConvertMapleClassName(pregTypeString, klassJavaDescriptor); - CompressHighFrequencyStr(klassJavaDescriptor); - annoArr += klassJavaDescriptor; - annoArr += "!"; - if (paramnumArray != nullptr) { - CHECK_FATAL(paramIndex != nullptr, "null ptr check"); - (*paramnumArray)[(*paramIndex)++] = prag->GetParamNum(); - } - for (MIRPragmaElement *elem : elemVector) { - idxNumMap[annoNum - 1]++; - std::string convertTmp = - NameMangler::DecodeName(GlobalTables::GetStrTable().GetStringFromStrIdx(elem->GetNameStrIdx())); - CompressHighFrequencyStr(convertTmp); - annoArr += convertTmp; - GStrIdx stridx; - annoArr += "!"; - std::ostringstream oss; - std::string tmp; - annoArr += std::to_string(elem->GetType()); - annoArr += "!"; - MapleVector subelemVector = elem->GetSubElemVec(); - switch (elem->GetType()) { - CASE_CONDITION(annoArr, elem) case kValueAnnotation : annoArr += - GetAnnotationValue(subelemVector, elem->GetTypeStrIdx()); - break; - case kValueArray: - break; - default: - stridx.SetIdx(elem->GetU64Val()); - std::string javaDescriptor; - ConvertMapleClassName(GlobalTables::GetStrTable().GetStringFromStrIdx(stridx), javaDescriptor); - annoArr += javaDescriptor; - } - annoArr += "!"; + if (prag->GetKind() == kPragmaClass) { + if ((GlobalTables::GetTypeTable().GetTypeFromTyIdx(prag->GetTyIdx())->GetName() == + kArkAnnotationEnclosingClassStr) && + !IsStaticClass(classType) && (classType.GetName() != kJavaLangEnumStr)) { + return 1; } } } -} - -uint32 ReflectionAnalysis::GetAnnoCstrIndex(std::map &idxNumMap, const std::string &annoArr) { - size_t annoNum = idxNumMap.size(); - uint32 signatureIdx = 0; - if (annoNum == 0) { - std::string subStr = "0!0"; - signatureIdx = FindOrInsertReflectString(subStr); - } else { - std::string subStr = std::to_string(annoNum); - subStr += "!"; - std::for_each(idxNumMap.begin(), idxNumMap.end(), [&subStr](const std::pair p) { - subStr += std::to_string(p.second); - subStr += "!"; - }); - subStr += annoArr; - signatureIdx = GetDeflateStringIdx(subStr); - } - return signatureIdx; + return 0; } bool ReflectionAnalysis::IsAnonymousClass(const std::string &annotationString) { // eg: `IC!`AF!4!0!name!30!! - size_t pos = annotationString.find(kAnonymousClassPrefix, 0); + uint32_t idx = ReflectionAnalysis::FindOrInsertReflectString(kAnonymousClassPrefix); + std::string target = annoDelimiterPrefix + std::to_string(idx) + annoDelimiter; + size_t pos = annotationString.find(target, 0); if (pos != std::string::npos) { int i = kAnonymousClassIndex; while (i--) {