diff --git a/src/mapleall/bin/dex2mpl b/src/mapleall/bin/dex2mpl
index 2e4d12eb305fbb1689ce4d65a3eab329fe852b4a..4c9ee78e699dd058f1d40c18e82db4f780042104 100755
Binary files a/src/mapleall/bin/dex2mpl and b/src/mapleall/bin/dex2mpl differ
diff --git a/src/mapleall/maple_be/src/cg/aarch64/aarch64_proepilog.cpp b/src/mapleall/maple_be/src/cg/aarch64/aarch64_proepilog.cpp
index 8a1939f7fa48a16701e7572411a8522f4ac913e5..fb6d239af766406f7e83337100d03cb8b63b0cb1 100644
--- a/src/mapleall/maple_be/src/cg/aarch64/aarch64_proepilog.cpp
+++ b/src/mapleall/maple_be/src/cg/aarch64/aarch64_proepilog.cpp
@@ -1294,9 +1294,9 @@ void AArch64GenProEpilog::GeneratePushUnnamedVarargRegs() {
       for (uint32 i = start_regno + static_cast<uint32>(V0); i < static_cast<uint32>(V8); i++) {
         Operand &stackloc = aarchCGFunc.CreateStkTopOpnd(offset, dataSizeBits);
         RegOperand &reg =
-            aarchCGFunc.GetOrCreatePhysicalRegisterOperand(static_cast<AArch64reg>(i), k64BitSize, kRegTyInt);
+            aarchCGFunc.GetOrCreatePhysicalRegisterOperand(static_cast<AArch64reg>(i), k64BitSize, kRegTyFloat);
         Insn &inst =
-            currCG->BuildInstruction<AArch64Insn>(aarchCGFunc.PickStInsn(dataSizeBits, PTY_i64), reg, stackloc);
+            currCG->BuildInstruction<AArch64Insn>(aarchCGFunc.PickStInsn(dataSizeBits, PTY_f64), reg, stackloc);
         cgFunc.GetCurBB()->AppendInsn(inst);
         offset += (kSizeOfPtr * k2BitSize);
       }
diff --git a/src/mapleall/maple_driver/BUILD.gn b/src/mapleall/maple_driver/BUILD.gn
index e9efbfca10adb342c239097b0f410163e9b082a8..47e497e17889e59df843fc6d9429d4ee99e7c14a 100644
--- a/src/mapleall/maple_driver/BUILD.gn
+++ b/src/mapleall/maple_driver/BUILD.gn
@@ -53,6 +53,7 @@ executable("maple") {
     "src/clang_compiler.cpp",
     "src/ld_compiler.cpp",
     "src/maple.cpp",
+    "src/maple_comb_compiler_wrapper.cpp",
     "src/maple_comb_compiler.cpp",
     "src/mpl_options.cpp",
     "src/mplcg_compiler.cpp",
diff --git a/src/mapleall/maple_driver/defs/default/O0_options_ld.def b/src/mapleall/maple_driver/defs/default/O0_options_ld.def
index 6ab606bc6c342a78c158b9438edd165742613035..035cffe53c9502acc9fe8f4fdb7a51e240dc5d8c 100644
--- a/src/mapleall/maple_driver/defs/default/O0_options_ld.def
+++ b/src/mapleall/maple_driver/defs/default/O0_options_ld.def
@@ -1,2 +1 @@
-{"-o", "", false},
 {"-static", "", false}
\ No newline at end of file
diff --git a/src/mapleall/maple_driver/include/compiler.h b/src/mapleall/maple_driver/include/compiler.h
index 9c542e7c1856aab59ff34a7bd09b34741a8a6f70..6dfe17d4cbe782497b3fe06ee777b1829b93fa50 100644
--- a/src/mapleall/maple_driver/include/compiler.h
+++ b/src/mapleall/maple_driver/include/compiler.h
@@ -40,6 +40,7 @@ const std::string kBinNameMe = "me";
 const std::string kBinNameMpl2mpl = "mpl2mpl";
 const std::string kBinNameMplcg = "mplcg";
 const std::string kBinNameMapleComb = "maplecomb";
+const std::string kBinNameMapleCombWrp = "maplecombwrp";
 const std::string kMachine = "aarch64-";
 const std::string kVendor = "unknown-";
 const std::string kOperatingSystem = "linux-gnu-";
@@ -58,15 +59,17 @@ class Compiler {
 
   virtual ~Compiler() = default;
 
-  virtual ErrorCode Compile(MplOptions &options, std::unique_ptr<MIRModule> &theModule);
+  virtual ErrorCode Compile(MplOptions &options, const Action &action,
+                            std::unique_ptr<MIRModule> &theModule);
 
-  virtual void GetTmpFilesToDelete(const MplOptions&, std::vector<std::string>&) const {}
+  virtual void GetTmpFilesToDelete(const MplOptions&, const Action &action,
+                                   std::vector<std::string>&) const {}
 
-  virtual std::unordered_set<std::string> GetFinalOutputs(const MplOptions&) const {
+  virtual std::unordered_set<std::string> GetFinalOutputs(const MplOptions&, const Action &) const {
     return std::unordered_set<std::string>();
   }
 
-  virtual void PrintCommand(const MplOptions&) const {}
+  virtual void PrintCommand(const MplOptions&, const Action &action) const {}
 
  protected:
   virtual std::string GetBinPath(const MplOptions &mplOptions) const;
@@ -74,21 +77,18 @@ class Compiler {
     return kBinNameNone;
   }
 
-  virtual std::string GetInputFileName(const MplOptions &options) const {
-    std::ostringstream stream;
-    for (const auto &inputFile : options.GetSplitsInputFiles()) {
-      stream << " " << inputFile;
-    }
-    return stream.str();
+  virtual std::string GetInputFileName(const MplOptions &, const Action &action) const {
+    return action.GetInputFile();
   }
 
-  virtual DefaultOption GetDefaultOptions(const MplOptions&) const {
+
+  virtual DefaultOption GetDefaultOptions(const MplOptions&, const Action &) const {
     return DefaultOption();
   }
 
  private:
   const std::string name;
-  std::string MakeOption(const MplOptions &options) const;
+  std::string MakeOption(const MplOptions &options, const Action &action) const;
   void AppendDefaultOptions(std::map<std::string, MplOption> &finalOptions,
                             const std::map<std::string, MplOption> &defaultOptions,
                             std::ostringstream &strOption, bool isDebug) const;
@@ -97,7 +97,7 @@ class Compiler {
   void AppendExtraOptions(std::map<std::string, MplOption> &finalOptions,
                           const MplOptions &options,
                           std::ostringstream &strOption, bool isDebug) const;
-  std::map<std::string, MplOption> MakeDefaultOptions(const MplOptions &options) const;
+  std::map<std::string, MplOption> MakeDefaultOptions(const MplOptions &options, const Action &action) const;
   int Exe(const MplOptions &mplOptions, const std::string &options) const;
   const std::string &GetName() const {
     return name;
@@ -112,9 +112,11 @@ class Jbc2MplCompiler : public Compiler {
 
  private:
   const std::string &GetBinName() const override;
-  DefaultOption GetDefaultOptions(const MplOptions &options) const override;
-  void GetTmpFilesToDelete(const MplOptions &mplOptions, std::vector<std::string> &tempFiles) const override;
-  std::unordered_set<std::string> GetFinalOutputs(const MplOptions &mplOptions) const override;
+  DefaultOption GetDefaultOptions(const MplOptions &options, const Action &action) const override;
+  void GetTmpFilesToDelete(const MplOptions &mplOptions, const Action &action,
+                           std::vector<std::string> &tempFiles) const override;
+  std::unordered_set<std::string> GetFinalOutputs(const MplOptions &mplOptions,
+                                                  const Action &action) const override;
 };
 
 class ClangCompiler : public Compiler {
@@ -126,9 +128,11 @@ class ClangCompiler : public Compiler {
  private:
   const std::string &GetBinName() const override;
   std::string GetBinPath(const MplOptions &options) const override;
-  DefaultOption GetDefaultOptions(const MplOptions &options) const override;
-  void GetTmpFilesToDelete(const MplOptions &mplOptions, std::vector<std::string> &tempFiles) const override;
-  std::unordered_set<std::string> GetFinalOutputs(const MplOptions &mplOptions) const override ;
+  DefaultOption GetDefaultOptions(const MplOptions &options, const Action &action) const override;
+  void GetTmpFilesToDelete(const MplOptions &mplOptions, const Action &action,
+                           std::vector<std::string> &tempFiles) const override;
+  std::unordered_set<std::string> GetFinalOutputs(const MplOptions &mplOptions,
+                                                  const Action &action) const override ;
 };
 
 class Cpp2MplCompiler : public Compiler {
@@ -140,10 +144,12 @@ class Cpp2MplCompiler : public Compiler {
  private:
   std::string GetBinPath(const MplOptions &options) const override;
   const std::string &GetBinName() const override;
-  std::string GetInputFileName(const MplOptions &options) const override;
-  DefaultOption GetDefaultOptions(const MplOptions &options) const override;
-  void GetTmpFilesToDelete(const MplOptions &mplOptions, std::vector<std::string> &tempFiles) const override;
-  std::unordered_set<std::string> GetFinalOutputs(const MplOptions &mplOptions) const override;
+  std::string GetInputFileName(const MplOptions &options, const Action &action) const override;
+  DefaultOption GetDefaultOptions(const MplOptions &options, const Action &action) const override;
+  void GetTmpFilesToDelete(const MplOptions &mplOptions, const Action &action,
+                           std::vector<std::string> &tempFiles) const override;
+  std::unordered_set<std::string> GetFinalOutputs(const MplOptions &mplOptions,
+                                                  const Action &action) const override;
 };
 
 class Dex2MplCompiler : public Compiler {
@@ -152,16 +158,19 @@ class Dex2MplCompiler : public Compiler {
 
   ~Dex2MplCompiler() = default;
 #ifdef INTERGRATE_DRIVER
-  ErrorCode Compile(MplOptions &options, std::unique_ptr<MIRModule> &theModule) override;
+  ErrorCode Compile(MplOptions &options, const Action &action,
+                    std::unique_ptr<MIRModule> &theModule) override;
 #endif
 
-  void PrintCommand(const MplOptions &options) const override;
+  void PrintCommand(const MplOptions &options, const Action &action) const override;
 
  private:
   const std::string &GetBinName() const override;
-  DefaultOption GetDefaultOptions(const MplOptions &options) const override;
-  void GetTmpFilesToDelete(const MplOptions &mplOptions, std::vector<std::string> &tempFiles) const override;
-  std::unordered_set<std::string> GetFinalOutputs(const MplOptions &mplOptions) const override;
+  DefaultOption GetDefaultOptions(const MplOptions &options, const Action &action) const override;
+  void GetTmpFilesToDelete(const MplOptions &mplOptions, const Action &action,
+                           std::vector<std::string> &tempFiles) const override;
+  std::unordered_set<std::string> GetFinalOutputs(const MplOptions &mplOptions,
+                                                  const Action &action) const override;
 #ifdef INTERGRATE_DRIVER
   void PostDex2Mpl(std::unique_ptr<MIRModule> &theModule) const;
   bool MakeDex2mplOptions(const MplOptions &options);
@@ -176,8 +185,8 @@ class IpaCompiler : public Compiler {
 
  private:
   const std::string &GetBinName() const override;
-  DefaultOption GetDefaultOptions(const MplOptions &options) const override;
-  std::string GetInputFileName(const MplOptions &options) const override;
+  DefaultOption GetDefaultOptions(const MplOptions &options, const Action &action) const override;
+  std::string GetInputFileName(const MplOptions &options, const Action &action) const override;
 };
 
 class MapleCombCompiler : public Compiler {
@@ -186,13 +195,16 @@ class MapleCombCompiler : public Compiler {
 
   ~MapleCombCompiler() = default;
 
-  ErrorCode Compile(MplOptions &options, std::unique_ptr<MIRModule> &theModule) override;
-  void PrintCommand(const MplOptions &options) const override;
-  std::string GetInputFileName(const MplOptions &options) const override;
+  ErrorCode Compile(MplOptions &options, const Action &action,
+                    std::unique_ptr<MIRModule> &theModule) override;
+  void PrintCommand(const MplOptions &options, const Action &action) const override;
+  std::string GetInputFileName(const MplOptions &options, const Action &action) const override;
 
  private:
-  std::unordered_set<std::string> GetFinalOutputs(const MplOptions &mplOptions) const override;
-  void GetTmpFilesToDelete(const MplOptions &mplOptions, std::vector<std::string> &tempFiles) const override;
+  std::unordered_set<std::string> GetFinalOutputs(const MplOptions &mplOptions,
+                                                  const Action &action) const override;
+  void GetTmpFilesToDelete(const MplOptions &mplOptions, const Action &action,
+                           std::vector<std::string> &tempFiles) const override;
   ErrorCode MakeMeOptions(const MplOptions &options, DriverRunner &runner);
   ErrorCode MakeMpl2MplOptions(const MplOptions &options, DriverRunner &runner);
   std::string DecideOutExe(const MplOptions &options);
@@ -203,19 +215,37 @@ class MplcgCompiler : public Compiler {
   explicit MplcgCompiler(const std::string &name) : Compiler(name) {}
 
   ~MplcgCompiler() = default;
-  ErrorCode Compile(MplOptions &options, std::unique_ptr<MIRModule> &theModule) override;
-  void PrintMplcgCommand(const MplOptions &options, const MIRModule &md) const;
-  void SetOutputFileName(const MplOptions &options, const MIRModule &md);
-  std::string GetInputFile(const MplOptions &options, const MIRModule *md) const;
+  ErrorCode Compile(MplOptions &options, const Action &action,
+                    std::unique_ptr<MIRModule> &theModule) override;
+  void PrintMplcgCommand(const MplOptions &options, const Action &action, const MIRModule &md) const;
+  void SetOutputFileName(const MplOptions &options, const Action &action, const MIRModule &md);
+  std::string GetInputFile(const MplOptions &options, const Action &action, const MIRModule *md) const;
  private:
-  DefaultOption GetDefaultOptions(const MplOptions &options) const override;
-  ErrorCode GetMplcgOptions(MplOptions &options, const MIRModule *theModule);
+  DefaultOption GetDefaultOptions(const MplOptions &options, const Action &action) const override;
+  ErrorCode GetMplcgOptions(MplOptions &options, const Action &action, const MIRModule *theModule);
   ErrorCode MakeCGOptions(const MplOptions &options);
   const std::string &GetBinName() const override;
   std::string baseName;
   std::string outputFile;
 };
 
+class MapleCombCompilerWrp : public Compiler {
+ public:
+  explicit MapleCombCompilerWrp(const std::string &name) : Compiler(name) {}
+  ~MapleCombCompilerWrp() = default;
+
+  std::string GetInputFileName(const MplOptions &options, const Action &action) const override;
+
+ private:
+  std::string GetBinPath(const MplOptions &options) const override;
+  const std::string &GetBinName() const override;
+  DefaultOption GetDefaultOptions(const MplOptions &options, const Action &action) const override;
+  void GetTmpFilesToDelete(const MplOptions &mplOptions, const Action &action,
+                           std::vector<std::string> &tempFiles) const override;
+  std::unordered_set<std::string> GetFinalOutputs(const MplOptions &mplOptions,
+                                                  const Action &action) const override;
+};
+
 // Build .s to .o
 class AsCompiler : public Compiler {
  public:
@@ -226,10 +256,12 @@ class AsCompiler : public Compiler {
  private:
   std::string GetBinPath(const MplOptions &options) const override;
   const std::string &GetBinName() const override;
-  DefaultOption GetDefaultOptions(const MplOptions &options) const override;
-  std::string GetInputFileName(const MplOptions &options) const override;
-  void GetTmpFilesToDelete(const MplOptions &mplOptions, std::vector<std::string> &tempFiles) const override;
-  std::unordered_set<std::string> GetFinalOutputs(const MplOptions &mplOptions) const override;
+  DefaultOption GetDefaultOptions(const MplOptions &options, const Action &action) const override;
+  std::string GetInputFileName(const MplOptions &options, const Action &action) const override;
+  void GetTmpFilesToDelete(const MplOptions &mplOptions, const Action &action,
+                           std::vector<std::string> &tempFiles) const override;
+  std::unordered_set<std::string> GetFinalOutputs(const MplOptions &mplOptions,
+                                                  const Action &action) const override;
 };
 
 // Build .o to .so
@@ -242,9 +274,8 @@ class LdCompiler : public Compiler {
  private:
   std::string GetBinPath(const MplOptions &options) const override;
   const std::string &GetBinName() const override;
-  DefaultOption GetDefaultOptions(const MplOptions &options) const override;
-  std::string GetInputFileName(const MplOptions &options) const override;
-  void GetTmpFilesToDelete(const MplOptions &mplOptions, std::vector<std::string> &tempFiles) const override;
+  DefaultOption GetDefaultOptions(const MplOptions &options, const Action &action) const override;
+  std::string GetInputFileName(const MplOptions &options, const Action &action) const override;
 };
 }  // namespace maple
 #endif  // MAPLE_DRIVER_INCLUDE_COMPILER_H
diff --git a/src/mapleall/maple_driver/include/compiler_factory.h b/src/mapleall/maple_driver/include/compiler_factory.h
index 4a6046d22b837144ee1b570bea020d37b83c5479..1b5118ff5d94164fede2fe4c98a248923824f84c 100644
--- a/src/mapleall/maple_driver/include/compiler_factory.h
+++ b/src/mapleall/maple_driver/include/compiler_factory.h
@@ -36,8 +36,8 @@ class CompilerFactory {
   bool compileFinished = false;
   CompilerFactory();
   void Insert(const std::string &name, Compiler *value);
-  ErrorCode DeleteTmpFiles(const MplOptions &mplOptions, const std::vector<std::string> &tempFiles,
-                           const std::unordered_set<std::string> &finalOutputs) const;
+  ErrorCode DeleteTmpFiles(const MplOptions &mplOptions,
+                           const std::vector<std::string> &tempFiles) const;
   SupportedCompilers supportedCompilers;
   CompilerSelector *compilerSelector;
   std::unique_ptr<MIRModule> theModule;
diff --git a/src/mapleall/maple_driver/include/compiler_selector.h b/src/mapleall/maple_driver/include/compiler_selector.h
index b226f9971d6b8a3a3fc1192163f3d87e58750e1a..9c819e7d27e7a32fe4c1ee523b9ca467df64a00d 100644
--- a/src/mapleall/maple_driver/include/compiler_selector.h
+++ b/src/mapleall/maple_driver/include/compiler_selector.h
@@ -27,7 +27,8 @@ class CompilerSelector {
 
   virtual ~CompilerSelector() = default;
 
-  virtual ErrorCode Select(const SupportedCompilers&, const MplOptions&, std::vector<Compiler*>&) const {
+  virtual ErrorCode Select(const SupportedCompilers&, const MplOptions&,
+                           std::vector<Action *>&) const {
     return kErrorToolNotFound;
   }
 };
@@ -39,12 +40,14 @@ class CompilerSelectorImpl : public CompilerSelector {
   ~CompilerSelectorImpl() = default;
 
   ErrorCode Select(const SupportedCompilers &supportedCompilers, const MplOptions &mplOptions,
-                   std::vector<Compiler*> &selected) const override;
+                   std::vector<Action *> &selectedActions) const override;
 
  private:
   Compiler *FindCompiler(const SupportedCompilers &compilers, const std::string &name) const;
   ErrorCode InsertCompilerIfNeeded(std::vector<Compiler*> &selected, const SupportedCompilers &compilers,
                                    const std::string &name) const;
+  ErrorCode Select(const SupportedCompilers &supportedCompilers, const MplOptions &mplOptions,
+                   Action &action, std::vector<Action *> &selectedActions) const;
 };
 }  // namespace maple
 #endif  // MAPLE_DRIVER_INCLUDE_COMPILER_SELECTOR_H
diff --git a/src/mapleall/maple_driver/include/driver_option_common.h b/src/mapleall/maple_driver/include/driver_option_common.h
index ee3f6e8a38a7eb80b5a7c8443d91fab6f67df035..5758a0bca78931a7488346e7f8da10e9816472b2 100644
--- a/src/mapleall/maple_driver/include/driver_option_common.h
+++ b/src/mapleall/maple_driver/include/driver_option_common.h
@@ -20,6 +20,7 @@ namespace maple {
 enum DriverOptionIndex {
   kUnknown,
   kHelp,
+  kMaplePrintPhases,
   kVersion,
   kInFile,
   kInMplt,
diff --git a/src/mapleall/maple_driver/include/mpl_options.h b/src/mapleall/maple_driver/include/mpl_options.h
index 547f1547079cb940fc13152413a928434bce753d..6a7a2cd98552aa224ddf69108f166cdd44c0b5c1 100644
--- a/src/mapleall/maple_driver/include/mpl_options.h
+++ b/src/mapleall/maple_driver/include/mpl_options.h
@@ -58,8 +58,171 @@ enum RunMode {
   kUnkownRun
 };
 
+class Compiler;
+
+class InputInfo {
+public:
+  InputInfo(const std::string &inputFile)
+    : inputFile(inputFile) {
+
+    inputFileType = GetInputFileType(inputFile);
+
+    inputName = FileUtils::GetFileName(inputFile, true);
+    inputFolder = FileUtils::GetFileFolder(inputFile);
+    outputFolder = inputFolder;
+    outputName = FileUtils::GetFileName(inputFile, false);
+    fullOutput = outputFolder + outputName;
+  }
+
+  static InputFileType GetInputFileType(const std::string &inputFile) {
+    InputFileType fileType = InputFileType::kFileTypeNone;
+    std::string extensionName = FileUtils::GetFileExtension(inputFile);
+
+    if (extensionName == "class") {
+      fileType = InputFileType::kFileTypeClass;
+    }
+    else if (extensionName == "dex") {
+      fileType = InputFileType::kFileTypeDex;
+    }
+    else if (extensionName == "c") {
+      fileType = InputFileType::kFileTypeC;
+    }
+    else if (extensionName == "cpp") {
+      fileType = InputFileType::kFileTypeCpp;
+    }
+    else if (extensionName == "ast") {
+      fileType = InputFileType::kFileTypeAst;
+    }
+    else if (extensionName == "jar") {
+      fileType = InputFileType::kFileTypeJar;
+    }
+    else if (extensionName == "mpl" || extensionName == "bpl") {
+      if (inputFile.find("VtableImpl") == std::string::npos) {
+        if (inputFile.find(".me.mpl") != std::string::npos) {
+          fileType = InputFileType::kFileTypeMeMpl;
+        } else {
+          fileType = extensionName == "mpl" ? InputFileType::kFileTypeMpl : InputFileType::kFileTypeBpl;
+        }
+      } else {
+        fileType = InputFileType::kFileTypeVtableImplMpl;
+      }
+    } else if (extensionName == "s") {
+      fileType = InputFileType::kFileTypeS;
+    }
+
+    return fileType;
+  }
+
+  InputFileType GetInputFileType() const {
+    return inputFileType;
+  }
+
+  const std::string &GetInputFile() const {
+    return inputFile;
+  }
+
+  const std::string &GetOutputFolder() const {
+    return outputFolder;
+  }
+
+  const std::string &GetOutputName() const {
+    return outputName;
+  }
+
+  const std::string &GetFullOutputName() const {
+    return fullOutput;
+  }
+
+private:
+  std::string inputFile = "";
+  InputFileType inputFileType = InputFileType::kFileTypeNone;
+
+  std::string inputName = "";
+  std::string inputFolder = "";
+  std::string outputName = "";
+  std::string outputFolder = "";
+  std::string fullOutput = "";
+};
+
+class Action {
+public:
+  Action(const std::string &tool, std::shared_ptr<InputInfo> inputInfo)
+    : inputInfo(inputInfo), tool(tool) {}
+
+  Action(const std::string &tool, std::shared_ptr<InputInfo> inputInfo,
+         std::shared_ptr<Action> in_action)
+    : inputInfo(inputInfo), tool(tool)  {
+    inputActions.push_back(in_action);
+  }
+
+  Action(const std::string &tool, const std::vector<std::shared_ptr<Action>> &inActions)
+    : tool(tool)  {
+
+    for (auto &inAction : inActions) {
+      inputActions.push_back(inAction);
+      linkInputFiles.push_back(inAction->GetInputFile());
+    }
+
+    /* FIXME: fix hardcode a.out */
+    inputInfo = std::make_shared<InputInfo>("./a.out");
+  }
+
+  const std::string &GetTool() const {
+    return tool;
+  }
+
+  const std::string &GetInputFile() const {
+    return inputInfo->GetInputFile();
+  }
+
+  const std::string &GetOutputFolder() const {
+    return inputInfo->GetOutputFolder();
+  }
+
+  const std::string &GetOutputName() const {
+    return inputInfo->GetOutputName();
+  }
+
+  const std::string &GetFullOutputName() const {
+    return inputInfo->GetFullOutputName();
+  }
+
+  InputFileType GetInputFileType() const {
+    return inputInfo->GetInputFileType();
+  }
+
+  const std::vector<std::string> &GetLinkFiles() const {
+    return linkInputFiles;
+  }
+
+  const std::vector<std::shared_ptr<Action>> &GetInputActions() const {
+    return inputActions;
+  }
+
+  Compiler *GetCompiler() const {
+    return compilerTool;
+  }
+
+  void SetCompiler(Compiler *compiler) {
+    compilerTool = compiler;
+  }
+
+private:
+  std::shared_ptr<InputInfo> inputInfo;
+
+  std::string tool = "";
+  std::string exeFolder = "";
+  std::vector<std::string> linkInputFiles;
+
+  Compiler *compilerTool;
+
+  /* This vector contains a links to previous actions in Action tree */
+  std::vector<std::shared_ptr<Action>> inputActions;
+};
+
 class MplOption {
  public:
+  MplOption(){needRootPath = false;}
   MplOption(const std::string &key, const std::string &value, bool needRootPath = false)
       : key(key),
         value(value),
@@ -81,6 +244,10 @@ class MplOption {
     value = val;
   }
 
+  void SetKey(std::string k) {
+    key = k;
+  }
+
   bool GetNeedRootPath() const {
     return needRootPath;
   }
@@ -207,6 +374,14 @@ class MplOptions {
     return generalRegOnly;
   }
 
+  const std::vector<std::shared_ptr<Action>> &GetActions() const {
+    return rootActions;
+  }
+
+  const std::vector<mapleOption::Option> &GetOptions() const {
+    return optionParser->GetOptions();
+  }
+
   ErrorCode AppendCombOptions(MIRSrcLang srcLang);
   ErrorCode AppendMplcgOptions(MIRSrcLang srcLang);
   std::string GetInputFileNameForPrint() const;
@@ -218,6 +393,12 @@ class MplOptions {
   ErrorCode HandleGeneralOptions();
   ErrorCode DecideRunType();
   ErrorCode DecideRunningPhases();
+  ErrorCode DecideRunningPhases(const std::vector<std::string> &runExes);
+  std::shared_ptr<Action> DecideRunningPhasesByType(const std::string &inputFile, bool isMultipleFiles);
+  ErrorCode MFCreateActionByExe(const std::string &exe, std::shared_ptr<Action> &currentAction,
+                                std::shared_ptr<InputInfo> inputInfo, bool &wasWrpCombCompilerCreated);
+  ErrorCode SFCreateActionByExe(const std::string &exe, std::shared_ptr<Action> &currentAction,
+                                std::shared_ptr<InputInfo> inputInfo, bool &isCombCompiler);
   ErrorCode CheckInputFileValidity();
   ErrorCode CheckFileExits();
   ErrorCode AddOption(const mapleOption::Option &option);
@@ -225,6 +406,8 @@ class MplOptions {
   ErrorCode UpdateExtraOptionOpt(const std::string &args);
   ErrorCode AppendDefaultOptions(const std::string &exeName, MplOption mplOptions[], unsigned int length);
   void UpdateRunningExe(const std::string &args);
+  void DumpActionTree(const Action &action, int idents) const;
+  void DumpActionTree() const;
   std::unique_ptr<mapleOption::OptionParser> optionParser = nullptr;
   std::map<std::string, std::vector<mapleOption::Option>> options = {};
   std::map<std::string, std::vector<mapleOption::Option>> exeOptions = {};
@@ -258,8 +441,11 @@ class MplOptions {
   bool genVtableImpl = false;
   bool hasPrinted = false;
   bool generalRegOnly = false;
+  bool isDriverPhasesDumpCmd = false;
   unsigned int helpLevel = mapleOption::kBuildTypeDefault;
   std::string partO2List = "";
+
+  std::vector<std::shared_ptr<Action>> rootActions;
 };
 }  // namespace maple
 #endif  // MAPLE_DRIVER_INCLUDE_MPL_OPTIONS_H
diff --git a/src/mapleall/maple_driver/include/option_descriptor.h b/src/mapleall/maple_driver/include/option_descriptor.h
index 02abb695de8e458b002b764cd3f20a2e36e7b07c..ebe7ad27c73fe55c5b614fd06ec72e6da5d6998f 100644
--- a/src/mapleall/maple_driver/include/option_descriptor.h
+++ b/src/mapleall/maple_driver/include/option_descriptor.h
@@ -36,6 +36,12 @@ enum ArgCheckPolicy {
   kArgCheckPolicyBool
 };
 
+enum OptionPrefixType {
+  shortOptPrefix,
+  longOptPrefix,
+  undefinedOpt,
+};
+
 constexpr size_t kMaxExtraOptions = 10;
 
 struct Descriptor {
@@ -89,6 +95,12 @@ class Option {
   Option(const Descriptor &desc, const std::string &optionKey, const std::string &args)
       : descriptor(desc), optionKey(optionKey), args(args) {}
 
+  Option(const Descriptor &desc, const std::string &optionKey,
+         const std::string &args, OptionPrefixType prefixType,
+         bool isEqualPrefix)
+    : descriptor(desc), optionKey(optionKey), args(args),
+      prefixType(prefixType), isEqualPrefix(isEqualPrefix) {}
+
   ~Option() = default;
 
   size_t Index() const {
@@ -99,6 +111,14 @@ class Option {
     return descriptor.type;
   }
 
+  OptionPrefixType GetPrefixType() const {
+    return prefixType;
+  }
+
+  bool CheckEqualPrefix() const {
+    return isEqualPrefix;
+  }
+
   const std::string &Args() const {
     return args;
   }
@@ -107,6 +127,10 @@ class Option {
     return optionKey;
   }
 
+  const Descriptor &GetDescriptor() const {
+    return descriptor;
+  }
+
   bool HasExtra() const {
     return (descriptor.extras.size() > 0);
   }
@@ -132,6 +156,8 @@ class Option {
   Descriptor descriptor;
   const std::string optionKey;
   const std::string args;
+  OptionPrefixType prefixType = undefinedOpt;
+  bool isEqualPrefix = false; // whether option contains "=", like -op=-value
 };
 
 enum EnabledIndex {
@@ -139,4 +165,4 @@ enum EnabledIndex {
   kEnable
 };
 }  // namespace mapleOption
-#endif // MAPLE_OPTION_DESCRIPTOR_H
\ No newline at end of file
+#endif // MAPLE_OPTION_DESCRIPTOR_H
diff --git a/src/mapleall/maple_driver/include/option_parser.h b/src/mapleall/maple_driver/include/option_parser.h
index 42782f63b7d49fda9d4a5c8fb00cbf4565c57d0a..43fd7895661bf6c78d6a2769dfff281cbfe1620c 100644
--- a/src/mapleall/maple_driver/include/option_parser.h
+++ b/src/mapleall/maple_driver/include/option_parser.h
@@ -56,19 +56,30 @@ class OptionParser {
   void PrintUsage(const std::string &helpType, const uint32_t helpLevel = kBuildTypeDefault) const;
 
  private:
+
+  struct UsageWrp {
+    UsageWrp(const Descriptor &desc, const OptionPrefixType &type) :
+      desc(desc),
+      type(type) {};
+    Descriptor desc;
+    OptionPrefixType type;
+  };
+
   bool HandleKeyValue(const std::string &key, const std::string &value,
                       std::vector<mapleOption::Option> &inputOption, const std::string &exeName,
-                      bool isAllOption = true);
+                      bool isAllOption = true, bool isEqualPrefix = false);
   bool CheckOpt(const std::string option, std::string &lastKey, bool &isLastMatch,
                 std::vector<mapleOption::Option> &inputOption, const std::string &exeName);
-  void InsertOption(const std::string &opt, const Descriptor &usage) {
+  void InsertOption(const std::string &opt, const Descriptor &usage,
+                    OptionPrefixType optPrefix) {
     if (usage.IsEnabledForCurrentBuild()) {
-      (void)usages.insert(make_pair(opt, usage));
+      (void)usages.insert(make_pair(opt, UsageWrp(usage, optPrefix)));
     }
   }
+
   bool CheckSpecialOption(const std::string &option, std::string &key, std::string &value);
   std::vector<Descriptor> rawUsages;
-  std::multimap<std::string, Descriptor> usages;
+  std::multimap<std::string, UsageWrp> usages;
   std::vector<Option> options;
   std::vector<std::string> nonOptionsArgs;
   bool isValueEmpty = false;
diff --git a/src/mapleall/maple_driver/src/as_compiler.cpp b/src/mapleall/maple_driver/src/as_compiler.cpp
index 79f7a1a0224cd40e94a031433756b4d816d418c3..69aa2f9cabb4ecbafd46bdad21c6d9379789b9d6 100644
--- a/src/mapleall/maple_driver/src/as_compiler.cpp
+++ b/src/mapleall/maple_driver/src/as_compiler.cpp
@@ -29,10 +29,10 @@ const std::string &AsCompiler::GetBinName() const {
   return kBinNameAs;
 }
 
-DefaultOption AsCompiler::GetDefaultOptions(const MplOptions &options) const {
+DefaultOption AsCompiler::GetDefaultOptions(const MplOptions &options, const Action &action) const {
   DefaultOption defaultOptions = { nullptr, 0 };
   defaultOptions.mplOptions = kAsDefaultOptions;
-  defaultOptions.mplOptions[0].SetValue(options.GetOutputFolder() + options.GetOutputName() + ".o");
+  defaultOptions.mplOptions[0].SetValue(action.GetFullOutputName() + ".o");
   defaultOptions.length = sizeof(kAsDefaultOptions) / sizeof(MplOption);
 
   for (uint32_t i = 0; i < defaultOptions.length; ++i) {
@@ -44,17 +44,19 @@ DefaultOption AsCompiler::GetDefaultOptions(const MplOptions &options) const {
   return defaultOptions;
 }
 
-std::string AsCompiler::GetInputFileName(const MplOptions &options) const {
-  return options.GetOutputFolder() + options.GetOutputName() + ".s";
+std::string AsCompiler::GetInputFileName(const MplOptions &, const Action &action) const {
+  return action.GetFullOutputName() + ".s";
 }
 
-void AsCompiler::GetTmpFilesToDelete(const MplOptions &mplOptions, std::vector<std::string> &tempFiles) const {
-  tempFiles.push_back(mplOptions.GetOutputFolder() + mplOptions.GetOutputName() + ".s");
+void AsCompiler::GetTmpFilesToDelete(const MplOptions &mplOptions, const Action &action,
+                                     std::vector<std::string> &tempFiles) const {
+  tempFiles.push_back(action.GetFullOutputName() + ".o");
 }
 
-std::unordered_set<std::string> AsCompiler::GetFinalOutputs(const MplOptions &mplOptions) const {
+std::unordered_set<std::string> AsCompiler::GetFinalOutputs(const MplOptions &,
+                                                            const Action &action) const {
   auto finalOutputs = std::unordered_set<std::string>();
-  (void)finalOutputs.insert(mplOptions.GetOutputFolder() + mplOptions.GetOutputName() + ".o");
+  (void)finalOutputs.insert(action.GetFullOutputName() + ".o");
   return finalOutputs;
 }
 }  // namespace maple
diff --git a/src/mapleall/maple_driver/src/clang_compiler.cpp b/src/mapleall/maple_driver/src/clang_compiler.cpp
index 9d0d1a2c824d54825b6168dd1811e9a4132127e0..262a1e8b744c0e83923c5451b89c2fea9979d4f5 100644
--- a/src/mapleall/maple_driver/src/clang_compiler.cpp
+++ b/src/mapleall/maple_driver/src/clang_compiler.cpp
@@ -27,10 +27,10 @@ const std::string &ClangCompiler::GetBinName() const {
   return kBinNameClang;
 }
 
-DefaultOption ClangCompiler::GetDefaultOptions(const MplOptions &options) const {
+DefaultOption ClangCompiler::GetDefaultOptions(const MplOptions &options, const Action &action) const {
   DefaultOption defaultOptions = { nullptr, 0 };
   defaultOptions.mplOptions = kClangDefaultOptions;
-  defaultOptions.mplOptions[1].SetValue(options.GetOutputFolder() + options.GetOutputName() + ".ast");
+  defaultOptions.mplOptions[1].SetValue(action.GetFullOutputName() + ".ast");
   defaultOptions.length = sizeof(kClangDefaultOptions) / sizeof(MplOption);
 
   for (uint32_t i = 0; i < defaultOptions.length; ++i) {
@@ -42,13 +42,15 @@ DefaultOption ClangCompiler::GetDefaultOptions(const MplOptions &options) const
   return defaultOptions;
 }
 
-void ClangCompiler::GetTmpFilesToDelete(const MplOptions &mplOptions, std::vector<std::string> &tempFiles) const {
-  tempFiles.push_back(mplOptions.GetOutputFolder() + mplOptions.GetOutputName() + ".ast");
+void ClangCompiler::GetTmpFilesToDelete(const MplOptions &, const Action &action,
+                                        std::vector<std::string> &tempFiles) const {
+  tempFiles.push_back(action.GetFullOutputName() + ".ast");
 }
 
-std::unordered_set<std::string> ClangCompiler::GetFinalOutputs(const MplOptions &mplOptions) const {
+std::unordered_set<std::string> ClangCompiler::GetFinalOutputs(const MplOptions &,
+                                                               const Action &action) const {
   std::unordered_set<std::string> finalOutputs;
-  (void)finalOutputs.insert(mplOptions.GetOutputFolder() + mplOptions.GetOutputName() + ".ast");
+  (void)finalOutputs.insert(action.GetFullOutputName() + ".ast");
   return finalOutputs;
 }
 }
diff --git a/src/mapleall/maple_driver/src/compiler.cpp b/src/mapleall/maple_driver/src/compiler.cpp
index 866b04f8710a88407be334eda814f2c3ae9f1066..f576fb298223d4b91c366f6156791d645bab3d9c 100644
--- a/src/mapleall/maple_driver/src/compiler.cpp
+++ b/src/mapleall/maple_driver/src/compiler.cpp
@@ -42,11 +42,12 @@ std::string Compiler::GetBinPath(const MplOptions &mplOptions) const {
   return binPath;
 }
 
-ErrorCode Compiler::Compile(MplOptions &options, std::unique_ptr<MIRModule> &) {
+ErrorCode Compiler::Compile(MplOptions &options, const Action &action,
+                            std::unique_ptr<MIRModule> &) {
   MPLTimer timer = MPLTimer();
   LogInfo::MapleLogger() << "Starting " << GetName() << '\n';
   timer.Start();
-  std::string strOption = MakeOption(options);
+  std::string strOption = MakeOption(options, action);
   if (strOption.empty()) {
     return kErrorInvalidParameter;
   }
@@ -58,15 +59,15 @@ ErrorCode Compiler::Compile(MplOptions &options, std::unique_ptr<MIRModule> &) {
   return kErrorNoError;
 }
 
-std::string Compiler::MakeOption(const MplOptions &options) const {
+std::string Compiler::MakeOption(const MplOptions &options, const Action &action) const {
   std::map<std::string, MplOption> finalOptions;
-  std::map<std::string, MplOption> defaultOptions = MakeDefaultOptions(options);
+  std::map<std::string, MplOption> defaultOptions = MakeDefaultOptions(options, action);
   std::ostringstream strOption;
   AppendDefaultOptions(finalOptions, defaultOptions, strOption, options.HasSetDebugFlag());
   AppendExtraOptions(finalOptions, options, strOption, options.HasSetDebugFlag());
-  strOption << " " << this->GetInputFileName(options);
+  strOption << " " << GetInputFileName(options, action);
   if (options.HasSetDebugFlag()) {
-    LogInfo::MapleLogger() << Compiler::GetName() << " input files: " << GetInputFileName(options) << '\n';
+    LogInfo::MapleLogger() << Compiler::GetName() << " input files: " << GetInputFileName(options, action) << '\n';
   }
   return strOption.str();
 }
@@ -113,8 +114,9 @@ void Compiler::AppendExtraOptions(std::map<std::string, MplOption> &finalOptions
   }
 }
 
-std::map<std::string, MplOption> Compiler::MakeDefaultOptions(const MplOptions &options) const {
-  DefaultOption rawDefaultOptions = GetDefaultOptions(options);
+std::map<std::string, MplOption> Compiler::MakeDefaultOptions(const MplOptions &options,
+                                                              const Action &action) const {
+  DefaultOption rawDefaultOptions = GetDefaultOptions(options, action);
   std::map<std::string, MplOption> defaultOptions;
   if (rawDefaultOptions.mplOptions != nullptr) {
     for (uint32_t i = 0; i < rawDefaultOptions.length; ++i) {
diff --git a/src/mapleall/maple_driver/src/compiler_factory.cpp b/src/mapleall/maple_driver/src/compiler_factory.cpp
index 8909e8897939d3f8b2a90a994792944cd8b74558..bee15fb9409fd4efd636a4925f0d43f88b52931d 100644
--- a/src/mapleall/maple_driver/src/compiler_factory.cpp
+++ b/src/mapleall/maple_driver/src/compiler_factory.cpp
@@ -40,6 +40,7 @@ CompilerFactory::CompilerFactory() {
   ADD_COMPILER("me", MapleCombCompiler)
   ADD_COMPILER("mpl2mpl", MapleCombCompiler)
   ADD_COMPILER("maplecomb", MapleCombCompiler)
+  ADD_COMPILER("maplecombwrp", MapleCombCompilerWrp)
   ADD_COMPILER("mplcg", MplcgCompiler)
   ADD_COMPILER("as", AsCompiler)
   ADD_COMPILER("ld", LdCompiler)
@@ -66,8 +67,8 @@ void CompilerFactory::Insert(const std::string &name, Compiler *value) {
   (void)supportedCompilers.insert(make_pair(name, value));
 }
 
-ErrorCode CompilerFactory::DeleteTmpFiles(const MplOptions &mplOptions, const std::vector<std::string> &tempFiles,
-                                          const std::unordered_set<std::string> &finalOutputs) const {
+ErrorCode CompilerFactory::DeleteTmpFiles(const MplOptions &mplOptions,
+                                          const std::vector<std::string> &tempFiles) const {
   int ret = 0;
   for (const std::string &tmpFile : tempFiles) {
     bool isSave = false;
@@ -77,9 +78,26 @@ ErrorCode CompilerFactory::DeleteTmpFiles(const MplOptions &mplOptions, const st
         break;
       }
     }
-    if (!isSave && mplOptions.GetInputFiles().find(tmpFile) == std::string::npos &&  // not input
-        (finalOutputs.find(tmpFile) == finalOutputs.end())) {                   // not output
-      ret = FileUtils::Remove(tmpFile);
+    if (!isSave && mplOptions.GetInputFiles().find(tmpFile) == std::string::npos /* not input */) {
+
+      bool isNeedRemove = true;
+      /* If we compile several files we can have several last Actions,
+       * so we need to NOT remove output files for each last Action.
+       */
+      for (auto lastAction : mplOptions.GetActions()) {
+        auto finalOutputs = lastAction->GetCompiler()->GetFinalOutputs(mplOptions, *lastAction);
+        /* do not remove output files */
+        if (finalOutputs.find(tmpFile) != finalOutputs.end()) {
+          isNeedRemove = false;
+        }
+      }
+
+      if (isNeedRemove == true) {
+        ret = FileUtils::Remove(tmpFile);
+        if (ret != 0) {
+          LogInfo::MapleLogger() << tmpFile << " File Not Found in DeleteTmpFiles\n";
+        }
+      }
     }
   }
   return ret == 0 ? kErrorNoError : kErrorFileNotFound;
@@ -91,22 +109,30 @@ ErrorCode CompilerFactory::Compile(MplOptions &mplOptions) {
         "Failed! Compilation has been completed in previous time and multi-instance compilation is not supported\n";
     return kErrorCompileFail;
   }
-  std::vector<Compiler*> compilers;
+
+  /* Actions owner is MplOption, so while MplOption is alive we can use raw pointers here */
+  std::vector<Action *> actions;
   if (compilerSelector == nullptr) {
     LogInfo::MapleLogger() << "Failed! Compiler is null." << "\n";
     return kErrorCompileFail;
   }
-  ErrorCode ret = compilerSelector->Select(supportedCompilers, mplOptions, compilers);
+  ErrorCode ret = compilerSelector->Select(supportedCompilers, mplOptions, actions);
   if (ret != kErrorNoError) {
     return ret;
   }
 
-  for (auto *compiler : compilers) {
-    if (compiler == nullptr) {
+  for (auto *action : actions) {
+    if (action == nullptr) {
       LogInfo::MapleLogger() << "Failed! Compiler is null." << "\n";
       return kErrorCompileFail;
     }
-    ret = compiler->Compile(mplOptions, this->theModule);
+
+    Compiler *compiler = action->GetCompiler();
+    if (compiler == nullptr) {
+      return kErrorToolNotFound;
+    }
+
+    ret = compiler->Compile(mplOptions, *action, this->theModule);
     if (ret != kErrorNoError) {
       return ret;
     }
@@ -119,10 +145,12 @@ ErrorCode CompilerFactory::Compile(MplOptions &mplOptions) {
 
   if (!mplOptions.HasSetSaveTmps() || !mplOptions.GetSaveFiles().empty()) {
     std::vector<std::string> tmpFiles;
-    for (auto *compiler : compilers) {
-      compiler->GetTmpFilesToDelete(mplOptions, tmpFiles);
+
+    for (auto *action : actions) {
+      action->GetCompiler()->GetTmpFilesToDelete(mplOptions, *action, tmpFiles);
     }
-    ret = DeleteTmpFiles(mplOptions, tmpFiles, compilers.back()->GetFinalOutputs(mplOptions));
+
+    ret = DeleteTmpFiles(mplOptions, tmpFiles);
   }
   return ret;
 }
diff --git a/src/mapleall/maple_driver/src/compiler_selector.cpp b/src/mapleall/maple_driver/src/compiler_selector.cpp
index 2b2b31c3b4b821bcabe46a9a6a142a0803a85990..e6549c65b3dd9caf3b75647420f42e158729406c 100644
--- a/src/mapleall/maple_driver/src/compiler_selector.cpp
+++ b/src/mapleall/maple_driver/src/compiler_selector.cpp
@@ -40,22 +40,36 @@ ErrorCode CompilerSelectorImpl::InsertCompilerIfNeeded(std::vector<Compiler*> &s
   return kErrorToolNotFound;
 }
 
-ErrorCode CompilerSelectorImpl::Select(const SupportedCompilers &supportedCompilers, const MplOptions &mplOptions,
-                                       std::vector<Compiler*> &selected) const {
-  bool combPhases = false;
-  if (!mplOptions.GetSelectedExes().empty()) {
-    for (const std::string &runningExe : mplOptions.GetSelectedExes()) {
-      if (runningExe == kBinNameMe) {
-        combPhases = true;
-      } else if (runningExe == kBinNameMpl2mpl && combPhases) {
-        continue;
-      }
-      ErrorCode ret = InsertCompilerIfNeeded(selected, supportedCompilers, runningExe);
-      if (ret != kErrorNoError) {
-        return kErrorToolNotFound;
-      }
-    }
+ErrorCode CompilerSelectorImpl::Select(const SupportedCompilers &supportedCompilers,
+                                       const MplOptions &mplOptions,
+                                       Action &action,
+                                       std::vector<Action *> &selectedActions) const {
+  /* Traverse Action tree recursively and select compilers in
+   * "from leaf(clang) to root(ld)" order */
+  for (const std::shared_ptr<Action> &a : action.GetInputActions()) {
+    Select(supportedCompilers, mplOptions, *a, selectedActions);
+  }
+
+  Compiler *compiler = FindCompiler(supportedCompilers, action.GetTool());
+  if (compiler == nullptr) {
+    return kErrorToolNotFound;
+  }
+  action.SetCompiler(compiler);
+  selectedActions.push_back(&action);
+
+  return kErrorNoError;
+}
+
+ErrorCode CompilerSelectorImpl::Select(const SupportedCompilers &supportedCompilers,
+                                       const MplOptions &mplOptions,
+                                       std::vector<Action *> &selectedActions) const {
+
+  ErrorCode ret = kErrorNoError;
+
+  for (const std::shared_ptr<Action> &action : mplOptions.GetActions()) {
+    ret = Select(supportedCompilers, mplOptions, *action, selectedActions);
   }
-  return selected.empty() ? kErrorToolNotFound : kErrorNoError;
+
+  return selectedActions.empty() ? kErrorToolNotFound : kErrorNoError;
 }
 }  // namespace maple
diff --git a/src/mapleall/maple_driver/src/cpp2mpl_compiler.cpp b/src/mapleall/maple_driver/src/cpp2mpl_compiler.cpp
index ee3567c902a5edc77ce9bd26a5863b60f3a8507f..06a121220191b71d1b950574a2daceed885b5fb4 100644
--- a/src/mapleall/maple_driver/src/cpp2mpl_compiler.cpp
+++ b/src/mapleall/maple_driver/src/cpp2mpl_compiler.cpp
@@ -27,22 +27,22 @@ const std::string &Cpp2MplCompiler::GetBinName() const {
   return kBinNameCpp2mpl;
 }
 
-std::string Cpp2MplCompiler::GetInputFileName(const MplOptions &options) const {
+std::string Cpp2MplCompiler::GetInputFileName(const MplOptions &options, const Action &action) const {
   if (!options.GetRunningExes().empty()) {
     if (options.GetRunningExes()[0] == kBinNameCpp2mpl) {
-      return options.GetInputFiles();
+      return action.GetInputFile();
     }
   }
   // Get base file name
-  auto idx = options.GetOutputName().find(".ast");
-  std::string outputName = options.GetOutputName();
+  auto idx = action.GetOutputName().find(".ast");
+  std::string outputName = action.GetOutputName();
   if (idx != std::string::npos) {
-    outputName = options.GetOutputName().substr(0, idx);
+    outputName = action.GetOutputName().substr(0, idx);
   }
-  return options.GetOutputFolder() + outputName + ".ast";
+  return action.GetOutputFolder() + outputName + ".ast";
 }
 
-DefaultOption Cpp2MplCompiler::GetDefaultOptions(const MplOptions &options) const {
+DefaultOption Cpp2MplCompiler::GetDefaultOptions(const MplOptions &options, const Action &) const {
   DefaultOption defaultOptions = { nullptr, 0 };
   defaultOptions.mplOptions = kCpp2MplDefaultOptionsForAst;
   defaultOptions.length = sizeof(kCpp2MplDefaultOptionsForAst) / sizeof(MplOption);
@@ -56,15 +56,17 @@ DefaultOption Cpp2MplCompiler::GetDefaultOptions(const MplOptions &options) cons
     return defaultOptions;
 }
 
-void Cpp2MplCompiler::GetTmpFilesToDelete(const MplOptions &mplOptions, std::vector<std::string> &tempFiles) const {
-  tempFiles.push_back(mplOptions.GetOutputFolder() + mplOptions.GetOutputName() + ".mpl");
-  tempFiles.push_back(mplOptions.GetOutputFolder() + mplOptions.GetOutputName() + ".mplt");
+void Cpp2MplCompiler::GetTmpFilesToDelete(const MplOptions &, const Action &action,
+                                          std::vector<std::string> &tempFiles) const {
+  tempFiles.push_back(action.GetFullOutputName() + ".mpl");
+  tempFiles.push_back(action.GetFullOutputName() + ".mplt");
 }
 
-std::unordered_set<std::string> Cpp2MplCompiler::GetFinalOutputs(const MplOptions &mplOptions) const {
+std::unordered_set<std::string> Cpp2MplCompiler::GetFinalOutputs(const MplOptions &,
+                                                                 const Action &action) const {
   std::unordered_set<std::string> finalOutputs;
-  (void)finalOutputs.insert(mplOptions.GetOutputFolder() + mplOptions.GetOutputName() + ".mpl");
-  (void)finalOutputs.insert(mplOptions.GetOutputFolder() + mplOptions.GetOutputName() + ".mplt");
+  (void)finalOutputs.insert(action.GetFullOutputName() + ".mpl");
+  (void)finalOutputs.insert(action.GetFullOutputName() + ".mplt");
   return finalOutputs;
 }
 }  // namespace maple
diff --git a/src/mapleall/maple_driver/src/dex2mpl_compiler.cpp b/src/mapleall/maple_driver/src/dex2mpl_compiler.cpp
index 2553da941a6a7253468a251cbaea28964d0d7f15..4176d1a53734038f926687f826730946e4fb1dac 100644
--- a/src/mapleall/maple_driver/src/dex2mpl_compiler.cpp
+++ b/src/mapleall/maple_driver/src/dex2mpl_compiler.cpp
@@ -24,7 +24,7 @@ const std::string &Dex2MplCompiler::GetBinName() const {
   return kBinNameDex2mpl;
 }
 
-DefaultOption Dex2MplCompiler::GetDefaultOptions(const MplOptions &options) const {
+DefaultOption Dex2MplCompiler::GetDefaultOptions(const MplOptions &options, const Action &) const {
   DefaultOption defaultOptions = { nullptr, 0 };
   if (options.GetOptimizationLevel() == kO0 && options.HasSetDefaultLevel()) {
     defaultOptions.mplOptions = kDex2mplDefaultOptionsO0;
@@ -42,15 +42,17 @@ DefaultOption Dex2MplCompiler::GetDefaultOptions(const MplOptions &options) cons
   return defaultOptions;
 }
 
-void Dex2MplCompiler::GetTmpFilesToDelete(const MplOptions &mplOptions, std::vector<std::string> &tempFiles) const {
-  tempFiles.push_back(mplOptions.GetOutputFolder() + mplOptions.GetOutputName() + ".mpl");
-  tempFiles.push_back(mplOptions.GetOutputFolder() + mplOptions.GetOutputName() + ".mplt");
+void Dex2MplCompiler::GetTmpFilesToDelete(const MplOptions &, const Action &action,
+                                          std::vector<std::string> &tempFiles) const {
+  tempFiles.push_back(action.GetFullOutputName() + ".mpl");
+  tempFiles.push_back(action.GetFullOutputName() + ".mplt");
 }
 
-std::unordered_set<std::string> Dex2MplCompiler::GetFinalOutputs(const MplOptions &mplOptions) const {
+std::unordered_set<std::string> Dex2MplCompiler::GetFinalOutputs(const MplOptions &,
+                                                                 const Action &action) const {
   auto finalOutputs = std::unordered_set<std::string>();
-  (void)finalOutputs.insert(mplOptions.GetOutputFolder() + mplOptions.GetOutputName() + ".mpl");
-  (void)finalOutputs.insert(mplOptions.GetOutputFolder() + mplOptions.GetOutputName() + ".mplt");
+  (void)finalOutputs.insert(action.GetFullOutputName() + ".mpl");
+  (void)finalOutputs.insert(action.GetFullOutputName() + ".mplt");
   return finalOutputs;
 }
 
@@ -171,7 +173,7 @@ void Dex2MplCompiler::PostDex2Mpl(std::unique_ptr<MIRModule> &theModule) const {
 }
 #endif
 
-void Dex2MplCompiler::PrintCommand(const MplOptions &options) const {
+void Dex2MplCompiler::PrintCommand(const MplOptions &options, const Action &action) const {
   std::string runStr = "--run=";
   std::string optionStr = "--option=\"";
   std::string connectSym = "";
@@ -185,7 +187,7 @@ void Dex2MplCompiler::PrintCommand(const MplOptions &options) const {
   }
   optionStr += "\"";
   LogInfo::MapleLogger() << "Starting:" << options.GetExeFolder() << "maple " << runStr << " " << optionStr
-                         << " --infile " << GetInputFileName(options) << '\n';
+                         << " --infile " << GetInputFileName(options, action) << '\n';
 }
 
 #ifdef INTERGRATE_DRIVER
@@ -205,14 +207,15 @@ bool Dex2MplCompiler::MakeDex2mplOptions(const MplOptions &options) {
   return true;
 }
 
-ErrorCode Dex2MplCompiler::Compile(MplOptions &options, std::unique_ptr<MIRModule> &theModule) {
+ErrorCode Dex2MplCompiler::Compile(MplOptions &options, const Action &action,
+                                   std::unique_ptr<MIRModule> &theModule) {
   Dex2mplOptions &dex2mplOptions = Dex2mplOptions::GetInstance();
   bool result = MakeDex2mplOptions(options);
   if (!result) {
     return ErrorCode::kErrorCompileFail;
   }
   // .dex
-  std::string dexFileName = options.GetSplitsInputFiles()[0];
+  std::string dexFileName = action.GetInputFile();
   theModule = std::make_unique<MIRModule>(dexFileName);
 
   const auto &runningExes = options.GetRunningExes();
@@ -240,7 +243,7 @@ ErrorCode Dex2MplCompiler::Compile(MplOptions &options, std::unique_ptr<MIRModul
     dex2mpl->MoveMirModule(theModule);
     PostDex2Mpl(theModule);
   }
-  PrintCommand(options);
+  PrintCommand(options, action);
   return ErrorCode::kErrorNoError;
 }
 #endif
diff --git a/src/mapleall/maple_driver/src/driver_option_common.cpp b/src/mapleall/maple_driver/src/driver_option_common.cpp
index 8983e003f833da32e42511b380cb91888e24e172..d81b104a6a9e398909f88e8e12a88358c565438e 100644
--- a/src/mapleall/maple_driver/src/driver_option_common.cpp
+++ b/src/mapleall/maple_driver/src/driver_option_common.cpp
@@ -357,6 +357,15 @@ const mapleOption::Descriptor kUsages[] = {
     "                              \tNUM=3: Debug options\n",
     "all",
     {} },
+  { kMaplePrintPhases,
+    0,
+    "maple-print-phases",
+    "maple-print-phases",
+    kBuildTypeAll,
+    kArgCheckPolicyOptional,
+    "  -maple-print-phases \tPrint Driver Phases.\n  --maple-print-phases\n",
+    "all",
+    {} },
   { kUnknown,
     0,
     "",
diff --git a/src/mapleall/maple_driver/src/ipa_compiler.cpp b/src/mapleall/maple_driver/src/ipa_compiler.cpp
index 2917187072f8b08ee78d41318b89633e000b39cf..09d342ef407dffd27375a66bcb00b9be7ac1d05b 100644
--- a/src/mapleall/maple_driver/src/ipa_compiler.cpp
+++ b/src/mapleall/maple_driver/src/ipa_compiler.cpp
@@ -20,7 +20,7 @@ const std::string &IpaCompiler::GetBinName() const {
   return kBinNameMplipa;
 }
 
-DefaultOption IpaCompiler::GetDefaultOptions(const MplOptions &options) const {
+DefaultOption IpaCompiler::GetDefaultOptions(const MplOptions &options, const Action &) const {
   DefaultOption defaultOptions = { nullptr, 0 };
   if (options.GetOptimizationLevel() == kO2 && options.HasSetDefaultLevel()) {
     defaultOptions.mplOptions = kMplipaDefaultOptionsO2;
@@ -35,7 +35,7 @@ DefaultOption IpaCompiler::GetDefaultOptions(const MplOptions &options) const {
   return defaultOptions;
 }
 
-std::string IpaCompiler::GetInputFileName(const MplOptions &options) const {
-  return options.GetOutputFolder() + options.GetOutputName() + ".mpl";
+std::string IpaCompiler::GetInputFileName(const MplOptions &, const Action &action) const {
+  return action.GetFullOutputName() + ".mpl";
 }
 }  // namespace maple
diff --git a/src/mapleall/maple_driver/src/jbc2mpl_compiler.cpp b/src/mapleall/maple_driver/src/jbc2mpl_compiler.cpp
index 531e8afc957bbe488884bf9e1d892871878f9022..f045a09f458fd68a19ece19ccffb9ca691a78d1c 100644
--- a/src/mapleall/maple_driver/src/jbc2mpl_compiler.cpp
+++ b/src/mapleall/maple_driver/src/jbc2mpl_compiler.cpp
@@ -21,20 +21,22 @@ const std::string &Jbc2MplCompiler::GetBinName() const {
   return kBinNameJbc2mpl;
 }
 
-DefaultOption Jbc2MplCompiler::GetDefaultOptions(const MplOptions&) const {
+DefaultOption Jbc2MplCompiler::GetDefaultOptions(const MplOptions&, const Action &) const {
   DefaultOption defaultOptions = { nullptr, 0 };
   return defaultOptions;
 }
 
-void Jbc2MplCompiler::GetTmpFilesToDelete(const MplOptions &mplOptions, std::vector<std::string> &tempFiles) const {
-  tempFiles.push_back(mplOptions.GetOutputFolder() + mplOptions.GetOutputName() + ".mpl");
-  tempFiles.push_back(mplOptions.GetOutputFolder() + mplOptions.GetOutputName() + ".mplt");
+void Jbc2MplCompiler::GetTmpFilesToDelete(const MplOptions &, const Action &action,
+                                          std::vector<std::string> &tempFiles) const {
+  tempFiles.push_back(action.GetFullOutputName() + ".mpl");
+  tempFiles.push_back(action.GetFullOutputName() + ".mplt");
 }
 
-std::unordered_set<std::string> Jbc2MplCompiler::GetFinalOutputs(const MplOptions &mplOptions) const {
+std::unordered_set<std::string> Jbc2MplCompiler::GetFinalOutputs(const MplOptions &,
+                                                                 const Action &action) const {
   std::unordered_set<std::string> finalOutputs;
-  (void)finalOutputs.insert(mplOptions.GetOutputFolder() + mplOptions.GetOutputName() + ".mpl");
-  (void)finalOutputs.insert(mplOptions.GetOutputFolder() + mplOptions.GetOutputName() + ".mplt");
+  (void)finalOutputs.insert(action.GetFullOutputName() + ".mpl");
+  (void)finalOutputs.insert(action.GetFullOutputName() + ".mplt");
   return finalOutputs;
 }
 }  // namespace maple
diff --git a/src/mapleall/maple_driver/src/ld_compiler.cpp b/src/mapleall/maple_driver/src/ld_compiler.cpp
index 0d19a70af9b90cb4b537c0dad2fc42286c1af19f..388f78d4529b795ffd0d12e6b53e8dac6733e435 100644
--- a/src/mapleall/maple_driver/src/ld_compiler.cpp
+++ b/src/mapleall/maple_driver/src/ld_compiler.cpp
@@ -30,10 +30,9 @@ const std::string &LdCompiler::GetBinName() const {
   return kBinNameGcc;
 }
 
-DefaultOption LdCompiler::GetDefaultOptions(const MplOptions &options) const {
+DefaultOption LdCompiler::GetDefaultOptions(const MplOptions &options, const Action &action) const {
   DefaultOption defaultOptions = { nullptr, 0 };
   defaultOptions.mplOptions = kLdDefaultOptions;
-  defaultOptions.mplOptions[0].SetValue(options.GetOutputFolder() + options.GetOutputName());
   defaultOptions.length = sizeof(kLdDefaultOptions) / sizeof(MplOption);
 
   for (uint32_t i = 0; i < defaultOptions.length; ++i) {
@@ -45,11 +44,13 @@ DefaultOption LdCompiler::GetDefaultOptions(const MplOptions &options) const {
   return defaultOptions;
 }
 
-std::string LdCompiler::GetInputFileName(const MplOptions &options) const {
-  return options.GetOutputFolder() + options.GetOutputName() + ".o";
+std::string LdCompiler::GetInputFileName(const MplOptions &, const Action &action) const {
+    std::string files;
+    for (const auto &file : action.GetLinkFiles()) {
+      files += FileUtils::GetFileName(file, false) + ".o";
+      files += " ";
+    }
+    return files;
 }
 
-void LdCompiler::GetTmpFilesToDelete(const MplOptions &mplOptions, std::vector<std::string> &tempFiles) const {
-  tempFiles.push_back(mplOptions.GetOutputFolder() + mplOptions.GetOutputName() + ".o");
-}
 }  // namespace maple
diff --git a/src/mapleall/maple_driver/src/maple_comb_compiler.cpp b/src/mapleall/maple_driver/src/maple_comb_compiler.cpp
index 9d50a86a811a01b22cd83d8e14879a560e26f45f..5855868900ba46b06a6348747a5ebd20fdd74e7a 100644
--- a/src/mapleall/maple_driver/src/maple_comb_compiler.cpp
+++ b/src/mapleall/maple_driver/src/maple_comb_compiler.cpp
@@ -25,26 +25,27 @@
 namespace maple {
 using namespace mapleOption;
 
-std::string MapleCombCompiler::GetInputFileName(const MplOptions &options) const {
+std::string MapleCombCompiler::GetInputFileName(const MplOptions &options, const Action &action) const {
   if (!options.GetRunningExes().empty()) {
     if (options.GetRunningExes()[0] == kBinNameMe || options.GetRunningExes()[0] == kBinNameMpl2mpl) {
-      return options.GetInputFiles();
+      return action.GetInputFile();
     }
   }
-  if (options.GetInputFileType() == InputFileType::kFileTypeVtableImplMpl) {
-    return options.GetOutputFolder() + options.GetOutputName() + ".VtableImpl.mpl";
+  if (action.GetInputFileType() == InputFileType::kFileTypeVtableImplMpl) {
+    return action.GetFullOutputName() + ".VtableImpl.mpl";
   }
-  if (options.GetInputFileType() == InputFileType::kFileTypeBpl) {
-    return options.GetOutputFolder() + options.GetOutputName() + ".bpl";
+  if (action.GetInputFileType() == InputFileType::kFileTypeBpl) {
+    return action.GetFullOutputName() + ".bpl";
   }
-  return options.GetOutputFolder() + options.GetOutputName() + ".mpl";
+  return action.GetFullOutputName() + ".mpl";
 }
 
-void MapleCombCompiler::GetTmpFilesToDelete(const MplOptions &mplOptions, std::vector<std::string> &tempFiles) const {
+void MapleCombCompiler::GetTmpFilesToDelete(const MplOptions &, const Action &action,
+                                            std::vector<std::string> &tempFiles) const {
   std::string filePath;
-  filePath = mplOptions.GetOutputFolder() + mplOptions.GetOutputName() + ".data.muid";
+  filePath = action.GetFullOutputName() + ".data.muid";
   tempFiles.push_back(filePath);
-  filePath = mplOptions.GetOutputFolder() + mplOptions.GetOutputName() + ".func.muid";
+  filePath = action.GetFullOutputName() + ".func.muid";
   tempFiles.push_back(filePath);
   for (auto iter = tempFiles.begin(); iter != tempFiles.end();) {
     std::ifstream infile;
@@ -58,13 +59,14 @@ void MapleCombCompiler::GetTmpFilesToDelete(const MplOptions &mplOptions, std::v
   }
 }
 
-std::unordered_set<std::string> MapleCombCompiler::GetFinalOutputs(const MplOptions &mplOptions) const {
+std::unordered_set<std::string> MapleCombCompiler::GetFinalOutputs(const MplOptions &,
+                                                                   const Action &action) const {
   std::unordered_set<std::string> finalOutputs;
-  (void)finalOutputs.insert(mplOptions.GetOutputFolder() + mplOptions.GetOutputName() + ".VtableImpl.mpl");
+  (void)finalOutputs.insert(action.GetFullOutputName() + ".VtableImpl.mpl");
   return finalOutputs;
 }
 
-void MapleCombCompiler::PrintCommand(const MplOptions &options) const {
+void MapleCombCompiler::PrintCommand(const MplOptions &options, const Action &action) const {
   std::string runStr = "--run=";
   std::ostringstream optionStr;
   optionStr << "--option=\"";
@@ -94,7 +96,7 @@ void MapleCombCompiler::PrintCommand(const MplOptions &options) const {
   }
   optionStr << "\"";
   LogInfo::MapleLogger() << "Starting:" << options.GetExeFolder() << "maple " << runStr << " " << optionStr.str() << " "
-                         << GetInputFileName(options) << options.GetPrintCommandStr() << '\n';
+                         << GetInputFileName(options, action) << options.GetPrintCommandStr() << '\n';
 }
 
 ErrorCode MapleCombCompiler::MakeMeOptions(const MplOptions &options, DriverRunner &runner) {
@@ -158,8 +160,9 @@ std::string MapleCombCompiler::DecideOutExe(const MplOptions &options) {
   return selectExes[selectExes.size() - 1];
 }
 
-ErrorCode MapleCombCompiler::Compile(MplOptions &options, std::unique_ptr<MIRModule> &theModule) {
-  std::string fileName = GetInputFileName(options);
+ErrorCode MapleCombCompiler::Compile(MplOptions &options, const Action &action,
+                                     std::unique_ptr<MIRModule> &theModule) {
+  std::string fileName = GetInputFileName(options, action);
   bool fileParsed = true;
   if (theModule == nullptr) {
     theModule = std::make_unique<MIRModule>(fileName);
@@ -168,7 +171,7 @@ ErrorCode MapleCombCompiler::Compile(MplOptions &options, std::unique_ptr<MIRMod
   options.PrintCommand();
   LogInfo::MapleLogger() << "Starting maplecomb\n";
   theModule->InitPartO2List(options.GetPartO2List());
-  DriverRunner runner(theModule.get(), options.GetSelectedExes(), options.GetInputFileType(), fileName,
+  DriverRunner runner(theModule.get(), options.GetSelectedExes(), action.GetInputFileType(), fileName,
                       fileName, fileName, options.WithDwarf(), fileParsed,
                       options.HasSetTimePhases(), options.HasSetGenVtableImpl(), options.HasSetGenMeMpl());
   // Parse the input file
@@ -192,7 +195,7 @@ ErrorCode MapleCombCompiler::Compile(MplOptions &options, std::unique_ptr<MIRMod
   }
   runner.SetPrintOutExe(DecideOutExe(options));
   if (options.HasSetDebugFlag()) {
-    PrintCommand(options);
+    PrintCommand(options, action);
   }
   ErrorCode nErr = runner.Run();
   return nErr;
diff --git a/src/mapleall/maple_driver/src/maple_comb_compiler_wrapper.cpp b/src/mapleall/maple_driver/src/maple_comb_compiler_wrapper.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..acae689bd5dabb9cdba5d26f4ce80b48a391cc34
--- /dev/null
+++ b/src/mapleall/maple_driver/src/maple_comb_compiler_wrapper.cpp
@@ -0,0 +1,121 @@
+/*
+ * Copyright (c) [2019-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * 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 v2 for more details.
+ */
+#include "compiler.h"
+#include <vector>
+
+namespace maple {
+using namespace mapleOption;
+
+// TODO: FixMe
+static const std::string tmpBin = "maple";
+
+const std::string &MapleCombCompilerWrp::GetBinName() const {
+  return tmpBin;
+}
+
+std::string MapleCombCompilerWrp::GetBinPath(const MplOptions &) const {
+  return FileUtils::SafeGetenv(kMapleRoot) + "/output/aarch64-clang-debug/bin/";
+}
+
+DefaultOption MapleCombCompilerWrp::GetDefaultOptions(const MplOptions &mplOptions,
+                                                      const Action &) const {
+  DefaultOption defaultOptions = { nullptr, 0 };
+
+  auto options = mplOptions.GetOptions();
+  std::vector<Option *> tmpOptions;
+
+  int optForWrapperCnt = 0;
+  for (Option &opt : options) {
+    auto desc = opt.GetDescriptor();
+    if (desc.exeName == "all" ||
+        desc.exeName == "mpl2mpl" ||
+        desc.exeName == "mplcg" ||
+        desc.exeName == "me") {
+      ++optForWrapperCnt;
+      tmpOptions.push_back(&opt);
+    }
+  }
+
+  defaultOptions.mplOptions = new MplOption[optForWrapperCnt];
+  defaultOptions.length = optForWrapperCnt;
+
+  for (int i = 0; i < optForWrapperCnt; ++i) {
+
+    /* TODO: Does not check -c in this place, after finish of -c flag logic implementation.
+     * Currently -c flag is used to generate ELF file. But it must be used to generate only objects .o files.
+     * We do not forward this -c flag into MapleCombCompilerWrp to Run only me,mpl2mpl,mplcg phases */
+    if (tmpOptions[i]->OptionKey() == "c") {
+      defaultOptions.length--;
+      optForWrapperCnt--;
+      continue;
+    }
+
+    std::string strOpt;
+    if (tmpOptions[i]->GetPrefixType() == shortOptPrefix) {
+      strOpt = "-";
+    } else if (tmpOptions[i]->GetPrefixType() == longOptPrefix) {
+      strOpt = "--";
+    }
+
+    if (!tmpOptions[i]->OptionKey().empty()) {
+      strOpt += tmpOptions[i]->OptionKey();
+    }
+
+    if (!tmpOptions[i]->Args().empty()) {
+      if (tmpOptions[i]->CheckEqualPrefix() == true) {
+        strOpt += "=";
+      } else {
+        strOpt += " ";
+      }
+      strOpt += tmpOptions[i]->Args();
+    }
+
+    defaultOptions.mplOptions[i].SetKey(strOpt);
+  }
+
+  return defaultOptions;
+}
+
+std::string MapleCombCompilerWrp::GetInputFileName(const MplOptions &options, const Action &action) const {
+  if (!options.GetRunningExes().empty()) {
+    if (options.GetRunningExes()[0] == kBinNameMe || options.GetRunningExes()[0] == kBinNameMpl2mpl) {
+      return action.GetInputFile();
+    }
+  }
+
+  InputFileType fileType = action.GetInputFileType();
+  auto fullOutput = action.GetFullOutputName();
+  if (fileType == InputFileType::kFileTypeVtableImplMpl) {
+    return fullOutput + ".VtableImpl.mpl";
+  }
+  if (fileType == InputFileType::kFileTypeBpl) {
+    return fullOutput + ".bpl";
+  }
+  return fullOutput + ".mpl";
+}
+
+void MapleCombCompilerWrp::GetTmpFilesToDelete(const MplOptions &, const Action &action,
+                                               std::vector<std::string> &tempFiles) const {
+  tempFiles.push_back(action.GetFullOutputName() + ".s");
+}
+
+std::unordered_set<std::string> MapleCombCompilerWrp::GetFinalOutputs(const MplOptions &,
+                                                                      const Action &action) const {
+  std::unordered_set<std::string> finalOutputs;
+  (void)finalOutputs.insert(action.GetFullOutputName() + ".s");
+  return finalOutputs;
+}
+
+}  // namespace maple
diff --git a/src/mapleall/maple_driver/src/mpl_options.cpp b/src/mapleall/maple_driver/src/mpl_options.cpp
index 9c96d2966726bcf67a4243e7d029e0b9d0d9fdcc..ee92e3027a2bed1d0aec03b4966892ac88172818 100644
--- a/src/mapleall/maple_driver/src/mpl_options.cpp
+++ b/src/mapleall/maple_driver/src/mpl_options.cpp
@@ -13,6 +13,7 @@
  * See the Mulan PSL v2 for more details.
  */
 #include "mpl_options.h"
+#include <memory>
 #include <string>
 #include <vector>
 #include <algorithm>
@@ -103,6 +104,18 @@ int MplOptions::Parse(int argc, char **argv) {
     }
   }
 
+  /* kCustomRun run mode is set if --run=tool1:tool2 option is used.
+   * This Option is parsed on DecideRunType step. DecideRunType fills runningExes vector.
+   * DecideRunningPhases(runningExes) creates ActionsTree in kCustomRun mode.
+   * Maybe we can create Actions tree in DecideRunType in order to not use runningExes?
+   */
+  else { // kCustomRun
+    ret = DecideRunningPhases(runningExes);
+    if (ret != kErrorNoError) {
+      return ret;
+    }
+  }
+
   // Handle other options
   ret = HandleGeneralOptions();
   if (ret != kErrorNoError) {
@@ -110,6 +123,12 @@ int MplOptions::Parse(int argc, char **argv) {
   }
   // Check whether the file was readable
   ret = CheckFileExits();
+
+  if (isDriverPhasesDumpCmd) {
+    DumpActionTree();
+    return kErrorExitHelp;
+  }
+
   return ret;
 }
 
@@ -209,6 +228,9 @@ ErrorCode MplOptions::HandleGeneralOptions() {
       case kAllDebug:
         debugFlag = true;
         break;
+      case kMaplePrintPhases:
+        isDriverPhasesDumpCmd = true;
+        break;
       case kWithDwarf:
         withDwarf = true;
         break;
@@ -293,8 +315,12 @@ ErrorCode MplOptions::DecideRunType() {
   return ret;
 }
 
-ErrorCode MplOptions::DecideRunningPhases() {
-  ErrorCode ret = kErrorNoError;
+std::shared_ptr<Action> MplOptions::DecideRunningPhasesByType(const std::string &inputFile,
+                                                              bool isMultipleFiles) {
+  auto inputInfo = std::make_shared<InputInfo>(inputFile);
+  InputFileType inputFileType = inputInfo->GetInputFileType();
+  std::shared_ptr<Action> currentAction = std::make_shared<Action>("Input", inputInfo);
+
   bool isNeedMapleComb = true;
   bool isNeedMplcg = true;
   bool isNeedAs = true;
@@ -302,19 +328,21 @@ ErrorCode MplOptions::DecideRunningPhases() {
     case InputFileType::kFileTypeC:
     case InputFileType::kFileTypeCpp:
       UpdateRunningExe(kBinNameClang);
-      UpdateRunningExe(kBinNameCpp2mpl);
-      break;
+      currentAction = std::make_shared<Action>(kBinNameClang, inputInfo, currentAction);
     case InputFileType::kFileTypeAst:
       UpdateRunningExe(kBinNameCpp2mpl);
+      currentAction = std::make_shared<Action>(kBinNameCpp2mpl, inputInfo, currentAction);
       break;
     case InputFileType::kFileTypeJar:
       // fall-through
     case InputFileType::kFileTypeClass:
       UpdateRunningExe(kBinNameJbc2mpl);
+      currentAction = std::make_shared<Action>(kBinNameJbc2mpl, inputInfo, currentAction);
       isNeedAs = false;
       break;
     case InputFileType::kFileTypeDex:
       UpdateRunningExe(kBinNameDex2mpl);
+      currentAction = std::make_shared<Action>(kBinNameDex2mpl, inputInfo, currentAction);
       isNeedAs = false;
       break;
     case InputFileType::kFileTypeMpl:
@@ -325,6 +353,7 @@ ErrorCode MplOptions::DecideRunningPhases() {
       break;
     case InputFileType::kFileTypeS:
       isNeedMplcg = false;
+      isNeedMapleComb = false;
       break;
     case InputFileType::kFileTypeNone:
       break;
@@ -332,22 +361,165 @@ ErrorCode MplOptions::DecideRunningPhases() {
       break;
   }
   if (isNeedMapleComb) {
-    selectedExes.push_back(kBinNameMapleComb);
+    if (isMultipleFiles) {
+      selectedExes.push_back(kBinNameMapleCombWrp);
+      currentAction = std::make_shared<Action>(kBinNameMapleCombWrp, inputInfo, currentAction);
+    } else {
+      selectedExes.push_back(kBinNameMapleComb);
+      currentAction = std::make_shared<Action>(kBinNameMapleComb, inputInfo, currentAction);
+    }
   }
-  if (isNeedMplcg) {
+  if (isNeedMplcg && !isMultipleFiles) {
     selectedExes.push_back(kBinNameMplcg);
     runningExes.push_back(kBinNameMplcg);
+    currentAction = std::make_shared<Action>(kBinNameMplcg, inputInfo, currentAction);
   }
 
-  // This condition is used for testing purposes: -c option will five you full compilation
+  // This condition is used for testing purposes: -c option will generate ELF file
   if (HasSetGenObj()) {
     // Required to use flags, since user will need them for specific scenarios
     UpdateRunningExe(kAsFlag);
+    currentAction = std::make_shared<Action>(kAsFlag, inputInfo, currentAction);
+
     UpdateRunningExe(kLdFlag);
+    /* "Linking step" Action can have several inputActions.
+     * Each inputAction links to previous Actions to create the action tree.
+     * For linking step, inputActions are all assembly actions.
+     * Linking step Action is created outside this function because
+     * we must create all assembly actions (for all input files) before.
+     */
+  }
+
+  return currentAction;
+}
+
+ErrorCode MplOptions::DecideRunningPhases() {
+  ErrorCode ret = kErrorNoError;
+  std::vector<std::shared_ptr<Action>> linkActions;
+  std::shared_ptr<Action> lastAction;
+
+  bool isMultipleFiles = (splitsInputFiles.size() > 1);
+
+  for (auto &inputFile : splitsInputFiles) {
+    lastAction = DecideRunningPhasesByType(inputFile, isMultipleFiles);
+    CHECK_FATAL(lastAction != nullptr, "Action must be created!!");
+
+    /* TODO: Uncomment "&& !HasSetGenObj()" condition after finish of -c flag logic implementation.
+     * Currently -c flag is used to generate ELF file. But it must be used to generate only objects .o files. */
+    if (lastAction->GetTool() == kAsFlag /*&& !HasSetGenObj()*/) {
+      /* For linking step, inputActions are all assembly actions. */
+      linkActions.push_back(lastAction);
+    } else {
+      rootActions.push_back(lastAction);
+    }
+  }
+
+  if (!linkActions.empty()) {
+    auto currentAction = std::make_shared<Action>(kLdFlag, linkActions);
+    rootActions.push_back(currentAction);
+  }
+
+  return ret;
+}
+
+ErrorCode MplOptions::MFCreateActionByExe(const std::string &exe, std::shared_ptr<Action> &currentAction,
+                                       std::shared_ptr<InputInfo> inputInfo, bool &wasWrpCombCompilerCreated) {
+  ErrorCode ret = kErrorNoError;
+
+  if (exe == kBinNameMe || exe == kBinNameMpl2mpl || exe == kBinNameMplcg) {
+    if (wasWrpCombCompilerCreated == false) {
+      currentAction = std::make_shared<Action>(kBinNameMapleCombWrp, inputInfo, currentAction);
+      wasWrpCombCompilerCreated = true;
+    } else {
+      return ret;
+    }
+  }
+
+  else {
+    currentAction = std::make_shared<Action>(exe, inputInfo, currentAction);
+  }
+
+  return ret;
+}
+
+ErrorCode MplOptions::SFCreateActionByExe(const std::string &exe, std::shared_ptr<Action> &currentAction,
+                                          std::shared_ptr<InputInfo> inputInfo, bool &isCombCompiler) {
+  ErrorCode ret = kErrorNoError;
+
+  if (exe == kBinNameMe || exe == kBinNameMpl2mpl) {
+    if (isCombCompiler == false) {
+      currentAction = std::make_shared<Action>(kBinNameMapleComb, inputInfo, currentAction);
+      isCombCompiler = true;
+    } else {
+      return ret;
+    }
+  }
+
+  else {
+    currentAction = std::make_shared<Action>(exe, inputInfo, currentAction);
+  }
+
+  return ret;
+}
+
+ErrorCode MplOptions::DecideRunningPhases(const std::vector<std::string> &runExes) {
+  ErrorCode ret = kErrorNoError;
+
+  bool isMultipleFiles = (splitsInputFiles.size() > 1);
+
+  for (auto &inputFile : splitsInputFiles) {
+    bool isCombCompiler = false;
+    bool wasWrpCombCompilerCreated = false;
+
+    auto inputInfo = std::make_shared<InputInfo>(inputFile);
+    std::shared_ptr<Action> currentAction = std::make_shared<Action>("Input", inputInfo);
+
+    for (const auto &exe : runExes) {
+      if (isMultipleFiles == true) {
+        ret = MFCreateActionByExe(exe, currentAction, inputInfo, wasWrpCombCompilerCreated);
+        if (ret != kErrorNoError) {
+          return ret;
+        }
+      } else {
+        ret = SFCreateActionByExe(exe, currentAction, inputInfo, isCombCompiler);
+        if (ret != kErrorNoError) {
+          return ret;
+        }
+      }
+    }
+
+    rootActions.push_back(currentAction);
   }
+
   return ret;
 }
 
+void MplOptions::DumpActionTree() const {
+  for (auto &rNode : rootActions) {
+    DumpActionTree(*rNode, 0);
+  }
+}
+
+void MplOptions::DumpActionTree(const Action &action, int indents) const {
+  for (const std::shared_ptr<Action> &a : action.GetInputActions()) {
+    DumpActionTree(*a, indents+1);
+  }
+
+  if (indents != 0) {
+    LogInfo::MapleLogger() << "|";
+    /* print indents */
+    for (int i = 0; i < indents; ++i) {
+      LogInfo::MapleLogger() << "-";
+    }
+  }
+
+  if (action.GetTool() == "Input") {
+    LogInfo::MapleLogger() << action.GetTool() << " " << action.GetInputFile() << '\n';
+  } else {
+    LogInfo::MapleLogger() << action.GetTool() << '\n';
+  }
+}
+
 ErrorCode MplOptions::CheckInputFileValidity() {
   // Get input fileName
   if (optionParser->GetNonOptionsCount() <= 0) {
diff --git a/src/mapleall/maple_driver/src/mplcg_compiler.cpp b/src/mapleall/maple_driver/src/mplcg_compiler.cpp
index 1f73b3c0122c2d07c4671a9f46ed3e3417a9823b..80c67fd1b4b575598ed6444241af6e3db2afa785 100644
--- a/src/mapleall/maple_driver/src/mplcg_compiler.cpp
+++ b/src/mapleall/maple_driver/src/mplcg_compiler.cpp
@@ -23,7 +23,7 @@ namespace maple {
 using namespace maplebe;
 using namespace mapleOption;
 
-DefaultOption MplcgCompiler::GetDefaultOptions(const MplOptions &options) const {
+DefaultOption MplcgCompiler::GetDefaultOptions(const MplOptions &options, const Action &) const {
   DefaultOption defaultOptions = { nullptr, 0 };
   if (options.GetOptimizationLevel() == kO0 && options.HasSetDefaultLevel()) {
     defaultOptions.mplOptions = kMplcgDefaultOptionsO0;
@@ -45,34 +45,36 @@ const std::string &MplcgCompiler::GetBinName() const {
   return kBinNameMplcg;
 }
 
-std::string MplcgCompiler::GetInputFile(const MplOptions &options, const MIRModule *md) const {
+std::string MplcgCompiler::GetInputFile(const MplOptions &options, const Action &action,
+                                        const MIRModule *md) const {
   if (!options.GetRunningExes().empty()) {
     if (options.GetRunningExes()[0] == kBinNameMplcg) {
-      return options.GetInputFiles();
+      return action.GetInputFile();
     }
   }
   // Get base file name
-  auto idx = options.GetOutputName().find(".VtableImpl");
-  std::string outputName = options.GetOutputName();
+  auto idx = action.GetOutputName().find(".VtableImpl");
+  std::string outputName = action.GetOutputName();
   if (idx != std::string::npos) {
-    outputName = options.GetOutputName().substr(0, idx);
+    outputName = action.GetOutputName().substr(0, idx);
   }
   if (md->GetSrcLang() == kSrcLangC) {
-    return options.GetOutputFolder() + outputName + ".me.mpl";
+    return action.GetOutputFolder() + outputName + ".me.mpl";
   }
-  return options.GetOutputFolder() + outputName + ".VtableImpl.mpl";
+  return action.GetOutputFolder() + outputName + ".VtableImpl.mpl";
 }
 
-void MplcgCompiler::SetOutputFileName(const MplOptions &options, const MIRModule &md) {
+void MplcgCompiler::SetOutputFileName(const MplOptions &options, const Action &action, const MIRModule &md) {
   if (md.GetSrcLang() == kSrcLangC) {
-    baseName = options.GetOutputFolder() + options.GetOutputName();
+    baseName = action.GetFullOutputName();
   } else {
-    baseName = options.GetOutputFolder() + FileUtils::GetFileName(GetInputFile(options, &md), false);
+    baseName = action.GetOutputFolder() + FileUtils::GetFileName(GetInputFile(options, action, &md), false);
   }
   outputFile = baseName + ".s";
 }
 
-void MplcgCompiler::PrintMplcgCommand(const MplOptions &options, const MIRModule &md) const {
+void MplcgCompiler::PrintMplcgCommand(const MplOptions &options, const Action &action,
+                                      const MIRModule &md) const {
   std::string runStr = "--run=";
   std::string optionStr = "--option=\"";
   std::string connectSym = "";
@@ -89,7 +91,7 @@ void MplcgCompiler::PrintMplcgCommand(const MplOptions &options, const MIRModule
   }
   optionStr += "\"";
   LogInfo::MapleLogger() << "Starting:" << options.GetExeFolder() << "maple " << runStr << " " << optionStr
-                         << " --infile " << GetInputFile(options, &md) << '\n';
+                         << " --infile " << GetInputFile(options, action, &md) << '\n';
 }
 
 ErrorCode MplcgCompiler::MakeCGOptions(const MplOptions &options) {
@@ -121,11 +123,12 @@ ErrorCode MplcgCompiler::MakeCGOptions(const MplOptions &options) {
   return kErrorNoError;
 }
 
-ErrorCode MplcgCompiler::GetMplcgOptions(MplOptions &options, const MIRModule *theModule) {
+ErrorCode MplcgCompiler::GetMplcgOptions(MplOptions &options, const Action &action,
+                                         const MIRModule *theModule) {
   ErrorCode ret;
   if (options.GetRunMode() == kAutoRun) {
     if (theModule == nullptr) {
-      std::string fileName = GetInputFile(options, theModule);
+      std::string fileName = GetInputFile(options, action, theModule);
       MIRModule module(fileName);
       std::unique_ptr<MIRParser> theParser;
       theParser.reset(new MIRParser(module));
@@ -150,13 +153,14 @@ ErrorCode MplcgCompiler::GetMplcgOptions(MplOptions &options, const MIRModule *t
   return ret;
 }
 
-ErrorCode MplcgCompiler::Compile(MplOptions &options, std::unique_ptr<MIRModule> &theModule) {
-  ErrorCode ret = GetMplcgOptions(options, theModule.get());
+ErrorCode MplcgCompiler::Compile(MplOptions &options, const Action &action,
+                                 std::unique_ptr<MIRModule> &theModule) {
+  ErrorCode ret = GetMplcgOptions(options, action, theModule.get());
   if (ret != kErrorNoError) {
     return kErrorCompileFail;
   }
   CGOptions &cgOption = CGOptions::GetInstance();
-  std::string fileName = GetInputFile(options, theModule.get());
+  std::string fileName = GetInputFile(options, action, theModule.get());
   bool fileRead = true;
   if (theModule == nullptr) {
     MPLTimer timer;
@@ -192,13 +196,13 @@ ErrorCode MplcgCompiler::Compile(MplOptions &options, std::unique_ptr<MIRModule>
     timer.Stop();
     LogInfo::MapleLogger() << "Mplcg Parser consumed " << timer.ElapsedMilliseconds() << "ms\n";
   }
-  SetOutputFileName(options, *theModule);
+  SetOutputFileName(options, action, *theModule);
   theModule->SetInputFileName(fileName);
   LogInfo::MapleLogger() << "Starting mplcg\n";
-  DriverRunner runner(theModule.get(), options.GetSelectedExes(), options.GetInputFileType(), fileName,
+  DriverRunner runner(theModule.get(), options.GetSelectedExes(), action.GetInputFileType(), fileName,
                       options.WithDwarf(), fileRead, options.HasSetTimePhases());
   if (options.HasSetDebugFlag()) {
-    PrintMplcgCommand(options, *theModule);
+    PrintMplcgCommand(options, action, *theModule);
   }
   runner.SetPrintOutExe(kBinNameMplcg);
   runner.SetCGInfo(&cgOption, fileName);
diff --git a/src/mapleall/maple_driver/src/option_parser.cpp b/src/mapleall/maple_driver/src/option_parser.cpp
index 1b7b1c77edced3bc49efa2570e16401d4bc96512..75b1e581d7055df6ad303cf2ce5fda747b8d380b 100644
--- a/src/mapleall/maple_driver/src/option_parser.cpp
+++ b/src/mapleall/maple_driver/src/option_parser.cpp
@@ -35,10 +35,10 @@ void OptionParser::InsertExtraUsage(const Descriptor &usage) {
                              usage.extras[index],
                              {} };
     if (usage.shortOption != "") {
-      InsertOption(usage.shortOption, tempUsage);
+      InsertOption(usage.shortOption, tempUsage, shortOptPrefix);
     }
     if (usage.longOption != "") {
-      InsertOption(usage.longOption, tempUsage);
+      InsertOption(usage.longOption, tempUsage, longOptPrefix);
     }
     rawUsages.push_back(tempUsage);
     ++index;
@@ -69,10 +69,10 @@ void OptionParser::CreateNoOption(const Descriptor &usage) {
                            usage.exeName,
                            usage.extras };
   if (usage.shortOption != "") {
-    InsertOption(shortOpt, tempUsage);
+    InsertOption(shortOpt, tempUsage, shortOptPrefix);
   }
   if (usage.longOption != "") {
-    InsertOption(longOpt, tempUsage);
+    InsertOption(longOpt, tempUsage, longOptPrefix);
   }
   // Insert usage for extra options
   InsertExtraUsage(tempUsage);
@@ -85,10 +85,10 @@ void OptionParser::RegisteUsages(const MapleDriverOptionBase &base) {
     }
     rawUsages.push_back(usage);
     if (usage.shortOption != "") {
-      InsertOption(usage.shortOption, usage);
+      InsertOption(usage.shortOption, usage, shortOptPrefix);
     }
     if (usage.longOption != "") {
-      InsertOption(usage.longOption, usage);
+      InsertOption(usage.longOption, usage, longOptPrefix);
     }
     // Insert usage for extra options
     InsertExtraUsage(usage);
@@ -103,10 +103,10 @@ void OptionParser::RegisteUsages(const Descriptor usage[]) {
   for (size_t i = 0; usage[i].help != ""; ++i) {
     rawUsages.push_back(usage[i]);
     if (usage[i].shortOption != "") {
-      InsertOption(usage[i].shortOption, usage[i]);
+      InsertOption(usage[i].shortOption, usage[i], shortOptPrefix);
     }
     if (usage[i].longOption != "") {
-      InsertOption(usage[i].longOption, usage[i]);
+      InsertOption(usage[i].longOption, usage[i], longOptPrefix);
     }
     // Insert usage for extra options
     InsertExtraUsage(usage[i]);
@@ -156,7 +156,7 @@ bool OptionParser::CheckSpecialOption(const std::string &option, std::string &ke
 
 bool OptionParser::HandleKeyValue(const std::string &key, const std::string &value,
                                   std::vector<mapleOption::Option> &inputOption, const std::string &exeName,
-                                  bool isAllOption) {
+                                  bool isAllOption, bool isEqualPrefix) {
   if (key.empty()) {
     if (!isAllOption) {
       LogInfo::MapleLogger(kLlErr) << "Cannot recognize " << value << '\n';
@@ -167,7 +167,7 @@ bool OptionParser::HandleKeyValue(const std::string &key, const std::string &val
   }
   size_t count = usages.count(key);
   auto item = usages.find(key);
-  while (count > 0 && item->second.exeName != exeName) {
+  while (count > 0 && item->second.desc.exeName != exeName) {
     ++item;
     --count;
   }
@@ -175,7 +175,7 @@ bool OptionParser::HandleKeyValue(const std::string &key, const std::string &val
     LogInfo::MapleLogger(kLlErr) << ("Unknown Option: " + key) << '\n';
     return false;
   }
-  switch (item->second.checkPolicy) {
+  switch (item->second.desc.checkPolicy) {
     case kArgCheckPolicyUnknown:
       LogInfo::MapleLogger(kLlErr) << ("Unknown option " + key) << '\n';
       return false;
@@ -204,7 +204,8 @@ bool OptionParser::HandleKeyValue(const std::string &key, const std::string &val
     default:
       break;
   }
-  inputOption.push_back(Option(item->second, key, value));
+  inputOption.push_back(Option(item->second.desc, key, value,
+                               item->second.type, isEqualPrefix));
   return true;
 }
 
@@ -227,12 +228,12 @@ bool OptionParser::SetOption(const std::string &rawKey, const std::string &value
   int count = usages.count(key);
   auto item = usages.find(key);
   while (count > 0) {
-    if (item->second.exeName != exeName) {
+    if (item->second.desc.exeName != exeName) {
       ++item;
       --count;
       continue;
     }
-    switch (item->second.checkPolicy) {
+    switch (item->second.desc.checkPolicy) {
       case kArgCheckPolicyNone:
       case kArgCheckPolicyOptional:
         break;
@@ -247,7 +248,7 @@ bool OptionParser::SetOption(const std::string &rawKey, const std::string &value
     }
     break;
   }
-  exeOption.push_back(Option(item->second, key, value));
+  exeOption.push_back(Option(item->second.desc, key, value));
   return true;
 }
 
@@ -272,11 +273,13 @@ bool OptionParser::CheckOpt(const std::string option, std::string &lastKey,
     std::string key = option.substr(0, pos);
     std::string value = option.substr(pos + 1);
     isValueEmpty = value.empty();
-    return HandleKeyValue(key, value, inputOption, exeName);
+    return HandleKeyValue(key, value, inputOption, exeName,
+                          false /*isAllOption*/,
+                          true /*isEqualPrefix*/);
   } else {
     auto item = usages.find(option);
     if (item != usages.end()) {
-      if (item->second.checkPolicy == kArgCheckPolicyRequired || item->second.checkPolicy == kArgCheckPolicyNumeric) {
+      if (item->second.desc.checkPolicy == kArgCheckPolicyRequired || item->second.desc.checkPolicy == kArgCheckPolicyNumeric) {
         lastKey = option;
         isLastMatch = true;
       } else {
diff --git a/src/mapleall/maple_ir/include/debug_info.h b/src/mapleall/maple_ir/include/debug_info.h
index 9f5a1a175fcd6143d02e59f9a4faa35265fc1c50..03b6b2924d6a2f5a4de8d6029e988d7b9e772e2a 100644
--- a/src/mapleall/maple_ir/include/debug_info.h
+++ b/src/mapleall/maple_ir/include/debug_info.h
@@ -49,6 +49,7 @@ class MIRLexer;
 class DBGLine {
  public:
   DBGLine(uint32 lnum, const char *l) : lineNum(lnum), codeLine(l) {}
+  virtual ~DBGLine() {}
 
   void Dump() {
     LogInfo::MapleLogger() << "LINE: " << lineNum << " " << codeLine << std::endl;
diff --git a/src/mapleall/maple_ir/include/global_tables.h b/src/mapleall/maple_ir/include/global_tables.h
index 42c76c2a373e46da94a6a428f5e17657115f0401..bc0e721953c4952f9cb6e113daf7e45f0274b980 100644
--- a/src/mapleall/maple_ir/include/global_tables.h
+++ b/src/mapleall/maple_ir/include/global_tables.h
@@ -65,6 +65,7 @@ class IntConstKey {
   friend class IntConstCmp;
  public:
   IntConstKey(int64 v, TyIdx tyIdx) : val(v), tyIdx(tyIdx) {}
+  virtual ~IntConstKey() {}
  private:
   int64 val;
   TyIdx tyIdx;
diff --git a/src/mapleall/maple_ir/include/mir_function.h b/src/mapleall/maple_ir/include/mir_function.h
index e1932cf75710361c75afcaccc0111c142a4041b0..02c5e3d875b8507c38bbe73b57a409396323252b 100644
--- a/src/mapleall/maple_ir/include/mir_function.h
+++ b/src/mapleall/maple_ir/include/mir_function.h
@@ -60,6 +60,7 @@ class FormalDef {
   TypeAttrs formalAttrs = TypeAttrs();  // the formal's type attributes
 
   FormalDef() {};
+  virtual ~FormalDef() {}
   FormalDef(MIRSymbol *s, const TyIdx &tidx, const TypeAttrs &at) : formalSym(s), formalTyIdx(tidx), formalAttrs(at) {}
   FormalDef(const GStrIdx &sidx, MIRSymbol *s, const TyIdx &tidx, const TypeAttrs &at)
       : formalStrIdx(sidx), formalSym(s), formalTyIdx(tidx), formalAttrs(at) {}
diff --git a/src/mapleall/maple_ir/include/mir_nodes.h b/src/mapleall/maple_ir/include/mir_nodes.h
index 5c5dd138e35612bf47d150f2d8fefea277eec029..e347b3dd2e930546b5d6e334eef4b23d4d540a74 100644
--- a/src/mapleall/maple_ir/include/mir_nodes.h
+++ b/src/mapleall/maple_ir/include/mir_nodes.h
@@ -577,6 +577,7 @@ class IreadPCoffNode : public IreadFPoffNode {
     ptyp = typ;
     numOpnds = numopns;
   }
+  virtual ~IreadPCoffNode() {}
 };
 
 typedef IreadPCoffNode AddroffPCNode;
@@ -2873,6 +2874,7 @@ class CallAssertNonnullStmtNode : public UnaryStmtNode, public SafetyCallCheckSt
  public:
   CallAssertNonnullStmtNode(Opcode o, std::string &funcName, size_t paramIndex)
       : UnaryStmtNode(o), SafetyCallCheckStmtNode(funcName, paramIndex) {}
+  virtual ~CallAssertNonnullStmtNode() {}
 
   void Dump(int32 indent) const override;
 
@@ -2889,6 +2891,7 @@ class CallAssertBoundaryStmtNode : public NaryStmtNode, public SafetyCallCheckSt
  public:
   CallAssertBoundaryStmtNode(MapleAllocator &allocator, Opcode o, std::string &funcName, size_t paramIndex)
       : NaryStmtNode(allocator, o), SafetyCallCheckStmtNode(funcName, paramIndex) {}
+  virtual ~CallAssertBoundaryStmtNode() {}
 
   CallAssertBoundaryStmtNode(MapleAllocator &allocator, const CallAssertBoundaryStmtNode& stmtNode)
       : NaryStmtNode(allocator, stmtNode),
diff --git a/src/mapleall/maple_me/src/simplifyCFG.cpp b/src/mapleall/maple_me/src/simplifyCFG.cpp
index 277825d8866798481a6f3a8575c8d0feb8ac2b6f..72f65112edf4c9ac653ef3bef0f6c384de977898 100644
--- a/src/mapleall/maple_me/src/simplifyCFG.cpp
+++ b/src/mapleall/maple_me/src/simplifyCFG.cpp
@@ -39,6 +39,56 @@ inline bool HasOnlyGotoStmt(BB &bb) {
   }
   return false;
 }
+
+inline bool IsEmptyBB(BB &bb) {
+  if (bb.IsMeStmtEmpty()) {
+    return true;
+  }
+  MeStmt *stmt = bb.GetFirstMe();
+  // Skip commont stmt
+  while (stmt != nullptr && stmt->GetOp() == OP_comment) {
+    stmt = stmt->GetNextMeStmt();
+  }
+  return stmt == nullptr;
+}
+
+// pred-connecting-succ
+// connectingBB has only one pred and succ, and has no stmt (except a single gotoStmt) in it
+bool IsConnectingBB(BB &bb) {
+  return (bb.GetPred().size() == 1 && bb.GetSucc().size() == 1) &&
+         (IsEmptyBB(bb) || HasOnlyGotoStmt(bb));
+}
+
+// RealSucc is a non-connecting BB which is not empty (or has just a single gotoStmt).
+// If we want to find the non-empty succ of currBB, we start from the succ (i.e. the argument)
+// skip those connecting bb used to connect its pred and succ, like: pred -- connecting -- succ
+BB *FindFirstRealSucc(BB *succ) {
+  while (succ != nullptr && IsConnectingBB(*succ)) {
+    succ = succ->GetSucc(0);
+  }
+  return succ;
+}
+
+// delete all empty bb used to connect its pred and succ, like: pred -- empty -- empty -- succ
+// the result after this will be : pred -- succ
+// if no empty exist, return;
+// we will stop at stopBB(stopBB will not be deleted), if stopBB is nullptr, means no constraint
+void EliminateEmptyConnectingBB(BB *predBB, BB *emptyBB, BB *stopBB, MeCFG &cfg) {
+  if (emptyBB == stopBB && emptyBB != nullptr && predBB->IsPredBB(*stopBB)) {
+    return;
+  }
+  // we can only eliminate those emptyBBs that have only one pred and succ
+  while (emptyBB != nullptr && emptyBB != stopBB && IsConnectingBB(*emptyBB)) {
+    BB *succ = emptyBB->GetSucc(0);
+    BB *pred = emptyBB->GetPred(0);
+    DEBUG_LOG() << "Delete empty connecting : BB" << LOG_BBID(pred) << "->BB" << LOG_BBID(emptyBB)
+                << "(deleted)->BB" << LOG_BBID(succ) << "\n";
+    succ->ReplacePred(emptyBB, pred);
+    emptyBB->RemoveAllPred();
+    cfg.DeleteBasicBlock(*emptyBB);
+    emptyBB = succ;
+  }
+}
 } // anonymous namespace
 
 static bool RemoveUnreachableBB(maple::MeFunction &f) {
@@ -123,8 +173,13 @@ class SimplifyCFG {
   void CombineCond2SelPattern(BB *condBB, BB *ftBB, BB *gtBB, BB *jointBB);
   // for SimplifyUncondBB
   bool MergeGotoBBToPred(BB *gotoBB, BB *pred);
+  // after moving pred from curr to curr's successor (i.e. succ), update the phiList of curr and succ
+  // a phiOpnd will be removed from curr's philist, and a phiOpnd will be inserted to succ's philist
+  // note: when replace pred's succ (i.e. curr) with succ, please DO NOT remove phiOpnd immediately,
+  // otherwise we cannot get phiOpnd in this step
+  void UpdatePhiForMovingPred(int predIdxForCurr, BB *pred, BB *curr, BB *succ);
   // for ChangeCondBr2UnCond
-  bool SimplifyCondBBToGotoBB(BB &bb);
+  bool SimplifyBranchBBToUncondBB(BB &bb);
 
   // Check before every simplification to avoid error induced by other optimization on currBB
   // please use macro CHECK_CURR_BB instead
@@ -218,23 +273,49 @@ bool SimplifyCFG::EliminateDeadBB() {
   return false;
 }
 
-bool SimplifyCFG::SimplifyCondBBToGotoBB(BB &bb) {
-  if (bb.GetKind() != kBBCondGoto) {
+// all branches of bb are the same if skipping all empty connecting BB
+// turn it into an unconditional BB (if destBB has other pred, bb->gotoBB, otherwise, bb->fallthruBB)
+//      bb                             bb
+//   /  |  \                            |
+//  A   B   C  (ABC are empty)  ==>     |
+//   \  |  /                            |
+//    destBB                          destBB
+bool SimplifyCFG::SimplifyBranchBBToUncondBB(BB &bb) {
+  if (bb.GetKind() != kBBCondGoto && bb.GetKind() != kBBSwitch) {
     return false;
   }
-  if (bb.GetSucc(0) == bb.GetSucc(1)) {
-    DEBUG_LOG() << "Conditional BB" << LOG_BBID(&bb) << " to unconditional BB\n";
-    LabelIdx label = f.GetOrCreateBBLabel(*bb.GetSucc(0));
-    auto *gotoStmt = irmap->New<GotoMeStmt>(label);
-    gotoStmt->SetSrcPos(bb.GetLastMe()->GetSrcPosition());
-    gotoStmt->SetBB(&bb);
+  // check if all successors of bb branch to the same destination (ignoring all empty bb between bb and destination)
+  BB *destBB = FindFirstRealSucc(bb.GetSucc(0));
+  for (size_t i = 1; i < bb.GetSucc().size(); ++i) {
+    if (FindFirstRealSucc(bb.GetSucc(i)) != destBB) {
+      return false;
+    }
+  }
+
+  DEBUG_LOG() << "SimplifyBranchBBToUncondBB : " << (bb.GetKind() == kBBCondGoto ? "Conditional " : "Switch ")
+              << "BB" << LOG_BBID(&bb) << " to unconditional BB\n";
+  // delete all empty bb between bb and destBB
+  // note : bb and destBB will be connected after empty BB is deleted
+  for (int i = bb.GetSucc().size() - 1; i >= 0; --i) {
+    EliminateEmptyConnectingBB(&bb, bb.GetSucc(i), destBB, *cfg);
+  }
+  while (bb.GetSucc().size() != 1) { // bb is an unconditional bb now, and its successor num should be 1
+    ASSERT(bb.GetSucc().back() == destBB, "[FUNC: %s]Goto BB%d has different destination", funcName, LOG_BBID(&bb));
+    bb.RemoveSucc(*bb.GetSucc().back());
+  }
+  if (destBB->GetPred().size() > 1) {
+    LabelIdx label = f.GetOrCreateBBLabel(*destBB);
+    auto *gotoStmt = irmap->CreateGotoMeStmt(label, &bb, &bb.GetLastMe()->GetSrcPosition());
     bb.RemoveLastMeStmt();
     bb.AddMeStmtLast(gotoStmt);
     bb.SetKind(kBBGoto);
-    return true;
+  } else {
+    bb.RemoveLastMeStmt();
+    bb.SetKind(kBBFallthru);
   }
-  return false;
+  return true;
 }
+
 // chang condition branch to unconditon branch if possible
 // 1.condition is a constant
 // 2.all branches of condition branch is the same BB
@@ -249,7 +330,7 @@ bool SimplifyCFG::ChangeCondBr2UnCond() {
   }
   // case 2
   if (currBB->GetSucc(0) == currBB->GetSucc(1)) {
-    if (SimplifyCondBBToGotoBB(*currBB)) {
+    if (SimplifyBranchBBToUncondBB(*currBB)) {
       SetBBRunAgain();
       return true;
     }
@@ -613,6 +694,89 @@ bool SimplifyCFG::SimplifyCondBB() {
   return false;
 }
 
+// after moving pred from curr to curr's successor (i.e. succ), update the phiList of curr and succ
+// a phiOpnd will be removed from curr's philist, and another phiOpnd will be inserted to succ's philist
+//
+//    ...  pred           ...     pred
+//      \  /  \            \       / \
+//      curr  ...   ==>   curr    /  ...
+//      /  \   ...         /  \  / ...
+//     /    \  /          /    \/ /
+//   ...    succ         ...  succ
+//
+// parameter predIdxForCurr is the index of pred in the predVector of curr
+// note:
+// 1.when replace pred's succ (i.e. curr) with succ, please DO NOT remove phiOpnd immediately,
+// otherwise we cannot get phiOpnd in this step
+// 2.predIdxForCurr should be get before disconnecting pred and curr
+void SimplifyCFG::UpdatePhiForMovingPred(int predIdxForCurr, BB *pred, BB *curr, BB *succ) {
+  auto &succPhiList = succ->GetMePhiList();
+  auto &currPhilist = curr->GetMePhiList();
+  if (succPhiList.empty()) {
+    // succ has only one pred(i.e. curr) before
+    // we copy curr's philist to succ, but not with all phiOpnd
+    for (auto &phiNode : currPhilist) {
+      auto *phiMeNode = irmap->NewInPool<MePhiNode>();
+      phiMeNode->SetDefBB(succ);
+      succPhiList.emplace(phiNode.first, phiMeNode);
+      auto &phiOpnds = phiMeNode->GetOpnds();
+      phiOpnds.resize(2); // succ has 2 pred now : curr and pred
+      int currPredIdx = succ->GetPredIndex(*curr);
+      int predPredIdx = succ->GetPredIndex(*pred);
+      // curr is already pred of succ, so we add its phiLHS as succ's phiOpnd
+      phiMeNode->SetOpnd(currPredIdx, phiNode.second->GetLHS());
+      // pred is a new pred for succ, we copy its corresponding phiopnd in curr to succ
+      phiMeNode->SetOpnd(predPredIdx, phiNode.second->GetOpnd(predIdxForCurr));
+      OStIdx ostIdx = phiNode.first;
+      // create a new version for new phi
+      phiMeNode->SetLHS(irmap->CreateRegOrVarMeExprVersion(ostIdx));
+    }
+    UpdateSSACandForBBPhiList(succ); // new philist has been created in succ
+  } else {
+    // succ has other pred besides curr
+    for (auto &phi : succPhiList) {
+      OStIdx ostIdx = phi.first;
+      auto it = currPhilist.find(ostIdx);
+      int predPredIdx = succ->GetPredIndex(*pred);
+      auto &phiOpnds = phi.second->GetOpnds();
+      if (it != currPhilist.end()) {
+        // curr has phiNode for this ost, we copy pred's corresponding phiOpnd in curr to succ
+        phiOpnds.insert(phiOpnds.begin() + predPredIdx, it->second->GetOpnd(predIdxForCurr));
+      } else {
+        // curr has no phiNode for this ost, pred's phiOpnd in succ will be the same as curr's phiOpnd in succ
+        int index = succ->GetPredIndex(*curr);
+        ASSERT(index != -1, "[FUNC: %s]succ is not newTarget's pred", f.GetName().c_str());
+        // pred's phi opnd is the same as curr.
+        phiOpnds.insert(phiOpnds.begin() + predPredIdx, phi.second->GetOpnd(index));
+      }
+    }
+    // search philist in curr for phinode that is not in succ yet
+    for (auto &phi : currPhilist) {
+      OStIdx ostIdx = phi.first;
+      auto resPair = succPhiList.emplace(ostIdx, nullptr);
+      if (!resPair.second) {
+        // phinode is in succ, last step has updated it
+        continue;
+      } else {
+        auto *phiMeNode = irmap->NewInPool<MePhiNode>();
+        phiMeNode->SetDefBB(succ);
+        resPair.first->second = phiMeNode; // replace nullptr inserted before
+        auto &phiOpnds = phiMeNode->GetOpnds();
+        // insert opnd into New phiNode : all phiOpnds (except for pred) are phiNode lhs in curr
+        phiOpnds.insert(phiOpnds.end(), succ->GetPred().size() - 1, phi.second->GetLHS());
+        // pred is new pred for succ, we copy its corresponding phiopnd in curr to succ
+        int predPredIdx = succ->GetPredIndex(*pred);
+        phiOpnds.insert(phiOpnds.begin() + predPredIdx, phi.second->GetOpnd(predIdxForCurr));
+        // create a new version for new phinode
+        phiMeNode->SetLHS(irmap->CreateRegOrVarMeExprVersion(ostIdx));
+        UpdateSSACandForOst(ostIdx, succ);
+      }
+    }
+  }
+  // remove pred's corresponding phiOpnd from curr's philist
+  curr->RemovePhiOpnd(predIdxForCurr);
+}
+
 // succ must have only one goto statement
 // pred must be three of below:
 // 1. fallthrough BB
@@ -641,20 +805,19 @@ bool SimplifyCFG::MergeGotoBBToPred(BB *succ, BB *pred) {
   if (newTarget->GetPred().size() == 1) {
     return false;
   }
-  int predIdx = succ->GetPredIndex(*pred);
   // pred is moved to newTarget
   if (pred->GetKind() == kBBFallthru) {
-    GotoMeStmt *gotoMeStmt = irmap->New<GotoMeStmt>(newTarget->GetBBLabel());
-    gotoMeStmt->SetSrcPos(succ->GetLastMe()->GetSrcPosition());
-    gotoMeStmt->SetBB(pred);
+    GotoMeStmt *gotoMeStmt = irmap->CreateGotoMeStmt(newTarget->GetBBLabel(), pred,
+                                                     &succ->GetLastMe()->GetSrcPosition());
     pred->AddMeStmtLast(gotoMeStmt);
     pred->SetKind(kBBGoto);
     DEBUG_LOG() << "Insert Uncond stmt to fallthru BB" << LOG_BBID(currBB) << ", and goto BB" << LOG_BBID(newTarget)
                 << "\n";
   }
+  int predIdx = succ->GetPredIndex(*pred);
   bool needUpdatePhi = false;
   if (pred->IsPredBB(*newTarget)) {
-    pred->RemoveSucc(*succ, false); // one of pred's succ has been newTarget, avoid duplicate succ here
+    pred->RemoveSucc(*succ, true); // one of pred's succ has been newTarget, avoid duplicate succ here
   } else {
     pred->ReplaceSucc(succ, newTarget); // phi opnd is not removed from currBB's philist, we will remove it later
     needUpdatePhi = true;
@@ -664,69 +827,9 @@ bool SimplifyCFG::MergeGotoBBToPred(BB *succ, BB *pred) {
               << ": BB" << LOG_BBID(pred) << "->BB" << LOG_BBID(succ) << "(merged)->BB" << LOG_BBID(newTarget) << "\n";
   cfg->UpdateBranchTarget(*pred, *succ, *newTarget, f);
   if (needUpdatePhi) {
-    // update phi
-    auto &newPhiList = newTarget->GetMePhiList();
-    auto &gotoPhilist = succ->GetMePhiList();
-    if (newPhiList.empty()) { // newTarget has only one pred(i.e. succ) before
-      // we copy succ's philist to newTarget, but not with all phiOpnd
-      for (auto &phiNode : gotoPhilist) {
-        auto *phiMeNode = irmap->NewInPool<MePhiNode>();
-        phiMeNode->SetDefBB(newTarget);
-        newPhiList.emplace(phiNode.first, phiMeNode);
-        phiMeNode->GetOpnds().push_back(phiNode.second->GetLHS()); // succ is the first pred of newTarget
-        // new pred to newTarget
-        phiMeNode->GetOpnds().push_back(phiNode.second->GetOpnd(predIdx));
-        OStIdx ostIdx = phiNode.first;
-        // create a new version for new phi
-        ScalarMeExpr *phiLHS = irmap->CreateRegOrVarMeExprVersion(ostIdx);
-        phiLHS->SetDefPhi(*phiMeNode);
-        phiLHS->SetDefBy(kDefByPhi);
-        phiMeNode->SetLHS(phiLHS);
-      }
-      UpdateSSACandForBBPhiList(newTarget);
-    } else { // newTarget has other pred besides succ
-      for (auto &phi : newPhiList) {
-        OStIdx ostIdx = phi.first;
-        auto it = gotoPhilist.find(ostIdx);
-        if (it != gotoPhilist.end()) {
-          // new pred to newTarget
-          phi.second->GetOpnds().push_back(it->second->GetOpnd(predIdx));
-        } else {
-          int index = newTarget->GetPredIndex(*succ);
-          ASSERT(index != -1, "[FUNC: %s]succ is not newTarget's pred", f.GetName().c_str());
-          // new pred's phi opnd is the same as succ.
-          phi.second->GetOpnds().push_back(phi.second->GetOpnd(index));
-        }
-      }
-      // search philist in curr for phinode that is not in succ yet
-      // note : the case will occur when succ dominates newTarget
-      for (auto &phi : gotoPhilist) {
-        OStIdx ostIdx = phi.first;
-        auto it = newPhiList.find(ostIdx);
-        if (it != newPhiList.end()) {
-          // phinode is in succ, last step has updated it
-          continue;
-        } else {
-          auto *phiMeNode = irmap->NewInPool<MePhiNode>();
-          phiMeNode->SetDefBB(newTarget);
-          newPhiList.emplace(ostIdx, phiMeNode);
-          auto &phiOpnds = phiMeNode->GetOpnds();
-          // insert opnd into New phiNode : all phiOpnds (except last one) are phiNode lhs in curr
-          phiOpnds.insert(phiOpnds.end(), newTarget->GetPred().size() - 1, phi.second->GetLHS());
-          // pred is new pred for succ, we copy its corresponding phiopnd in curr to succ
-          phiMeNode->GetOpnds().push_back(phi.second->GetOpnd(predIdx));
-          // create a new version for new phinode
-          ScalarMeExpr *phiLHS = irmap->CreateRegOrVarMeExprVersion(ostIdx);
-          phiLHS->SetDefPhi(*phiMeNode);
-          phiLHS->SetDefBy(kDefByPhi);
-          phiMeNode->SetLHS(phiLHS);
-          UpdateSSACandForOst(ostIdx, newTarget);
-        }
-      }
-    }
+    // remove phiOpnd in succ, and add phiOpnd to newTarget
+    UpdatePhiForMovingPred(predIdx, pred, succ, newTarget);
   }
-  // remove redundant phiOpnd of succ's philist
-  succ->RemovePhiOpnd(predIdx);
   // remove succ if succ has no pred
   if (succ->GetPred().empty()) {
     newTarget->RemovePred(*succ, true);
@@ -734,6 +837,8 @@ bool SimplifyCFG::MergeGotoBBToPred(BB *succ, BB *pred) {
     UpdateSSACandForBBPhiList(succ, newTarget);
     DeleteBB(succ);
   }
+  // if all branch destination of pred (condBB or switchBB) are the same, we should turn pred into uncond
+  (void) SimplifyBranchBBToUncondBB(*pred);
   return true;
 }
 
diff --git a/src/mapleall/mpl2mpl/src/constantfold.cpp b/src/mapleall/mpl2mpl/src/constantfold.cpp
index d9714b80d72da1f84ce5df8737cb9ac2257db193..71c810fe3f4adcc1f72a36069d04bd2abbda4f37 100644
--- a/src/mapleall/mpl2mpl/src/constantfold.cpp
+++ b/src/mapleall/mpl2mpl/src/constantfold.cpp
@@ -2030,28 +2030,26 @@ std::pair<BaseNode*, int64> ConstantFold::FoldTernary(TernaryNode *node) {
           foldedPrimType = primTypes[2];
         }
         if (dconst1 == 1.0 && dconst2 == 0.0) {
-          BaseNode *tmpNode = node->Opnd(0);
-          std::pair<BaseNode*, int64> pairTemp = DispatchFold(tmpNode);
           if (IsPrimitiveInteger(foldedPrimType)) {
-            result = PairToExpr(foldedPrimType, pairTemp);
+            result = PairToExpr(foldedPrimType, p[0]);
           } else {
-            result = PairToExpr(tmpNode->GetPrimType(), pairTemp);
+            result = PairToExpr(primTypes[0], p[0]);
             result = mirModule->CurFuncCodeMemPool()->New<TypeCvtNode>(
-                OP_cvt, foldedPrimType, tmpNode->GetPrimType(), result);
+                OP_cvt, foldedPrimType, primTypes[0], result);
           }
           return std::make_pair(result, 0);
         }
         if (dconst1 == 0.0 && dconst2 == 1.0) {
-          BaseNode *lnot = mirModule->CurFuncCodeMemPool()->New<UnaryNode>(
-              OP_lnot, node->Opnd(0)->GetPrimType(), node->Opnd(0));
-          BaseNode *tmpNode = lnot;
-          std::pair<BaseNode*, int64> pairTemp = DispatchFold(tmpNode);
+          BaseNode *lnot = mirModule->CurFuncCodeMemPool()->New<CompareNode>(
+              OP_eq, primTypes[0], primTypes[0], PairToExpr(primTypes[0], p[0]),
+              mirModule->GetMIRBuilder()->CreateIntConst(0, primTypes[0]));
+          std::pair<BaseNode*, int64> pairTemp = DispatchFold(lnot);
           if (IsPrimitiveInteger(foldedPrimType)) {
             result = PairToExpr(foldedPrimType, pairTemp);
           } else {
-            result = PairToExpr(tmpNode->GetPrimType(), pairTemp);
+            result = PairToExpr(primTypes[0], pairTemp);
             result = mirModule->CurFuncCodeMemPool()->New<TypeCvtNode>(
-                OP_cvt, foldedPrimType, tmpNode->GetPrimType(), result);
+                OP_cvt, foldedPrimType, primTypes[0], result);
           }
           return std::make_pair(result, 0);
         }
@@ -2174,7 +2172,7 @@ StmtNode *ConstantFold::SimplifyCondGoto(CondGotoNode *node) {
   BaseNode *returnValue = nullptr;
   returnValue = Fold(node->Opnd(0));
   returnValue = (returnValue == nullptr) ? node : returnValue;
-  if (node->Opnd(0)->GetOpCode() == OP_select) {
+  if (returnValue == node && node->Opnd(0)->GetOpCode() == OP_select) {
     return SimplifyCondGotoSelect(node);
   } else {
     if (returnValue != node) {