diff --git a/src/mapleall/maple_be/src/cg/aarch64/aarch64_cgfunc.cpp b/src/mapleall/maple_be/src/cg/aarch64/aarch64_cgfunc.cpp
index 63c33b5e583f0fdc54fb7ff98c83105470e37508..f88b63df39106d179650d18949599e709c54319a 100644
--- a/src/mapleall/maple_be/src/cg/aarch64/aarch64_cgfunc.cpp
+++ b/src/mapleall/maple_be/src/cg/aarch64/aarch64_cgfunc.cpp
@@ -28,6 +28,7 @@
 #include "metadata_layout.h"
 #include "emit.h"
 #include "simplify.h"
+#include <algorithm>
 
 namespace maplebe {
 using namespace maple;
@@ -8948,6 +8949,49 @@ bool AArch64CGFunc::IsDuplicateAsmList(const MIRSymbol &sym) const {
 }
 
 void AArch64CGFunc::SelectMPLProfCounterInc(const IntrinsiccallNode &intrnNode) {
+  if (Options::profileGen) {
+    ASSERT(intrnNode.NumOpnds() == 1, "must be 1 operand");
+    BaseNode *arg1 = intrnNode.Opnd(0);
+    ASSERT(arg1 != nullptr, "nullptr check");
+    regno_t vRegNO1 = NewVReg(GetRegTyFromPrimTy(PTY_a64), GetPrimTypeSize(PTY_a64));
+    RegOperand &vReg1 = CreateVirtualRegisterOperand(vRegNO1);
+    vReg1.SetRegNotBBLocal();
+    static const MIRSymbol *bbProfileTab = nullptr;
+
+    // Ref: MeProfGen::InstrumentFunc on ctrTbl naming
+    std::string ctrTblName = namemangler::kprefixProfCtrTbl +
+                             GetMirModule().GetFileName() + "_" + GetName();
+    std::replace(ctrTblName.begin(), ctrTblName.end(), '.', '_');
+    std::replace(ctrTblName.begin(), ctrTblName.end(), '-', '_');
+    std::replace(ctrTblName.begin(), ctrTblName.end(), '/', '_');
+
+    if (!bbProfileTab || bbProfileTab->GetName() != ctrTblName) {
+      bbProfileTab = GetMirModule().GetMIRBuilder()->GetGlobalDecl(ctrTblName);
+      CHECK_FATAL(bbProfileTab != nullptr, "expect counter table");
+    }
+
+    ConstvalNode *constvalNode = static_cast<ConstvalNode*>(arg1);
+    MIRConst *mirConst = constvalNode->GetConstVal();
+    ASSERT(mirConst != nullptr, "nullptr check");
+    CHECK_FATAL(mirConst->GetKind() == kConstInt, "expect MIRIntConst type");
+    MIRIntConst *mirIntConst = safe_cast<MIRIntConst>(mirConst);
+    int64 offset = GetPrimTypeSize(PTY_u64) * mirIntConst->GetValue();
+
+    if (!GetCG()->IsQuiet()) {
+      maple::LogInfo::MapleLogger(kLlInfo) << "At counter table offset: " << offset << std::endl;
+    }
+    MemOperand *memOpnd = &GetOrCreateMemOpnd(*bbProfileTab, offset, k64BitSize);
+    AArch64MemOperand &ctrMemOpnd = *static_cast<AArch64MemOperand*>(memOpnd);
+    if (IsImmediateOffsetOutOfRange(ctrMemOpnd, k64BitSize)) {
+      memOpnd = &SplitOffsetWithAddInstruction(ctrMemOpnd, k64BitSize);
+    }
+    Operand *reg = &SelectCopy(*memOpnd, PTY_u64, PTY_u64);
+    AArch64ImmOperand &one = CreateImmOperand(1, k64BitSize, false);
+    SelectAdd(*reg, *reg, one, PTY_u64);
+    SelectCopy(*memOpnd, PTY_u64, *reg, PTY_u64);
+    return;
+  }
+
   ASSERT(intrnNode.NumOpnds() == 1, "must be 1 operand");
   BaseNode *arg1 = intrnNode.Opnd(0);
   ASSERT(arg1 != nullptr, "nullptr check");
diff --git a/src/mapleall/maple_be/src/cg/aarch64/aarch64_emitter.cpp b/src/mapleall/maple_be/src/cg/aarch64/aarch64_emitter.cpp
index 26d79c03d84104a4c37eb86c6b9eba1dbd7750a0..ebcca62cb67b0bbb0db4b5221ac8361f13f682f5 100644
--- a/src/mapleall/maple_be/src/cg/aarch64/aarch64_emitter.cpp
+++ b/src/mapleall/maple_be/src/cg/aarch64/aarch64_emitter.cpp
@@ -408,6 +408,14 @@ void AArch64AsmEmitter::Run(FuncEmitInfo &funcEmitInfo) {
     (void)emitter.Emit("\t.section\t.init_array,\"aw\"\n");
     (void)emitter.Emit("\t.quad\t").Emit(cgFunc.GetName()).Emit("\n");
   }
+  if (cgFunc.GetFunction().GetAttr(FUNCATTR_initialization)) {
+    (void)emitter.Emit("\t.section\t.init_array,\"aw\"\n");
+    (void)emitter.Emit("\t.quad\t").Emit(cgFunc.GetName()).Emit("\n");
+  }
+  if (cgFunc.GetFunction().GetAttr(FUNCATTR_termination)) {
+    (void)emitter.Emit("\t.section\t.fini_array,\"aw\"\n");
+    (void)emitter.Emit("\t.quad\t").Emit(cgFunc.GetName()).Emit("\n");
+  }
   emitter.Emit("\n");
   EmitMethodDesc(funcEmitInfo, emitter);
   /* emit java code to the java section. */
diff --git a/src/mapleall/maple_be/src/cg/emit.cpp b/src/mapleall/maple_be/src/cg/emit.cpp
index a7c2a137f3f6fdbcc003ce340f05e1f2955d6ca4..4df2c9ec5a928eebebcb3b6a2d71f58426d50673 100644
--- a/src/mapleall/maple_be/src/cg/emit.cpp
+++ b/src/mapleall/maple_be/src/cg/emit.cpp
@@ -1645,6 +1645,8 @@ void Emitter::EmitArrayConstant(MIRConst &mirConst) {
     } else if (elemConst->GetType().GetKind() == kTypeStruct || elemConst->GetType().GetKind() == kTypeClass ||
                elemConst->GetType().GetKind() == kTypeUnion) {
       EmitStructConstant(*elemConst);
+    } else if (elemConst->GetKind() == kConstAddrofFunc) {
+      EmitScalarConstant(*elemConst);
     } else {
       ASSERT(false, "should not run here");
     }
diff --git a/src/mapleall/maple_driver/include/driver_option_common.h b/src/mapleall/maple_driver/include/driver_option_common.h
index 0b79889d36684227fc6e5f33f092202e13e03e8a..8a583e16b9272366da5d20ae3aad5df948c30a4e 100644
--- a/src/mapleall/maple_driver/include/driver_option_common.h
+++ b/src/mapleall/maple_driver/include/driver_option_common.h
@@ -41,6 +41,8 @@ enum DriverOptionIndex {
   // DAI2.0
   kDecoupleInit,
   kProfilePath,
+  kProfileGen,
+  kProfileUse,
   kGCOnly,
   kBigEndian,
   kMplcgOpt,
diff --git a/src/mapleall/maple_driver/src/driver_option_common.cpp b/src/mapleall/maple_driver/src/driver_option_common.cpp
index a59b93c8912376e6ba43b9baf8442cfef546901c..e84c980877d690360315061ba668226c2c50855d 100644
--- a/src/mapleall/maple_driver/src/driver_option_common.cpp
+++ b/src/mapleall/maple_driver/src/driver_option_common.cpp
@@ -221,6 +221,24 @@ const mapleOption::Descriptor kUsages[] = {
     "                              \t--profile=list_file\n",
     "driver",
     { "dex2mpl", "mpl2mpl", "mplcg" } },
+  { kProfileGen,
+    kEnable,
+    "",
+    "profileGen",
+    kBuildTypeProduct,
+    kArgCheckPolicyBool,
+    "  --profileGen                \tGenerate profile data for static languages\n",
+    "driver",
+    { "me", "mpl2mpl", "mplcg" } },
+  { kProfileUse,
+    kEnable,
+    "",
+    "profileUse",
+    kBuildTypeProduct,
+    kArgCheckPolicyBool,
+    "  --profileUse                \tOptimize static languages with profile data\n",
+    "driver",
+    { "me", "mpl2mpl", "mplcg" } },
   { kGCOnly,
     kEnable,
     "",
diff --git a/src/mapleall/maple_driver/src/mpl_options.cpp b/src/mapleall/maple_driver/src/mpl_options.cpp
index 9bd86f1dcdb8a958d08e3af3f13d1518957ee0d0..4de0925df6bdaa9802fa1e8799227fe07bdbe1c5 100644
--- a/src/mapleall/maple_driver/src/mpl_options.cpp
+++ b/src/mapleall/maple_driver/src/mpl_options.cpp
@@ -152,7 +152,12 @@ ErrorCode MplOptions::HandleGeneralOptions() {
         LogInfo::MapleLogger() << kMapleDriverVersion << "\n";
         return kErrorExitHelp;
       }
-
+      case kProfileGen: {
+        exeOptions[kBinNameMe].push_back(opt);
+        exeOptions[kBinNameMpl2mpl].push_back(opt);
+        //exeOptions[kBinNameMplcg].push_back(opt);
+        continue;
+      }
       case kDex2mplOpt:
         updatedOptToolName = &kBinNameDex2mpl;
         break;
diff --git a/src/mapleall/maple_ipa/include/ipa_phase_manager.h b/src/mapleall/maple_ipa/include/ipa_phase_manager.h
index 39b95bc705aa72089b83387bd4413bd3cf0739b3..187737ed047a3aac97d5f05e3ca4022d8dc6e147 100644
--- a/src/mapleall/maple_ipa/include/ipa_phase_manager.h
+++ b/src/mapleall/maple_ipa/include/ipa_phase_manager.h
@@ -66,5 +66,19 @@ class SCCEmit : public MapleSccPhase<SCCNode<CGNode>>, public MaplePhaseManager
  private:
   void GetAnalysisDependence(maple::AnalysisDep &aDep) const override;
 };
+
+class SCCProfile : public MapleSccPhase<SCCNode<CGNode>>, public MaplePhaseManager {
+ public:
+  explicit SCCProfile(MemPool *mp) : MapleSccPhase<SCCNode<CGNode>>(&id, mp), MaplePhaseManager(*mp) {}
+  ~SCCProfile() override = default;
+  std::string PhaseName() const override;
+  PHASECONSTRUCTOR(SCCProfile);
+  bool PhaseRun(SCCNode<CGNode> &f) override;
+  AnalysisDataManager *GetResult() {
+    return result;
+  }
+ private:
+  AnalysisDataManager *result = nullptr;
+};
 }  // namespace maple
 #endif  // MAPLE_IPA_INCLUDE_IPA_PHASE_MANAGER_H
diff --git a/src/mapleall/maple_ipa/src/ipa_phase_manager.cpp b/src/mapleall/maple_ipa/src/ipa_phase_manager.cpp
index ddf7fd655178d93a66014a8e353960774e9be0a6..cede8ca0718b5edc3d6132a42f6371a7a0f6ea37 100644
--- a/src/mapleall/maple_ipa/src/ipa_phase_manager.cpp
+++ b/src/mapleall/maple_ipa/src/ipa_phase_manager.cpp
@@ -83,12 +83,16 @@ bool IpaSccPM::PhaseRun(MIRModule &m) {
 
 void IpaSccPM::DoPhasesPopulate(const MIRModule &mirModule) {
   (void)mirModule;
-  AddPhase("sccprepare", true);
-  AddPhase("prop_param_type",  MeOption::npeCheckMode != SafetyCheckMode::kNoCheck);
-  AddPhase("prop_return_attr",  MeOption::npeCheckMode != SafetyCheckMode::kNoCheck);
-  AddPhase("collect_ipa_info", true);
-  AddPhase("sccsideeffect", true);
-  AddPhase("sccemit", true);
+  if (Options::profileGen || Options::profileUse) {
+    AddPhase("sccprofile", true);
+  } else {
+    AddPhase("sccprepare", true);
+    AddPhase("prop_param_type",  MeOption::npeCheckMode != SafetyCheckMode::kNoCheck);
+    AddPhase("prop_return_attr",  MeOption::npeCheckMode != SafetyCheckMode::kNoCheck);
+    AddPhase("collect_ipa_info", true);
+    AddPhase("sccsideeffect", Options::sideEffect);
+    AddPhase("sccemit", true);
+  }
 }
 
 void IpaSccPM::GetAnalysisDependence(maple::AnalysisDep &aDep) const {
@@ -183,7 +187,50 @@ void SCCEmit::GetAnalysisDependence(maple::AnalysisDep &aDep) const {
   aDep.AddRequired<SCCPrepare>();
 }
 
+bool SCCProfile::PhaseRun(SCCNode<CGNode> &scc) {
+  SetQuiet(true);
+  AddPhase("mecfgbuild", true);
+  if (Options::profileGen) {
+    AddPhase("ssatab", true);
+    AddPhase("aliasclass", true);
+    AddPhase("ssa", true);
+    AddPhase("irmapbuild", true);
+    //AddPhase("profileIntrusionPM", true); //ref: MEProfGen
+    AddPhase("profileGen", true);
+  } else {
+    AddPhase("profileUse", true);
+  }
+  AddPhase("emitforipa", true);
+  // Not like other phasemanager which use temp mempool to hold analysis results generated from the sub phases.
+  // Here we use GetManagerMemPool which lives longer than this phase(manager) itself to hold all the analysis result.
+  // So the following phase can access the result in this phase.
+  result = GetManagerMemPool()->New<AnalysisDataManager>(*GetPhaseMemPool());
+  for (auto *cgNode : scc.GetNodes()) {
+    MIRFunction *func = cgNode->GetMIRFunction();
+    if (func->IsEmpty()) {
+      continue;
+    }
+    MIRModule &m = *func->GetModule();
+    m.SetCurFunction(func);
+    MeFunction &meFunc = *func->GetMeFunc();
+    for (size_t i = 0; i < phasesSequence.size(); ++i) {
+      const MaplePhaseInfo *phase = MaplePhaseRegister::GetMaplePhaseRegister()->GetPhaseByID(phasesSequence[i]);
+      if (!IsQuiet()) {
+        LogInfo::MapleLogger() << " >> Prepare " << (phase->IsAnalysis() ? "analysis" : "transform")
+                               << " Phase [ " << phase->PhaseName() << " ] <<\n";
+      }
+      if (phase->IsAnalysis()) {
+        (void)RunAnalysisPhase<meFuncOptTy, MeFunction>(*phase, *result, meFunc, 1);
+      } else {
+        (void)RunTransformPhase<meFuncOptTy, MeFunction>(*phase, *result, meFunc, 1);
+      }
+    }
+  }
+  return false;
+}
+
 MAPLE_ANALYSIS_PHASE_REGISTER(SCCPrepare, sccprepare)
+MAPLE_ANALYSIS_PHASE_REGISTER(SCCProfile, sccprofile)
 MAPLE_ANALYSIS_PHASE_REGISTER(SCCCollectIpaInfo, collect_ipa_info);
 MAPLE_ANALYSIS_PHASE_REGISTER(SCCPropReturnAttr, prop_return_attr);
 MAPLE_TRANSFORM_PHASE_REGISTER(SCCPropParamType, prop_param_type);
diff --git a/src/mapleall/maple_ir/include/all_attributes.def b/src/mapleall/maple_ir/include/all_attributes.def
index 025166edbe03cbe30be3c2c944426cfba189c011..6f51deb7545f4fc236b457d2035005df21b72041 100644
--- a/src/mapleall/maple_ir/include/all_attributes.def
+++ b/src/mapleall/maple_ir/include/all_attributes.def
@@ -106,3 +106,7 @@
 #if (defined(TYPE_ATTR) || defined(FIELD_ATTR)) && !defined(NOCONTENT_ATTR)
   ATTR(pack)
 #endif
+#ifdef FUNC_ATTR
+  ATTR(initialization)
+  ATTR(termination)
+#endif
diff --git a/src/mapleall/maple_ir/include/mir_function.h b/src/mapleall/maple_ir/include/mir_function.h
index 4767206ed60abe0c39abbc4cd1a656be276883ca..52ee2bccd10319133fc20f828a60b29f39e6e5a0 100644
--- a/src/mapleall/maple_ir/include/mir_function.h
+++ b/src/mapleall/maple_ir/include/mir_function.h
@@ -1113,6 +1113,42 @@ class MIRFunction {
     funcDesc = value;
   }
 
+  void SetProfCtrTbl(MIRSymbol *pct) {
+    CHECK_FATAL(Options::profileGen, "This is only for profileGen");
+    profCtrTbl = pct;
+  }
+
+  MIRSymbol *GetProfCtrTbl() {
+    return profCtrTbl;
+  }
+
+  void SetNumCtrs(uint32 num) {
+    CHECK_FATAL(Options::profileGen, "This is only for profileGen");
+    nCtrs = num;
+  }
+
+  uint32 GetNumCtrs() {
+    return nCtrs;
+  }
+
+  void SetFileLineNoChksum(uint64 chksum) {
+    CHECK_FATAL(Options::profileGen, "This is only for profileGen");
+    fileLinenoChksum = chksum;
+  }
+
+  uint64 GetFileLineNoChksum() {
+    return fileLinenoChksum;
+  }
+
+  void SetCFGChksum(uint64 chksum) {
+    CHECK_FATAL(Options::profileGen, "This is only for profileGen");
+    cfgChksum = chksum;
+  }
+
+  uint64 GetCFGChksum() {
+    return cfgChksum;
+  }
+
   void InitFuncDescToBest() {
     funcDesc.InitToBest();
   }
@@ -1234,7 +1270,10 @@ class MIRFunction {
   PointerAttr returnKind = PointerAttr::kPointerUndeiced;
   std::map<MIRSymbol*, PointerAttr> paramNonullTypeMap;
   FuncDesc funcDesc{};
-
+  MIRSymbol *profCtrTbl = nullptr;
+  uint32 nCtrs = 0; // number of counters
+  uint64 fileLinenoChksum = 0;
+  uint64 cfgChksum = 0;
   void DumpFlavorLoweredThanMmpl() const;
   MIRFuncType *ReconstructFormals(const std::vector<MIRSymbol*> &symbols, bool clearOldArgs);
 };
diff --git a/src/mapleall/maple_ir/include/option.h b/src/mapleall/maple_ir/include/option.h
index f3c2eb535cd63a669e6f627f81471af7b8d0ad6a..05abab257f72c41e51d7c316a6387ac46b4c49e6 100644
--- a/src/mapleall/maple_ir/include/option.h
+++ b/src/mapleall/maple_ir/include/option.h
@@ -147,6 +147,8 @@ class Options : public MapleDriverOptionBase {
   static std::string readDevirtualList;
   static bool usePreloadedClass;
   static std::string profile;
+  static bool profileGen;
+  static bool profileUse;
   static std::string appPackageName;
   static std::string proFileData;
   static std::string proFileFuncData;
diff --git a/src/mapleall/maple_ir/src/option.cpp b/src/mapleall/maple_ir/src/option.cpp
index 85f84739c0c5cec777168f0de6afec3c71b2a86d..fccdbc2922b4dae06cd6ef58b5f29b920fa5b46c 100644
--- a/src/mapleall/maple_ir/src/option.cpp
+++ b/src/mapleall/maple_ir/src/option.cpp
@@ -59,6 +59,9 @@ bool Options::emitVtableImpl = false;
 #if MIR_JAVA
 bool Options::skipVirtualMethod = false;
 #endif
+bool Options::profileGen = false;
+bool Options::profileUse = false;
+
 // Ready to be deleted.
 bool Options::noRC = false;
 bool Options::analyzeCtor = true;
@@ -1226,6 +1229,17 @@ bool Options::SolveOptions(const std::deque<Option> &opts, bool isDebug) const {
       case kProfilePath:
         profile = opt.Args();
         break;
+      case kProfileGen:
+        if (O2) {
+          LogInfo::MapleLogger(kLlErr) << "profileGen requires no optimization\n";
+          result = false;
+        } else {
+          profileGen = true;
+        }
+        break;
+      case kProfileUse:
+        profileUse = true;
+        break;
       case kAppPackageName:
         appPackageName = opt.Args();
         break;
diff --git a/src/mapleall/maple_me/src/me_option.cpp b/src/mapleall/maple_me/src/me_option.cpp
index fb2c2ab3db31207414e31313ae928b1bb1375dec..4ac0ddd3da816fea4311e461a8fb01dcfb62d150 100644
--- a/src/mapleall/maple_me/src/me_option.cpp
+++ b/src/mapleall/maple_me/src/me_option.cpp
@@ -1457,6 +1457,11 @@ bool MeOption::SolveOptions(const std::deque<mapleOption::Option> &opts, bool is
         break;
       case kVerbose:
         quiet = (opt.Type() == kEnable) ? false : true;
+      case kProfileGen:
+        if (optLevel != kLevelZero) {
+          WARN(kLncWarn, "profileGen requires no optimization");
+          result = false;
+        }
         break;
       case kSetCalleeHasSideEffect:
         setCalleeHasSideEffect = (opt.Type() == kEnable);
diff --git a/src/mapleall/maple_me/src/me_profile_gen.cpp b/src/mapleall/maple_me/src/me_profile_gen.cpp
index 52ecfc3f298581f76dea6e0dcbda8831165bd2fa..970e146dccc468b38f61d832b0e448a5d7d583d8 100644
--- a/src/mapleall/maple_me/src/me_profile_gen.cpp
+++ b/src/mapleall/maple_me/src/me_profile_gen.cpp
@@ -19,6 +19,9 @@
 #include "me_function.h"
 #include "me_irmap_build.h"
 #include "mir_builder.h"
+#include "gen_profile.h"
+#include "itab_util.h"
+#include <algorithm>
 
 /*
  * This phase do CFG edge profile using a minimum spanning tree based
@@ -52,6 +55,9 @@ void MeProfGen::IncTotalFunc() {
 }
 
 void MeProfGen::Init() {
+  if (Options::profileGen) {
+    return;
+  }
   if (!firstRun) {
     return;
   }
@@ -97,6 +103,51 @@ void MeProfGen::InstrumentFunc() {
   FindInstrumentEdges();
   std::vector<BB*> instrumentBBs;
   GetInstrumentBBs(instrumentBBs);
+
+  if (Options::profileGen) {
+    counterIdx = 0;
+    MIRModule *mod = func->GetMirFunc()->GetModule();
+    uint32 nCtrs = instrumentBBs.size();
+    func->GetMirFunc()->SetNumCtrs(nCtrs);
+    if (nCtrs != 0) {
+      MIRType *arrOfInt64Ty = GlobalTables::GetTypeTable().GetOrCreateArrayType(
+         *GlobalTables::GetTypeTable().GetInt64(), nCtrs);
+
+      // Likely pathname is needed
+      std::string ctrTblName = namemangler::kprefixProfCtrTbl +
+                               func->GetMIRModule().GetFileName() + "_" +
+                               func->GetMirFunc()->GetName();
+      std::replace(ctrTblName.begin(), ctrTblName.end(), '.', '_');
+      std::replace(ctrTblName.begin(), ctrTblName.end(), '-', '_');
+      std::replace(ctrTblName.begin(), ctrTblName.end(), '/', '_');
+
+      MIRSymbol *ctrTblSym = mod->GetMIRBuilder()->CreateGlobalDecl(ctrTblName, *arrOfInt64Ty, kScFstatic);
+      func->GetMirFunc()->SetProfCtrTbl(ctrTblSym);
+
+    }
+    for (auto *bb : instrumentBBs) {
+      InstrumentBB(*bb);
+    }
+
+    // Checksums are relatively sensible to source changes
+    // Generate the function's lineno checksum
+    std::string fileName = func->GetMIRModule().GetFileName();
+    uint64 fileNameHash = DJBHash(fileName.c_str());
+    std::string lineNo = std::to_string(func->GetMirFunc()->GetSrcPosition().LineNum());
+    uint64 linenoHash = fileNameHash << 32 | DJBHash(lineNo.c_str());
+    func->GetMirFunc()->SetFileLineNoChksum(linenoHash);
+
+    // Generate The function's CFG checksum
+    uint64 cfgCheckSum = ComputeFuncHash();
+    func->GetMirFunc()->SetCFGChksum(cfgCheckSum);
+
+    if (dump) {
+      LogInfo::MapleLogger() << "******************after profileGen dump function******************\n";
+      func->Dump(true);
+    }
+    return;
+  }
+
   // record the current counter start, used in the function profile description
   uint32 counterStart = static_cast<uint32>(counterIdx);
   MIRAggConst *bbProfileTab = safe_cast<MIRAggConst>(bbCounterTabSym->GetKonst());
diff --git a/src/mapleall/maple_phase/include/phases.def b/src/mapleall/maple_phase/include/phases.def
index dc2ab3aca50cb47c99640b5f28a64019b8e51bda..3ba00ccc494a85e7fa363b918afc1f15ba5357bc 100644
--- a/src/mapleall/maple_phase/include/phases.def
+++ b/src/mapleall/maple_phase/include/phases.def
@@ -14,8 +14,9 @@ ADDMODULEPHASE("callgraph", Options::O2 && Options::useInline)
 ADDMODULEPHASE("simplify", Options::O2)
 ADDMODULEPHASE("ConstantFold", Options::O2)
 // ipa phase manager
-ADDMODULEPHASE("IpaSccPM", CLANG && Options::O2)
+ADDMODULEPHASE("IpaSccPM", CLANG && (Options::O2 || Options::profileGen))
 ADDMODULEPHASE("ipaclone", CLANG && Options::O2 && Options::enableIPAClone)
+ADDMODULEPHASE("ProfileGenPM", CLANG && Options::profileGen)
 // me phase manager is also a phase itself.
 ADDMAPLEPHASE("meFuncPM", IsRunMe());
 ADDMODULEPHASE("clinit", JAVALANG)
diff --git a/src/mapleall/maple_util/include/namemangler.h b/src/mapleall/maple_util/include/namemangler.h
index d561f3ce90d937221bba305620e04b7658d0fb8c..9a838540e0ace5b9a213017f665b91bbdefe888e 100644
--- a/src/mapleall/maple_util/include/namemangler.h
+++ b/src/mapleall/maple_util/include/namemangler.h
@@ -174,6 +174,16 @@ static constexpr const char kFunctionProfileTabPrefixStr[] = "__muid_profile_fun
 static constexpr const char kBBProfileTabPrefixStr[] = "__muid_prof_counter_tab";
 static constexpr const char kFuncIRProfInfTabPrefixStr[] = "__muid_prof_ir_desc_tab";
 
+static constexpr const char kprefixProfModDesc[] = "__mpl_prof_moddesc_";
+static constexpr const char kprefixProfCtrTbl[] = "__mpl_prof_ctrtbl_";
+static constexpr const char kprefixProfFuncDesc[] = "__mpl_prof_funcdesc_";
+static constexpr const char kprefixProfFuncDescTbl[] = "__mpl_func_prof_desc_tbl_";
+static constexpr const char kprefixProfInit[] = "__mpl_prof_init_";
+static constexpr const char kprefixProfExit[] = "__mpl_prof_exit_";
+static constexpr const char kGCCProfInit[] = "__gcov_init";
+static constexpr const char kGCCProfExit[] = "__gcov_exit";
+static constexpr const char kMplMergeFuncAdd[] = "__gcov_merge_add";
+
 static constexpr const char kBindingProtectedRegionStr[] = "__BindingProtectRegion__";
 
 static constexpr const char kClassNamePrefixStr[] = "L";
diff --git a/src/mapleall/mpl2mpl/BUILD.gn b/src/mapleall/mpl2mpl/BUILD.gn
index dd6ed42a3e0522dc8009a37798051b8c7b69c775..b4dfefbedd9de40e15a1c85397c90de0ee524918 100755
--- a/src/mapleall/mpl2mpl/BUILD.gn
+++ b/src/mapleall/mpl2mpl/BUILD.gn
@@ -45,6 +45,7 @@ src_libmpl2mpl = [
   "src/ext_constantfold.cpp",
   "src/coderelayout.cpp",
   "src/annotation_analysis.cpp",
+  "src/gen_profile.cpp",
   "src/preme.cpp",
   "src/scalarreplacement.cpp",
   "src/module_phase_manager.cpp",
diff --git a/src/mapleall/mpl2mpl/include/gen_profile.h b/src/mapleall/mpl2mpl/include/gen_profile.h
new file mode 100644
index 0000000000000000000000000000000000000000..6f3bf3930217ed854825188566a8479a01ef0ebf
--- /dev/null
+++ b/src/mapleall/mpl2mpl/include/gen_profile.h
@@ -0,0 +1,78 @@
+/*
+ * Copyright (c) [2020-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.
+ */
+#ifndef MAPLE_MPL2MPL_INCLUDE_PROFILEGEN_H
+#define MAPLE_MPL2MPL_INCLUDE_PROFILEGEN_H
+#include "module_phase_manager.h"
+#include "me_pgo_instrument.h"
+#include "bb.h"
+#include "me_irmap.h"
+#include "maple_phase_manager.h"
+#include <algorithm>
+
+namespace maple {
+static constexpr const uint32_t kMplModProfMergeFuncs = 9;  // gcov reserves 9 slots
+static constexpr const uint32_t kGCCVersion = 0x4137352A;   // gcc v7.5 under tools
+//static constexpr const uint32_t kGCCVersion = 0x4139342A; // GCC V9.3/9.4
+static constexpr const char kProfFileNameExt[] = ".gcda";
+// anything other than merge_add will be supported supported in future
+static constexpr const uint32_t kMplFuncProfCtrInfoNum = 1;
+
+class ProfileGenPM : public SccPM {
+ public:
+  explicit ProfileGenPM(MemPool *memPool) : SccPM(memPool, &id) {}
+  bool PhaseRun(MIRModule &m) override;
+  PHASECONSTRUCTOR(ProfileGenPM);
+  ~ProfileGenPM() override {}
+  std::string PhaseName() const override;
+ private:
+  void GetAnalysisDependence(AnalysisDep &aDep) const override;
+};
+
+class ProfileGen {
+  public:
+  ProfileGen(MIRModule &module) : mod(module) {
+    for (MIRFunction *f : mod.GetFunctionList()) {
+      if (!f->IsEmpty()) { validFuncs.push_back(f); }
+    }
+  };
+
+  std::string flatenName(const std::string &name) {
+    std::string filteredName = name;
+    std::replace(filteredName.begin(), filteredName.end(), '.', '_');
+    std::replace(filteredName.begin(), filteredName.end(), '-', '_');
+    std::replace(filteredName.begin(), filteredName.end(), '/', '_');
+    return filteredName;
+  }
+
+  void CreateModProfDesc();
+  void CreateFuncProfDesc();
+  void CreateFuncProfDescTbl();
+  void FixupDesc();
+  void CreateInitProc();
+  void CreateExitProc();
+  void GenFuncCtrTbl();
+  void Run();
+  std::vector<MIRFunction *> getValidFuncs() { return validFuncs; }
+
+  private:
+    MIRModule &mod;
+    MIRSymbol *modProfDesc;
+    // Keep order of funcs visited
+    MIRSymbol *funcProfDescTbl;
+    std::vector<MIRSymbol *> funcProfDescs;
+    std::vector<MIRFunction *> validFuncs;
+};
+}  // namespace maple
+#endif  // MAPLE_MPL2MPL_INCLUDE_PROFILEGEN_H
diff --git a/src/mapleall/mpl2mpl/include/module_phase_manager.h b/src/mapleall/mpl2mpl/include/module_phase_manager.h
index 86b090c5b40ea783fa3ed1837075f527eb9b4cd0..b65ad2a3c6745e738b88ebe2e167ae56b75fd796 100644
--- a/src/mapleall/mpl2mpl/include/module_phase_manager.h
+++ b/src/mapleall/mpl2mpl/include/module_phase_manager.h
@@ -26,6 +26,7 @@
 #include "verify_mark.h"
 #include "inline.h"
 #include "method_replace.h"
+#include "gen_profile.h"
 #if MIR_JAVA
 #include "native_stub_func.h"
 #include "vtable_analysis.h"
diff --git a/src/mapleall/mpl2mpl/src/gen_profile.cpp b/src/mapleall/mpl2mpl/src/gen_profile.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..b39548a44dbe7af1e4be66a979eac9806855f0d3
--- /dev/null
+++ b/src/mapleall/mpl2mpl/src/gen_profile.cpp
@@ -0,0 +1,382 @@
+/*
+ * Copyright (c) [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 <ctime>
+#include "gen_profile.h"
+#include "ipa_phase_manager.h"
+//#include "file_utils.h"
+
+// namespace maple
+namespace maple {
+void ProfileGen::CreateModProfDesc() {
+  // Ref gcov_info
+  MIRBuilder *mirBuilder = mod.GetMIRBuilder();
+  MemPool *modMP = mod.GetMemPool();
+  FieldVector modProfDescFields;                                                   // Field
+  GStrIdx verStrIdx = mirBuilder->GetOrCreateStringIndex("version");               // 1
+  GStrIdx pad4b1StrIdx = mirBuilder->GetOrCreateStringIndex("pad4b1");             // 2
+  GStrIdx nextStrIdx = mirBuilder->GetOrCreateStringIndex("next");                 // 3
+  GStrIdx stampStrIdx = mirBuilder->GetOrCreateStringIndex("stamp");               // 4
+  GStrIdx chksumStrIdx = mirBuilder->GetOrCreateStringIndex("checksum");           // 5
+  GStrIdx outputFNStrIdx = mirBuilder->GetOrCreateStringIndex("outputfile_name");  // 6
+  GStrIdx mergeFuncsStrIdx = mirBuilder->GetOrCreateStringIndex("merge_funcs");    // 7
+  GStrIdx nFuncsStrIdx = mirBuilder->GetOrCreateStringIndex("n_funcs");            // 8
+  GStrIdx pad4b2StrIdx = mirBuilder->GetOrCreateStringIndex("pad4b2");             // 9
+  GStrIdx funcDescTblStrIdx = mirBuilder->GetOrCreateStringIndex("func_desc_tbl"); // 10
+
+  TyIdx i16TyIdx = GlobalTables::GetTypeTable().GetInt16()->GetTypeIndex();
+  MIRType *u32Ty = GlobalTables::GetTypeTable().GetUInt32();
+  TyIdx u32TyIdx = u32Ty->GetTypeIndex();
+  TyIdx ptrTyIdx = GlobalTables::GetTypeTable().GetPtr()->GetTypeIndex();
+  MIRType *voidTy = GlobalTables::GetTypeTable().GetVoid();
+  MIRType *voidPtrTy = GlobalTables::GetTypeTable().GetVoidPtr();
+  TyIdx charPtrTyIdx = GlobalTables::GetTypeTable().
+                           GetOrCreatePointerType(TyIdx(PTY_u8))->GetTypeIndex();
+
+  // Ref: __gcov_merge_add (gcov_type *, unsigned)
+  MIRType *retTy = GlobalTables::GetTypeTable().GetVoid();
+  std::vector<TyIdx> argTys;
+  std::vector<TypeAttrs> argAttrs;
+  MIRType *arg1Ty = GlobalTables::GetTypeTable().GetOrCreatePointerType(i16TyIdx); // need to verify on 7.5
+  MIRType *arg2Ty = GlobalTables::GetTypeTable().GetUInt16();
+  argTys.push_back(arg1Ty->GetTypeIndex());
+  argTys.push_back(arg2Ty->GetTypeIndex());
+  MIRType *funcTy = GlobalTables::GetTypeTable().GetOrCreateFunctionType(retTy->GetTypeIndex(), argTys, argAttrs);
+  MIRType *funcPtrTy = GlobalTables::GetTypeTable().GetOrCreatePointerType(*funcTy, PTY_ptr);
+  MIRType *arrOfPtrsTy = GlobalTables::GetTypeTable().GetOrCreateArrayType(*funcPtrTy, kMplModProfMergeFuncs);
+  TyIdx arrOfPtrsTyIdx = arrOfPtrsTy->GetTypeIndex();
+
+  // Form descriptor type                                                                                    // Field
+  modProfDescFields.push_back(FieldPair(verStrIdx, TyIdxFieldAttrPair(u32TyIdx, FieldAttrs())));             // 1
+  modProfDescFields.push_back(FieldPair(pad4b1StrIdx, TyIdxFieldAttrPair(u32TyIdx, FieldAttrs())));          // 2
+  modProfDescFields.push_back(FieldPair(nextStrIdx, TyIdxFieldAttrPair(ptrTyIdx, FieldAttrs())));            // 3
+  modProfDescFields.push_back(FieldPair(stampStrIdx, TyIdxFieldAttrPair(u32TyIdx, FieldAttrs())));           // 4
+  modProfDescFields.push_back(FieldPair(chksumStrIdx, TyIdxFieldAttrPair(u32TyIdx, FieldAttrs())));          // 5
+  modProfDescFields.push_back(FieldPair(outputFNStrIdx, TyIdxFieldAttrPair(charPtrTyIdx, FieldAttrs())));    // 6
+  modProfDescFields.push_back(FieldPair(mergeFuncsStrIdx, TyIdxFieldAttrPair(arrOfPtrsTyIdx, FieldAttrs())));// 7
+  modProfDescFields.push_back(FieldPair(nFuncsStrIdx, TyIdxFieldAttrPair(u32TyIdx, FieldAttrs())));          // 8
+  modProfDescFields.push_back(FieldPair(pad4b2StrIdx, TyIdxFieldAttrPair(u32TyIdx, FieldAttrs())));          // 9
+  modProfDescFields.push_back(FieldPair(funcDescTblStrIdx, TyIdxFieldAttrPair(ptrTyIdx, FieldAttrs())));     // 10
+  FieldVector parentFields;
+
+  std::string srcFN = mod.GetFileName();
+  std::string useName = flatenName(srcFN);
+
+  MIRType *modProfDescTy = GlobalTables::GetTypeTable().GetOrCreateStructType(
+      namemangler::kprefixProfModDesc + useName + "_ty", modProfDescFields, parentFields, mod);
+
+  MIRSymbol *modProfDescSym = mod.GetMIRBuilder()->CreateGlobalDecl(
+      namemangler::kprefixProfModDesc + useName, *modProfDescTy, kScFstatic);
+
+  // Initialization
+  MIRAggConst *modProfDescSymMirConst = modMP->New<MIRAggConst>(mod, *modProfDescTy);
+
+  MIRIntConst *verMirConst = GlobalTables::GetIntConstTable().GetOrCreateIntConst(kGCCVersion, *u32Ty);
+  modProfDescSymMirConst->AddItem(verMirConst, 1); // checked by gcov
+
+  MIRIntConst *zeroMirConst = GlobalTables::GetIntConstTable().GetOrCreateIntConst(0, *u32Ty);
+  modProfDescSymMirConst->AddItem(zeroMirConst, 2);
+
+  MIRIntConst *nextMirConst = GlobalTables::GetIntConstTable().GetOrCreateIntConst(0, *voidPtrTy);
+  modProfDescSymMirConst->AddItem(nextMirConst, 3);
+
+  uint32 timeStamp = time(NULL);
+  MIRIntConst *stampMirConst = GlobalTables::GetIntConstTable().GetOrCreateIntConst(timeStamp, *u32Ty);
+  modProfDescSymMirConst->AddItem(stampMirConst, 4);
+
+  uint32 cfgChkSum = 0;
+  for (MIRFunction *f : validFuncs) {
+    cfgChkSum ^= static_cast<uint32>((f->GetCFGChksum() >> 32) ^ (f->GetCFGChksum() & 0xffffffff));
+  }
+  MIRIntConst *checksumMirConst = GlobalTables::GetIntConstTable().GetOrCreateIntConst(cfgChkSum, *u32Ty);
+  modProfDescSymMirConst->AddItem(checksumMirConst, 5);
+
+  // Make the profile file name as fileName.gcda
+  std::string profFileName = flatenName(srcFN.substr(0,srcFN.find_last_of("."))) + kProfFileNameExt;
+  MIRStrConst *profileFNMirConst = modMP->New<MIRStrConst>(
+      "./" + profFileName, *GlobalTables::GetTypeTable().GetTypeFromTyIdx((TyIdx)PTY_a64));
+  modProfDescSymMirConst->AddItem(profileFNMirConst, 6);
+
+  // Additional profiling (in addition to frequency profiling) should be added here
+  MIRFunction *profFuncProtoTy =
+      mod.GetMIRBuilder()->GetOrCreateFunction(namemangler::kMplMergeFuncAdd, voidTy->GetTypeIndex());
+  profFuncProtoTy->AllocSymTab();
+  MIRSymbol *profFuncArg1Sym = profFuncProtoTy->GetSymTab()->CreateSymbol(kScopeLocal);
+  profFuncArg1Sym->SetTyIdx(arg1Ty->GetTypeIndex());
+  profFuncProtoTy->AddArgument(profFuncArg1Sym);
+  MIRSymbol *profFuncArg2Sym = profFuncProtoTy->GetSymTab()->CreateSymbol(kScopeLocal);
+  profFuncArg2Sym->SetTyIdx(arg2Ty->GetTypeIndex());
+  profFuncProtoTy->AddArgument(profFuncArg2Sym);
+  MIRAddroffuncConst *profEdgeCountMirConst =
+      modMP->New<MIRAddroffuncConst>(profFuncProtoTy->GetPuidx(), *funcPtrTy);
+  MIRAggConst *mergeFuncsMirConst = modMP->New<MIRAggConst>(mod, *arrOfPtrsTy);
+
+  mergeFuncsMirConst->AddItem(profEdgeCountMirConst, 0);
+  mergeFuncsMirConst->AddItem(nextMirConst, 1);
+  mergeFuncsMirConst->AddItem(nextMirConst, 2);
+  mergeFuncsMirConst->AddItem(nextMirConst, 3);
+  mergeFuncsMirConst->AddItem(nextMirConst, 4);
+  mergeFuncsMirConst->AddItem(nextMirConst, 5);
+  mergeFuncsMirConst->AddItem(nextMirConst, 6);
+  mergeFuncsMirConst->AddItem(nextMirConst, 7);
+  mergeFuncsMirConst->AddItem(nextMirConst, 8);
+
+  modProfDescSymMirConst->AddItem(mergeFuncsMirConst, 7);
+
+  uint32 numOfFunc = validFuncs.size();
+  MIRIntConst *nfuncsMirConst = GlobalTables::GetIntConstTable().GetOrCreateIntConst(numOfFunc, *u32Ty);
+  modProfDescSymMirConst->AddItem(nfuncsMirConst, 8);
+
+  modProfDescSymMirConst->AddItem(zeroMirConst, 9);
+
+  // func_desc_tbl will be fixed up later in fixup
+  MIRAddrofConst *funcProfDescTbl = modMP->New<MIRAddrofConst>(
+      modProfDescSym->GetStIdx(), 0, *GlobalTables::GetTypeTable().GetPtr());
+  modProfDescSymMirConst->AddItem(funcProfDescTbl, 10);
+
+  modProfDescSym->SetKonst(modProfDescSymMirConst);
+  modProfDesc = modProfDescSym;
+}
+
+void ProfileGen::CreateFuncProfDesc() {
+  // Ref: gcov_ctr_info
+  //      gcov_fn_info
+  MIRBuilder *mirBuilder = mod.GetMIRBuilder();
+  MemPool *modMP = mod.GetMemPool();
+  FieldVector parentFields;
+  MIRType *u32Ty = GlobalTables::GetTypeTable().GetUInt32();
+  MIRType *i64Ty = GlobalTables::GetTypeTable().GetInt64();
+  MIRType *i64PtrTy = GlobalTables::GetTypeTable().GetOrCreatePointerType(i64Ty->GetTypeIndex());
+
+  // Create counter info type                                            // Field
+  GStrIdx nCtrStrIdx = mirBuilder->GetOrCreateStringIndex("num_ctr");    // 1
+  GStrIdx ctrTblStrIdx = mirBuilder->GetOrCreateStringIndex("ctr_tbl");  // 2
+
+  FieldVector ctrInfoFields;
+  ctrInfoFields.push_back(FieldPair(nCtrStrIdx, TyIdxFieldAttrPair(u32Ty->GetTypeIndex(), FieldAttrs())));      // 1
+  ctrInfoFields.push_back(FieldPair(ctrTblStrIdx, TyIdxFieldAttrPair(i64PtrTy->GetTypeIndex(), FieldAttrs()))); // 2
+  MIRType *ctrDescTy = GlobalTables::GetTypeTable().GetOrCreateStructType("__mpl_ctr_desc_ty", ctrInfoFields, parentFields, mod);
+
+  // Create function profile descriptor type                                 // Field
+  GStrIdx modDescStrIdx = mirBuilder->GetOrCreateStringIndex("mod_desc");    // 1
+  GStrIdx funcIDStrIdx = mirBuilder->GetOrCreateStringIndex("func_id");      // 2
+  GStrIdx lnChkStrIdx = mirBuilder->GetOrCreateStringIndex("lineno_chksum"); // 3
+  GStrIdx cfgChkStrIdx = mirBuilder->GetOrCreateStringIndex("cfg_chksum");   // 4
+  GStrIdx pad4bStrIdx = mirBuilder->GetOrCreateStringIndex("pad4b");         // 5
+  GStrIdx ctrDescStrIdx = mirBuilder->GetOrCreateStringIndex("ctr_desc");    // 6
+
+  MIRType *modProfDescPtrTy = GlobalTables::GetTypeTable().GetOrCreatePointerType(modProfDesc->GetTyIdx());
+  MIRType *arrOfCtrDescTy = GlobalTables::GetTypeTable().GetOrCreateArrayType(*ctrDescTy, kMplFuncProfCtrInfoNum);
+
+  FieldVector funcProfDescFields;                                                                                             // Field
+  funcProfDescFields.push_back(FieldPair(modDescStrIdx, TyIdxFieldAttrPair(modProfDescPtrTy->GetTypeIndex(), FieldAttrs()))); // 1
+  funcProfDescFields.push_back(FieldPair(funcIDStrIdx, TyIdxFieldAttrPair(u32Ty->GetTypeIndex(), FieldAttrs())));             // 2
+  funcProfDescFields.push_back(FieldPair(lnChkStrIdx, TyIdxFieldAttrPair(u32Ty->GetTypeIndex(), FieldAttrs())));              // 3
+  funcProfDescFields.push_back(FieldPair(cfgChkStrIdx, TyIdxFieldAttrPair(u32Ty->GetTypeIndex(), FieldAttrs())));             // 4
+  funcProfDescFields.push_back(FieldPair(pad4bStrIdx, TyIdxFieldAttrPair(u32Ty->GetTypeIndex(), FieldAttrs())));              // 5
+  funcProfDescFields.push_back(FieldPair(ctrDescStrIdx, TyIdxFieldAttrPair(arrOfCtrDescTy->GetTypeIndex(), FieldAttrs())));   // 6
+
+  MIRType *funcProfDescTy =
+      GlobalTables::GetTypeTable().GetOrCreateStructType("__mpl_prof_desc_ty", funcProfDescFields, parentFields, mod);
+
+  for (MIRFunction *f : validFuncs) {
+    if (f->GetBody() == nullptr) continue;
+
+    uint64  nCtrs = f->GetNumCtrs();
+    MIRSymbol *ctrTblSym = f->GetProfCtrTbl();
+
+    // Initialization of counter table
+    MIRType *u64Ty = GlobalTables::GetTypeTable().GetUInt64();
+    MIRIntConst *zeroMirConst = GlobalTables::GetIntConstTable().GetOrCreateIntConst(0, *u64Ty);
+    MIRType *arrOfUInt64Ty = GlobalTables::GetTypeTable().GetOrCreateArrayType(*u64Ty, nCtrs);
+    MIRAggConst *initCtrTblMirConst = modMP->New<MIRAggConst>(mod, *arrOfUInt64Ty);
+    for (uint32 i=0; i<nCtrs; i++) {
+      initCtrTblMirConst->AddItem(zeroMirConst, 0);
+    }
+    ctrTblSym->SetKonst(initCtrTblMirConst);
+
+    PUIdx puID = f->GetPuidx();
+
+    // Create const func profile descriptor
+    MIRAggConst *funcProfDescMirConst = modMP->New<MIRAggConst>(mod, *funcProfDescTy);
+
+    MIRAddrofConst *modDescMirConst = modMP->New<MIRAddrofConst>(modProfDesc->GetStIdx(), 0, *GlobalTables::GetTypeTable().GetPtr());
+    funcProfDescMirConst->AddItem(modDescMirConst, 1);
+
+    uint32 funcID = puID;
+    MIRIntConst *funcIDMirConst = GlobalTables::GetIntConstTable().GetOrCreateIntConst(funcID, *u32Ty);
+    funcProfDescMirConst->AddItem(funcIDMirConst, 2);
+
+    uint32 lineNoChkSum = static_cast<uint32>((f->GetFileLineNoChksum() >> 32) ^ (f->GetFileLineNoChksum() & 0xffffffff));
+    MIRIntConst *lineNoChkSumMirConst = GlobalTables::GetIntConstTable().GetOrCreateIntConst(lineNoChkSum, *u32Ty);
+    funcProfDescMirConst->AddItem(lineNoChkSumMirConst, 3);
+
+    uint32 cfgChkSum = static_cast<uint32>((f->GetCFGChksum() >> 32) ^ (f->GetCFGChksum() & 0xffffffff));
+    MIRIntConst *cfgChkSumMirConst = GlobalTables::GetIntConstTable().GetOrCreateIntConst(cfgChkSum, *u32Ty);
+    funcProfDescMirConst->AddItem(cfgChkSumMirConst, 4);
+
+    uint32 pad4b = 0;
+    MIRIntConst *pad4bMirConst = GlobalTables::GetIntConstTable().GetOrCreateIntConst(pad4b, *u32Ty);
+    funcProfDescMirConst->AddItem(pad4bMirConst, 5);
+
+    MIRAggConst *ctrDescMirConst = modMP->New<MIRAggConst>(mod, *ctrDescTy);
+
+    MIRIntConst *nCtrMirConst = GlobalTables::GetIntConstTable().GetOrCreateIntConst(nCtrs, *u32Ty);
+    ctrDescMirConst->AddItem(nCtrMirConst, 1);
+    MIRAddrofConst *ctrTblMirConst =
+        modMP->New<MIRAddrofConst>(ctrTblSym->GetStIdx(), 0, *GlobalTables::GetTypeTable().GetPtr());
+    ctrDescMirConst->AddItem(ctrTblMirConst, 2);
+    MIRType *arrOfCtrDescTy =
+        GlobalTables::GetTypeTable().GetOrCreateArrayType(*ctrDescTy, kMplFuncProfCtrInfoNum);
+    MIRAggConst *arrOfCtrDescMirConst = modMP->New<MIRAggConst>(mod, *arrOfCtrDescTy);
+
+    // if kMplFuncProfCtrInfoNum > 1, more counter descriptors need to add
+    arrOfCtrDescMirConst->AddItem(ctrDescMirConst, 0);
+    funcProfDescMirConst->AddItem(arrOfCtrDescMirConst, 6);
+
+    MIRSymbol *funcProfDescSym = mod.GetMIRBuilder()->CreateGlobalDecl(
+        namemangler::kprefixProfFuncDesc + flatenName(mod.GetFileName() + "_" + f->GetName()), *funcProfDescTy, kScFstatic);
+    funcProfDescSym->SetKonst(funcProfDescMirConst);
+    funcProfDescs.push_back(funcProfDescSym);
+  }
+}
+
+void ProfileGen::CreateFuncProfDescTbl() {
+  uint tblSize = validFuncs.size();
+
+  if (tblSize == 0) {
+    funcProfDescTbl = nullptr;
+    return;
+  }
+
+  // Create function descriptor table
+  MIRType *funcProfDescPtrTy = GlobalTables::GetTypeTable().GetOrCreatePointerType(funcProfDescs[0]->GetTyIdx());
+  MIRType *arrOffuncProfDescPtrTy = GlobalTables::GetTypeTable().GetOrCreateArrayType(*funcProfDescPtrTy, tblSize);
+  std::string fileName = mod.GetFileName();
+  MIRSymbol *funcProfDescTblSym = mod.GetMIRBuilder()->CreateGlobalDecl(
+      namemangler::kprefixProfFuncDescTbl + flatenName(fileName), *arrOffuncProfDescPtrTy, kScFstatic);
+  MIRAggConst *funcDescTblMirConst = mod.GetMemPool()->New<MIRAggConst>(mod, *arrOffuncProfDescPtrTy);
+
+  for (auto i = 0; i < tblSize; i++) {
+    MIRAddrofConst *funcProfDescMirConst = mod.GetMemPool()->New<MIRAddrofConst>(
+        funcProfDescs[i]->GetStIdx(), 0, *GlobalTables::GetTypeTable().GetPtr());
+    funcDescTblMirConst->AddItem(funcProfDescMirConst, i);
+  }
+
+  funcProfDescTblSym->SetKonst(funcDescTblMirConst);
+  funcProfDescTbl = funcProfDescTblSym;
+}
+
+void ProfileGen::FixupDesc() {
+  MIRAggConst *modProfDescMirConst = static_cast<MIRAggConst *>(modProfDesc->GetKonst());
+  MIRAddrofConst *funcProfDescTblAddr = mod.GetMemPool()->New<MIRAddrofConst>(
+      funcProfDescTbl->GetStIdx(), 0, *GlobalTables::GetTypeTable().GetPtr());
+  modProfDescMirConst->SetItem(9, funcProfDescTblAddr, 10);
+}
+
+// Ref: void gcov_init (struct gcov_info *info);
+void ProfileGen::CreateInitProc() {
+  MIRBuilder *mirBuilder = mod.GetMIRBuilder();
+  MIRFunction *origFunc = mirBuilder->GetCurrentFunction();
+
+  MIRType *voidTy = GlobalTables::GetTypeTable().GetVoid();;
+  ArgVector formals(mod.GetMPAllocator().Adapter());
+  MIRFunction *mplProfInit = mirBuilder->CreateFunction(
+      namemangler::kprefixProfInit + flatenName(mod.GetFileName()), *voidTy, formals);
+  mplProfInit->SetPuidxOrigin(mplProfInit->GetPuidx());
+  mplProfInit->SetAttr(FUNCATTR_initialization);
+  mirBuilder->SetCurrentFunction(*mplProfInit);
+
+  MIRFunction *gccProfInitProtoTy = mirBuilder->GetOrCreateFunction(
+      namemangler::kGCCProfInit, voidTy->GetTypeIndex());
+  gccProfInitProtoTy->AllocSymTab();
+  MIRSymbol *gccProfInitArgSym = gccProfInitProtoTy->GetSymTab()->CreateSymbol(kScopeLocal);
+  MIRType *argPtrTy = GlobalTables::GetTypeTable().GetOrCreatePointerType(modProfDesc->GetTyIdx());
+  gccProfInitArgSym->SetTyIdx(argPtrTy->GetTypeIndex());
+  gccProfInitProtoTy->AddArgument(gccProfInitArgSym);
+
+  MapleVector<BaseNode*> ActArg(mirBuilder->GetCurrentFuncCodeMpAllocator()->Adapter());
+  AddrofNode *addrModProfDesc = mirBuilder->CreateExprAddrof(0, *modProfDesc);
+  ActArg.push_back(addrModProfDesc);
+  CallNode *callGInit = mirBuilder->CreateStmtCall(gccProfInitProtoTy->GetPuidx(), ActArg);
+
+  BlockNode *block =mplProfInit->GetCodeMemPool()->New<BlockNode>();;
+  block->AddStatement(callGInit);
+  mplProfInit->SetBody(block);
+  mod.AddFunction(mplProfInit);
+
+  mirBuilder->SetCurrentFunction(*origFunc);
+}
+
+// Ref: void gcov_exit ();
+void ProfileGen::CreateExitProc() {
+  MIRBuilder *mirBuilder = mod.GetMIRBuilder();
+  MIRFunction *origFunc = mirBuilder->GetCurrentFunction();
+  MIRType *voidTy = GlobalTables::GetTypeTable().GetVoid();
+
+  ArgVector formals(mod.GetMPAllocator().Adapter());
+  MIRFunction *mplProfExit = mirBuilder->CreateFunction(
+      namemangler::kprefixProfExit + flatenName(mod.GetFileName()), *voidTy, formals);
+  mplProfExit->SetPuidxOrigin(mplProfExit->GetPuidx());
+  mplProfExit->SetAttr(FUNCATTR_termination);
+  mirBuilder->SetCurrentFunction(*mplProfExit);
+
+  MIRFunction *gccProfExitProtoTy = mirBuilder->GetOrCreateFunction(namemangler::kGCCProfExit, voidTy->GetTypeIndex());
+  gccProfExitProtoTy->AllocSymTab();
+
+  MapleVector<BaseNode*> ActArg(mirBuilder->GetCurrentFuncCodeMpAllocator()->Adapter());
+  CallNode *callGExit = mirBuilder->CreateStmtCall(gccProfExitProtoTy->GetPuidx(), ActArg);
+
+  BlockNode *block = mplProfExit->GetCodeMemPool()->New<BlockNode>();;
+  block->AddStatement(callGExit);
+  mplProfExit->SetBody(block);
+  mod.AddFunction(mplProfExit);
+
+  mirBuilder->SetCurrentFunction(*origFunc);
+}
+
+void ProfileGen::Run() {
+  // Note: all internal symbols are named as prefix+mplfilename (+ funcname)
+
+  // Create module profile descriptor (.LPBX0)
+  CreateModProfDesc();
+
+  // Create function profile descriptor including counter table
+  CreateFuncProfDesc();
+
+  // Create function profile descriptor table (.LPBX1)
+  CreateFuncProfDescTbl();
+
+  // Fixup symbol references among descriptors
+  FixupDesc();
+
+  // Create module profile init proc (_sub_I_00100_0)
+  CreateInitProc();
+
+  // Create module profiling exit proc (_sub_D_00100_1)
+  CreateExitProc();
+}
+
+bool ProfileGenPM::PhaseRun(MIRModule &mod) {
+  ProfileGen profileGen(mod);
+  profileGen.Run();
+  return false;
+}
+
+void ProfileGenPM::GetAnalysisDependence(maple::AnalysisDep &aDep) const {
+  // Note: IpaSccPM calls MeProfGen to finish instrumentation based on MST
+  aDep.AddRequired<IpaSccPM>();
+  aDep.AddPreserved<IpaSccPM>();
+}
+}
diff --git a/src/mapleall/mpl2mpl/src/module_phase_manager.cpp b/src/mapleall/mpl2mpl/src/module_phase_manager.cpp
index 815517a891df971b6d7238d0b61861aca0267867..2c5c0b3d610706308de6fb6de98389dd382db2fa 100644
--- a/src/mapleall/mpl2mpl/src/module_phase_manager.cpp
+++ b/src/mapleall/mpl2mpl/src/module_phase_manager.cpp
@@ -106,6 +106,7 @@ MAPLE_ANALYSIS_PHASE_REGISTER(M2MIpaClone, ipaclone)
 MAPLE_ANALYSIS_PHASE_REGISTER(M2MCallGraph, callgraph)
 MAPLE_ANALYSIS_PHASE_REGISTER(M2MKlassHierarchy, classhierarchy)
 MAPLE_ANALYSIS_PHASE_REGISTER(M2MAnnotationAnalysis, annotationanalysis)
+MAPLE_ANALYSIS_PHASE_REGISTER(ProfileGenPM, ProfileGenPM)
 
 MAPLE_TRANSFORM_PHASE_REGISTER(M2MInline, inline)
 MAPLE_TRANSFORM_PHASE_REGISTER(M2MIPODevirtualize, ipodevirtulize)