diff --git a/src/mapleall/bin/dex2mpl b/src/mapleall/bin/dex2mpl index 7b2d016b6fb6db943e3be17454c50a59c5a0e357..b1166de284b11cd90f8437f5270d9851174e7134 100755 Binary files a/src/mapleall/bin/dex2mpl and b/src/mapleall/bin/dex2mpl differ diff --git a/src/mapleall/bin/jbc2mpl b/src/mapleall/bin/jbc2mpl index d7eaa122f703dcce085d9033c36d2016ea44c743..f4b667eddf19b55158bf2c8690d3d79de3ce44c6 100755 Binary files a/src/mapleall/bin/jbc2mpl and b/src/mapleall/bin/jbc2mpl differ diff --git a/src/mapleall/maple_be/include/cg/cg.h b/src/mapleall/maple_be/include/cg/cg.h index 93e951a61314bb77d487eeb1d1f5e29c4c0980be..350aa00bd5815a57f41ec2f5632fd04fa10d06fe 100644 --- a/src/mapleall/maple_be/include/cg/cg.h +++ b/src/mapleall/maple_be/include/cg/cg.h @@ -311,6 +311,10 @@ class CG { return cgOption; } + void UpdateCGOptions(const CGOptions &newOption) { + cgOption.SetOptionFlag(newOption.GetOptionFlag()); + } + bool IsLibcore() const { return isLibcore; } diff --git a/src/mapleall/maple_be/include/cg/cg_option.h b/src/mapleall/maple_be/include/cg/cg_option.h index 7343a72ed6adc0b749dac380d21035832b7c65d1..f5b6244bfb5335b0a9511b87c6f7c1c65f72a4e1 100644 --- a/src/mapleall/maple_be/include/cg/cg_option.h +++ b/src/mapleall/maple_be/include/cg/cg_option.h @@ -1017,6 +1017,14 @@ class CGOptions : public MapleDriverOptionBase { return gcOnly; } + const OptionFlag &GetOptionFlag() const { + return options; + } + + void SetOptionFlag(const OptionFlag &flag) { + options = flag; + } + private: std::vector phaseSequence; diff --git a/src/mapleall/maple_driver/include/driver_option_common.h b/src/mapleall/maple_driver/include/driver_option_common.h index b2cd14dae7a3d3aa2f0bc1884db37950eba04fe1..510df0f1ec34d96dc5bd6fd1c7c2363d5b248fba 100644 --- a/src/mapleall/maple_driver/include/driver_option_common.h +++ b/src/mapleall/maple_driver/include/driver_option_common.h @@ -49,6 +49,7 @@ enum DriverOptionIndex { kVerbose, kAllDebug, kHelpLevel, + kPartO2, kCommonOptionEnd, }; diff --git a/src/mapleall/maple_driver/include/driver_runner.h b/src/mapleall/maple_driver/include/driver_runner.h index 6643748655572742a503d7fc5a02a2b90f98a16e..745b5cd5a783c4e42c14851bc0d52bd2846019fa 100644 --- a/src/mapleall/maple_driver/include/driver_runner.h +++ b/src/mapleall/maple_driver/include/driver_runner.h @@ -94,7 +94,9 @@ class DriverRunner final { std::string cgInput; BECommon *beCommon = nullptr; CG *CreateCGAndBeCommon(const std::string &outputFile, const std::string &oriBasename); - void RunCGFunctions(CG &cg, CgFuncPhaseManager &cgfpm, std::vector &extraPhasesTime, + void RunCGFunctions(CG &cg, CgFuncPhaseManager &cgNormalfpm, + CgFuncPhaseManager &cgO0fpm, + std::vector &extraPhasesTime, std::vector &extraPhasesName) const; void EmitGlobalInfo(CG &cg) const; void EmitDuplicatedAsmFunc(const CG &cg) const; diff --git a/src/mapleall/maple_driver/include/mpl_options.h b/src/mapleall/maple_driver/include/mpl_options.h index 24d6045902f16e451c25ec1a13540f48ff9dfe35..4a1755e2cf0649c99cb6260d7bf2c3e142537691 100644 --- a/src/mapleall/maple_driver/include/mpl_options.h +++ b/src/mapleall/maple_driver/include/mpl_options.h @@ -135,6 +135,10 @@ class MplOptions { return mpltFile; } + const std::string &GetPartO2List() const { + return partO2List; + } + const RunMode &GetRunMode() const { return runMode; } @@ -235,6 +239,7 @@ class MplOptions { bool genVtableImpl = false; bool hasPrinted = false; unsigned int helpLevel = mapleOption::kBuildTypeDefault; + std::string partO2List = ""; }; } // namespace maple #endif // MAPLE_DRIVER_INCLUDE_MPL_OPTIONS_H diff --git a/src/mapleall/maple_driver/src/driver_option_common.cpp b/src/mapleall/maple_driver/src/driver_option_common.cpp index 87c89867c90cae16628386fef0646e1283bf0b35..70310bf919056b1282a9966e32232bb906b5596f 100644 --- a/src/mapleall/maple_driver/src/driver_option_common.cpp +++ b/src/mapleall/maple_driver/src/driver_option_common.cpp @@ -91,6 +91,15 @@ const mapleOption::Descriptor usages[] = { " -O2 \tDo more optimization. (Default)\n", "all", {} }, + { kPartO2, + 0, + "", + "partO2", + kBuildTypeProduct, + kArgCheckPolicyNone, + " --partO2 \tSet func list for O2\n", + "all", + {} }, { kGCOnly, kEnable, "", diff --git a/src/mapleall/maple_driver/src/driver_runner.cpp b/src/mapleall/maple_driver/src/driver_runner.cpp index e37bebdea3415040ffd1f660bf0399d9edeb008c..4cb8b5f02c69751fb793b564742059a9eefe3d8b 100644 --- a/src/mapleall/maple_driver/src/driver_runner.cpp +++ b/src/mapleall/maple_driver/src/driver_runner.cpp @@ -327,8 +327,18 @@ void DriverRunner::ProcessCGPhase(const std::string &outputFile, const std::stri cg->GetEmitter()->EmitFileInfo(actualInput); } // Run the cg optimizations phases - RunCGFunctions(*cg, cgfpm, extraPhasesTime, extraPhasesName); - + if (theModule->HasPartO2List()) { + CHECK_FATAL(cgOptions->GetOptimizeLevel() == CGOptions::kLevel2, "partO2 need coroperate with O2"); + CgFuncPhaseManager cgO0fpm(*optMp, *theModule); + cgO0fpm.RegisterFuncPhases(); + cgO0fpm.SetCGPhase(kCgPhaseMainOpt); + cgOptions->EnableO0(); + std::vector phases; + cgO0fpm.AddPhases(phases); + RunCGFunctions(*cg, cgfpm, cgO0fpm, extraPhasesTime, extraPhasesName); + } else { + RunCGFunctions(*cg, cgfpm, cgfpm, extraPhasesTime, extraPhasesName); + } // Emit global info timeStart = std::chrono::system_clock::now(); EmitGlobalInfo(*cg); @@ -386,7 +396,8 @@ CG *DriverRunner::CreateCGAndBeCommon(const std::string &outputFile, const std:: } -void DriverRunner::RunCGFunctions(CG &cg, CgFuncPhaseManager &cgfpm, std::vector &extraPhasesTime, +void DriverRunner::RunCGFunctions(CG &cg, CgFuncPhaseManager &cgNormalfpm, CgFuncPhaseManager &cgO0fpm, + std::vector &extraPhasesTime, std::vector &extraPhasesName) const { MPLTimer timer; long lowerTime = 0; @@ -404,7 +415,7 @@ void DriverRunner::RunCGFunctions(CG &cg, CgFuncPhaseManager &cgfpm, std::vector timer.Stop(); lowerTime += timer.ElapsedMicroseconds(); - if (cg.AddStackGuard()) { + if (cg.AddStackGuard() || theModule->HasPartO2List()) { cg.AddStackGuardvar(); } @@ -416,7 +427,20 @@ void DriverRunner::RunCGFunctions(CG &cg, CgFuncPhaseManager &cgfpm, std::vector if (mirFunc->GetBody() == nullptr) { continue; } - + CgFuncPhaseManager *cgfpm = nullptr; + if (&cgNormalfpm == &cgO0fpm) { + cgfpm = &cgNormalfpm; + } else { + if (theModule->HasPartO2List() && theModule->IsInPartO2List(mirFunc->GetNameStrIdx())) { + cgfpm = &cgNormalfpm; + cgOptions->EnableO2(); + } else { + cgfpm = &cgO0fpm; + cgOptions->EnableO0(); + } + cg.UpdateCGOptions(*cgOptions); + Globals::GetInstance()->SetOptimLevel(cgOptions->GetOptimizeLevel()); + } // LowerIR. theModule->SetCurFunction(mirFunc); timer.Start(); @@ -453,15 +477,15 @@ void DriverRunner::RunCGFunctions(CG &cg, CgFuncPhaseManager &cgfpm, std::vector CHECK_FATAL(cgFunc != nullptr, "nullptr check"); CG::SetCurCGFunc(*cgFunc); - cgfpm.Run(*cgFunc); + cgfpm->Run(*cgFunc); cg.GetEmitter()->EmitLocalVariable(*cgFunc); // Invalid all analysis result. - cgfpm.Emit(*cgFunc); + cgfpm->Emit(*cgFunc); cg.GetEmitter()->EmitHugeSoRoutines(); - cgfpm.GetAnalysisResultManager()->InvalidIRbaseAnalysisResult(*cgFunc); - cgfpm.ClearPhaseNameInfo(); + cgfpm->GetAnalysisResultManager()->InvalidIRbaseAnalysisResult(*cgFunc); + cgfpm->ClearPhaseNameInfo(); // Delete mempool. mirFunc->ReleaseCodeMemory(); diff --git a/src/mapleall/maple_driver/src/maple_comb_compiler.cpp b/src/mapleall/maple_driver/src/maple_comb_compiler.cpp index 21811a18e48b705bac15b39e875b55f5f054a79e..489af3353dd772c925ae7f3ed525d7734ec9432b 100644 --- a/src/mapleall/maple_driver/src/maple_comb_compiler.cpp +++ b/src/mapleall/maple_driver/src/maple_comb_compiler.cpp @@ -173,7 +173,7 @@ ErrorCode MapleCombCompiler::Compile(MplOptions &options, std::unique_ptrInitPartO2List(options.GetPartO2List()); DriverRunner runner(theModule.get(), options.GetSelectedExes(), options.GetInputFileType(), fileName, fileName, fileName, optMp, fileParsed, options.HasSetTimePhases(), options.HasSetGenVtableImpl(), options.HasSetGenMeMpl()); diff --git a/src/mapleall/maple_driver/src/mpl_options.cpp b/src/mapleall/maple_driver/src/mpl_options.cpp index 1473f195aa71dc877bd9a11cbf3acc529407059c..bdd3fecaade764c9e383345cdee00993aca8e0c5 100644 --- a/src/mapleall/maple_driver/src/mpl_options.cpp +++ b/src/mapleall/maple_driver/src/mpl_options.cpp @@ -153,6 +153,9 @@ ErrorCode MplOptions::HandleGeneralOptions() { case kAllDebug: debugFlag = true; break; + case kPartO2: + partO2List = opt.Args(); + break; default: // I do not care break; diff --git a/src/mapleall/maple_ipa/src/interleaved_manager.cpp b/src/mapleall/maple_ipa/src/interleaved_manager.cpp index 83b564aa1bb440f12c9c0a3abb333cd7d506e21a..ddae053802c3d041784ab6fdb15aa98bb548c89c 100644 --- a/src/mapleall/maple_ipa/src/interleaved_manager.cpp +++ b/src/mapleall/maple_ipa/src/interleaved_manager.cpp @@ -189,6 +189,10 @@ void InterleavedManager::OptimizeFuncs(MeFuncPhaseManager &fpm, MapleVectorGetNameStrIdx())) { + continue; + } // skip empty func, and skip the func out of range if `useRange` is true if (func->GetBody() == nullptr || (MeOption::useRange && (i < MeOption::range[0] || i > MeOption::range[1]))) { continue; @@ -210,6 +214,10 @@ void InterleavedManager::OptimizeFuncsParallel(const MeFuncPhaseManager &fpm, Ma for (size_t i = 0; i < compList.size(); ++i) { MIRFunction *func = compList[i]; ASSERT_NOT_NULL(func); + // when partO2 is set, skip func which not exists in partO2FuncList. + if (mirModule.HasPartO2List() && !mirModule.IsInPartO2List(func->GetNameStrIdx())) { + continue; + } // skip empty func, and skip the func out of range if `useRange` is true if (func->GetBody() == nullptr || (MeOption::useRange && (i < MeOption::range[0] || i > MeOption::range[1]))) { continue; diff --git a/src/mapleall/maple_ir/include/mir_module.h b/src/mapleall/maple_ir/include/mir_module.h index a31cb0e52cb9dd738824bd9c4d498575baa7ae4a..68ceff7c5969ec82260c4d05c33a031ba45f7e43 100644 --- a/src/mapleall/maple_ir/include/mir_module.h +++ b/src/mapleall/maple_ir/include/mir_module.h @@ -555,13 +555,28 @@ class MIRModule { DebugInfo *GetDbgInfo() { return dbgInfo; } + void SetWithDbgInfo(bool v) { withDbgInfo = v; } + bool IsWithDbgInfo() const { return withDbgInfo; } + bool HasPartO2List() { + return hasPartO2List; + } + + void SetHasPartO2List(bool value) { + hasPartO2List = value; + } + + void InitPartO2List(const std::string &list); + bool IsInPartO2List(GStrIdx idx) { + return partO2FuncList.count(idx) > 0; + } + private: void DumpTypeTreeToCxxHeaderFile(MIRType &ty, std::unordered_set &dumpedClasses) const; @@ -643,6 +658,8 @@ class MIRModule { mutable std::shared_timed_mutex fieldMapMutex; std::map, GStrIdx> realCaller; MapleSet inliningGlobals; // global symbols accessed, used for inlining + bool hasPartO2List = false; + MapleSet partO2FuncList; }; #endif // MIR_FEATURE_FULL } // namespace maple diff --git a/src/mapleall/maple_ir/src/mir_module.cpp b/src/mapleall/maple_ir/src/mir_module.cpp index 858eb2743cd0188d6a07d8e005b44ac72d4b4855..e401c5de06cb87f9d6cf29e61736e0283ff5dc48 100644 --- a/src/mapleall/maple_ir/src/mir_module.cpp +++ b/src/mapleall/maple_ir/src/mir_module.cpp @@ -52,7 +52,8 @@ MIRModule::MIRModule(const std::string &fn) classList(memPoolAllocator.Adapter()), optimizedFuncs(memPoolAllocator.Adapter()), puIdxFieldInitializedMap(std::less(), memPoolAllocator.Adapter()), - inliningGlobals(memPoolAllocator.Adapter()) { + inliningGlobals(memPoolAllocator.Adapter()), + partO2FuncList(memPoolAllocator.Adapter()) { GlobalTables::GetGsymTable().SetModule(this); typeNameTab = memPool->New(memPoolAllocator); mirBuilder = memPool->New(this); @@ -712,4 +713,27 @@ void MIRModule::ReleaseCurFuncMemPoolTmp() { void MIRModule::SetFuncInfoPrinted() const { CurFunction()->SetInfoPrinted(); } + +void MIRModule::InitPartO2List(const std::string &list) { + if (list.empty()) { + return; + } + SetHasPartO2List(true); + std::ifstream infile(list); + if (!infile.is_open()) { + LogInfo::MapleLogger(kLlErr) << "Cannot open partO2 function list file " << list << '\n'; + return; + } + std::string str; + + while (getline(infile, str)) { + if (str.empty()) { + continue; + } + GStrIdx funcStrIdx = GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(str); + partO2FuncList.insert(funcStrIdx); + } + infile.close(); +} + } // namespace maple diff --git a/src/mplfe/ast_input/include/ast_decl.h b/src/mplfe/ast_input/include/ast_decl.h index a9060504744d73a9706add5779d34720537ea87d..a3225a215fc043a9c770d3133983de99d3bb6eaa 100644 --- a/src/mplfe/ast_input/include/ast_decl.h +++ b/src/mplfe/ast_input/include/ast_decl.h @@ -24,6 +24,16 @@ namespace maple { using Pos = std::pair; +enum DeclKind { + kUnknownDecl = 0, + kASTDecl, + kASTField, + kASTFunc, + kASTStruct, + kASTVar, + kASTLocalEnumDecl, +}; + class ASTDecl { public: ASTDecl(const std::string &srcFile, const std::string &nameIn, const std::vector &typeDescIn) @@ -60,6 +70,10 @@ class ASTDecl { pos = p; } + DeclKind GetDeclKind() const { + return declKind; + } + MIRConst *Translate2MIRConst() const; std::string GenerateUniqueVarName(); @@ -77,16 +91,24 @@ class ASTDecl { std::vector typeDesc; GenericAttrs genAttrs; Pos pos = { 0, 0 }; + DeclKind declKind = kASTDecl; }; class ASTField : public ASTDecl { public: ASTField(const std::string &srcFile, const std::string &nameIn, const std::vector &typeDescIn, - const GenericAttrs &genAttrsIn) - : ASTDecl(srcFile, nameIn, typeDescIn) { + const GenericAttrs &genAttrsIn, bool isAnonymous = false) + : ASTDecl(srcFile, nameIn, typeDescIn), isAnonymousField(isAnonymous) { genAttrs = genAttrsIn; + declKind = kASTField; } ~ASTField() = default; + bool IsAnonymousField() const { + return isAnonymousField; + } + + private: + bool isAnonymousField = false; }; class ASTFunc : public ASTDecl { @@ -95,6 +117,7 @@ class ASTFunc : public ASTDecl { const GenericAttrs &genAttrsIn, const std::vector &parmNamesIn) : ASTDecl(srcFile, nameIn, typeDescIn), compound(nullptr), parmNames(parmNamesIn) { genAttrs = genAttrsIn; + declKind = kASTFunc; } ~ASTFunc() { compound = nullptr; @@ -119,6 +142,7 @@ class ASTStruct : public ASTDecl { const GenericAttrs &genAttrsIn) : ASTDecl(srcFile, nameIn, typeDescIn), isUnion(false) { genAttrs = genAttrsIn; + declKind = kASTStruct; } ~ASTStruct() = default; @@ -152,6 +176,7 @@ class ASTVar : public ASTDecl { const GenericAttrs &genAttrsIn) : ASTDecl(srcFile, nameIn, typeDescIn) { genAttrs = genAttrsIn; + declKind = kASTVar; } virtual ~ASTVar() = default; @@ -178,6 +203,7 @@ class ASTLocalEnumDecl : public ASTDecl { const GenericAttrs &genAttrsIn) : ASTDecl(srcFile, nameIn, typeDescIn) { genAttrs = genAttrsIn; + declKind = kASTLocalEnumDecl; } ~ASTLocalEnumDecl() = default; diff --git a/src/mplfe/ast_input/include/ast_decl_builder.h b/src/mplfe/ast_input/include/ast_decl_builder.h index f9bcc02123df2f03eb1b785fd080b337c7fc7e46..39e49afa15b17d339ba6e15ab8f7df908427310c 100644 --- a/src/mplfe/ast_input/include/ast_decl_builder.h +++ b/src/mplfe/ast_input/include/ast_decl_builder.h @@ -47,8 +47,14 @@ class ASTDeclsBuilder { } static ASTLocalEnumDecl *ASTLocalEnumDeclBuilder(MapleAllocator &allocator, const std::string &srcFile, - const std::string &varName, const std::vector &desc, const GenericAttrs &genAttrsIn) { - return allocator.GetMemPool()->New(srcFile, varName, desc, genAttrsIn); + const std::string &varName, const std::vector &desc, const GenericAttrs &genAttrsIn, + int64 id = INT64_MAX) { + if (id == INT64_MAX) { + return allocator.GetMemPool()->New(srcFile, varName, desc, genAttrsIn); + } else if (declesTable[id] == nullptr) { + declesTable[id] = allocator.GetMemPool()->New(srcFile, varName, desc, genAttrsIn); + } + return static_cast(declesTable[id]); } static ASTFunc *ASTFuncBuilder(MapleAllocator &allocator, const std::string &srcFile, const std::string &nameIn, @@ -83,8 +89,14 @@ class ASTDeclsBuilder { } static ASTField *ASTFieldBuilder(MapleAllocator &allocator, const std::string &srcFile, const std::string &varName, - const std::vector &desc, const GenericAttrs &genAttrsIn) { - return allocator.GetMemPool()->New(srcFile, varName, desc, genAttrsIn); + const std::vector &desc, const GenericAttrs &genAttrsIn, int64 id = INT64_MAX, + bool isAnonymous = false) { + if (id == INT64_MAX) { + allocator.GetMemPool()->New(srcFile, varName, desc, genAttrsIn, isAnonymous); + } else if (declesTable[id] == nullptr) { + declesTable[id] = allocator.GetMemPool()->New(srcFile, varName, desc, genAttrsIn, isAnonymous); + } + return static_cast(declesTable[id]); } }; } // namespace maple diff --git a/src/mplfe/ast_input/include/ast_expr.h b/src/mplfe/ast_input/include/ast_expr.h index ca27a77453cf1a1d979c6863f73efb33b266ad38..31357eac3dfbbc2cf9ca61eca9fa197d396b2b65 100644 --- a/src/mplfe/ast_input/include/ast_expr.h +++ b/src/mplfe/ast_input/include/ast_expr.h @@ -33,6 +33,12 @@ struct ASTValue { MIRConst *Translate2MIRConst() const; }; +enum ParentFlag { + kNoParent, + kArrayParent, + kStructParent +}; + class ASTExpr { public: explicit ASTExpr(ASTOp o) : op(o) {} @@ -73,6 +79,19 @@ class ASTExpr { return GenerateMIRConstImpl(); } + void SetSrcLOC(uint32 fileIdx, uint32 lineNum) { + srcFileIdx = fileIdx; + srcFileLineNum = lineNum; + } + + uint32 GetSrcFileIdx() const { + return srcFileIdx; + } + + uint32 GetSrcFileLineNum() const { + return srcFileLineNum; + } + protected: virtual ASTValue *GetConstantValueImpl() const { return value; @@ -84,6 +103,9 @@ class ASTExpr { ASTDecl *refedDecl = nullptr; bool isConstantFolded = false; ASTValue *value = nullptr; + + uint32 srcFileIdx = 0; + uint32 srcFileLineNum = 0; }; class ASTImplicitCastExpr : public ASTExpr { @@ -410,7 +432,7 @@ class ASTOffsetOfExpr : public ASTExpr { ASTOffsetOfExpr() : ASTExpr(kASTOpOffsetOfExpr) {} ~ASTOffsetOfExpr() = default; void SetStructType(MIRType *stype); - void SetFieldName(std::string); + void SetFieldName(std::string fName); void SetOffset(size_t val) { offset = val; @@ -438,16 +460,33 @@ class ASTInitListExpr : public ASTExpr { varName = argVarName; } + void SetParentFlag(ParentFlag argParentFlag) { + parentFlag = argParentFlag; + } + + void SetIsUnionInitListExpr(bool flag) { + isUnionInitListExpr = flag; + } + + bool IsUnionInitListExpr() const { + return isUnionInitListExpr; + } + private: MIRConst *GenerateMIRConstImpl() const override; UniqueFEIRExpr Emit2FEExprImpl(std::list &stmts) const override; + void Emit2FEExprForStruct4ArrayElemIsStruct(uint32 i, std::list &stmts) const; void Emit2FEExprForArray(std::list &stmts) const; + void Emit2FEExprForArrayForNest(UniqueFEIRType typeNative, UniqueFEIRExpr arrayExpr, + std::list &stmts) const; void Emit2FEExprForStruct(std::list &stmts) const; MIRConst *GenerateMIRConstForArray() const; MIRConst *GenerateMIRConstForStruct() const; std::vector fillers; MIRType *initListType; std::string varName; + ParentFlag parentFlag = kNoParent; + bool isUnionInitListExpr = false; }; class ASTBinaryConditionalOperator : public ASTExpr { @@ -466,7 +505,7 @@ class ASTBinaryConditionalOperator : public ASTExpr { class ASTBinaryOperatorExpr : public ASTExpr { public: explicit ASTBinaryOperatorExpr(ASTOp o) : ASTExpr(o) {} - ASTBinaryOperatorExpr() : ASTExpr(kASTOpBO) {} + ASTBinaryOperatorExpr() : ASTExpr(kASTOpBO), varName(FEUtils::GetSequentialName("shortCircuit_")) {} ~ASTBinaryOperatorExpr() override = default; @@ -514,6 +553,10 @@ class ASTBinaryOperatorExpr : public ASTExpr { rightImagExpr = expr; } + void SetCvtNeeded(bool needed) { + cvtNeeded = needed; + } + protected: UniqueFEIRExpr Emit2FEExprImpl(std::list &stmts) const override; @@ -526,6 +569,8 @@ class ASTBinaryOperatorExpr : public ASTExpr { ASTExpr *leftImagExpr = nullptr; ASTExpr *rightRealExpr = nullptr; ASTExpr *rightImagExpr = nullptr; + bool cvtNeeded = false; + std::string varName; }; class ASTImplicitValueInitExpr : public ASTExpr { @@ -609,6 +654,14 @@ class ASTArraySubscriptExpr : public ASTExpr { return memberExpr; } + std::string GetBaseExprVarName() const { + return baseExprVarName; + } + + void SetBaseExprVarName(std::string argBaseExprVarName) { + baseExprVarName = argBaseExprVarName; + } + void SetAddrOfFlag(bool flag) { isAddrOf = flag; } @@ -619,6 +672,7 @@ class ASTArraySubscriptExpr : public ASTExpr { ASTExpr *memberExpr = nullptr; std::vector idxExprs; bool isAddrOf = false; + std::string baseExprVarName; }; class ASTExprUnaryExprOrTypeTraitExpr : public ASTExpr { @@ -690,9 +744,12 @@ class ASTMemberExpr : public ASTExpr { return isArrow; } + ASTMemberExpr *findFinalMember(ASTMemberExpr *startExpr, std::list &memberNames) const; + private: UniqueFEIRExpr Emit2FEExprImpl(std::list &stmts) const override; - ASTMemberExpr *findFinalMember(ASTMemberExpr *startExpr, std::list &memberNames) const; + void Emit2FEExprImplForArrayElemIsStruct(UniqueFEIRExpr baseFEExpr, std::string &tmpStructName, + std::list &stmts) const; ASTExpr *baseExpr; std::string memberName; MIRType *memberType; @@ -740,16 +797,21 @@ class ASTDesignatedInitUpdateExpr : public ASTExpr { class ASTAssignExpr : public ASTBinaryOperatorExpr { public: - ASTAssignExpr() : ASTBinaryOperatorExpr(kASTOpAssign) {} - ASTAssignExpr(ASTOp o) : ASTBinaryOperatorExpr(o) {} + ASTAssignExpr() : ASTBinaryOperatorExpr(kASTOpAssign), isCompoundAssign(false) {} ~ASTAssignExpr() override = default; + void SetIsCompoundAssign(bool argIsCompoundAssign) { + isCompoundAssign = argIsCompoundAssign; + } + protected: UniqueFEIRExpr ProcessAssign(std::list &stmts, UniqueFEIRExpr leftExpr, UniqueFEIRExpr rightExpr) const; - + void ProcessAssign4ExprArrayStoreForC(std::list &stmts, UniqueFEIRExpr leftFEExpr, + UniqueFEIRExpr rightFEExpr) const; private: UniqueFEIRExpr Emit2FEExprImpl(std::list &stmts) const override; + bool isCompoundAssign; }; class ASTBOComma : public ASTBinaryOperatorExpr { @@ -772,7 +834,7 @@ class ASTBOPtrMemExpr : public ASTBinaryOperatorExpr { class ASTCallExpr : public ASTExpr { public: - ASTCallExpr() : ASTExpr(kASTOpCall) {} + ASTCallExpr() : ASTExpr(kASTOpCall), varName(FEUtils::GetSequentialName("retVar_")) {} ~ASTCallExpr() = default; void SetCalleeExpr(ASTExpr *astExpr) { calleeExpr = astExpr; @@ -806,6 +868,14 @@ class ASTCallExpr : public ASTExpr { return funcName; } + void SetFuncAttrs(const FuncAttrs &attrs) { + funcAttrs = attrs; + } + + const FuncAttrs &GetFuncAttrs() const { + return funcAttrs; + } + void SetIcall(bool icall) { isIcall = icall; } @@ -828,7 +898,9 @@ class ASTCallExpr : public ASTExpr { ASTExpr *calleeExpr = nullptr; MIRType *retType = nullptr; std::string funcName; + FuncAttrs funcAttrs; bool isIcall = false; + std::string varName; }; class ASTParenExpr : public ASTExpr { @@ -953,20 +1025,6 @@ class ASTVAArgExpr : public ASTExpr { ASTExpr *child = nullptr; }; -class ASTCompoundAssignOperatorExpr : public ASTAssignExpr { - public: - ASTCompoundAssignOperatorExpr() : ASTAssignExpr(kASTOpCompoundAssign) {} - ~ASTCompoundAssignOperatorExpr() override = default; - - void SetOpForCompoundAssign(Opcode opcode){ - opForCompoundAssign = opcode; - } - - protected: - Opcode opForCompoundAssign; - UniqueFEIRExpr Emit2FEExprImpl(std::list &stmts) const override; -}; - class ASTConstantExpr : public ASTExpr { public: ASTConstantExpr() : ASTExpr(kConstantExpr) {} diff --git a/src/mplfe/ast_input/include/ast_parser.h b/src/mplfe/ast_input/include/ast_parser.h index 983617e47d80f31aae5e9696b62503dba930836d..5d167b6b5a1dce65195fa4895e05c1d16732b7f9 100644 --- a/src/mplfe/ast_input/include/ast_parser.h +++ b/src/mplfe/ast_input/include/ast_parser.h @@ -142,6 +142,7 @@ class ASTParser { ASTDecl *PROCESS_DECL(Enum); ASTDecl *PROCESS_DECL(Typedef); ASTDecl *PROCESS_DECL(EnumConstant); + ASTDecl *PROCESS_DECL(Label); private: ASTValue *TranslateRValue2ASTValue(MapleAllocator &allocator, const clang::Expr *expr) const; @@ -150,6 +151,8 @@ class ASTParser { ASTDecl *GetAstDeclOfDeclRefExpr(MapleAllocator &allocator, const clang::Expr &expr); void SetSourceFileInfo(clang::Decl *decl); uint32 GetSizeFromQualType(const clang::QualType qualType); + uint32_t GetAlignOfType(const clang::QualType currQualType, clang::UnaryExprOrTypeTrait exprKind); + uint32_t GetAlignOfExpr(const clang::Expr &expr, clang::UnaryExprOrTypeTrait exprKind); ASTExpr *ProcessExprBinaryOperatorComplex(MapleAllocator &allocator, const clang::BinaryOperator &bo); uint32 fileIdx; const std::string fileName; diff --git a/src/mplfe/ast_input/include/ast_stmt.h b/src/mplfe/ast_input/include/ast_stmt.h index bc52466432c38e7611a6ca53fac89f8672132ff6..aafa2180be340a68356842aa69d99a29fe980609 100644 --- a/src/mplfe/ast_input/include/ast_stmt.h +++ b/src/mplfe/ast_input/include/ast_stmt.h @@ -38,10 +38,26 @@ class ASTStmt { return exprs; } + void SetSrcLOC(uint32 fileIdx, uint32 lineNum) { + srcFileIdx = fileIdx; + srcFileLineNum = lineNum; + } + + uint32 GetSrcFileIdx() const { + return srcFileIdx; + } + + uint32 GetSrcFileLineNum() const { + return srcFileLineNum; + } + protected: virtual std::list Emit2FEStmtImpl() const = 0; ASTStmtOp op; std::vector exprs; + + uint32 srcFileIdx = 0; + uint32 srcFileLineNum = 0; }; class ASTCompoundStmt : public ASTStmt { @@ -463,7 +479,7 @@ class ASTCStyleCastExprStmt : public ASTStmt { class ASTCallExprStmt : public ASTStmt { public: - ASTCallExprStmt() : ASTStmt(kASTStmtCallExpr) {} + ASTCallExprStmt() : ASTStmt(kASTStmtCallExpr), varName(FEUtils::GetSequentialName("retVar_")) {} ~ASTCallExprStmt() override = default; private: @@ -476,6 +492,7 @@ class ASTCallExprStmt : public ASTStmt { std::list ProcessBuiltinVaEnd() const; static std::map funcPtrMap; + std::string varName; }; class ASTAtomicExprStmt : public ASTStmt { diff --git a/src/mplfe/ast_input/lib/ast_interface.cpp b/src/mplfe/ast_input/lib/ast_interface.cpp index 251ec9a58edd9a5ef1bfca8675c5f2fae45edbeb..fa5db60f079bd06e65385341d8b139dab162e35e 100644 --- a/src/mplfe/ast_input/lib/ast_interface.cpp +++ b/src/mplfe/ast_input/lib/ast_interface.cpp @@ -22,6 +22,9 @@ bool LibAstFile::Open(const std::string &fileName, int excludeDeclFromPCH, int displayDiagnostics) { CXIndex index = clang_createIndex(excludeDeclFromPCH, displayDiagnostics); CXTranslationUnit translationUnit = clang_createTranslationUnit(index, fileName.c_str()); + if (translationUnit == nullptr) { + return false; + } clang::ASTUnit *astUnit = translationUnit->TheASTUnit; if (astUnit == nullptr) { return false; @@ -69,12 +72,23 @@ std::string LibAstFile::GetMangledName(const clang::NamedDecl &decl) { return mangledName; } -Pos LibAstFile::GetDeclPosInfo(const clang::Decl &decl) { +Pos LibAstFile::GetDeclPosInfo(const clang::Decl &decl) const { clang::FullSourceLoc fullLocation = astContext->getFullLoc(decl.getBeginLoc()); return std::make_pair(static_cast(fullLocation.getSpellingLineNumber()), static_cast(fullLocation.getSpellingColumnNumber())); } +Pos LibAstFile::GetStmtLOC(const clang::Stmt &stmt) const { + return GetLOC(stmt.getBeginLoc()); +} + +Pos LibAstFile::GetLOC(const clang::SourceLocation &srcLoc) const { + clang::FullSourceLoc fullLocation = astContext->getFullLoc(srcLoc); + const auto *fileEntry = fullLocation.getFileEntry(); + return std::make_pair(static_cast(fileEntry == nullptr ? 0 : fullLocation.getFileEntry()->getUID()), + static_cast(fullLocation.getSpellingLineNumber())); +} + void LibAstFile::GetCVRAttrs(uint32_t qualifiers, GenericAttrs &genAttrs) { if (qualifiers & clang::Qualifiers::Const) { genAttrs.SetAttr(GENATTR_const); diff --git a/src/mplfe/ast_input/lib/ast_interface.h b/src/mplfe/ast_input/lib/ast_interface.h index ff8a4aeb1397432b8a7872cc04cf0b9f24451569..f37736f6d422523e4992a24de8a96b7de17997ea 100644 --- a/src/mplfe/ast_input/lib/ast_interface.h +++ b/src/mplfe/ast_input/lib/ast_interface.h @@ -75,7 +75,9 @@ class LibAstFile { return astContext; } - Pos GetDeclPosInfo(const clang::Decl &decl); + Pos GetDeclPosInfo(const clang::Decl &decl) const; + Pos GetStmtLOC(const clang::Stmt &stmt) const; + Pos GetLOC(const clang::SourceLocation &srcLoc) const; private: using RecordDeclMap = std::map; diff --git a/src/mplfe/ast_input/src/ast_decl.cpp b/src/mplfe/ast_input/src/ast_decl.cpp index eb6462fc5643068d1a18a0a63286f22434ff1ce7..22001e01d882039f72811ad03340523df007985f 100644 --- a/src/mplfe/ast_input/src/ast_decl.cpp +++ b/src/mplfe/ast_input/src/ast_decl.cpp @@ -60,11 +60,15 @@ MIRConst *ASTVar::Translate2MIRConstImpl() const { } void ASTVar::GenerateInitStmtImpl(std::list &stmts) { - if (GetInitExpr() == nullptr) { + if (genAttrs.GetAttr(GenericAttrKind::GENATTR_static)) { + return; + } + ASTExpr *initExpr = GetInitExpr(); + if (initExpr == nullptr) { return; } UniqueFEIRVar feirVar = Translate2FEIRVar(); - UniqueFEIRExpr expr = GetInitExpr()->Emit2FEExpr(stmts); + UniqueFEIRExpr expr = initExpr->Emit2FEExpr(stmts); if (expr == nullptr) { return; } @@ -102,8 +106,18 @@ std::vector> ASTFunc::GenArgVarList() const { std::list ASTFunc::EmitASTStmtToFEIR() const { std::list stmts; + // fix int main() no return stmt. there are multiple branches, insert return at the end. + bool needRet = false; + UniqueFEIRExpr feExpr = std::make_unique(static_cast(0), PTY_i32); + UniqueFEIRStmt retStmt = std::make_unique(std::move(feExpr)); + if (name == "main" && typeDesc[1]->GetPrimType() == PTY_i32) { + needRet = true; + } const ASTStmt *astStmt = GetCompoundStmt(); if (astStmt == nullptr) { + if (needRet) { + stmts.emplace_back(std::move(retStmt)); + } return stmts; } const ASTCompoundStmt *astCpdStmt = static_cast(astStmt); @@ -115,6 +129,9 @@ std::list ASTFunc::EmitASTStmtToFEIR() const { stmts.emplace_back(std::move(stmt)); } } + if (needRet && (stmts.size() == 0 || stmts.back()->GetKind() != kStmtReturn)) { + stmts.emplace_back(std::move(retStmt)); + } return stmts; } // ---------- ASTStruct ---------- diff --git a/src/mplfe/ast_input/src/ast_expr.cpp b/src/mplfe/ast_input/src/ast_expr.cpp index f3e80e1e7f197f06ecfefb1ecc919c1772b0da6d..4f19b49916cd6ee30372ff3eecf1e56d99e30a6a 100644 --- a/src/mplfe/ast_input/src/ast_expr.cpp +++ b/src/mplfe/ast_input/src/ast_expr.cpp @@ -56,7 +56,13 @@ MIRConst *ASTValue::Translate2MIRConst() const { // ---------- ASTExpr ---------- UniqueFEIRExpr ASTExpr::Emit2FEExpr(std::list &stmts) const { - return Emit2FEExprImpl(stmts); + auto feirExpr = Emit2FEExprImpl(stmts); + for (auto &stmt : stmts) { + if (!stmt->HasSetLOCInfo()) { + stmt->SetSrcFileInfo(srcFileIdx, srcFileLineNum); + } + } + return feirExpr; } UniqueFEIRExpr ASTExpr::ImplicitInitFieldValue(MIRType *type, std::list &stmts) const { @@ -91,7 +97,8 @@ UniqueFEIRExpr ASTExpr::ImplicitInitFieldValue(MIRType *type, std::listClone(); UniqueFEIRExpr arrayExprTmp = arrayExpr->Clone(); auto stmt = FEIRBuilder::CreateStmtArrayStoreOneStmtForC(std::move(exprElem), std::move(arrayExprTmp), - std::move(exprIndex), std::move(typeNativeTmp)); + std::move(exprIndex), std::move(typeNativeTmp), + tmpName); stmts.emplace_back(std::move(stmt)); } implicitInitFieldExpr = FEIRBuilder::CreateExprDRead(std::move(tmpVar)); @@ -132,17 +139,24 @@ MIRConst *ASTDeclRefExpr::GenerateMIRConstImpl() const { UniqueFEIRExpr ASTDeclRefExpr::Emit2FEExprImpl(std::list &stmts) const { MIRType *mirType = refedDecl->GetTypeDesc().front(); UniqueFEIRExpr feirRefExpr; + auto attrs = refedDecl->GetGenericAttrs(); if (mirType->GetKind() == kTypePointer && static_cast(mirType)->GetPointedType()->GetKind() == kTypeFunction) { feirRefExpr = FEIRBuilder::CreateExprAddrofFunc(refedDecl->GetName()); - } else if (mirType->GetKind() == kTypeArray) { - UniqueFEIRVar feirVar = - FEIRBuilder::CreateVarNameForC(refedDecl->GenerateUniqueVarName(), *mirType, refedDecl->IsGlobal(), false); - feirRefExpr = FEIRBuilder::CreateExprAddrofVar(std::move(feirVar)); } else { UniqueFEIRVar feirVar = FEIRBuilder::CreateVarNameForC(refedDecl->GenerateUniqueVarName(), *mirType, refedDecl->IsGlobal(), false); - feirRefExpr = FEIRBuilder::CreateExprDRead(std::move(feirVar)); + if (attrs.GetAttr(GENATTR_static) && !refedDecl->IsGlobal()) { + feirVar->SetAttrs(attrs); + if (static_cast(refedDecl)->GetInitExpr() != nullptr) { + feirVar->SetConst(refedDecl->Translate2MIRConst()); + } + } + if (mirType->GetKind() == kTypeArray) { + feirRefExpr = FEIRBuilder::CreateExprAddrofVar(std::move(feirVar)); + } else { + feirRefExpr = FEIRBuilder::CreateExprDRead(std::move(feirVar)); + } } return feirRefExpr; } @@ -175,18 +189,24 @@ UniqueFEIRExpr ASTCallExpr::Emit2FEExprCall(std::list &stmts) co StructElemNameIdx *nameIdx = FEManager::GetManager().GetStructElemMempool()->New(funcName); FEStructMethodInfo *info = static_cast( FEManager::GetTypeManager().RegisterStructMethodInfo(*nameIdx, kSrcLangC, false)); - std::unique_ptr callStmt = std::make_unique( - *info, OP_callassigned, nullptr, false); + Opcode op; + if (retType->GetPrimType() != PTY_void) { + op = OP_callassigned; + } else { + op = OP_call; + } + std::unique_ptr callStmt = std::make_unique(*info, op, nullptr, false); // args for (int32 i = args.size() - 1; i >= 0; --i) { UniqueFEIRExpr expr = args[i]->Emit2FEExpr(stmts); callStmt->AddExprArgReverse(std::move(expr)); } + // attrs + info->SetFuncAttrs(funcAttrs); // return FEIRTypeNative *retTypeInfo = FEManager::GetManager().GetModule().GetMemPool()->New(*retType); info->SetReturnType(retTypeInfo); if (retType->GetPrimType() != PTY_void) { - const std::string &varName = FEUtils::GetSequentialName("retVar_"); UniqueFEIRVar var = FEIRBuilder::CreateVarNameForC(varName, *retType, false, false); UniqueFEIRVar dreadVar = var->Clone(); callStmt->SetVar(std::move(var)); @@ -201,11 +221,14 @@ UniqueFEIRExpr ASTCallExpr::Emit2FEExprICall(std::list &stmts) c std::unique_ptr icallStmt = std::make_unique(); CHECK_NULL_FATAL(calleeExpr); // args + for (int32 i = args.size() - 1; i >= 0; --i) { + UniqueFEIRExpr exprArg = args[i]->Emit2FEExpr(stmts); + icallStmt->AddExprArgReverse(std::move(exprArg)); + } UniqueFEIRExpr expr = calleeExpr->Emit2FEExpr(stmts); icallStmt->AddExprArgReverse(std::move(expr)); // return if (retType->GetPrimType() != PTY_void) { - const std::string &varName = FEUtils::GetSequentialName("retVar_"); UniqueFEIRVar var = FEIRBuilder::CreateVarNameForC(varName, *retType, false, false); UniqueFEIRVar dreadVar = var->Clone(); icallStmt->SetVar(std::move(var)); @@ -263,6 +286,10 @@ MIRConst *ASTImplicitCastExpr::GenerateMIRDoubleConst() const { return FEManager::GetModule().GetMemPool()->New( static_cast(GetConstantValue()->val.i64), *GlobalTables::GetTypeTable().GetPrimType(PTY_f64)); } + case PTY_f64: { + return FEManager::GetModule().GetMemPool()->New( + static_cast(GetConstantValue()->val.f64), *GlobalTables::GetTypeTable().GetPrimType(PTY_f64)); + } default: { CHECK_FATAL(false, "Unsupported pty type: %d", GetConstantValue()->pty); return nullptr; @@ -306,6 +333,7 @@ MIRConst *ASTImplicitCastExpr::GenerateMIRIntConst() const { UniqueFEIRExpr ASTImplicitCastExpr::Emit2FEExprImpl(std::list &stmts) const { const ASTExpr *childExpr = child; + UniqueFEIRType srcType = std::make_unique(*src); CHECK_FATAL(childExpr != nullptr, "childExpr is nullptr"); UniqueFEIRExpr subExpr = childExpr->Emit2FEExpr(stmts); if (complexType == nullptr) { @@ -325,7 +353,7 @@ UniqueFEIRExpr ASTImplicitCastExpr::Emit2FEExprImpl(std::list &s imagExpr->Clone(), kComplexImagID); stmts.emplace_back(std::move(imagStmtNode)); dreadAgg = FEIRBuilder::CreateExprDRead(std::move(tmpVar)); - static_cast(dreadAgg.get())->SetFieldType(src); + static_cast(dreadAgg.get())->SetFieldType(srcType->Clone()); } else { UniqueFEIRExpr realExpr; UniqueFEIRExpr imagExpr; @@ -336,9 +364,9 @@ UniqueFEIRExpr ASTImplicitCastExpr::Emit2FEExprImpl(std::list &s static_cast(cloneSubExpr.get())->SetFieldID(kComplexImagID); } else if (subNodeKind == kExprDRead) { static_cast(subExpr.get())->SetFieldID(kComplexRealID); - static_cast(subExpr.get())->SetFieldType(src); + static_cast(subExpr.get())->SetFieldType(srcType->Clone()); static_cast(cloneSubExpr.get())->SetFieldID(kComplexImagID); - static_cast(cloneSubExpr.get())->SetFieldType(src); + static_cast(cloneSubExpr.get())->SetFieldType(srcType->Clone()); } realExpr = FEIRBuilder::CreateExprCvtPrim(std::move(subExpr), dst->GetPrimType()); imagExpr = FEIRBuilder::CreateExprCvtPrim(std::move(cloneSubExpr), dst->GetPrimType()); @@ -428,7 +456,7 @@ UniqueFEIRExpr ASTUOPostIncExpr::Emit2FEExprImpl(std::list &stmt UniqueFEIRExpr childFEIRExpr = childExpr->Emit2FEExpr(stmts); UniqueFEIRExpr incIecExpr = (subPrimType == PTY_ptr) ? - std::make_unique(pointeeLen, PTY_ptr) : + std::make_unique(pointeeLen, PTY_i32) : FEIRBuilder::CreateExprConstAnyScalar(subPrimType, 1); UniqueFEIRExpr selfAddExpr = FEIRBuilder::CreateExprMathBinary(OP_add, std::move(childFEIRExpr), std::move(incIecExpr)); @@ -455,7 +483,7 @@ UniqueFEIRExpr ASTUOPostDecExpr::Emit2FEExprImpl(std::list &stmt UniqueFEIRExpr childFEIRExpr = childExpr->Emit2FEExpr(stmts); UniqueFEIRExpr incDecExpr = (subPrimType == PTY_ptr) ? - std::make_unique(pointeeLen, PTY_ptr) : + std::make_unique(pointeeLen, PTY_i32) : FEIRBuilder::CreateExprConstAnyScalar(subPrimType, 1); UniqueFEIRExpr selfAddExpr = FEIRBuilder::CreateExprMathBinary(OP_sub, std::move(childFEIRExpr), std::move(incDecExpr)); @@ -472,7 +500,7 @@ UniqueFEIRExpr ASTUOPreIncExpr::Emit2FEExprImpl(std::list &stmts UniqueFEIRExpr childFEIRExpr = childExpr->Emit2FEExpr(stmts); PrimType subPrimType = subType->GetPrimType(); UniqueFEIRExpr incIecExpr = (subPrimType == PTY_ptr) ? - std::make_unique(pointeeLen, PTY_ptr) : + std::make_unique(pointeeLen, PTY_i32) : FEIRBuilder::CreateExprConstAnyScalar(subPrimType, 1); UniqueFEIRExpr astUOPreIncExpr = FEIRBuilder::CreateExprMathBinary(OP_add, std::move(childFEIRExpr), std::move(incIecExpr)); @@ -491,7 +519,7 @@ UniqueFEIRExpr ASTUOPreDecExpr::Emit2FEExprImpl(std::list &stmts UniqueFEIRExpr childFEIRExpr = childExpr->Emit2FEExpr(stmts); PrimType subPrimType = subType->GetPrimType(); UniqueFEIRExpr incDecExpr = (subPrimType == PTY_ptr) ? - std::make_unique(pointeeLen, PTY_ptr) : + std::make_unique(pointeeLen, PTY_i32) : FEIRBuilder::CreateExprConstAnyScalar(subPrimType, 1); UniqueFEIRExpr astUOPreIncExpr = FEIRBuilder::CreateExprMathBinary(OP_sub, std::move(childFEIRExpr), std::move(incDecExpr)); @@ -534,19 +562,44 @@ UniqueFEIRExpr ASTUOAddrOfExpr::Emit2FEExprImpl(std::list &stmts addrOfExpr = FEIRBuilder::CreateExprAddrofVar(std::move(addrOfVar)); } else if (astOp == kASTMemberExpr) { ASTMemberExpr *memberExpr = static_cast(childExpr); - UniqueFEIRExpr baseFEExpr = memberExpr->GetBaseExpr()->Emit2FEExpr(stmts); - if (memberExpr->GetIsArrow()) { - addrOfExpr = std::move(baseFEExpr); - static_cast(addrOfExpr.get())->SetFieldName(memberExpr->GetMemberName()); + ASTExpr *baseExpr = memberExpr->GetBaseExpr(); + UniqueFEIRExpr baseFEExpr; + std::string fieldName = memberExpr->GetMemberName(); + bool isArrow = memberExpr->GetIsArrow(); + MIRType *baseType = memberExpr->GetBaseType(); + if (baseExpr->GetASTOp() == kASTMemberExpr) { + std::list memberNameList; + memberNameList.emplace_back(memberExpr->GetMemberName()); + ASTMemberExpr *finalMember = memberExpr->findFinalMember(static_cast(baseExpr), memberNameList); + baseFEExpr = finalMember->GetBaseExpr()->Emit2FEExpr(stmts); + isArrow = finalMember->GetIsArrow(); + baseType = finalMember->GetBaseType(); + fieldName = ASTUtil::Join(memberNameList, "."); } else { - UniqueFEIRVar tmpVar; - if (baseFEExpr->GetKind() == kExprDRead) { // other potential expr should concern - auto dreadFEExpr = static_cast(baseFEExpr.get()); - tmpVar = dreadFEExpr->GetVar()->Clone(); - addrOfExpr = FEIRBuilder::CreateExprAddrofVar(std::move(tmpVar)); - static_cast(addrOfExpr.get())->SetFieldName(memberExpr->GetMemberName()); - static_cast(addrOfExpr.get())->SetFieldType(memberExpr->GetMemberType()); - } + baseFEExpr = baseExpr->Emit2FEExpr(stmts); + } + + FieldID fieldID = 0; + if (isArrow) { + CHECK_FATAL(baseType->IsMIRPtrType(), "Must be ptr type!"); + MIRPtrType *mirPtrType = static_cast(baseType); + MIRType *pointedMirType = mirPtrType->GetPointedType(); + CHECK_FATAL(pointedMirType->IsStructType(), "pointedMirType must be StructType"); + MIRStructType *structType = static_cast(pointedMirType); + fieldID = FEUtils::GetStructFieldID(structType, fieldName); + UniqueFEIRType baseFEType = std::make_unique(*baseType); + addrOfExpr = std::make_unique(std::move(baseFEType), fieldID, std::move(baseFEExpr)); + } else { + // other potential expr should concern + CHECK_FATAL(baseFEExpr->GetKind() == kExprDRead, "baseFEExpr kind isn't DRead"); + auto dreadFEExpr = static_cast(baseFEExpr.get()); + UniqueFEIRVar tmpVar = dreadFEExpr->GetVar()->Clone(); + CHECK_FATAL(baseType->IsStructType(), "basetype must be StructType"); + MIRStructType *structType = static_cast(baseType); + fieldID = FEUtils::GetStructFieldID(structType, fieldName); + addrOfExpr = FEIRBuilder::CreateExprAddrofVar(std::move(tmpVar)); + static_cast(addrOfExpr.get())->SetFieldID(fieldID); + static_cast(addrOfExpr.get())->SetFieldType(memberExpr->GetMemberType()); } } else if (astOp == kASTSubscriptExpr) { ASTArraySubscriptExpr *arraySubExpr = static_cast(childExpr); @@ -555,7 +608,13 @@ UniqueFEIRExpr ASTUOAddrOfExpr::Emit2FEExprImpl(std::list &stmts } else { // other potential expr should concern UniqueFEIRExpr childFEIRExpr; childFEIRExpr = childExpr->Emit2FEExpr(stmts); - addrOfExpr = std::make_unique(OP_addrof, uoType, std::move(childFEIRExpr)); + if (childFEIRExpr->GetKind() == kExprDRead && childFEIRExpr->GetPrimType() == PTY_agg) { + FEIRExprDRead *dread = static_cast(childFEIRExpr.get()); + UniqueFEIRVar dreadVar = dread->GetVar()->Clone(); + addrOfExpr = FEIRBuilder::CreateExprAddrofVar(std::move(dreadVar)); + } else { + addrOfExpr = std::make_unique(OP_addrof, uoType, std::move(childFEIRExpr)); + } } return addrOfExpr; } @@ -589,7 +648,8 @@ UniqueFEIRExpr ASTUORealExpr::Emit2FEExprImpl(std::list &stmts) static_cast(subFEIRExpr.get())->SetFieldID(kComplexRealID); } else if (subNodeKind == kExprDRead) { static_cast(subFEIRExpr.get())->SetFieldID(kComplexRealID); - static_cast(subFEIRExpr.get())->SetFieldType(elementType); + UniqueFEIRType elementFEType = std::make_unique(*elementType); + static_cast(subFEIRExpr.get())->SetFieldType(std::move(elementFEType)); } else { CHECK_FATAL(false, "NIY"); } @@ -611,7 +671,8 @@ UniqueFEIRExpr ASTUOImagExpr::Emit2FEExprImpl(std::list &stmts) static_cast(subFEIRExpr.get())->SetFieldID(kComplexImagID); } else if (subNodeKind == kExprDRead) { static_cast(subFEIRExpr.get())->SetFieldID(kComplexImagID); - static_cast(subFEIRExpr.get())->SetFieldType(elementType); + UniqueFEIRType elementFEType = std::make_unique(*elementType); + static_cast(subFEIRExpr.get())->SetFieldType(std::move(elementFEType)); } else { CHECK_FATAL(false, "NIY"); } @@ -780,12 +841,25 @@ MIRConst *ASTInitListExpr::GenerateMIRConstForArray() const { } MIRConst *ASTInitListExpr::GenerateMIRConstForStruct() const { + if (fillers.empty()) { + return nullptr; // No var constant generation + } + bool hasFiller = false; + for (auto e : fillers) { + if (e != nullptr) { + hasFiller = true; + break; + } + } + if (!hasFiller) { + return nullptr; + } MIRAggConst *aggConst = FEManager::GetModule().GetMemPool()->New(FEManager::GetModule(), *initListType); #ifndef USE_OPS CHECK_FATAL(false, "Not support"); #else for (size_t i = 0; i < fillers.size(); ++i) { - if (fillers[i]->GetASTOp() == kASTImplicitValueInitExpr) { + if (fillers[i] == nullptr || fillers[i]->GetASTOp() == kASTImplicitValueInitExpr) { continue; } aggConst->AddItem(fillers[i]->GenerateMIRConst(), i + 1); @@ -803,28 +877,38 @@ UniqueFEIRExpr ASTInitListExpr::Emit2FEExprImpl(std::list &stmts return nullptr; } +void ASTInitListExpr::Emit2FEExprForArrayForNest(UniqueFEIRType typeNative, UniqueFEIRExpr arrayExpr, + std::list &stmts) const { + for (int i = 0; i < fillers.size(); ++i) { + if (static_cast(fillers[i])->initListType->IsStructType()) { // array elem is struct + Emit2FEExprForStruct(stmts); + return; + } + MIRType *mirType = static_cast(fillers[i])->initListType; + std::string tmpName = FEUtils::GetSequentialName("subArray_"); + UniqueFEIRVar tmpVar = FEIRBuilder::CreateVarNameForC(tmpName, *mirType); + static_cast(fillers[i])->SetInitListVarName(tmpName); + (void)(fillers[i])->Emit2FEExpr(stmts); + UniqueFEIRType elemType = tmpVar->GetType()->Clone(); + UniqueFEIRExpr dreadAgg = FEIRBuilder::CreateExprDRead(std::move(tmpVar)); + UniqueFEIRExpr arrayExprTmp = arrayExpr->Clone(); + UniqueFEIRExpr exprIndex = FEIRBuilder::CreateExprConstI32(i); + UniqueFEIRType typeNativeTmp = typeNative->Clone(); + auto fieldStmt = FEIRBuilder::CreateStmtArrayStoreOneStmtForC(std::move(dreadAgg), std::move(arrayExprTmp), + std::move(exprIndex), std::move(typeNativeTmp), + std::move(elemType), + varName); + stmts.emplace_back(std::move(fieldStmt)); + } +} + void ASTInitListExpr::Emit2FEExprForArray(std::list &stmts) const { UniqueFEIRVar feirVar = FEIRBuilder::CreateVarNameForC(varName, *initListType); UniqueFEIRVar feirVarTmp = feirVar->Clone(); UniqueFEIRType typeNative = FEIRTypeHelper::CreateTypeNative(*initListType); UniqueFEIRExpr arrayExpr = FEIRBuilder::CreateExprAddrofVar(std::move(feirVarTmp)); if (fillers[0]->GetASTOp() == kASTOpInitListExpr) { - for (int i = 0; i < fillers.size(); ++i) { - MIRType *mirType = static_cast(fillers[i])->initListType; - std::string tmpName = FEUtils::GetSequentialName("subArray_"); - UniqueFEIRVar tmpVar = FEIRBuilder::CreateVarNameForC(tmpName, *mirType); - static_cast(fillers[i])->SetInitListVarName(tmpName); - (void)(fillers[i])->Emit2FEExpr(stmts); - UniqueFEIRType elemType = tmpVar->GetType()->Clone(); - UniqueFEIRExpr dreadAgg = FEIRBuilder::CreateExprDRead(std::move(tmpVar)); - UniqueFEIRExpr arrayExprTmp = arrayExpr->Clone(); - UniqueFEIRExpr exprIndex = FEIRBuilder::CreateExprConstI32(i); - UniqueFEIRType typeNativeTmp = typeNative->Clone(); - auto fieldStmt = FEIRBuilder::CreateStmtArrayStoreOneStmtForC(std::move(dreadAgg), std::move(arrayExprTmp), - std::move(exprIndex), std::move(typeNativeTmp), - std::move(elemType)); - stmts.emplace_back(std::move(fieldStmt)); - } + Emit2FEExprForArrayForNest(typeNative->Clone(), arrayExpr->Clone(), stmts); } else { for (int i = 0; i < fillers.size(); ++i) { UniqueFEIRExpr exprIndex = FEIRBuilder::CreateExprConstI32(i); @@ -832,13 +916,15 @@ void ASTInitListExpr::Emit2FEExprForArray(std::list &stmts) cons UniqueFEIRType typeNativeTmp = typeNative->Clone(); UniqueFEIRExpr arrayExprTmp = arrayExpr->Clone(); auto stmt = FEIRBuilder::CreateStmtArrayStoreOneStmtForC(std::move(exprElem), std::move(arrayExprTmp), - std::move(exprIndex), std::move(typeNativeTmp)); + std::move(exprIndex), std::move(typeNativeTmp), + varName); stmts.emplace_back(std::move(stmt)); } - MIRType *ptrMIRArrayType = typeNative->GenerateMIRType(false); + MIRType *ptrMIRArrayType = typeNative->GenerateMIRTypeAuto(); auto allSize = static_cast(ptrMIRArrayType)->GetSize(); auto elemSize = static_cast(ptrMIRArrayType)->GetElemType()->GetSize(); + CHECK_FATAL(elemSize != 0, "elemSize should not 0"); auto allElemCnt = allSize / elemSize; uint32 needInitFurtherCnt = allElemCnt - fillers.size(); PrimType elemPrimType = static_cast(ptrMIRArrayType)->GetElemType()->GetPrimType(); @@ -849,27 +935,73 @@ void ASTInitListExpr::Emit2FEExprForArray(std::list &stmts) cons UniqueFEIRExpr exprElemOther = std::make_unique(static_cast(0), elemPrimType); auto stmt = FEIRBuilder::CreateStmtArrayStoreOneStmtForC(std::move(exprElemOther), std::move(arrayExprTmp), - std::move(exprIndex), std::move(typeNativeTmp)); + std::move(exprIndex), + std::move(typeNativeTmp), + varName); stmts.emplace_back(std::move(stmt)); } } } +void ASTInitListExpr::Emit2FEExprForStruct4ArrayElemIsStruct(uint32 i, std::list &stmts) const { + MIRType *ptrMIRElemType = GlobalTables::GetTypeTable().GetOrCreatePointerType(*initListType, PTY_ptr); + UniqueFEIRVar tmpVar = FEIRBuilder::CreateVarNameForC(varName, *ptrMIRElemType); + UniqueFEIRExpr dreadAddr = FEIRBuilder::CreateExprDRead(std::move(tmpVar)); + MIRArrayType* arrayType = static_cast(initListType); + UniqueFEIRType typeArray = std::make_unique(*static_cast(initListType)); + UniqueFEIRType uTypeArray = typeArray->Clone(); + std::list indexsExprs; + UniqueFEIRExpr indexExpr = FEIRBuilder::CreateExprConstAnyScalar(PTY_i32, i); + indexsExprs.push_back(std::move(indexExpr)); + UniqueFEIRExpr srcExpr = FEIRBuilder::CreateExprAddrofArray(std::move(uTypeArray), std::move(dreadAddr), + varName, indexsExprs); + MIRType *ptrElemType = GlobalTables::GetTypeTable().GetOrCreatePointerType(*arrayType->GetElemType(), PTY_ptr); + auto tmpArrayName = FEUtils::GetSequentialName("struct_tmpvar_"); + UniqueFEIRVar tmpArrayVar = FEIRBuilder::CreateVarNameForC(tmpArrayName, *ptrElemType); + UniqueFEIRStmt stmtDAssign = FEIRBuilder::CreateStmtDAssign(std::move(tmpArrayVar), std::move(srcExpr)); + stmts.emplace_back(std::move(stmtDAssign)); + static_cast(fillers[i])->SetInitListVarName(tmpArrayName); + static_cast(fillers[i])->SetParentFlag(kArrayParent); + (void)(fillers[i])->Emit2FEExpr(stmts); +} + void ASTInitListExpr::Emit2FEExprForStruct(std::list &stmts) const { UniqueFEIRVar feirVar = FEIRBuilder::CreateVarNameForC(varName, *initListType); + if (IsUnionInitListExpr()) { +#ifndef USE_OPS + CHECK_FATAL(false, "Unsupported INTRN_C_memset"); +#else + std::unique_ptr> argExprList = std::make_unique>(); + UniqueFEIRExpr addrOfExpr = FEIRBuilder::CreateExprAddrofVar(feirVar->Clone()); + argExprList->emplace_back(std::move(addrOfExpr)); + argExprList->emplace_back(FEIRBuilder::CreateExprConstU32(0)); + argExprList->emplace_back(FEIRBuilder::CreateExprSizeOfType(std::make_unique(*initListType))); + std::unique_ptr stmt = std::make_unique( + INTRN_C_memset, nullptr, nullptr, std::move(argExprList)); + stmts.emplace_back(std::move(stmt)); +#endif + } MIRStructType *structType = static_cast(initListType); for (uint32 i = 0; i < fillers.size(); i++) { + if (fillers[i] == nullptr) { + continue; // skip anonymous field + } uint32 fieldID = 0; if (fillers[i]->GetASTOp() == kASTOpInitListExpr) { - MIRType *mirType = static_cast(fillers[i])->GetInitListType(); - std::string tmpName = FEUtils::GetSequentialName("subInitListVar_"); - UniqueFEIRVar tmpVar = FEIRBuilder::CreateVarNameForC(tmpName, *mirType); - static_cast(fillers[i])->SetInitListVarName(tmpName); - (void)(fillers[i])->Emit2FEExpr(stmts); - UniqueFEIRExpr dreadAgg = FEIRBuilder::CreateExprDRead(std::move(tmpVar)); - FEManager::GetMIRBuilder().TraverseToNamedField(*structType, structType->GetElemStrIdx(i), fieldID); - UniqueFEIRStmt fieldStmt = std::make_unique(feirVar->Clone(), std::move(dreadAgg), fieldID); - stmts.emplace_back(std::move(fieldStmt)); + if (initListType->GetKind() == kTypeStruct) { + MIRType *mirType = static_cast(fillers[i])->GetInitListType(); + std::string tmpName = FEUtils::GetSequentialName("subInitListVar_"); + UniqueFEIRVar tmpVar = FEIRBuilder::CreateVarNameForC(tmpName, *mirType); + static_cast(fillers[i])->SetInitListVarName(tmpName); + static_cast(fillers[i])->SetParentFlag(kStructParent); + (void)(fillers[i])->Emit2FEExpr(stmts); + UniqueFEIRExpr dreadAgg = FEIRBuilder::CreateExprDRead(std::move(tmpVar)); + FEManager::GetMIRBuilder().TraverseToNamedField(*structType, structType->GetElemStrIdx(i), fieldID); + UniqueFEIRStmt fieldStmt = std::make_unique(feirVar->Clone(), std::move(dreadAgg), fieldID); + stmts.emplace_back(std::move(fieldStmt)); + } else if (initListType->GetKind() == kTypeArray) { // array elem is struct + Emit2FEExprForStruct4ArrayElemIsStruct(i, stmts); + } } else if (fillers[i]->GetASTOp() == kASTASTDesignatedInitUpdateExpr) { MIRType *mirType = static_cast(fillers[i])->GetInitListType(); std::string tmpName = FEUtils::GetSequentialName("subVarToBeUpdate_"); @@ -881,10 +1013,20 @@ void ASTInitListExpr::Emit2FEExprForStruct(std::list &stmts) con UniqueFEIRStmt fieldStmt = std::make_unique(feirVar->Clone(), std::move(dreadAgg), fieldID); stmts.emplace_back(std::move(fieldStmt)); } else { - FEManager::GetMIRBuilder().TraverseToNamedField(*structType, structType->GetElemStrIdx(i), fieldID); - UniqueFEIRExpr fieldFEExpr = fillers[i]->Emit2FEExpr(stmts); - UniqueFEIRStmt fieldStmt = std::make_unique(feirVar->Clone(), fieldFEExpr->Clone(), fieldID); - stmts.emplace_back(std::move(fieldStmt)); + if (parentFlag == kStructParent || (parentFlag == kNoParent)) { + FEManager::GetMIRBuilder().TraverseToNamedField(*structType, structType->GetElemStrIdx(i), fieldID); + UniqueFEIRExpr fieldFEExpr = fillers[i]->Emit2FEExpr(stmts); + UniqueFEIRStmt fieldStmt = std::make_unique(feirVar->Clone(), fieldFEExpr->Clone(), fieldID); + stmts.emplace_back(std::move(fieldStmt)); + } else if (parentFlag == kArrayParent) { // array elem is struct / no nest case + UniqueFEIRExpr exprIndex = FEIRBuilder::CreateExprConstI32(i); + UniqueFEIRExpr fieldFEExpr = fillers[i]->Emit2FEExpr(stmts); + MIRType *ptrBaseType = GlobalTables::GetTypeTable().GetOrCreatePointerType(*initListType, PTY_ptr); + UniqueFEIRVar tmpVar = FEIRBuilder::CreateVarNameForC(varName, *ptrBaseType); + UniqueFEIRStmt stmt = FEIRBuilder::CreateStmtFieldStoreForC(std::move(tmpVar), std::move(fieldFEExpr), + structType, i + 1); + stmts.emplace_back(std::move(stmt)); + } } } } @@ -936,12 +1078,18 @@ UniqueFEIRExpr ASTArraySubscriptExpr::Emit2FEExprImpl(std::list if (memberExpr != nullptr) { auto memExpr = static_cast(memberExpr)->Emit2FEExpr(stmts); auto memType = FEIRTypeHelper::CreateTypeNative(*static_cast(memberExpr)->GetMemberType()); - UniqueFEIRType typeArrayNative = FEIRTypeHelper::CreateTypeNative(*baseExpr->GetType()); + CHECK_FATAL(memType, "memType should not be nullptr"); arrayStoreForCExpr = FEIRBuilder::CreateExprArrayStoreForC(std::move(memExpr), indexExprs, std::move(memType), - std::move(baseFEExpr), std::move(typeNative)); + std::move(baseFEExpr), std::move(typeNative), + baseExprVarName); } else { + if (baseFEExpr->GetKind() == kExprCStyleCast) { + FEIRExprCStyleCast *expr = static_cast(baseFEExpr.get()); + baseFEExpr = expr->GetSubExpr()->Clone(); + typeNative = FEIRTypeHelper::CreateTypeNative(*expr->GetMIRType()); + } arrayStoreForCExpr = FEIRBuilder::CreateExprArrayStoreForC(std::move(baseFEExpr), indexExprs, - std::move(typeNative)); + std::move(typeNative), baseExprVarName); } static_cast(arrayStoreForCExpr.get())->SetAddrOfFlag(isAddrOf); return arrayStoreForCExpr; @@ -960,11 +1108,32 @@ ASTMemberExpr *ASTMemberExpr::findFinalMember(ASTMemberExpr *startExpr, std::lis return findFinalMember(static_cast(startExpr->baseExpr), memberNames); } +void ASTMemberExpr::Emit2FEExprImplForArrayElemIsStruct(UniqueFEIRExpr baseFEExpr, std::string &tmpStructName, + std::list &stmts) const { + if (baseExpr->GetASTOp() == kASTSubscriptExpr) { + auto arrayStoreForC = static_cast(baseFEExpr.get()); + FEIRExpr &exprArray = arrayStoreForC->GetExprArray(); + std::list &indexsExpr = arrayStoreForC->GetExprIndexs(); + UniqueFEIRType typeArray = arrayStoreForC->GetTypeArray().Clone(); + UniqueFEIRExpr uExprArray = exprArray.Clone(); + const std::string &arrayName = static_cast(baseExpr)->GetBaseExprVarName(); + UniqueFEIRExpr srcExpr = FEIRBuilder::CreateExprAddrofArray(std::move(typeArray), std::move(baseFEExpr), + arrayName, indexsExpr); + MIRType *ptrBaseType = GlobalTables::GetTypeTable().GetOrCreatePointerType(*baseType, PTY_ptr); + tmpStructName = FEUtils::GetSequentialName("struct_tmpvar_"); + UniqueFEIRVar tmpVar = FEIRBuilder::CreateVarNameForC(tmpStructName, *ptrBaseType); + auto uTmpVar = tmpVar->Clone(); + UniqueFEIRStmt readStmt1 = FEIRBuilder::CreateStmtDAssign(uTmpVar->Clone(), std::move(srcExpr)); + stmts.emplace_back(std::move(readStmt1)); + } +} + UniqueFEIRExpr ASTMemberExpr::Emit2FEExprImpl(std::list &stmts) const { UniqueFEIRExpr baseFEExpr; std::string fieldName = memberName; bool isArrow = this->isArrow; MIRType *baseType = this->baseType; + std::string tmpStructName; if (baseExpr->GetASTOp() == kASTMemberExpr) { std::list memberNameList; memberNameList.emplace_back(memberName); @@ -975,20 +1144,53 @@ UniqueFEIRExpr ASTMemberExpr::Emit2FEExprImpl(std::list &stmts) fieldName = ASTUtil::Join(memberNameList, "."); } else { baseFEExpr = baseExpr->Emit2FEExpr(stmts); + Emit2FEExprImplForArrayElemIsStruct(baseFEExpr->Clone(), tmpStructName, stmts); } UniqueFEIRType baseFEType = std::make_unique(*baseType); if (isArrow) { - auto iread = std::make_unique(baseFEType->Clone(), std::move(baseFEType), 0, - std::move(baseFEExpr)); - iread->SetFieldName(fieldName); - return iread; + CHECK_FATAL(baseType->IsMIRPtrType(), "Must be ptr type!"); + MIRPtrType *mirPtrType = static_cast(baseType); + MIRType *pointedMirType = mirPtrType->GetPointedType(); + CHECK_FATAL(pointedMirType->IsStructType(), "pointedMirType must be StructType"); + MIRStructType *structType = static_cast(pointedMirType); + FieldID fieldID = FEUtils::GetStructFieldID(structType, fieldName); + MIRType *reType = FEUtils::GetStructFieldType(structType, fieldID); + UniqueFEIRType retFEType = std::make_unique(*reType); + if (retFEType->IsArray()) { + return std::make_unique(std::move(baseFEType), fieldID, std::move(baseFEExpr)); + } else { + return FEIRBuilder::CreateExprIRead(std::move(retFEType), std::move(baseFEType), std::move(baseFEExpr), fieldID); + } } else { - UniqueFEIRVar tmpVar = static_cast(baseFEExpr.get())->GetVar()->Clone(); - auto dread = std::make_unique(std::move(tmpVar)); - dread->SetFieldName(fieldName); - dread->SetFieldType(memberType); - return dread; + if (baseExpr->GetASTOp() != kASTSubscriptExpr) { + CHECK_FATAL(baseType->IsStructType(), "basetype must be StructType"); + UniqueFEIRVar tmpVar = static_cast(baseFEExpr.get())->GetVar()->Clone(); + MIRStructType *structType = static_cast(baseType); + FieldID fieldID = FEUtils::GetStructFieldID(structType, fieldName); + UniqueFEIRType memberFEType = std::make_unique(*memberType); + if (memberFEType->IsArray()) { + auto addrofExpr = std::make_unique(std::move(tmpVar)); + addrofExpr->SetFieldID(fieldID); + addrofExpr->SetFieldName(fieldName); + addrofExpr->SetFieldType(memberType); + return addrofExpr; + } else { + return FEIRBuilder::CreateExprDReadAggField(std::move(tmpVar), fieldID, std::move(memberFEType)); + } + } else { // GetASTOp() is kASTSubscriptExpr + uint32 fieldID = 0; + GStrIdx fieldNameIdx = GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(memberName); + auto ptrMIRStructType = std::make_unique(*baseType); + MIRStructType* mirStructType = static_cast(ptrMIRStructType->GenerateMIRType()); + FEManager::GetMIRBuilder().TraverseToNamedField(*mirStructType, fieldNameIdx, fieldID); + auto fieldVar = FEIRBuilder::CreateVarNameForC(memberName, *memberType); + MIRType *ptrBaseType = GlobalTables::GetTypeTable().GetOrCreatePointerType(*baseType, PTY_ptr); + UniqueFEIRVar tmpVar = FEIRBuilder::CreateVarNameForC(tmpStructName, *ptrBaseType); + return FEIRBuilder::CreateExprFieldLoadForC(std::move(tmpVar), std::move(fieldVar), + mirStructType, fieldID); + } } + return nullptr; } // ---------- ASTDesignatedInitUpdateExpr ---------- @@ -1010,37 +1212,113 @@ UniqueFEIRExpr ASTBinaryOperatorExpr::Emit2FEExprImpl(std::list if (complexElementType != nullptr) { UniqueFEIRVar tempVar = FEIRBuilder::CreateVarNameForC(FEUtils::GetSequentialName("Complex_"), *retType); if (opcode == OP_add || opcode == OP_sub) { - UniqueFEIRExpr realFEExpr = FEIRBuilder::CreateExprBinary(opcode, leftRealExpr->Emit2FEExpr(stmts), + auto complexElementFEType = std::make_unique(*complexElementType); + UniqueFEIRExpr realFEExpr = FEIRBuilder::CreateExprBinary(complexElementFEType->Clone(), opcode, + leftRealExpr->Emit2FEExpr(stmts), rightRealExpr->Emit2FEExpr(stmts)); - UniqueFEIRExpr imagFEExpr = FEIRBuilder::CreateExprBinary(opcode, leftImagExpr->Emit2FEExpr(stmts), + UniqueFEIRExpr imagFEExpr = FEIRBuilder::CreateExprBinary(complexElementFEType->Clone(), opcode, + leftImagExpr->Emit2FEExpr(stmts), rightImagExpr->Emit2FEExpr(stmts)); auto realStmt = FEIRBuilder::CreateStmtDAssignAggField(tempVar->Clone(), std::move(realFEExpr), kComplexRealID); auto imagStmt = FEIRBuilder::CreateStmtDAssignAggField(tempVar->Clone(), std::move(imagFEExpr), kComplexImagID); stmts.emplace_back(std::move(realStmt)); stmts.emplace_back(std::move(imagStmt)); auto dread = FEIRBuilder::CreateExprDRead(std::move(tempVar)); - static_cast(dread.get())->SetFieldType(complexElementType); + static_cast(dread.get())->SetFieldType(std::move(complexElementFEType)); return dread; } else if (opcode == OP_eq || opcode == OP_ne) { - UniqueFEIRExpr realFEExpr = FEIRBuilder::CreateExprBinary(opcode, leftRealExpr->Emit2FEExpr(stmts), + auto boolFEType = std::make_unique(*GlobalTables::GetTypeTable().GetPrimType(PTY_i32)); + UniqueFEIRExpr realFEExpr = FEIRBuilder::CreateExprBinary(boolFEType->Clone(), opcode, + leftRealExpr->Emit2FEExpr(stmts), rightRealExpr->Emit2FEExpr(stmts)); - UniqueFEIRExpr imagFEExpr = FEIRBuilder::CreateExprBinary(opcode, leftImagExpr->Emit2FEExpr(stmts), + UniqueFEIRExpr imagFEExpr = FEIRBuilder::CreateExprBinary(boolFEType->Clone(), opcode, + leftImagExpr->Emit2FEExpr(stmts), rightImagExpr->Emit2FEExpr(stmts)); UniqueFEIRExpr finalExpr; if (opcode == OP_eq) { - finalExpr = FEIRBuilder::CreateExprBinary(OP_land, std::move(realFEExpr), std::move(imagFEExpr)); + finalExpr = FEIRBuilder::CreateExprBinary(boolFEType->Clone(), OP_land, std::move(realFEExpr), + std::move(imagFEExpr)); } else { - finalExpr = FEIRBuilder::CreateExprBinary(OP_lior, std::move(realFEExpr), std::move(imagFEExpr)); + finalExpr = FEIRBuilder::CreateExprBinary(boolFEType->Clone(), OP_lior, std::move(realFEExpr), + std::move(imagFEExpr)); } return finalExpr; } else { CHECK_FATAL(false, "NIY"); } } else { - auto leftFEExpr = leftExpr->Emit2FEExpr(stmts); - auto rightFEExpr = rightExpr->Emit2FEExpr(stmts); - UniqueFEIRType feirType = std::make_unique(*retType); - return FEIRBuilder::CreateExprBinary(std::move(feirType), opcode, std::move(leftFEExpr), std::move(rightFEExpr)); + if (opcode == OP_lior || opcode == OP_land) { + Opcode op = opcode == OP_lior ? OP_brtrue : OP_brfalse; + MIRType *tempVarType = GlobalTables::GetTypeTable().GetInt32(); + UniqueFEIRType tempFeirType = std::make_unique(*tempVarType); + UniqueFEIRVar shortCircuit = FEIRBuilder::CreateVarNameForC(varName, *tempVarType); + std::string labelName = FEUtils::GetSequentialName("shortCircuit_label_"); + + auto leftFEExpr = leftExpr->Emit2FEExpr(stmts); + auto leftStmt = std::make_unique(shortCircuit->Clone(), leftFEExpr->Clone(), 0); + stmts.emplace_back(std::move(leftStmt)); + + auto dreadExpr = FEIRBuilder::CreateExprDRead(shortCircuit->Clone()); + UniqueFEIRStmt condGoToExpr = std::make_unique(dreadExpr->Clone(), op, labelName); + stmts.emplace_back(std::move(condGoToExpr)); + + auto rightFEExpr = rightExpr->Emit2FEExpr(stmts); + auto rightStmt = std::make_unique(shortCircuit->Clone(), rightFEExpr->Clone(), 0); + stmts.emplace_back(std::move(rightStmt)); + + auto labelStmt = std::make_unique(labelName); + labelStmt->SetSrcFileInfo(GetSrcFileIdx(), GetSrcFileLineNum()); + stmts.emplace_back(std::move(labelStmt)); + + UniqueFEIRExpr zeroConstExpr = FEIRBuilder::CreateExprConstAnyScalar(PTY_i32, 0); + return FEIRBuilder::CreateExprBinary(std::move(tempFeirType), OP_ne, + dreadExpr->Clone(), std::move(zeroConstExpr)); + } else { + auto leftFEExpr = leftExpr->Emit2FEExpr(stmts); + auto rightFEExpr = rightExpr->Emit2FEExpr(stmts); + UniqueFEIRType feirType = std::make_unique(*retType); + if (cvtNeeded) { + if (leftFEExpr->GetPrimType() != feirType->GetPrimType()) { + leftFEExpr = FEIRBuilder::CreateExprCvtPrim(std::move(leftFEExpr), feirType->GetPrimType()); + } + if (rightFEExpr->GetPrimType() != feirType->GetPrimType()) { + rightFEExpr = FEIRBuilder::CreateExprCvtPrim(std::move(rightFEExpr), feirType->GetPrimType()); + } + } + return FEIRBuilder::CreateExprBinary(std::move(feirType), opcode, std::move(leftFEExpr), std::move(rightFEExpr)); + } + } +} + +void ASTAssignExpr::ProcessAssign4ExprArrayStoreForC(std::list &stmts, UniqueFEIRExpr leftFEExpr, + UniqueFEIRExpr rightFEExpr) const { + auto arrayStoreForC = static_cast(leftFEExpr.get()); + FEIRExpr &exprArray = arrayStoreForC->GetExprArray(); + std::list &indexsExpr = arrayStoreForC->GetExprIndexs(); + FEIRType &typeArray = arrayStoreForC->GetTypeArray(); + UniqueFEIRExpr uExprArray = exprArray.Clone(); + UniqueFEIRType uTypeArray = typeArray.Clone(); + auto arrayName = arrayStoreForC->GetArrayName(); + if (arrayStoreForC->IsMember()) { + FEIRExpr &exprStruct = arrayStoreForC->GetExprStruct(); + FEIRType &typeStruct = arrayStoreForC->GetTypeSruct(); + UniqueFEIRExpr uExprStruct = exprStruct.Clone(); + UniqueFEIRType uTypeStruct = typeStruct.Clone(); + UniqueFEIRStmt stmt = std::make_unique(std::move(rightFEExpr), + std::move(uExprArray), + indexsExpr, + std::move(uTypeArray), + std::move(uExprStruct), + std::move(uTypeStruct), + arrayName); + stmts.emplace_back(std::move(stmt)); + } else { + UniqueFEIRStmt stmt = std::make_unique(std::move(rightFEExpr), + std::move(uExprArray), + indexsExpr, + std::move(uTypeArray), + arrayName); + stmts.emplace_back(std::move(stmt)); } } @@ -1050,52 +1328,39 @@ UniqueFEIRExpr ASTAssignExpr::ProcessAssign(std::list &stmts, Un if (leftFEExpr->GetKind() == FEIRNodeKind::kExprDRead && !leftFEExpr->GetType()->IsArray()) { auto dreadFEExpr = static_cast(leftFEExpr.get()); FieldID fieldID = dreadFEExpr->GetFieldID(); - std::string fieldName = dreadFEExpr->GetFieldName(); UniqueFEIRVar var = dreadFEExpr->GetVar()->Clone(); auto preStmt = std::make_unique(std::move(var), std::move(rightFEExpr), fieldID); - preStmt->SetFieldName(fieldName); stmts.emplace_back(std::move(preStmt)); return leftFEExpr; } else if (leftFEExpr->GetKind() == FEIRNodeKind::kExprIRead) { auto ireadFEExpr = static_cast(leftFEExpr.get()); FieldID fieldID = ireadFEExpr->GetFieldID(); - auto preStmt = std::make_unique(ireadFEExpr->GetClonedType(), ireadFEExpr->GetClonedOpnd(), + auto preStmt = std::make_unique(ireadFEExpr->GetClonedPtrType(), ireadFEExpr->GetClonedOpnd(), std::move(rightFEExpr), fieldID); - preStmt->SetFieldName(ireadFEExpr->GetFieldName()); stmts.emplace_back(std::move(preStmt)); return leftFEExpr; } else if (leftFEExpr->GetKind() == FEIRNodeKind::kExprArrayStoreForC) { - auto arrayStoreForC = static_cast(leftFEExpr.get()); - FEIRExpr &exprArray = arrayStoreForC->GetExprArray(); - std::list &indexsExpr = arrayStoreForC->GetExprIndexs(); - FEIRType &typeArray = arrayStoreForC->GetTypeArray(); - UniqueFEIRExpr uExprArray = exprArray.Clone(); - UniqueFEIRType uTypeArray = typeArray.Clone(); - if (arrayStoreForC->IsMember()) { - FEIRExpr &exprStruct = arrayStoreForC->GetExprStruct(); - FEIRType &typeStruct = arrayStoreForC->GetTypeSruct(); - UniqueFEIRExpr uExprStruct = exprStruct.Clone(); - UniqueFEIRType uTypeStruct = typeStruct.Clone(); - UniqueFEIRStmt stmt = std::make_unique(std::move(rightFEExpr), - std::move(uExprArray), - indexsExpr, - std::move(uTypeArray), - std::move(uExprStruct), - std::move(uTypeStruct)); - stmts.emplace_back(std::move(stmt)); - } else { - UniqueFEIRStmt stmt = std::make_unique(std::move(rightFEExpr), - std::move(uExprArray), - indexsExpr, - std::move(uTypeArray)); - stmts.emplace_back(std::move(stmt)); - } + ProcessAssign4ExprArrayStoreForC(stmts, leftFEExpr->Clone(), rightFEExpr->Clone()); + } else if (leftFEExpr->GetKind() == FEIRNodeKind::kExprFieldLoadForC) { + auto exprFieldLoadForC = static_cast(leftFEExpr.get()); + UniqueFEIRVar varStruct = exprFieldLoadForC->GetStructVar().Clone(); + MIRStructType *structType = exprFieldLoadForC->GetMIRStructType(); + uint32 fieldID = exprFieldLoadForC->GetFieldID(); + UniqueFEIRStmt stmt = FEIRBuilder::CreateStmtFieldStoreForC(std::move(varStruct), std::move(rightFEExpr), + structType, fieldID); + stmts.emplace_back(std::move(stmt)); } return nullptr; } UniqueFEIRExpr ASTAssignExpr::Emit2FEExprImpl(std::list &stmts) const { - UniqueFEIRExpr leftFEExpr = leftExpr->Emit2FEExpr(stmts); + UniqueFEIRExpr leftFEExpr; + if (isCompoundAssign) { + std::list dummyStmts; + leftFEExpr = leftExpr->Emit2FEExpr(dummyStmts); + } else { + leftFEExpr = leftExpr->Emit2FEExpr(stmts); + } UniqueFEIRExpr rightFEExpr = rightExpr->Emit2FEExpr(stmts); return ProcessAssign(stmts, std::move(leftFEExpr), std::move(rightFEExpr)); } @@ -1167,6 +1432,11 @@ UniqueFEIRExpr ASTConditionalOperator::Emit2FEExprImpl(std::list return FEIRBuilder::CreateExprTernary(OP_select, std::move(type), std::move(condFEIRExpr), std::move(trueFEIRExpr), std::move(falseFEIRExpr)); } + if (trueFEIRExpr == nullptr || falseFEIRExpr == nullptr) { + UniqueFEIRStmt stmtIf = FEIRBuilder::CreateStmtIf(std::move(condFEIRExpr), trueStmts, falseStmts); + stmts.emplace_back(std::move(stmtIf)); + return nullptr; + } // Otherwise, (e.g., a < 1 ? 1 : a++) create a temporary var to hold the return trueExpr or falseExpr value CHECK_FATAL(trueFEIRExpr->GetPrimType() == falseFEIRExpr->GetPrimType(), "The types of trueFEIRExpr and falseFEIRExpr are inconsistent"); @@ -1210,19 +1480,6 @@ UniqueFEIRExpr ASTImaginaryLiteral::Emit2FEExprImpl(std::list &s return expr; } -// ---------- ASTCompoundAssignOperatorExpr ---------- -UniqueFEIRExpr ASTCompoundAssignOperatorExpr::Emit2FEExprImpl(std::list &stmts) const { - UniqueFEIRExpr leftFEExpr = leftExpr->Emit2FEExpr(stmts); - UniqueFEIRExpr rightFEExpr = rightExpr->Emit2FEExpr(stmts); - PrimType leftPrimType = leftFEExpr->GetPrimType(); - PrimType rightPrimType = rightFEExpr->GetPrimType(); - if (rightPrimType != leftPrimType) { - rightFEExpr = FEIRBuilder::CreateExprCvtPrim(std::move(rightFEExpr), leftPrimType); - } - rightFEExpr = FEIRBuilder::CreateExprBinary(opForCompoundAssign, leftFEExpr->Clone(), std::move(rightFEExpr)); - return ProcessAssign(stmts, std::move(leftFEExpr), std::move(rightFEExpr)); -} - // ---------- ASTVAArgExpr ---------- UniqueFEIRExpr ASTVAArgExpr::Emit2FEExprImpl(std::list &stmts) const { CHECK_NULL_FATAL(mirType); @@ -1232,9 +1489,10 @@ UniqueFEIRExpr ASTVAArgExpr::Emit2FEExprImpl(std::list &stmts) c UniqueFEIRVar vaListVar = static_cast(dreadVaList.get())->GetVar()->Clone(); // The va_arg_offset temp var is created and assigned from __gr_offs or __vr_offs of va_list MIRType *int32Type = GlobalTables::GetTypeTable().GetInt32(); + UniqueFEIRType int32FETRType = std::make_unique(*int32Type); UniqueFEIRVar offsetVar = FEIRBuilder::CreateVarNameForC(FEUtils::GetSequentialName("va_arg_offs_"), *int32Type); UniqueFEIRExpr dreadVaListOffset = FEIRBuilder::CreateExprDReadAggField( - vaListVar->Clone(), info.isGPReg ? 4 : 5, int32Type); + vaListVar->Clone(), info.isGPReg ? 4 : 5, int32FETRType->Clone()); UniqueFEIRStmt dassignOffsetVar = FEIRBuilder::CreateStmtDAssign(offsetVar->Clone(), dreadVaListOffset->Clone()); stmts.emplace_back(std::move(dassignOffsetVar)); UniqueFEIRExpr dreadOffsetVar = FEIRBuilder::CreateExprDRead(offsetVar->Clone()); @@ -1247,7 +1505,7 @@ UniqueFEIRExpr ASTVAArgExpr::Emit2FEExprImpl(std::list &stmts) c MIRType *ptrType = GlobalTables::GetTypeTable().GetOrCreatePointerType((!info.isCopyedMem ? *mirType : *uint64Type)); UniqueFEIRVar vaArgVar = FEIRBuilder::CreateVarNameForC(FEUtils::GetSequentialName("va_arg"), *ptrType); UniqueFEIRExpr dreadVaArgTop = FEIRBuilder::CreateExprDReadAggField( - vaListVar->Clone(), info.isGPReg ? 2 : 3, uint64Type); + vaListVar->Clone(), info.isGPReg ? 2 : 3, uint64FEIRType->Clone()); UniqueFEIRExpr cvtOffset = FEIRBuilder::CreateExprCvtPrim(dreadOffsetVar->Clone(), PTY_u64); UniqueFEIRExpr addTopAndOffs = FEIRBuilder::CreateExprBinary(OP_add, std::move(dreadVaArgTop), std::move(cvtOffset)); UniqueFEIRStmt dassignVaArgFromReg = FEIRBuilder::CreateStmtDAssign(vaArgVar->Clone(), std::move(addTopAndOffs)); @@ -1272,7 +1530,7 @@ UniqueFEIRExpr ASTVAArgExpr::Emit2FEExprImpl(std::list &stmts) c trueStmtsInLower.emplace_back(std::move(dassignArgNextOffs)); trueStmtsInLower.emplace_back(std::move(stmtIfCondUpper)); // Otherwise, the va_arg will be got from stack and set next stack setoff - UniqueFEIRExpr dreadStackTop = FEIRBuilder::CreateExprDReadAggField(vaListVar->Clone(), 1, uint64Type); + UniqueFEIRExpr dreadStackTop = FEIRBuilder::CreateExprDReadAggField(vaListVar->Clone(), 1, uint64FEIRType->Clone()); UniqueFEIRStmt dassignVaArgFromStack = FEIRBuilder::CreateStmtDAssign(vaArgVar->Clone(), dreadStackTop->Clone()); UniqueFEIRExpr stackAUnitOffs = FEIRBuilder::CreateExprBinary( OP_add, dreadStackTop->Clone(), FEIRBuilder::CreateExprConstU64(info.stackOffset)); @@ -1388,6 +1646,13 @@ void ASTVAArgExpr::CvtHFA2Struct(MIRStructType &structType, UniqueFEIRVar vaArgV // ---------- ASTCStyleCastExpr ---------- UniqueFEIRExpr ASTCStyleCastExpr::Emit2FEExprImpl(std::list &stmts) const { + if (destType->GetPrimType() == PTY_void) { + std::list feExprs; + feExprs.emplace_back(child->Emit2FEExpr(stmts)); + UniqueFEIRStmt stmt = std::make_unique(OP_eval, std::move(feExprs)); + stmts.emplace_back(std::move(stmt)); + return nullptr; + } MIRType *src = canCastArray ? decl->GetTypeDesc().front() : srcType; auto feirCStyleCastExpr = std::make_unique(src, destType, child->Emit2FEExpr(stmts), diff --git a/src/mplfe/ast_input/src/ast_parser.cpp b/src/mplfe/ast_input/src/ast_parser.cpp index 5ae2f6a99a6c88fa9951ef52ae2cf23c4b8d874e..ec29e60d43ecb470db9d441c9591b368b12891b6 100644 --- a/src/mplfe/ast_input/src/ast_parser.cpp +++ b/src/mplfe/ast_input/src/ast_parser.cpp @@ -40,12 +40,7 @@ bool ASTParser::Verify() { } ASTBinaryOperatorExpr *ASTParser::AllocBinaryOperatorExpr(MapleAllocator &allocator, const clang::BinaryOperator &bo) { - if (bo.isCompoundAssignmentOp()) { - auto *expr = ASTDeclsBuilder::ASTExprBuilder(allocator); - clang::BinaryOperator::Opcode opcode = clang::BinaryOperator::getOpForCompoundAssignment(bo.getOpcode()); - Opcode mirOpcode = ASTUtil::CvtBinaryOpcode(opcode); - expr->SetOpForCompoundAssign(mirOpcode); - } else if (bo.isAssignmentOp()) { + if (bo.isAssignmentOp() && !bo.isCompoundAssignmentOp()) { return ASTDeclsBuilder::ASTExprBuilder(allocator); } if (bo.getOpcode() == clang::BO_Comma) { @@ -56,7 +51,11 @@ ASTBinaryOperatorExpr *ASTParser::AllocBinaryOperatorExpr(MapleAllocator &alloca return ASTDeclsBuilder::ASTExprBuilder(allocator); } MIRType *lhTy = astFile->CvtType(bo.getLHS()->getType()); - Opcode mirOpcode = ASTUtil::CvtBinaryOpcode(bo.getOpcode(), lhTy->GetPrimType()); + auto opcode = bo.getOpcode(); + if (bo.isCompoundAssignmentOp()) { + opcode = clang::BinaryOperator::getOpForCompoundAssignment(bo.getOpcode()); + } + Opcode mirOpcode = ASTUtil::CvtBinaryOpcode(opcode, lhTy->GetPrimType()); CHECK_FATAL(mirOpcode != OP_undef, "Opcode not support!"); auto *expr = ASTDeclsBuilder::ASTExprBuilder(allocator); expr->SetOpcode(mirOpcode); @@ -74,12 +73,7 @@ ASTStmt *ASTParser::ProcessStmtCompoundStmt(MapleAllocator &allocator, const cla clang::CompoundStmt::const_body_iterator it; ASTStmt *childStmt = nullptr; for (it = cpdStmt.body_begin(); it != cpdStmt.body_end(); ++it) { - if (llvm::isa(*it)) { - auto *tmpCpdStmt = llvm::cast(*it); - childStmt = ProcessStmtCompoundStmt(allocator, *tmpCpdStmt); - } else { - childStmt = ProcessStmt(allocator, **it); - } + childStmt = ProcessStmt(allocator, **it); if (childStmt != nullptr) { astCompoundStmt->SetASTStmt(childStmt); } else { @@ -89,9 +83,13 @@ ASTStmt *ASTParser::ProcessStmtCompoundStmt(MapleAllocator &allocator, const cla return astCompoundStmt; } -#define STMT_CASE(CLASS) \ - case clang::Stmt::CLASS##Class: \ - return ProcessStmt##CLASS(allocator, llvm::cast(stmt)); +#define STMT_CASE(CLASS) \ + case clang::Stmt::CLASS##Class: { \ + ASTStmt *astStmt = ProcessStmt##CLASS(allocator, llvm::cast(stmt)); \ + Pos loc = astFile->GetStmtLOC(stmt); \ + astStmt->SetSrcLOC(loc.first, loc.second); \ + return astStmt; \ + } ASTStmt *ASTParser::ProcessStmt(MapleAllocator &allocator, const clang::Stmt &stmt) { switch (stmt.getStmtClass()) { @@ -250,7 +248,7 @@ ASTStmt *ASTParser::ProcessStmtCStyleCastExpr(MapleAllocator &allocator, const c ASTStmt *ASTParser::ProcessStmtStmtExpr(MapleAllocator &allocator, const clang::StmtExpr &stmtExpr) { ASTStmtExprStmt *astStmt = ASTDeclsBuilder::ASTStmtBuilder(allocator); const clang::CompoundStmt *cpdStmt = stmtExpr.getSubStmt(); - ASTStmt *astCompoundStmt = ProcessStmtCompoundStmt(allocator, *cpdStmt); + ASTStmt *astCompoundStmt = ProcessStmt(allocator, *cpdStmt); astStmt->SetBodyStmt(astCompoundStmt); return astStmt; } @@ -298,7 +296,7 @@ ASTStmt *ASTParser::ProcessStmtIfStmt(MapleAllocator &allocator, const clang::If ASTStmt *astThenStmt = nullptr; const clang::Stmt *thenStmt = ifStmt.getThen(); if (thenStmt->getStmtClass() == clang::Stmt::CompoundStmtClass) { - astThenStmt = ProcessStmtCompoundStmt(allocator, *llvm::cast(thenStmt)); + astThenStmt = ProcessStmt(allocator, *llvm::cast(thenStmt)); } else { astThenStmt = ProcessStmt(allocator, *thenStmt); } @@ -307,7 +305,7 @@ ASTStmt *ASTParser::ProcessStmtIfStmt(MapleAllocator &allocator, const clang::If ASTStmt *astElseStmt = nullptr; const clang::Stmt *elseStmt = ifStmt.getElse(); if (elseStmt->getStmtClass() == clang::Stmt::CompoundStmtClass) { - astElseStmt = ProcessStmtCompoundStmt(allocator, *llvm::cast(elseStmt)); + astElseStmt = ProcessStmt(allocator, *llvm::cast(elseStmt)); } else { astElseStmt = ProcessStmt(allocator, *elseStmt); } @@ -343,7 +341,7 @@ ASTStmt *ASTParser::ProcessStmtForStmt(MapleAllocator &allocator, const clang::F ASTStmt *bodyStmt = nullptr; if (forStmt.getBody()->getStmtClass() == clang::Stmt::CompoundStmtClass) { const auto *tmpCpdStmt = llvm::cast(forStmt.getBody()); - bodyStmt = ProcessStmtCompoundStmt(allocator, *tmpCpdStmt); + bodyStmt = ProcessStmt(allocator, *tmpCpdStmt); } else { bodyStmt = ProcessStmt(allocator, *forStmt.getBody()); } @@ -359,13 +357,7 @@ ASTStmt *ASTParser::ProcessStmtWhileStmt(MapleAllocator &allocator, const clang: return nullptr; } astStmt->SetCondExpr(condExpr); - ASTStmt *bodyStmt = nullptr; - if (whileStmt.getBody()->getStmtClass() == clang::Stmt::CompoundStmtClass) { - const auto *tmpCpdStmt = llvm::cast(whileStmt.getBody()); - bodyStmt = ProcessStmtCompoundStmt(allocator, *tmpCpdStmt); - } else { - bodyStmt = ProcessStmt(allocator, *whileStmt.getBody()); - } + ASTStmt *bodyStmt = ProcessStmt(allocator, *whileStmt.getBody()); astStmt->SetBodyStmt(bodyStmt); return astStmt; } @@ -452,12 +444,7 @@ ASTStmt *ASTParser::ProcessStmtDoStmt(MapleAllocator &allocator, const clang::Do return nullptr; } astStmt->SetCondExpr(condExpr); - ASTStmt *bodyStmt = nullptr; - if (doStmt.getBody()->getStmtClass() == clang::Stmt::CompoundStmtClass) { - bodyStmt = ProcessStmtCompoundStmt(allocator, *llvm::cast(doStmt.getBody())); - } else { - bodyStmt = ProcessStmt(allocator, *doStmt.getBody()); - } + ASTStmt *bodyStmt = ProcessStmt(allocator, *doStmt.getBody()); astStmt->SetBodyStmt(bodyStmt); return astStmt; } @@ -581,7 +568,15 @@ ASTValue *ASTParser::TranslateLValue2ASTValue(MapleAllocator &allocator, const c astValue->pty = PTY_a64; switch (lvExpr->getStmtClass()) { case clang::Stmt::StringLiteralClass: { - std::string str = llvm::cast(*lvExpr).getString().str(); + const clang::StringLiteral &strExpr = llvm::cast(*lvExpr); + std::string str = ""; + if (strExpr.isWide()) { + for (uint32 i = 0; i < strExpr.getLength(); ++i) { + str += std::to_string(strExpr.getCodeUnit(i)); + } + } else { + str = strExpr.getString().str(); + } UStrIdx strIdx = GlobalTables::GetUStrTable().GetOrCreateStrIdxFromName(str); astValue->val.strIdx = strIdx; break; @@ -617,6 +612,8 @@ ASTValue *ASTParser::TranslateExprEval(MapleAllocator &allocator, const clang::E case clang::Stmt::CLASS##Class: { \ ASTExpr *astExpr = ProcessExpr##CLASS(allocator, llvm::cast(*expr)); \ astExpr->SetConstantValue(TranslateExprEval(allocator, expr)); \ + Pos loc = astFile->GetStmtLOC(*expr); \ + astExpr->SetSrcLOC(loc.first, loc.second); \ return astExpr; \ } @@ -855,16 +852,43 @@ ASTExpr *ASTParser::ProcessExprInitListExpr(MapleAllocator &allocator, const cla ASTInitListExpr *astInitListExpr = ASTDeclsBuilder::ASTExprBuilder(allocator); CHECK_FATAL(astInitListExpr != nullptr, "ASTInitListExpr is nullptr"); MIRType *initListType = astFile->CvtType(expr.getType()); + clang::QualType aggType = expr.getType().getCanonicalType(); astInitListExpr->SetInitListType(initListType); + const clang::FieldDecl *fieldDecl = expr.getInitializedFieldInUnion(); + astInitListExpr->SetIsUnionInitListExpr(fieldDecl != nullptr); uint32 n = expr.getNumInits(); + if (n == 0) { + return astInitListExpr; + } clang::Expr * const *le = expr.getInits(); - for (uint32 i = 0; i < n; ++i) { - const clang::Expr *eExpr = le[i]; - ASTExpr *astExpr = ProcessExpr(allocator, eExpr); - if (astExpr == nullptr) { - return nullptr; + if (aggType->isRecordType()) { + const auto *recordType = llvm::cast(aggType); + clang::RecordDecl *recordDecl = recordType->getDecl(); + ASTDecl *astDecl = ProcessDecl(allocator, *recordDecl); + CHECK_FATAL(astDecl != nullptr && astDecl->GetDeclKind() == kASTStruct, "Undefined record type"); + uint i = 0; + for (const auto field : static_cast(astDecl)->GetFields()) { + if (field->IsAnonymousField()) { + astInitListExpr->SetFillerExprs(nullptr); + } else { + if (i < n) { + const clang::Expr *eExpr = le[i]; + ASTExpr *astExpr = ProcessExpr(allocator, eExpr); + CHECK_FATAL(astExpr != nullptr, "Invalid InitListExpr"); + astInitListExpr->SetFillerExprs(astExpr); + i++; + } + } + } + } else { + for (uint32 i = 0; i < n; ++i) { + const clang::Expr *eExpr = le[i]; + ASTExpr *astExpr = ProcessExpr(allocator, eExpr); + if (astExpr == nullptr) { + return nullptr; + } + astInitListExpr->SetFillerExprs(astExpr); } - astInitListExpr->SetFillerExprs(astExpr); } return astInitListExpr; } @@ -945,7 +969,13 @@ ASTExpr *ASTParser::ProcessExprArraySubscriptExpr(MapleAllocator &allocator, con if (idxExpr == nullptr) { return nullptr; } + if (base->getStmtClass() != clang::Stmt::ImplicitCastExprClass) { + break; + } base = static_cast(base)->getSubExpr(); + if (base->getStmtClass() != clang::Stmt::ArraySubscriptExprClass) { + break; + } exprTmp = static_cast(base); } // array in struct @@ -957,6 +987,7 @@ ASTExpr *ASTParser::ProcessExprArraySubscriptExpr(MapleAllocator &allocator, con } astArraySubscriptExpr->SetBaseExpr(declRefExpr); astArraySubscriptExpr->SetMemberExpr(*memberExpr); + astArraySubscriptExpr->SetBaseExprVarName(declRefExpr->GetASTDecl()->GenerateUniqueVarName()); } else { // base is DeclRefExpr ASTExpr *baseExpr = ProcessExpr(allocator, base); @@ -964,6 +995,10 @@ ASTExpr *ASTParser::ProcessExprArraySubscriptExpr(MapleAllocator &allocator, con return nullptr; } astArraySubscriptExpr->SetBaseExpr(baseExpr); + ASTDecl *decl = baseExpr->GetASTDecl(); + if (decl != nullptr) { + astArraySubscriptExpr->SetBaseExprVarName(decl->GenerateUniqueVarName()); + } } return astArraySubscriptExpr; } @@ -973,6 +1008,39 @@ uint32 ASTParser::GetSizeFromQualType(const clang::QualType qualType) { return astFile->GetContext()->getTypeSizeInChars(desugaredType).getQuantity(); } +uint32_t ASTParser::GetAlignOfType(const clang::QualType currQualType, clang::UnaryExprOrTypeTrait exprKind) { + clang::QualType qualType = currQualType; + clang::CharUnits alignInCharUnits = clang::CharUnits::Zero(); + if (const auto *ref = currQualType->getAs()) { + qualType = ref->getPointeeType(); + } + if (qualType.getQualifiers().hasUnaligned()) { + alignInCharUnits = clang::CharUnits::One(); + } + if (exprKind == clang::UETT_AlignOf) { + alignInCharUnits = astFile->GetContext()->getTypeAlignInChars(qualType.getTypePtr()); + } else if (exprKind == clang::UETT_PreferredAlignOf) { + alignInCharUnits = astFile->GetContext()->toCharUnitsFromBits( + astFile->GetContext()->getPreferredTypeAlign(qualType.getTypePtr())); + } else { + CHECK_FATAL(false, "NIY"); + } + return static_cast(alignInCharUnits.getQuantity()); +} + +uint32_t ASTParser::GetAlignOfExpr(const clang::Expr &expr, clang::UnaryExprOrTypeTrait exprKind) { + clang::CharUnits alignInCharUnits = clang::CharUnits::Zero(); + const clang::Expr *exprNoParens = expr.IgnoreParens(); + if (const auto *declRefExpr = clang::dyn_cast(exprNoParens)) { + alignInCharUnits = astFile->GetContext()->getDeclAlign(declRefExpr->getDecl(), true); + } else if (const auto *memberExpr = clang::dyn_cast(exprNoParens)) { + alignInCharUnits = astFile->GetContext()->getDeclAlign(memberExpr->getMemberDecl(), true); + } else { + return GetAlignOfType(exprNoParens->getType(), exprKind); + } + return static_cast(alignInCharUnits.getQuantity()); +} + ASTExpr *ASTParser::ProcessExprUnaryExprOrTypeTraitExpr(MapleAllocator &allocator, const clang::UnaryExprOrTypeTraitExpr &expr) { auto *astExprUnaryExprOrTypeTraitExpr = ASTDeclsBuilder::ASTExprBuilder(allocator); @@ -1000,8 +1068,16 @@ ASTExpr *ASTParser::ProcessExprUnaryExprOrTypeTraitExpr(MapleAllocator &allocato case clang::UETT_PreferredAlignOf: case clang::UETT_AlignOf: { // C11 specification: ISO/IEC 9899:201x - CHECK_FATAL(false, "NIY"); - break; + uint32_t align; + if (expr.isArgumentType()) { + align = GetAlignOfType(expr.getArgumentType(), expr.getKind()); + } else { + align = GetAlignOfExpr(*expr.getArgumentExpr(), expr.getKind()); + } + auto integerExpr = ASTDeclsBuilder::ASTExprBuilder(allocator); + integerExpr->SetType(PTY_u64); + integerExpr->SetVal(align); + return integerExpr; } case clang::UETT_VecStep: CHECK_FATAL(false, "NIY"); @@ -1079,30 +1155,7 @@ ASTExpr *ASTParser::ProcessExprConditionalOperator(MapleAllocator &allocator, co ASTExpr *ASTParser::ProcessExprCompoundAssignOperator(MapleAllocator &allocator, const clang::CompoundAssignOperator &expr) { - auto *astCompoundAssignOperatorExpr = ASTDeclsBuilder::ASTExprBuilder(allocator); - ASSERT(astCompoundAssignOperatorExpr != nullptr, "astCompoundAssignOperatorExpr is nullptr"); - clang::Expr *lExpr = expr.getLHS(); - if (lExpr != nullptr) { - ASTExpr *astLExpr = ProcessExpr(allocator, lExpr); - if (astLExpr != nullptr) { - astCompoundAssignOperatorExpr->SetLeftExpr(astLExpr); - } else { - return nullptr; - } - } - clang::Expr *rExpr = expr.getRHS(); - if (rExpr != nullptr) { - ASTExpr *astRExpr = ProcessExpr(allocator, rExpr); - if (astRExpr != nullptr) { - astCompoundAssignOperatorExpr->SetRightExpr(astRExpr); - } else { - return nullptr; - } - } - clang::BinaryOperator::Opcode op = clang::BinaryOperator::getOpForCompoundAssignment(expr.getOpcode()); - astCompoundAssignOperatorExpr->SetOpForCompoundAssign(ASTUtil::CvtBinaryOpcode(op)); - astCompoundAssignOperatorExpr->SetRetType(astFile->CvtType(expr.getComputationResultType())); - return astCompoundAssignOperatorExpr; + return ProcessExprBinaryOperator(allocator, expr); } ASTExpr *ASTParser::ProcessExprSizeOfPackExpr(MapleAllocator &allocator, const clang::SizeOfPackExpr &expr) { @@ -1194,6 +1247,9 @@ ASTExpr *ASTParser::ProcessExprCallExpr(MapleAllocator &allocator, const clang:: ASTUtil::AdjustName(funcName); } astCallExpr->SetFuncName(funcName); + GenericAttrs attrs; + astFile->CollectFuncAttrs(*funcDecl, attrs, kPublic); + astCallExpr->SetFuncAttrs(attrs.ConvertToFuncAttrs()); } else { astCallExpr->SetIcall(true); } @@ -1299,6 +1355,7 @@ ASTExpr *ASTParser::ProcessExprImplicitCastExpr(MapleAllocator &allocator, const CHECK_FATAL(astImplicitCastExpr != nullptr, "astImplicitCastExpr is nullptr"); switch (expr.getCastKind()) { case clang::CK_NoOp: + case clang::CK_ToVoid: break; case clang::CK_ArrayToPointerDecay: astImplicitCastExpr->SetIsArrayToPointerDecay(true); @@ -1413,36 +1470,51 @@ ASTExpr *ASTParser::ProcessExprBinaryOperator(MapleAllocator &allocator, const c ASTBinaryOperatorExpr *astBinOpExpr = AllocBinaryOperatorExpr(allocator, bo); CHECK_FATAL(astBinOpExpr != nullptr, "astBinOpExpr is nullptr"); clang::QualType qualType = bo.getType(); - if ((qualType->isAnyComplexType() && (bo.isAdditiveOp() || bo.isMultiplicativeOp())) || - (bo.isEqualityOp() && bo.getRHS()->getType()->isAnyComplexType() && bo.getLHS()->getType()->isAnyComplexType())) { + auto clangOpCode = bo.getOpcode(); + if (bo.isCompoundAssignmentOp()) { + clangOpCode = clang::BinaryOperator::getOpForCompoundAssignment(bo.getOpcode()); + } + if ((qualType->isAnyComplexType() && + (clang::BinaryOperator::isAdditiveOp(clangOpCode) || clang::BinaryOperator::isMultiplicativeOp(clangOpCode))) || + (clang::BinaryOperator::isEqualityOp(clangOpCode) && bo.getRHS()->getType()->isAnyComplexType() && + bo.getLHS()->getType()->isAnyComplexType())) { return ProcessExprBinaryOperatorComplex(allocator, bo); } astBinOpExpr->SetRetType(astFile->CvtType(qualType)); ASTExpr *astRExpr = ProcessExpr(allocator, bo.getRHS()); ASTExpr *astLExpr = ProcessExpr(allocator, bo.getLHS()); - if (bo.getType()->isPointerType() && bo.isAdditiveOp()) { + auto leftMirType = astFile->CvtType(bo.getLHS()->getType()); + auto rightMirType = astFile->CvtType(bo.getRHS()->getType()); + if ((leftMirType->GetPrimType() != astBinOpExpr->GetRetType()->GetPrimType() || + rightMirType->GetPrimType() != astBinOpExpr->GetRetType()->GetPrimType()) + && (clang::BinaryOperator::isAdditiveOp(clangOpCode) || clang::BinaryOperator::isMultiplicativeOp(clangOpCode)) + && !bo.getType()->isPointerType() && !bo.getLHS()->getType()->isPointerType() && + !bo.getRHS()->getType()->isPointerType()) { + astBinOpExpr->SetCvtNeeded(true); + } + if (bo.getType()->isPointerType() && clang::BinaryOperator::isAdditiveOp(clangOpCode)) { auto ptrSizeExpr = ASTDeclsBuilder::ASTExprBuilder(allocator); - ptrSizeExpr->SetType(astBinOpExpr->GetRetType()->GetPrimType()); + ptrSizeExpr->SetType(PTY_i32); ptrSizeExpr->SetVal(GetSizeFromQualType(bo.getType()->getPointeeType())); if (bo.getLHS()->getType()->isPointerType()) { auto rhs = ASTDeclsBuilder::ASTExprBuilder(allocator); rhs->SetLeftExpr(astRExpr); rhs->SetRightExpr(ptrSizeExpr); rhs->SetOpcode(OP_mul); - rhs->SetRetType(astBinOpExpr->GetRetType()); + rhs->SetRetType(GlobalTables::GetTypeTable().GetPrimType(PTY_i32)); astRExpr = rhs; } else if (bo.getRHS()->getType()->isPointerType()) { auto lhs = ASTDeclsBuilder::ASTExprBuilder(allocator); lhs->SetLeftExpr(astLExpr); lhs->SetRightExpr(ptrSizeExpr); lhs->SetOpcode(OP_mul); - lhs->SetRetType(astBinOpExpr->GetRetType()); + lhs->SetRetType(GlobalTables::GetTypeTable().GetPrimType(PTY_i32)); astLExpr = lhs; } } astBinOpExpr->SetLeftExpr(astLExpr); astBinOpExpr->SetRightExpr(astRExpr); - if (bo.getOpcode() == clang::BO_Sub && bo.getRHS()->getType()->isPointerType() && + if (clangOpCode == clang::BO_Sub && bo.getRHS()->getType()->isPointerType() && bo.getLHS()->getType()->isPointerType()) { auto ptrSizeExpr = ASTDeclsBuilder::ASTExprBuilder(allocator); ptrSizeExpr->SetType(astBinOpExpr->GetRetType()->GetPrimType()); @@ -1454,6 +1526,14 @@ ASTExpr *ASTParser::ProcessExprBinaryOperator(MapleAllocator &allocator, const c retASTExpr->SetRetType(astBinOpExpr->GetRetType()); astBinOpExpr = retASTExpr; } + if (bo.isCompoundAssignmentOp()) { + auto assignExpr = ASTDeclsBuilder::ASTExprBuilder(allocator); + assignExpr->SetLeftExpr(astLExpr); + assignExpr->SetRightExpr(astBinOpExpr); + assignExpr->SetRetType(astFile->CvtType(bo.getType())); + assignExpr->SetIsCompoundAssign(true); + return assignExpr; + } return astBinOpExpr; } @@ -1677,6 +1757,7 @@ ASTDecl *ASTParser::ProcessDecl(MapleAllocator &allocator, const clang::Decl &de DECL_CASE(Enum); DECL_CASE(Typedef); DECL_CASE(EnumConstant); + DECL_CASE(Label); default: CHECK_FATAL(false, "ASTDecl: %s NIY", decl.getDeclKindName()); return nullptr; @@ -1685,6 +1766,10 @@ ASTDecl *ASTParser::ProcessDecl(MapleAllocator &allocator, const clang::Decl &de } ASTDecl *ASTParser::ProcessDeclRecordDecl(MapleAllocator &allocator, const clang::RecordDecl &recDecl) { + ASTStruct *curStructOrUnion = static_cast(ASTDeclsBuilder::GetASTDecl(recDecl.getID())); + if (curStructOrUnion != nullptr) { + return curStructOrUnion; + } std::stringstream recName; clang::QualType qType = recDecl.getTypeForDecl()->getCanonicalTypeInternal(); astFile->EmitTypeName(*qType->getAs(), recName); @@ -1699,7 +1784,7 @@ ASTDecl *ASTParser::ProcessDeclRecordDecl(MapleAllocator &allocator, const clang uint32 id = qType->getAs()->getDecl()->getLocation().getRawEncoding(); structName = astFile->GetOrCreateMappedUnnamedName(id); } - ASTStruct *curStructOrUnion = ASTDeclsBuilder::ASTStructBuilder( + curStructOrUnion = ASTDeclsBuilder::ASTStructBuilder( allocator, fileName, structName, std::vector{recType}, attrs, recDecl.getID()); if (recDecl.isUnion()) { curStructOrUnion->SetIsUnion(); @@ -1738,6 +1823,10 @@ ASTDecl *ASTParser::ProcessDeclRecordDecl(MapleAllocator &allocator, const clang } ASTDecl *ASTParser::ProcessDeclFunctionDecl(MapleAllocator &allocator, const clang::FunctionDecl &funcDecl) { + ASTFunc *astFunc = static_cast(ASTDeclsBuilder::GetASTDecl(funcDecl.getID())); + if (astFunc != nullptr) { + return astFunc; + } std::string funcName = astFile->GetMangledName(funcDecl); if (funcName.empty()) { return nullptr; @@ -1765,12 +1854,11 @@ ASTDecl *ASTParser::ProcessDeclFunctionDecl(MapleAllocator &allocator, const cla } GenericAttrs attrs; astFile->CollectFuncAttrs(funcDecl, attrs, kPublic); - ASTFunc *astFunc = ASTDeclsBuilder::ASTFuncBuilder( + astFunc = ASTDeclsBuilder::ASTFuncBuilder( allocator, fileName, funcName, typeDescIn, attrs, parmNamesIn, funcDecl.getID()); CHECK_FATAL(astFunc != nullptr, "astFunc is nullptr"); if (funcDecl.hasBody()) { - ASTStmt *astCompoundStmt = ProcessStmtCompoundStmt(allocator, - *llvm::cast(funcDecl.getBody())); + ASTStmt *astCompoundStmt = ProcessStmt(allocator, *llvm::cast(funcDecl.getBody())); if (astCompoundStmt != nullptr) { astFunc->SetCompoundStmt(astCompoundStmt); } else { @@ -1781,9 +1869,15 @@ ASTDecl *ASTParser::ProcessDeclFunctionDecl(MapleAllocator &allocator, const cla } ASTDecl *ASTParser::ProcessDeclFieldDecl(MapleAllocator &allocator, const clang::FieldDecl &decl) { + ASTField *astField = static_cast(ASTDeclsBuilder::GetASTDecl(decl.getID())); + if (astField != nullptr) { + return astField; + } clang::QualType qualType = decl.getType(); std::string fieldName = astFile->GetMangledName(decl); + bool isAnonymousField = false; if (fieldName.empty()) { + isAnonymousField = true; uint32 id = decl.getLocation().getRawEncoding(); fieldName = astFile->GetOrCreateMappedUnnamedName(id); } @@ -1800,10 +1894,15 @@ ASTDecl *ASTParser::ProcessDeclFieldDecl(MapleAllocator &allocator, const clang: } GenericAttrs attrs; astFile->CollectAttrs(decl, attrs, kPublic); - return ASTDeclsBuilder::ASTFieldBuilder(allocator, fileName, fieldName, std::vector{fieldType}, attrs); + return ASTDeclsBuilder::ASTFieldBuilder( + allocator, fileName, fieldName, std::vector{fieldType}, attrs, decl.getID(), isAnonymousField); } ASTDecl *ASTParser::ProcessDeclVarDecl(MapleAllocator &allocator, const clang::VarDecl &varDecl) { + ASTVar *astVar = static_cast(ASTDeclsBuilder::GetASTDecl(varDecl.getID())); + if (astVar != nullptr) { + return astVar; + } std::string varName = astFile->GetMangledName(varDecl); if (varName.empty()) { return nullptr; @@ -1815,7 +1914,7 @@ ASTDecl *ASTParser::ProcessDeclVarDecl(MapleAllocator &allocator, const clang::V } GenericAttrs attrs; astFile->CollectAttrs(varDecl, attrs, kPublic); - ASTVar *astVar = ASTDeclsBuilder::ASTVarBuilder( + astVar = ASTDeclsBuilder::ASTVarBuilder( allocator, fileName, varName, std::vector{varType}, attrs, varDecl.getID()); if (varDecl.hasInit()) { @@ -1831,6 +1930,10 @@ ASTDecl *ASTParser::ProcessDeclVarDecl(MapleAllocator &allocator, const clang::V } ASTDecl *ASTParser::ProcessDeclParmVarDecl(MapleAllocator &allocator, const clang::ParmVarDecl &parmVarDecl) { + ASTVar *parmVar = static_cast(ASTDeclsBuilder::GetASTDecl(parmVarDecl.getID())); + if (parmVar != nullptr) { + return parmVar; + } const clang::QualType parmQualType = parmVarDecl.getType(); std::string parmName = parmVarDecl.getNameAsString(); if (parmName.length() == 0) { @@ -1842,18 +1945,22 @@ ASTDecl *ASTParser::ProcessDeclParmVarDecl(MapleAllocator &allocator, const clan } GenericAttrs attrs; astFile->CollectAttrs(parmVarDecl, attrs, kPublic); - ASTVar *parmVar = ASTDeclsBuilder::ASTVarBuilder( + parmVar = ASTDeclsBuilder::ASTVarBuilder( allocator, fileName, parmName, std::vector{paramType}, attrs, parmVarDecl.getID()); parmVar->SetIsParam(true); return parmVar; } ASTDecl *ASTParser::ProcessDeclEnumDecl(MapleAllocator &allocator, const clang::EnumDecl &enumDecl) { + ASTLocalEnumDecl *localEnumDecl = static_cast(ASTDeclsBuilder::GetASTDecl(enumDecl.getID())); + if (localEnumDecl != nullptr) { + return localEnumDecl; + } GenericAttrs attrs; astFile->CollectAttrs(*clang::dyn_cast(&enumDecl), attrs, kPublic); const std::string &enumName = clang::dyn_cast(&enumDecl)->getNameAsString(); - ASTLocalEnumDecl *localEnumDecl = ASTDeclsBuilder::ASTLocalEnumDeclBuilder(allocator, fileName, enumName, - std::vector{}, attrs); + localEnumDecl = ASTDeclsBuilder::ASTLocalEnumDeclBuilder(allocator, fileName, enumName, + std::vector{}, attrs, enumDecl.getID()); TraverseDecl(&enumDecl, [&](clang::Decl *child) { CHECK_FATAL(child->getKind() == clang::Decl::EnumConstant, "Unsupported decl kind: %u", child->getKind()); localEnumDecl->PushConstantVar(static_cast(ProcessDecl(allocator, *child))); @@ -1876,11 +1983,15 @@ ASTDecl *ASTParser::ProcessDeclTypedefDecl(MapleAllocator &allocator, const clan } ASTDecl *ASTParser::ProcessDeclEnumConstantDecl(MapleAllocator &allocator, const clang::EnumConstantDecl &decl) { + ASTVar *astVar = static_cast(ASTDeclsBuilder::GetASTDecl(decl.getID())); + if (astVar != nullptr) { + return astVar; + } GenericAttrs attrs; astFile->CollectAttrs(*clang::dyn_cast(&decl), attrs, kPublic); const std::string &varName = clang::dyn_cast(&decl)->getNameAsString(); MIRType *mirType = astFile->CvtType(clang::dyn_cast(&decl)->getType()); - ASTVar *astVar = + astVar = ASTDeclsBuilder::ASTVarBuilder(allocator, fileName, varName, std::vector{mirType}, attrs, decl.getID()); auto constExpr = ASTDeclsBuilder::ASTExprBuilder(allocator); constExpr->SetVal( @@ -1896,6 +2007,10 @@ ASTDecl *ASTParser::ProcessDeclEnumConstantDecl(MapleAllocator &allocator, const return astVar; } +ASTDecl *ASTParser::ProcessDeclLabelDecl(MapleAllocator &allocator, const clang::LabelDecl &decl) { + return nullptr; +} + bool ASTParser::RetrieveStructs(MapleAllocator &allocator) { for (auto &decl : recordDecles) { clang::RecordDecl *recDecl = llvm::cast(decl->getCanonicalDecl()); diff --git a/src/mplfe/ast_input/src/ast_stmt.cpp b/src/mplfe/ast_input/src/ast_stmt.cpp index 5db6119c8d7b1fadef5e1a2434b6cf5dbff45944..2ae654e53d68428a61e54db6f2206bd983bbd531 100644 --- a/src/mplfe/ast_input/src/ast_stmt.cpp +++ b/src/mplfe/ast_input/src/ast_stmt.cpp @@ -49,6 +49,7 @@ std::list ASTReturnStmt::Emit2FEStmtImpl() const { auto astExpr = exprs.front(); UniqueFEIRExpr feExpr = (astExpr != nullptr) ? astExpr->Emit2FEExpr(stmts) : nullptr; UniqueFEIRStmt stmt = std::make_unique(std::move(feExpr)); + stmt->SetSrcFileInfo(GetSrcFileIdx(), GetSrcFileLineNum()); stmts.emplace_back(std::move(stmt)); return stmts; } @@ -66,6 +67,7 @@ std::list ASTIfStmt::Emit2FEStmtImpl() const { UniqueFEIRExpr condFEExpr = condExpr->Emit2FEExpr(stmts); UniqueFEIRStmt ifStmt; ifStmt = FEIRBuilder::CreateStmtIf(std::move(condFEExpr), thenStmts, elseStmts); + ifStmt->SetSrcFileInfo(GetSrcFileIdx(), GetSrcFileLineNum()); stmts.emplace_back(std::move(ifStmt)); return stmts; } @@ -85,10 +87,7 @@ std::list ASTForStmt::Emit2FEStmtImpl() const { bodyFEStmts.emplace_back(std::move(labelBodyEndStmt)); UniqueFEIRExpr condFEExpr; if (condExpr != nullptr) { - condFEExpr = condExpr->Emit2FEExpr(stmts); - std::list condStmts; - condFEExpr = condExpr->Emit2FEExpr(condStmts); - bodyFEStmts.splice(bodyFEStmts.cend(), condStmts); + (void)condExpr->Emit2FEExpr(stmts); } else { condFEExpr = std::make_unique(static_cast(1), PTY_i32); } @@ -101,7 +100,13 @@ std::list ASTForStmt::Emit2FEStmtImpl() const { incStmts.emplace_back(std::move(incStmt)); bodyFEStmts.splice(bodyFEStmts.cend(), incStmts); } + if (condExpr != nullptr) { + std::list condStmts; + condFEExpr = condExpr->Emit2FEExpr(condStmts); + bodyFEStmts.splice(bodyFEStmts.cend(), condStmts); + } UniqueFEIRStmt whileStmt = std::make_unique(OP_while, std::move(condFEExpr), std::move(bodyFEStmts)); + whileStmt->SetSrcFileInfo(GetSrcFileIdx(), GetSrcFileLineNum()); stmts.emplace_back(std::move(whileStmt)); stmts.emplace_back(std::move(labelLoopEndStmt)); AstLoopUtil::Instance().PopCurrentLoop(); @@ -123,6 +128,7 @@ std::list ASTWhileStmt::Emit2FEStmtImpl() const { bodyFEStmts.emplace_back(std::move(labelBodyEndStmt)); bodyFEStmts.splice(bodyFEStmts.end(), condPreStmts); auto whileStmt = std::make_unique(OP_while, std::move(condFEExpr), std::move(bodyFEStmts)); + whileStmt->SetSrcFileInfo(GetSrcFileIdx(), GetSrcFileLineNum()); stmts.splice(stmts.end(), condStmts); stmts.emplace_back(std::move(whileStmt)); stmts.emplace_back(std::move(labelLoopEndStmt)); @@ -147,6 +153,7 @@ std::list ASTDoStmt::Emit2FEStmtImpl() const { bodyFEStmts.splice(bodyFEStmts.end(), condStmts); UniqueFEIRStmt whileStmt = std::make_unique(OP_dowhile, std::move(condFEExpr), std::move(bodyFEStmts)); + whileStmt->SetSrcFileInfo(GetSrcFileIdx(), GetSrcFileLineNum()); stmts.emplace_back(std::move(whileStmt)); stmts.emplace_back(std::move(labelLoopEndStmt)); AstLoopUtil::Instance().PopCurrentLoop(); @@ -159,6 +166,7 @@ std::list ASTBreakStmt::Emit2FEStmtImpl() const { if (!AstLoopUtil::Instance().IsLoopLabelsEmpty()) { stmt->SetLoopLabelName(AstLoopUtil::Instance().GetCurrentLoop().second); } + stmt->SetSrcFileInfo(GetSrcFileIdx(), GetSrcFileLineNum()); stmts.emplace_back(std::move(stmt)); return stmts; } @@ -166,6 +174,7 @@ std::list ASTBreakStmt::Emit2FEStmtImpl() const { std::list ASTLabelStmt::Emit2FEStmtImpl() const { std::list stmts; auto feStmt = std::make_unique(labelName); + feStmt->SetSrcFileInfo(GetSrcFileIdx(), GetSrcFileLineNum()); stmts.emplace_back(std::move(feStmt)); stmts.splice(stmts.end(), subStmt->Emit2FEStmt()); return stmts; @@ -174,6 +183,7 @@ std::list ASTLabelStmt::Emit2FEStmtImpl() const { std::list ASTContinueStmt::Emit2FEStmtImpl() const { std::list stmts; auto stmt = std::make_unique(); + stmt->SetSrcFileInfo(GetSrcFileIdx(), GetSrcFileLineNum()); stmt->SetLabelName(AstLoopUtil::Instance().GetCurrentLoop().first); stmts.emplace_back(std::move(stmt)); return stmts; @@ -191,6 +201,7 @@ std::list ASTUnaryOperatorStmt::Emit2FEStmtImpl() const { std::list ASTGotoStmt::Emit2FEStmtImpl() const { std::list stmts; UniqueFEIRStmt stmt = FEIRBuilder::CreateStmtGoto(labelName); + stmt->SetSrcFileInfo(GetSrcFileIdx(), GetSrcFileLineNum()); stmts.emplace_back(std::move(stmt)); return stmts; } @@ -200,6 +211,7 @@ std::list ASTSwitchStmt::Emit2FEStmtImpl() const { std::list stmts; UniqueFEIRExpr expr = condExpr->Emit2FEExpr(stmts); auto switchStmt = std::make_unique(std::move(expr), hasDefualt); + switchStmt->SetSrcFileInfo(GetSrcFileIdx(), GetSrcFileLineNum()); for (auto &s : bodyStmt->Emit2FEStmt()) { switchStmt.get()->AddFeirStmt(std::move(s)); } @@ -211,6 +223,7 @@ std::list ASTSwitchStmt::Emit2FEStmtImpl() const { std::list ASTCaseStmt::Emit2FEStmtImpl() const { std::list stmts; auto caseStmt = std::make_unique(lCaseTag); + caseStmt->SetSrcFileInfo(GetSrcFileIdx(), GetSrcFileLineNum()); caseStmt.get()->AddCaseTag2CaseVec(lCaseTag, rCaseTag); for (auto &s : subStmt->Emit2FEStmt()) { caseStmt.get()->AddFeirStmt(std::move(s)); @@ -222,11 +235,12 @@ std::list ASTCaseStmt::Emit2FEStmtImpl() const { // ---------- ASTDefaultStmt ---------- std::list ASTDefaultStmt::Emit2FEStmtImpl() const { std::list stmts; - auto defalutStmt = std::make_unique(); + auto defaultStmt = std::make_unique(); + defaultStmt->SetSrcFileInfo(GetSrcFileIdx(), GetSrcFileLineNum()); for (auto &s : child->Emit2FEStmt()) { - defalutStmt.get()->AddFeirStmt(std::move(s)); + defaultStmt.get()->AddFeirStmt(std::move(s)); } - stmts.emplace_back(std::move(defalutStmt)); + stmts.emplace_back(std::move(defaultStmt)); return stmts; } @@ -265,20 +279,27 @@ std::list ASTCallExprStmt::Emit2FEStmtCall() const { StructElemNameIdx *nameIdx = FEManager::GetManager().GetStructElemMempool()->New(funcName); FEStructMethodInfo *info = static_cast( FEManager::GetTypeManager().RegisterStructMethodInfo(*nameIdx, kSrcLangC, false)); - std::unique_ptr callStmt = std::make_unique( - *info, OP_callassigned, nullptr, false); + MIRType *retType = callExpr->GetRetType(); + Opcode op; + if (retType->GetPrimType() != PTY_void) { + op = OP_callassigned; + } else { + op = OP_call; + } + std::unique_ptr callStmt = std::make_unique(*info, op, nullptr, false); + callStmt->SetSrcFileInfo(GetSrcFileIdx(), GetSrcFileLineNum()); // args std::vector argsExprs = callExpr->GetArgsExpr(); for (int32 i = argsExprs.size() - 1; i >= 0; --i) { UniqueFEIRExpr expr = argsExprs[i]->Emit2FEExpr(stmts); callStmt->AddExprArgReverse(std::move(expr)); } + // attrs + info->SetFuncAttrs(callExpr->GetFuncAttrs()); // return - MIRType *retType = callExpr->GetRetType(); FEIRTypeNative *retTypeInfo = FEManager::GetManager().GetModule().GetMemPool()->New(*retType); info->SetReturnType(retTypeInfo); if (retType->GetPrimType() != PTY_void) { - const std::string &varName = FEUtils::GetSequentialName("retVar_"); UniqueFEIRVar var = FEIRBuilder::CreateVarNameForC(varName, *retType, false, false); callStmt->SetVar(std::move(var)); } @@ -289,6 +310,7 @@ std::list ASTCallExprStmt::Emit2FEStmtCall() const { std::list ASTCallExprStmt::Emit2FEStmtICall() const { std::list stmts; std::unique_ptr icallStmt = std::make_unique(); + icallStmt->SetSrcFileInfo(GetSrcFileIdx(), GetSrcFileLineNum()); ASTCallExpr *callExpr = static_cast(exprs.front()); ASTExpr *calleeExpr = callExpr->GetCalleeExpr(); CHECK_NULL_FATAL(calleeExpr); @@ -298,7 +320,6 @@ std::list ASTCallExprStmt::Emit2FEStmtICall() const { // return MIRType *retType = callExpr->GetRetType(); if (retType->GetPrimType() != PTY_void) { - const std::string &varName = FEUtils::GetSequentialName("retVar_"); UniqueFEIRVar var = FEIRBuilder::CreateVarNameForC(varName, *retType, false, false); icallStmt->SetVar(std::move(var)); } @@ -342,6 +363,7 @@ std::list ASTCallExprStmt::ProcessBuiltinVaStart() const { #else std::unique_ptr stmt = std::make_unique( INTRN_C_va_start, nullptr /* type */, nullptr /* retVar */, std::move(exprArgList)); + stmt->SetSrcFileInfo(GetSrcFileIdx(), GetSrcFileLineNum()); stmts.emplace_back(std::move(stmt)); #endif return stmts; @@ -363,6 +385,7 @@ std::list ASTCallExprStmt::ProcessBuiltinVaEnd() const { exprArgList.push_front(std::move(expr)); } auto stmt = std::make_unique(OP_eval, std::move(exprArgList)); + stmt->SetSrcFileInfo(GetSrcFileIdx(), GetSrcFileLineNum()); stmts.emplace_back(std::move(stmt)); return stmts; } @@ -375,6 +398,7 @@ std::list ASTImplicitCastExprStmt::Emit2FEStmtImpl() const { std::list feirExprs; feirExprs.emplace_back(std::move(feirExpr)); auto stmt = std::make_unique(OP_eval, std::move(feirExprs)); + stmt->SetSrcFileInfo(GetSrcFileIdx(), GetSrcFileLineNum()); stmts.emplace_back(std::move(stmt)); return stmts; } @@ -387,6 +411,7 @@ std::list ASTParenExprStmt::Emit2FEStmtImpl() const { if (feExpr != nullptr) { feExprs.emplace_back(std::move(feExpr)); auto stmt = std::make_unique(OP_eval, std::move(feExprs)); + stmt->SetSrcFileInfo(GetSrcFileIdx(), GetSrcFileLineNum()); stmts.emplace_back(std::move(stmt)); } return stmts; @@ -451,6 +476,7 @@ std::list ASTBinaryOperatorStmt::Emit2FEStmtImpl() const { std::list exprs; exprs.emplace_back(std::move(boFEExpr)); auto stmt = std::make_unique(OP_eval, std::move(exprs)); + stmt->SetSrcFileInfo(GetSrcFileIdx(), GetSrcFileLineNum()); stmts.emplace_back(std::move(stmt)); } else { // has been processed by child expr emit, skip here @@ -466,6 +492,7 @@ std::list ASTAtomicExprStmt::Emit2FEStmtImpl() const { auto astExpr = exprs.front(); UniqueFEIRExpr feExpr = astExpr->Emit2FEExpr(stmts); auto stmt = std::make_unique(std::move(feExpr)); + stmt->SetSrcFileInfo(GetSrcFileIdx(), GetSrcFileLineNum()); stmts.emplace_back(std::move(stmt)); return stmts; } diff --git a/src/mplfe/common/include/fe_options.h b/src/mplfe/common/include/fe_options.h index 73046f5483ecb7feaf6516e5ed2fb2aed26d0247..5cd34d0bf1793f961e3d05646095df5321a49c22 100644 --- a/src/mplfe/common/include/fe_options.h +++ b/src/mplfe/common/include/fe_options.h @@ -429,7 +429,7 @@ class FEOptions { int dumpLevel; bool isDumpTime; bool isDumpComment = false; - bool isDumpLOC = false; + bool isDumpLOC = true; bool isDumpPhaseTime = false; bool isDumpPhaseTimeDetail = false; diff --git a/src/mplfe/common/include/fe_struct_elem_info.h b/src/mplfe/common/include/fe_struct_elem_info.h index e61eab49ea32c34397281c12a8940b0cae42230d..ffa64f3e8aebb43097bd3639f99a698aaebb0f7b 100644 --- a/src/mplfe/common/include/fe_struct_elem_info.h +++ b/src/mplfe/common/include/fe_struct_elem_info.h @@ -188,6 +188,10 @@ class FEStructMethodInfo : public FEStructElemInfo { return isReturnVoid; } + void SetReturnVoid() { + isReturnVoid = true; + } + bool IsJavaPolymorphicCall() const { return isJavaPolymorphicCall; } @@ -224,6 +228,22 @@ class FEStructMethodInfo : public FEStructElemInfo { argTypes = argTypesIn; } + void SetArgsName(const std::vector &names) { + argNames = names; + } + + const std::vector &GetArgsName() const { + return argNames; + } + + void SetFuncAttrs(const FuncAttrs &attrs) { + funcAttrs = attrs; + } + + const FuncAttrs &GetFuncAttrs() const { + return funcAttrs; + } + LLT_PROTECTED: void PrepareImpl(MIRBuilder &mirBuilder, bool argIsStatic) override; @@ -247,6 +267,8 @@ class FEStructMethodInfo : public FEStructElemInfo { FEIRType *ownerType; MIRFunction *mirFunc; MapleVector argTypes; + std::vector argNames; + FuncAttrs funcAttrs; }; } // namespace maple #endif // MPLFE_INCLUDE_COMMON_FE_STRUCT_ELEM_INFO_H diff --git a/src/mplfe/common/include/fe_utils.h b/src/mplfe/common/include/fe_utils.h index 25822f93631630f88ede1e56c53f39aff52a8686..6efd73595269ba9e92cbe7a17e2a2f3bfc4c1765 100644 --- a/src/mplfe/common/include/fe_utils.h +++ b/src/mplfe/common/include/fe_utils.h @@ -40,7 +40,8 @@ class FEUtils { static PrimType GetPrimType(const GStrIdx &typeNameIdx); static std::string GetSequentialName0(const std::string &prefix, uint32_t num); static std::string GetSequentialName(const std::string &prefix); - static FieldID GetStructFieldID(MIRBuilder &mirBuilder, MIRStructType *base, const std::string &fieldName); + static FieldID GetStructFieldID(MIRStructType *base, const std::string &fieldName); + static MIRType *GetStructFieldType(MIRStructType *type, FieldID feildID); static const std::string kBoolean; static const std::string kByte; diff --git a/src/mplfe/common/include/feir_builder.h b/src/mplfe/common/include/feir_builder.h index 9e9c598542e641a9895e80f6d08fc42fdd0a2c69..7b7a206a841530d3160786999ae7a6f9d985ac1a 100644 --- a/src/mplfe/common/include/feir_builder.h +++ b/src/mplfe/common/include/feir_builder.h @@ -42,11 +42,15 @@ class FEIRBuilder { static UniqueFEIRVar CreateVarNameForC(const std::string &name, MIRType &mirType, bool isGlobal = false, bool withType = false); // Expr + static UniqueFEIRExpr CreateExprSizeOfType(UniqueFEIRType ty); static UniqueFEIRExpr CreateExprDRead(UniqueFEIRVar srcVar); - static UniqueFEIRExpr CreateExprDReadAggField(UniqueFEIRVar srcVar, FieldID fieldID, MIRType *fieldType); + static UniqueFEIRExpr CreateExprDReadAggField(UniqueFEIRVar srcVar, FieldID fieldID, UniqueFEIRType fieldType); static UniqueFEIRExpr CreateExprAddrof(const std::vector &array); static UniqueFEIRExpr CreateExprAddrofVar(UniqueFEIRVar srcVar); static UniqueFEIRExpr CreateExprAddrofFunc(const std::string &addr); + static UniqueFEIRExpr CreateExprAddrofArray(UniqueFEIRType argTypeNativeArray, + UniqueFEIRExpr argExprArray, std::string argArrayName, + std::list &argExprIndexs); static UniqueFEIRExpr CreateExprIRead(UniqueFEIRType returnType, UniqueFEIRType ptrType, UniqueFEIRExpr expr, FieldID id = 0); static UniqueFEIRExpr CreateExprTernary(Opcode op, UniqueFEIRType type, UniqueFEIRExpr cExpr, @@ -56,6 +60,7 @@ class FEIRBuilder { static UniqueFEIRExpr CreateExprConstI8(int8 val); static UniqueFEIRExpr CreateExprConstI16(int16 val); static UniqueFEIRExpr CreateExprConstI32(int32 val); + static UniqueFEIRExpr CreateExprConstU32(uint32 val); static UniqueFEIRExpr CreateExprConstI64(int64 val); static UniqueFEIRExpr CreateExprConstU64(uint64 val); static UniqueFEIRExpr CreateExprConstF32(float val); @@ -86,11 +91,13 @@ class FEIRBuilder { static UniqueFEIRExpr CreateExprArrayStoreForC(UniqueFEIRExpr argExprArray, UniqueFEIRExpr argExprIndex, UniqueFEIRType argTypeNative); static UniqueFEIRExpr CreateExprArrayStoreForC(UniqueFEIRExpr argExprArray, std::list &argExprIndexs, - UniqueFEIRType argTypeNative); + UniqueFEIRType argTypeNative, + std::string argArrayName); static UniqueFEIRExpr CreateExprArrayStoreForC(UniqueFEIRExpr argExprArray, std::list &argExprIndexs, UniqueFEIRType argArrayTypeNative, UniqueFEIRExpr argExprStruct, - UniqueFEIRType argStructTypeNative); + UniqueFEIRType argStructTypeNative, + std::string argArrayName); // Stmt static UniqueFEIRStmt CreateStmtDAssign(UniqueFEIRVar dstVar, UniqueFEIRExpr srcExpr, bool hasException = false); static UniqueFEIRStmt CreateStmtDAssignAggField(UniqueFEIRVar dstVar, UniqueFEIRExpr srcExpr, FieldID fieldID); @@ -119,10 +126,21 @@ class FEIRBuilder { UniqueFEIRExpr exprIndex, UniqueFEIRType arrayType); static UniqueFEIRStmt CreateStmtArrayStoreOneStmtForC(UniqueFEIRExpr exprElem, UniqueFEIRExpr exprArray, UniqueFEIRExpr exprIndex, UniqueFEIRType arrayType, - UniqueFEIRType elemType); + std::string argArrayName); + static UniqueFEIRStmt CreateStmtArrayStoreOneStmtForC(UniqueFEIRExpr exprElem, UniqueFEIRExpr exprArray, + std::list exprIndexs, + UniqueFEIRType arrayType, std::string argArrayName); + static UniqueFEIRStmt CreateStmtArrayStoreOneStmtForC(UniqueFEIRExpr exprElem, UniqueFEIRExpr exprArray, + UniqueFEIRExpr exprIndex, UniqueFEIRType arrayType, + UniqueFEIRType elemType, std::string argArrayName); static std::list CreateStmtArrayLoad(UniqueFEIRVar varElem, UniqueFEIRVar varArray, UniqueFEIRVar varIndex); + static UniqueFEIRExpr CreateExprFieldLoadForC(UniqueFEIRVar argVarObj, UniqueFEIRVar argVarField, + MIRStructType *argStructType, + FieldID argFieldID); static UniqueFEIRStmt CreateStmtArrayLength(UniqueFEIRVar varLength, UniqueFEIRVar varArray); + static UniqueFEIRStmt CreateStmtFieldStoreForC(UniqueFEIRVar varObj, UniqueFEIRExpr exprField, + MIRStructType *structType, FieldID fieldID); static UniqueFEIRStmt CreateStmtRetype(UniqueFEIRVar varDst, const UniqueFEIRVar &varSrc); static UniqueFEIRStmt CreateStmtComment(const std::string &comment); }; // class FEIRBuilder diff --git a/src/mplfe/common/include/feir_node_kind.def b/src/mplfe/common/include/feir_node_kind.def index cb2f11c874279c2e643798d54f8866a9e00805ef..516007003bf114765f76106a6b14f189cd70aa68 100644 --- a/src/mplfe/common/include/feir_node_kind.def +++ b/src/mplfe/common/include/feir_node_kind.def @@ -23,10 +23,13 @@ FEIR_NODE_KIND(StmtSwitch, "StmtSwitch") FEIR_NODE_KIND(StmtArrayStore, "StmtArrayStore") FEIR_NODE_KIND(StmtFieldStore, "StmtFieldStore") FEIR_NODE_KIND(StmtFieldLoad, "StmtFieldLoad") +FEIR_NODE_KIND(StmtFieldStoreForC, "StmtFieldStoreForC") +FEIR_NODE_KIND(ExprFieldLoadForC, "ExprFieldLoadForC") FEIR_NODE_KIND(Expr, "Expr") FEIR_NODE_KIND(ExprNestable, "ExprNestable") FEIR_NODE_KIND(ExprNonNestable, "ExprNonNestable") FEIR_NODE_KIND(ExprConst, "ExprConst") +FEIR_NODE_KIND(ExprSizeOfType, "ExprSizeOfType") FEIR_NODE_KIND(ExprDRead, "ExprDRead") FEIR_NODE_KIND(ExprIRead, "ExprIRead") FEIR_NODE_KIND(ExprRegRead, "ExprRegRead") @@ -40,8 +43,10 @@ FEIR_NODE_KIND(ExprTernary, "ExprTernary") FEIR_NODE_KIND(ExprNary, "ExprNary") FEIR_NODE_KIND(ExprArray, "ExprArray") FEIR_NODE_KIND(ExprAddrof, "ExprAddrof") +FEIR_NODE_KIND(ExprIAddrof, "ExprIAddrof") FEIR_NODE_KIND(ExprAddrofVar, "ExprAddrofVar") FEIR_NODE_KIND(ExprAddrofFunc, "ExprAddrofFunc") +FEIR_NODE_KIND(ExprAddrofArray, "ExprAddrofArray") FEIR_NODE_KIND(ExprAddrofStruct, "ExprAddrofStruct") FEIR_NODE_KIND(ExprIntrinsicop, "ExprIntrinsicop") FEIR_NODE_KIND(FEIRExprJavaMerge, "FEIRExprJavaMerge") diff --git a/src/mplfe/common/include/feir_stmt.h b/src/mplfe/common/include/feir_stmt.h index 90a56173925b121972ca828ebff751f8212ef01c..2311a6c0e60d08e9fcb79333dfafcb36981e41c3 100644 --- a/src/mplfe/common/include/feir_stmt.h +++ b/src/mplfe/common/include/feir_stmt.h @@ -121,7 +121,7 @@ class FEIRStmt : public GeneralStmt { std::list GenMIRStmts(MIRBuilder &mirBuilder) const { std::list stmts = GenMIRStmtsImpl(mirBuilder); - SetSrcPos(stmts); + SetMIRStmtSrcPos(stmts); return stmts; } @@ -160,6 +160,10 @@ class FEIRStmt : public GeneralStmt { srcFileLineNum = srcFileLineNumIn; } + bool HasSetLOCInfo() const { + return (srcFileLineNum != 0 || srcFileIndex != 0); + } + protected: std::string DumpDotStringImpl() const override; virtual void RegisterDFGNodes2CheckPointImpl(FEIRStmtCheckPoint &checkPoint) {} @@ -198,13 +202,11 @@ class FEIRStmt : public GeneralStmt { return hexPC; } - void SetSrcPos(std::list &stmts) const { -#ifdef DEBUG + void SetMIRStmtSrcPos(std::list &stmts) const { if (FEOptions::GetInstance().IsDumpLOC() && !stmts.empty()) { (*stmts.begin())->GetSrcPos().SetFileNum(srcFileIndex); (*stmts.begin())->GetSrcPos().SetLineNum(srcFileLineNum); } -#endif } FEIRNodeKind kind; @@ -294,13 +296,11 @@ class FEIRExpr { } FEIRType *GetType() const { - ASSERT(type != nullptr, "type is nullptr"); - return type.get(); + return GetTypeImpl(); } const FEIRType &GetTypeRef() const { - ASSERT(type != nullptr, "type is nullptr"); - return *type.get(); + return GetTypeRefImpl(); } PrimType GetPrimType() const { @@ -328,6 +328,16 @@ class FEIRExpr { return type->GetPrimType(); } + virtual FEIRType *GetTypeImpl() const { + ASSERT(type != nullptr, "type is nullptr"); + return type.get(); + } + + virtual const FEIRType &GetTypeRefImpl() const { + ASSERT(GetTypeImpl() != nullptr, "type is nullptr"); + return *GetTypeImpl(); + } + virtual bool IsNestableImpl() const; virtual bool IsAddrofImpl() const; virtual bool HasExceptionImpl() const; @@ -361,6 +371,7 @@ class FEIRExprConst : public FEIRExpr { FEIRExprConst(); FEIRExprConst(int64 val, PrimType argType); FEIRExprConst(uint64 val, PrimType argType); + explicit FEIRExprConst(uint32 val); explicit FEIRExprConst(float val); explicit FEIRExprConst(double val); ~FEIRExprConst() = default; @@ -380,12 +391,25 @@ class FEIRExprConst : public FEIRExpr { ConstExprValue value; }; +// ---------- FEIRExprSizeOfType ---------- +class FEIRExprSizeOfType : public FEIRExpr { + public: + explicit FEIRExprSizeOfType(UniqueFEIRType ty); + ~FEIRExprSizeOfType() = default; + + protected: + std::unique_ptr CloneImpl() const override; + BaseNode *GenMIRNodeImpl(MIRBuilder &mirBuilder) const override; + + private: + UniqueFEIRType feirType; +}; + // ---------- FEIRExprDRead ---------- class FEIRExprDRead : public FEIRExpr { public: explicit FEIRExprDRead(std::unique_ptr argVarSrc); FEIRExprDRead(std::unique_ptr argType, std::unique_ptr argVarSrc); - FEIRExprDRead(std::unique_ptr argType, std::unique_ptr argVarSrc, const std::string &argFieldName); ~FEIRExprDRead() = default; void SetVarSrc(std::unique_ptr argVarSrc); void SetTrans(UniqueFEIRVarTrans argTrans) { @@ -415,20 +439,12 @@ class FEIRExprDRead : public FEIRExpr { return varSrc; } - void SetFieldName(const std::string &argFieldName) { - fieldName = argFieldName; - } - - std::string GetFieldName() const { - return fieldName; - } - - void SetFieldType(MIRType *type) { - fieldType = type; + void SetFieldType(std::unique_ptr type) { + fieldType = std::move(type); } - MIRType *GetFieldType() const { - return fieldType; + std::unique_ptr GetFieldType() const { + return fieldType->Clone(); } void SetFieldID(FieldID argFieldID) { @@ -442,12 +458,13 @@ class FEIRExprDRead : public FEIRExpr { BaseNode *GenMIRNodeImpl(MIRBuilder &mirBuilder) const override; std::vector GetVarUsesImpl() const override; PrimType GetPrimTypeImpl() const override; + FEIRType *GetTypeImpl() const override; + const FEIRType &GetTypeRefImpl() const override; private: std::unique_ptr varSrc; FieldID fieldID = 0; - std::string fieldName; - MIRType *fieldType = nullptr; + std::unique_ptr fieldType; }; // ---------- FEIRExprRegRead ---------- @@ -486,7 +503,7 @@ class FEIRExprAddrofVar : public FEIRExpr { : FEIRExpr(FEIRNodeKind::kExprAddrofVar), varSrc(std::move(argVarSrc)) {} ~FEIRExprAddrofVar() = default; - void SetFieldName(const std::string &argFieldName) { + void SetFieldName(std::string argFieldName) { fieldName = argFieldName; } @@ -501,6 +518,7 @@ class FEIRExprAddrofVar : public FEIRExpr { protected: std::unique_ptr CloneImpl() const override; BaseNode *GenMIRNodeImpl(MIRBuilder &mirBuilder) const override; + std::vector GetVarUsesImpl() const override; private: std::unique_ptr varSrc; @@ -509,6 +527,47 @@ class FEIRExprAddrofVar : public FEIRExpr { MIRType *fieldType = nullptr; }; +// ---------- FEIRExprIAddrof ---------- +class FEIRExprIAddrof : public FEIRExpr { + public: + FEIRExprIAddrof(UniqueFEIRType pointeeType, FieldID id, UniqueFEIRExpr expr) + : FEIRExpr(FEIRNodeKind::kExprIAddrof, + std::make_unique(*GlobalTables::GetTypeTable().GetPtrType())), + ptrType(std::move(pointeeType)), + fieldID(id), + subExpr(std::move(expr)) {} + ~FEIRExprIAddrof() = default; + + void SetFieldID(FieldID argFieldID) { + fieldID = argFieldID; + } + + FieldID GetFieldID() const { + return fieldID; + } + + UniqueFEIRType GetClonedRetType() const { + return type->Clone(); + } + + UniqueFEIRExpr GetClonedOpnd() const { + return subExpr->Clone(); + } + + UniqueFEIRType GetClonedPtrType() const { + return ptrType->Clone(); + } + + protected: + std::unique_ptr CloneImpl() const override; + BaseNode *GenMIRNodeImpl(MIRBuilder &mirBuilder) const override; + + private: + UniqueFEIRType ptrType; + FieldID fieldID = 0; + UniqueFEIRExpr subExpr; +}; + class FEIRExprAddrofFunc : public FEIRExpr { public: explicit FEIRExprAddrofFunc(const std::string &addr) @@ -523,6 +582,32 @@ class FEIRExprAddrofFunc : public FEIRExpr { std::string funcAddr; }; +// ---------- FEIRExprAddrofArray ---------- +class FEIRExprAddrofArray : public FEIRExpr { + public: + FEIRExprAddrofArray(UniqueFEIRType argTypeNativeArray, UniqueFEIRExpr argExprArray, std::string argArrayName, + std::list &argExprIndexs); + ~FEIRExprAddrofArray() = default; + + void SetIndexsExprs(std::list &exprs) { + exprIndexs.clear(); + for (auto &e : exprs) { + auto ue = e->Clone(); + exprIndexs.push_back(std::move(ue)); + } + } + + protected: + std::unique_ptr CloneImpl() const override; + BaseNode *GenMIRNodeImpl(MIRBuilder &mirBuilder) const override; + + private: + mutable std::list exprIndexs; + UniqueFEIRType typeNativeArray = nullptr; + UniqueFEIRExpr exprArray = nullptr; + std::string arrayName; +}; + // ---------- FEIRExprUnary ---------- class FEIRExprUnary : public FEIRExpr { public: @@ -624,8 +709,10 @@ class FEIRExprExtractBits : public FEIRExprUnary { class FEIRExprIRead : public FEIRExpr { public: FEIRExprIRead(UniqueFEIRType returnType, UniqueFEIRType pointeeType, FieldID id, UniqueFEIRExpr expr) - : FEIRExpr(FEIRNodeKind::kExprIRead), retType(std::move(returnType)), ptrType(std::move(pointeeType)), - fieldID(id), subExpr(std::move(expr)) {} + : FEIRExpr(FEIRNodeKind::kExprIRead, std::move(returnType)), + ptrType(std::move(pointeeType)), + fieldID(id), + subExpr(std::move(expr)) {} ~FEIRExprIRead() override = default; void SetFieldID(FieldID argFieldID) { @@ -636,23 +723,15 @@ class FEIRExprIRead : public FEIRExpr { return fieldID; } - const UniqueFEIRType &GetRetType() const { - return retType; - } - - void SetFieldName(const std::string &argFieldName) { - fieldName = argFieldName; - } - - std::string GetFieldName() const { - return fieldName; + UniqueFEIRType GetClonedRetType() const { + return type->Clone(); } UniqueFEIRExpr GetClonedOpnd() const { return subExpr->Clone(); } - UniqueFEIRType GetClonedType() const { + UniqueFEIRType GetClonedPtrType() const { return ptrType->Clone(); } @@ -662,11 +741,9 @@ class FEIRExprIRead : public FEIRExpr { PrimType GetPrimTypeImpl() const override; private: - UniqueFEIRType retType = nullptr; UniqueFEIRType ptrType = nullptr; FieldID fieldID = 0; UniqueFEIRExpr subExpr = nullptr; - std::string fieldName; }; // ---------- FEIRExprBinary ---------- @@ -886,12 +963,13 @@ class FEIRExprJavaArrayLength : public FEIRExpr { class FEIRExprArrayStoreForC : public FEIRExpr { public: FEIRExprArrayStoreForC(UniqueFEIRExpr argExprArray, std::list &argExprIndexs, - UniqueFEIRType argTypeNative); + UniqueFEIRType argTypeNative, std::string argArrayName); // for array in struct FEIRExprArrayStoreForC(UniqueFEIRExpr argExprArray, std::list &argExprIndexs, UniqueFEIRType argArrayTypeNative, UniqueFEIRExpr argExprStruct, - UniqueFEIRType argStructTypeNative); + UniqueFEIRType argStructTypeNative, + std::string argArrayName); ~FEIRExprArrayStoreForC() = default; FEIRExpr &GetExprArray() const { @@ -905,7 +983,11 @@ class FEIRExprArrayStoreForC : public FEIRExpr { } void SetIndexsExprs(std::list &exprs) { - std::move(begin(exprs), end(exprs), std::inserter(exprIndexs, end(exprIndexs))); + exprIndexs.clear(); + for (auto &e : exprs) { + auto ue = e->Clone(); + exprIndexs.push_back(std::move(ue)); + } } FEIRExpr &GetExprStruct() const { @@ -923,6 +1005,10 @@ class FEIRExprArrayStoreForC : public FEIRExpr { return *typeNativeStruct.get(); } + std::string GetArrayName() const { + return arrayName; + } + bool IsMember() const { return typeNativeStruct != nullptr; } @@ -945,6 +1031,7 @@ class FEIRExprArrayStoreForC : public FEIRExpr { // for array in struct UniqueFEIRExpr exprStruct = nullptr; UniqueFEIRType typeNativeStruct = nullptr; + std::string arrayName; }; // ---------- FEIRExprArrayLoad ---------- @@ -989,10 +1076,20 @@ class FEIRExprCStyleCast : public FEIRExpr { void SetArray2Pointer(bool isArr2Ptr) { isArray2Pointer = isArr2Ptr; } + void SetRefName(const std::string &name) { refName = name; } + const UniqueFEIRExpr &GetSubExpr() const { + return subExpr; + } + + MIRType *GetMIRType() const { + CHECK_NULL_FATAL(destType); + return destType; + } + protected: std::unique_ptr CloneImpl() const override; BaseNode *GenMIRNodeImpl(MIRBuilder &mirBuilder) const override; @@ -1127,7 +1224,7 @@ class FEIRStmtAssign : public FEIRStmt { std::string DumpDotStringImpl() const override; void RegisterDFGNodes2CheckPointImpl(FEIRStmtCheckPoint &checkPoint) override; bool hasException; - std::unique_ptr var; + std::unique_ptr var = nullptr; }; // ---------- FEIRStmtDAssign ---------- @@ -1143,10 +1240,6 @@ class FEIRStmtDAssign : public FEIRStmtAssign { expr = std::move(argExpr); } - void SetFieldName(const std::string &argFieldName) { - fieldName = argFieldName; - } - protected: std::string DumpDotStringImpl() const override; void RegisterDFGNodes2CheckPointImpl(FEIRStmtCheckPoint &checkPoint) override; @@ -1155,7 +1248,6 @@ class FEIRStmtDAssign : public FEIRStmtAssign { std::list GenMIRStmtsImpl(MIRBuilder &mirBuilder) const override; std::unique_ptr expr; FieldID fieldID; - std::string fieldName; }; // ---------- FEIRStmtIAssign ---------- @@ -1169,16 +1261,11 @@ class FEIRStmtIAssign : public FEIRStmt { fieldID(id) {} ~FEIRStmtIAssign() = default; - void SetFieldName(std::string name){ - fieldName = std::move(name); - } - protected: std::list GenMIRStmtsImpl(MIRBuilder &mirBuilder) const override; UniqueFEIRType addrType; UniqueFEIRExpr addrExpr; UniqueFEIRExpr baseExpr; - std::string fieldName; FieldID fieldID; }; @@ -1473,6 +1560,36 @@ class FEIRStmtGotoForC : public FEIRStmt { std::string labelName; }; +// ---------- FEIRStmtCondGotoForC ---------- +class FEIRStmtCondGotoForC : public FEIRStmt { + public: + explicit FEIRStmtCondGotoForC(UniqueFEIRExpr argExpr, Opcode op, const std::string &name) + : FEIRStmt(FEIRNodeKind::kStmtCondGoto), expr(std::move(argExpr)), opCode(op), labelName(std::move(name)) {} + virtual ~FEIRStmtCondGotoForC() = default; + void SetLabelName(std::string name) { + labelName = std::move(name); + } + + std::string GetLabelName() const { + return labelName; + } + + protected: + bool IsFallThroughImpl() const override { + return false; + } + + bool IsBranchImpl() const override { + return true; + } + + std::string DumpDotStringImpl() const override; + std::list GenMIRStmtsImpl(MIRBuilder &mirBuilder) const override; + UniqueFEIRExpr expr; + Opcode opCode; + std::string labelName; +}; + // ---------- FEIRStmtCondGoto ---------- class FEIRStmtCondGoto : public FEIRStmtGoto { public: @@ -1732,21 +1849,31 @@ class FEIRStmtArrayStore : public FEIRStmt { public: FEIRStmtArrayStore(UniqueFEIRExpr argExprElem, UniqueFEIRExpr argExprArray, UniqueFEIRExpr argExprIndex, UniqueFEIRType argTypeArray); + + // for C + FEIRStmtArrayStore(UniqueFEIRExpr argExprElem, UniqueFEIRExpr argExprArray, UniqueFEIRExpr argExprIndex, + UniqueFEIRType argTypeArray, std::string argArrayName); + // for C mul array FEIRStmtArrayStore(UniqueFEIRExpr argExprElem, UniqueFEIRExpr argExprArray, UniqueFEIRExpr argExprIndex, - UniqueFEIRType argTypeArray, UniqueFEIRType argTypeElem); + UniqueFEIRType argTypeArray, UniqueFEIRType argTypeElem, std::string argArrayName); // for C mul array FEIRStmtArrayStore(UniqueFEIRExpr argExprElem, UniqueFEIRExpr argExprArray, std::list &argExprIndexs, - UniqueFEIRType argTypeArray); + UniqueFEIRType argTypeArray, std::string argArrayName); // for C array in struct FEIRStmtArrayStore(UniqueFEIRExpr argExprElem, UniqueFEIRExpr argExprArray, std::list &argExprIndexs, - UniqueFEIRType argTypeArray, UniqueFEIRExpr argExprStruct, UniqueFEIRType argTypeStruct); + UniqueFEIRType argTypeArray, UniqueFEIRExpr argExprStruct, UniqueFEIRType argTypeStruct, + std::string argArrayName); ~FEIRStmtArrayStore() = default; void SetIndexsExprs(std::list &exprs) { - std::move(begin(exprs), end(exprs), std::inserter(exprIndexs, end(exprIndexs))); + exprIndexs.clear(); + for (auto &e : exprs) { + auto ue = e->Clone(); + exprIndexs.push_back(std::move(ue)); + } } protected: @@ -1770,6 +1897,23 @@ class FEIRStmtArrayStore : public FEIRStmt { // for C array in struct UniqueFEIRExpr exprStruct; UniqueFEIRType typeStruct; + std::string arrayName; +}; + +// ---------- FEIRStmtFieldStoreForC ---------- +class FEIRStmtFieldStoreForC : public FEIRStmt { + public: + FEIRStmtFieldStoreForC(UniqueFEIRVar varObj, UniqueFEIRExpr argExprField, MIRStructType *argStructType, + FieldID argFieldID); + + protected: + std::list GenMIRStmtsImpl(MIRBuilder &mirBuilder) const; + + private: + UniqueFEIRVar varObj = nullptr; + UniqueFEIRExpr exprField = nullptr; + MIRStructType *structType = nullptr; + FieldID fieldID = -1; }; // ---------- FEIRStmtFieldStore ---------- @@ -1834,6 +1978,45 @@ class FEIRStmtFieldLoad : public FEIRStmtAssign { int32 dexFileHashCode = -1; }; +// ---------- FEIRExprFieldLoadForC ---------- +class FEIRExprFieldLoadForC : public FEIRExpr { + public: + FEIRExprFieldLoadForC(UniqueFEIRVar argVarObj, UniqueFEIRVar argVarField, + MIRStructType *argStructType, + FieldID argFieldID); + ~FEIRExprFieldLoadForC() = default; + + MIRStructType *GetMIRStructType() const { + return structType; + } + + FEIRVar &GetStructVar() const { + return *varObj.get(); + } + + FEIRVar &GetFieldVar() const { + return *varField.get(); + } + + FieldID GetFieldID() const { + return fieldID; + } + + protected: + BaseNode *GenMIRNodeImpl(MIRBuilder &mirBuilder) const override; + std::unique_ptr CloneImpl() const override; + + PrimType GetPrimTypeImpl() const override { + return varField->GetType()->GetPrimType(); + } + + private: + UniqueFEIRVar varObj = nullptr; + UniqueFEIRVar varField = nullptr; + MIRStructType *structType = nullptr; + FieldID fieldID = -1; +}; + // ---------- FEIRStmtCallAssign ---------- class FEIRStmtCallAssign : public FEIRStmtAssign { public: diff --git a/src/mplfe/common/include/feir_var.h b/src/mplfe/common/include/feir_var.h index cad4faf23cb3c94aab447cc63259a937b15a2145..62b77f77d2b95a5a8aee97c7068ad25c0147f282 100644 --- a/src/mplfe/common/include/feir_var.h +++ b/src/mplfe/common/include/feir_var.h @@ -141,6 +141,14 @@ class FEIRVar { return HashImpl(); } + void SetAttrs(GenericAttrs &argGenericAttrs) { + genAttrs = argGenericAttrs; + } + + void SetConst(MIRConst *argMirConst) { + mirConst = argMirConst; + } + protected: virtual MIRSymbol *GenerateGlobalMIRSymbolImpl(MIRBuilder &builder) const; virtual MIRSymbol *GenerateLocalMIRSymbolImpl(MIRBuilder &builder) const; @@ -156,6 +164,8 @@ class FEIRVar { bool isDef : 1; UniqueFEIRType type; UniqueFEIRVarTrans trans; + GenericAttrs genAttrs; + MIRConst *mirConst; }; using UniqueFEIRVar = std::unique_ptr; diff --git a/src/mplfe/common/src/fe_struct_elem_info.cpp b/src/mplfe/common/src/fe_struct_elem_info.cpp index b854ce68b16d3f61ed09d5eebbe329daa17cbd89..254b851e81a0bfb7821e8b6295db65b593d1fe54 100644 --- a/src/mplfe/common/src/fe_struct_elem_info.cpp +++ b/src/mplfe/common/src/fe_struct_elem_info.cpp @@ -324,16 +324,15 @@ void FEStructMethodInfo::LoadMethodTypeJava() { void FEStructMethodInfo::PrepareMethodC() { mirFunc = FEManager::GetTypeManager().GetMIRFunction(methodNameIdx, isStatic); if (mirFunc == nullptr) { - // This branch should not be used for C languages, and mirFunc must not be nullptr. MIRType *mirRetType = retType->GenerateMIRTypeAuto(srcLang); - bool isVarg = false; // need to update std::vector argsTypeIdx; for (const FEIRType *argType : argTypes) { MIRType *mirArgType = argType->GenerateMIRTypeAuto(srcLang); argsTypeIdx.push_back(mirArgType->GetTypeIndex()); } mirFunc = FEManager::GetTypeManager().CreateFunction(methodNameIdx, mirRetType->GetTypeIndex(), - argsTypeIdx, isVarg, isStatic); + argsTypeIdx, false, isStatic); + mirFunc->SetFuncAttrs(funcAttrs); } isPrepared = true; } diff --git a/src/mplfe/common/src/fe_utils.cpp b/src/mplfe/common/src/fe_utils.cpp index 0e30b97f53c40546252d39c0d6e85ef0be800afc..d938f837c7ad521c8c8e76f8e044a004303f7eb7 100644 --- a/src/mplfe/common/src/fe_utils.cpp +++ b/src/mplfe/common/src/fe_utils.cpp @@ -17,6 +17,7 @@ #include "mpl_logging.h" #include "mir_type.h" #include "mir_builder.h" +#include "fe_manager.h" namespace maple { // ---------- FEUtils ---------- const std::string FEUtils::kBoolean = "Z"; @@ -194,26 +195,32 @@ std::string FEUtils::GetSequentialName(const std::string &prefix) { return name; } -FieldID FEUtils::GetStructFieldID(MIRBuilder &mirBuilder, MIRStructType *base, const std::string &fieldName) { +FieldID FEUtils::GetStructFieldID(MIRStructType *base, const std::string &fieldName) { MIRStructType *type = base; std::vector fieldNames = FEUtils::Split(fieldName, '.'); std::reverse(fieldNames.begin(), fieldNames.end()); FieldID fieldID = 0; for (const auto &f: fieldNames) { - auto &structType = static_cast(*type); - GStrIdx strIdx = mirBuilder.GetStringIndex(f); + GStrIdx strIdx = GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(f); uint32 tempFieldID = fieldID; - if (mirBuilder.TraverseToNamedFieldWithTypeAndMatchStyle(structType, strIdx, TyIdx(0), tempFieldID, - MIRBuilder::MatchStyle::kMatchAnyField)) { + if (FEManager::GetMIRBuilder().TraverseToNamedFieldWithTypeAndMatchStyle(*type, strIdx, TyIdx(0), tempFieldID, + MIRBuilder::MatchStyle::kMatchAnyField)) { fieldID = tempFieldID; - FieldID tmpId = tempFieldID; - FieldPair fieldPair = base->TraverseToFieldRef(tmpId); + FieldID tmpID = tempFieldID; + FieldPair fieldPair = base->TraverseToFieldRef(tmpID); type = static_cast(GlobalTables::GetTypeTable().GetTypeFromTyIdx(fieldPair.second.first)); } } return fieldID; } +MIRType *FEUtils::GetStructFieldType(MIRStructType *type, FieldID fieldID) { + FieldID tmpID = fieldID; + FieldPair fieldPair = type->TraverseToFieldRef(tmpID); + MIRType *fieldType = GlobalTables::GetTypeTable().GetTypeFromTyIdx(fieldPair.second.first); + return fieldType; +} + // ---------- FELinkListNode ---------- FELinkListNode::FELinkListNode() : prev(nullptr), next(nullptr) {} diff --git a/src/mplfe/common/src/feir_builder.cpp b/src/mplfe/common/src/feir_builder.cpp index 5dc4c416e25659cffc3c7583cbedc32b006a808d..82b4b1ec0ca61a02638e8d71e6e3839dc43dba56 100644 --- a/src/mplfe/common/src/feir_builder.cpp +++ b/src/mplfe/common/src/feir_builder.cpp @@ -90,18 +90,23 @@ UniqueFEIRVar FEIRBuilder::CreateVarNameForC(const std::string &name, MIRType &m return CreateVarNameForC(nameIdx, mirType, isGlobal, withType); } +UniqueFEIRExpr FEIRBuilder::CreateExprSizeOfType(UniqueFEIRType ty) { + UniqueFEIRExpr expr = std::make_unique(std::move(ty)); + return expr; +} + UniqueFEIRExpr FEIRBuilder::CreateExprDRead(UniqueFEIRVar srcVar) { UniqueFEIRExpr expr = std::make_unique(std::move(srcVar)); CHECK_NULL_FATAL(expr); return expr; } -UniqueFEIRExpr FEIRBuilder::CreateExprDReadAggField(UniqueFEIRVar srcVar, FieldID fieldID, MIRType *fieldType) { +UniqueFEIRExpr FEIRBuilder::CreateExprDReadAggField(UniqueFEIRVar srcVar, FieldID fieldID, UniqueFEIRType fieldType) { CHECK_FATAL(srcVar != nullptr && srcVar->GetType()->GetPrimType() == PTY_agg, "var type must be struct type, %u", srcVar->GetType()->GetPrimType()); std::unique_ptr expr = std::make_unique(std::move(srcVar)); expr->SetFieldID(fieldID); - expr->SetFieldType(fieldType); + expr->SetFieldType(std::move(fieldType)); return expr; } @@ -128,6 +133,14 @@ UniqueFEIRExpr FEIRBuilder::CreateExprAddrofFunc(const std::string &addr) { return expr; } +UniqueFEIRExpr FEIRBuilder::CreateExprAddrofArray(UniqueFEIRType argTypeNativeArray, + UniqueFEIRExpr argExprArray, std::string argArrayName, + std::list &argExprIndexs) { + UniqueFEIRExpr expr = std::make_unique(std::move(argTypeNativeArray), + std::move(argExprArray), argArrayName, argExprIndexs); + return expr; +} + UniqueFEIRExpr FEIRBuilder::CreateExprTernary(Opcode op, UniqueFEIRType type, UniqueFEIRExpr cExpr, UniqueFEIRExpr tExpr, UniqueFEIRExpr fExpr) { UniqueFEIRExpr expr = std::make_unique(op, std::move(type), std::move(cExpr), @@ -155,6 +168,10 @@ UniqueFEIRExpr FEIRBuilder::CreateExprConstI32(int32 val) { return std::make_unique(int64{ val }, PTY_i32); } +UniqueFEIRExpr FEIRBuilder::CreateExprConstU32(uint32 val) { + return std::make_unique(val); +} + UniqueFEIRExpr FEIRBuilder::CreateExprConstI64(int64 val) { return std::make_unique(val, PTY_i64); } @@ -310,9 +327,10 @@ UniqueFEIRExpr FEIRBuilder::CreateExprJavaArrayLength(UniqueFEIRExpr exprArray) UniqueFEIRExpr FEIRBuilder::CreateExprArrayStoreForC(UniqueFEIRExpr argExprArray, std::list &argExprIndexs, - UniqueFEIRType argTypeNative) { + UniqueFEIRType argTypeNative, + std::string argArrayName) { UniqueFEIRExpr expr = std::make_unique(std::move(argExprArray), argExprIndexs, - std::move(argTypeNative)); + std::move(argTypeNative), argArrayName); CHECK_NULL_FATAL(expr); return expr; } @@ -321,11 +339,13 @@ UniqueFEIRExpr FEIRBuilder::CreateExprArrayStoreForC(UniqueFEIRExpr argExprArray std::list &argExprIndexs, UniqueFEIRType argArrayTypeNative, UniqueFEIRExpr argExprStruct, - UniqueFEIRType argStructTypeNative) { + UniqueFEIRType argStructTypeNative, + std::string argArrayName) { UniqueFEIRExpr expr = std::make_unique(std::move(argExprArray), argExprIndexs, std::move(argArrayTypeNative), std::move(argExprStruct), - std::move(argStructTypeNative)); + std::move(argStructTypeNative), + argArrayName); CHECK_NULL_FATAL(expr); return expr; } @@ -465,13 +485,43 @@ UniqueFEIRStmt FEIRBuilder::CreateStmtArrayStoreOneStmtForC(UniqueFEIRExpr exprE UniqueFEIRStmt FEIRBuilder::CreateStmtArrayStoreOneStmtForC(UniqueFEIRExpr exprElem, UniqueFEIRExpr exprArray, UniqueFEIRExpr exprIndex, UniqueFEIRType arrayType, - UniqueFEIRType elemType) { + std::string argArrayName) { UniqueFEIRStmt stmt = std::make_unique(std::move(exprElem), std::move(exprArray), std::move(exprIndex), std::move(arrayType), - std::move(elemType)); + argArrayName); return stmt; } +UniqueFEIRStmt FEIRBuilder::CreateStmtArrayStoreOneStmtForC(UniqueFEIRExpr exprElem, UniqueFEIRExpr exprArray, + std::list exprIndexs, + UniqueFEIRType arrayType, std::string argArrayName) { + UniqueFEIRStmt stmt = std::make_unique(std::move(exprElem), std::move(exprArray), + exprIndexs, std::move(arrayType), + argArrayName); + return stmt; +} + +UniqueFEIRStmt FEIRBuilder::CreateStmtArrayStoreOneStmtForC(UniqueFEIRExpr exprElem, UniqueFEIRExpr exprArray, + UniqueFEIRExpr exprIndex, UniqueFEIRType arrayType, + UniqueFEIRType elemType, std::string argArrayName) { + UniqueFEIRStmt stmt = std::make_unique(std::move(exprElem), std::move(exprArray), + std::move(exprIndex), std::move(arrayType), + std::move(elemType), argArrayName); + return stmt; +} + +UniqueFEIRExpr FEIRBuilder::CreateExprFieldLoadForC(UniqueFEIRVar argVarObj, UniqueFEIRVar argVarField, + MIRStructType *argStructType, + FieldID argFieldID) { + return std::make_unique(std::move(argVarObj), std::move(argVarField), argStructType, + argFieldID); +} + +UniqueFEIRStmt FEIRBuilder::CreateStmtFieldStoreForC(UniqueFEIRVar varObj, UniqueFEIRExpr exprField, + MIRStructType *structType, FieldID fieldID) { + return std::make_unique(std::move(varObj), std::move(exprField), structType, fieldID); +} + std::list FEIRBuilder::CreateStmtArrayLoad(UniqueFEIRVar varElem, UniqueFEIRVar varArray, UniqueFEIRVar varIndex) { std::list ans; diff --git a/src/mplfe/common/src/feir_stmt.cpp b/src/mplfe/common/src/feir_stmt.cpp index 4573ab0bd8ed1212b8da0c01e0843cc41f2ecbf7..4df9fc977d96faa3d13f8a758a1b5c57388b8b21 100644 --- a/src/mplfe/common/src/feir_stmt.cpp +++ b/src/mplfe/common/src/feir_stmt.cpp @@ -289,11 +289,9 @@ std::list FEIRStmtDAssign::GenMIRStmtsImpl(MIRBuilder &mirBuilder) co MIRSymbol *dstSym = var->GenerateMIRSymbol(mirBuilder); BaseNode *srcNode = expr->GenMIRNode(mirBuilder); MIRType *mirType = var->GetType()->GenerateMIRTypeAuto(); - FieldID fieldID = this->fieldID; - if ((mirType->GetKind() == MIRTypeKind::kTypeStruct || mirType->GetKind() == MIRTypeKind::kTypeUnion) && - !fieldName.empty() && fieldID == 0) { - MIRStructType *mirStructType = static_cast(mirType); - fieldID = FEUtils::GetStructFieldID(mirBuilder, mirStructType, fieldName); + if (fieldID != 0) { + CHECK_FATAL((mirType->GetKind() == MIRTypeKind::kTypeStruct || mirType->GetKind() == MIRTypeKind::kTypeUnion), + "If fieldID is not 0, then the variable must be a structure"); } StmtNode *mirStmt = mirBuilder.CreateStmtDassign(*dstSym, fieldID, srcNode); ans.push_back(mirStmt); @@ -789,6 +787,22 @@ std::string FEIRStmtGotoForC::DumpDotStringImpl() const { return ss.str(); } +// ---------- FEIRStmtCondGotoForC ---------- +std::list FEIRStmtCondGotoForC::GenMIRStmtsImpl(MIRBuilder &mirBuilder) const { + std::list ans; + LabelIdx labelID = mirBuilder.GetOrCreateMIRLabel(labelName); + BaseNode *condNode = expr->GenMIRNode(mirBuilder); + CondGotoNode *gotoNode = mirBuilder.CreateStmtCondGoto(condNode, opCode, labelID); + ans.push_back(gotoNode); + return ans; +} + +std::string FEIRStmtCondGotoForC::DumpDotStringImpl() const { + std::stringstream ss; + ss << " " << id << ": " << GetFEIRNodeKindDescription(kind); + return ss.str(); +} + // ---------- FEIRStmtCondGoto ---------- FEIRStmtCondGoto::FEIRStmtCondGoto(Opcode argOp, uint32 argLabelIdx, UniqueFEIRExpr argExpr) : FEIRStmtGoto(argLabelIdx), @@ -1104,32 +1118,47 @@ FEIRStmtArrayStore::FEIRStmtArrayStore(UniqueFEIRExpr argExprElem, UniqueFEIRExp FEIRStmtArrayStore::FEIRStmtArrayStore(UniqueFEIRExpr argExprElem, UniqueFEIRExpr argExprArray, UniqueFEIRExpr argExprIndex, UniqueFEIRType argTypeArray, - UniqueFEIRType argTypeElem) + std::string argArrayName) + : FEIRStmt(FEIRNodeKind::kStmtArrayStore), + exprElem(std::move(argExprElem)), + exprArray(std::move(argExprArray)), + exprIndex(std::move(argExprIndex)), + typeArray(std::move(argTypeArray)), + arrayName(argArrayName) {} + +FEIRStmtArrayStore::FEIRStmtArrayStore(UniqueFEIRExpr argExprElem, UniqueFEIRExpr argExprArray, + UniqueFEIRExpr argExprIndex, UniqueFEIRType argTypeArray, + UniqueFEIRType argTypeElem, std::string argArrayName) : FEIRStmt(FEIRNodeKind::kStmtArrayStore), exprElem(std::move(argExprElem)), exprArray(std::move(argExprArray)), exprIndex(std::move(argExprIndex)), typeArray(std::move(argTypeArray)), - typeElem(std::move(argTypeElem)) {} + typeElem(std::move(argTypeElem)), + arrayName(argArrayName) {} FEIRStmtArrayStore::FEIRStmtArrayStore(UniqueFEIRExpr argExprElem, UniqueFEIRExpr argExprArray, - std::list &argExprIndexs, UniqueFEIRType argTypeArray) + std::list &argExprIndexs, UniqueFEIRType argTypeArray, + std::string argArrayName) : FEIRStmt(FEIRNodeKind::kStmtArrayStore), exprElem(std::move(argExprElem)), exprArray(std::move(argExprArray)), - typeArray(std::move(argTypeArray)) { + typeArray(std::move(argTypeArray)), + arrayName(argArrayName) { SetIndexsExprs(argExprIndexs); } FEIRStmtArrayStore::FEIRStmtArrayStore(UniqueFEIRExpr argExprElem, UniqueFEIRExpr argExprArray, std::list &argExprIndexs, UniqueFEIRType argTypeArray, - UniqueFEIRExpr argExprStruct, UniqueFEIRType argTypeStruct) + UniqueFEIRExpr argExprStruct, UniqueFEIRType argTypeStruct, + std::string argArrayName) : FEIRStmt(FEIRNodeKind::kStmtArrayStore), exprElem(std::move(argExprElem)), exprArray(std::move(argExprArray)), typeArray(std::move(argTypeArray)), exprStruct(std::move(argExprStruct)), - typeStruct(std::move(argTypeStruct)) { + typeStruct(std::move(argTypeStruct)), + arrayName(argArrayName) { SetIndexsExprs(argExprIndexs); } @@ -1198,19 +1227,26 @@ void FEIRStmtArrayStore::GenMIRStmtsImplForCPart(MIRBuilder &mirBuilder, MIRType uint32 fieldID = 0; // array in struct if (typeStruct != nullptr) { - GStrIdx fieldNameIdx = GlobalTables::GetStrTable().GetOrCreateStrIdxFromName( - static_cast(exprArray.get())->GetFieldName()); + fieldID = static_cast(exprArray.get())->GetFieldID(); MIRType *ptrMIRStructType = typeStruct->GenerateMIRType(false); MIRStructType* mirStructType = static_cast(ptrMIRStructType); - FEManager::GetMIRBuilder().TraverseToNamedField(*mirStructType, fieldNameIdx, fieldID); + // for no init, create the struct symbol +#ifndef USE_OPS + (void)SymbolBuilder::Instance().GetOrCreateLocalSymbol(*mirStructType, arrayName, + *mirBuilder.GetCurrentFunction()); +#else + (void)mirBuilder.GetOrCreateLocalDecl(arrayName, *mirStructType); +#endif } + *mIRElemType = typeElem->GenerateMIRType(true); - BaseNode *arrayAddrOfExpr; - if (exprArray->GetKind() == kExprDRead) { - MIRSymbol *mirSymbol = exprArray->GetVarUses().front()->GenerateLocalMIRSymbol(mirBuilder); - arrayAddrOfExpr = mirBuilder.CreateExprAddrof(fieldID, *mirSymbol); - } else { + BaseNode *arrayAddrOfExpr = nullptr; + MIRSymbol *mirSymbol = exprArray->GetVarUses().front()->GenerateMIRSymbol(mirBuilder); + auto mirtype = mirSymbol->GetType(); + if (mirtype->GetKind() == kTypePointer) { arrayAddrOfExpr = exprArray->GenMIRNode(mirBuilder); + } else { + arrayAddrOfExpr = mirBuilder.CreateExprAddrof(fieldID, *mirSymbol); } if (exprIndex == nullptr) { std::vector nds; @@ -1237,6 +1273,29 @@ std::string FEIRStmtArrayStore::DumpDotStringImpl() const { return ss.str(); } +// ---------- FEIRStmtFieldStoreForC ---------- +FEIRStmtFieldStoreForC::FEIRStmtFieldStoreForC(UniqueFEIRVar varObj, UniqueFEIRExpr argExprField, + MIRStructType *argStructType, + FieldID argFieldID) + : FEIRStmt(FEIRNodeKind::kStmtFieldStoreForC), + varObj(std::move(varObj)), + exprField(std::move(argExprField)), + structType(argStructType), + fieldID(argFieldID) {} + +std::list FEIRStmtFieldStoreForC::GenMIRStmtsImpl(MIRBuilder &mirBuilder) const { + std::list ans; + CHECK_NULL_FATAL(structType); + MIRSymbol *mirSymbol = varObj->GenerateLocalMIRSymbol(mirBuilder); + BaseNode *valueNode = mirBuilder.CreateExprDread(*mirSymbol); // dread the ptr addr + BaseNode *nodeField = exprField->GenMIRNode(mirBuilder); + MIRType *ptrMirType = GlobalTables::GetTypeTable().GetOrCreatePointerType(*structType, PTY_ptr); + MIRStructType *ptrStructType = static_cast(ptrMirType); + StmtNode *stmt = mirBuilder.CreateStmtIassign(*ptrStructType, fieldID, valueNode, nodeField); + ans.emplace_back(stmt); + return ans; +} + // ---------- FEIRStmtFieldStore ---------- FEIRStmtFieldStore::FEIRStmtFieldStore(UniqueFEIRVar argVarObj, UniqueFEIRVar argVarField, FEStructFieldInfo &argFieldInfo, bool argIsStatic) @@ -1589,6 +1648,32 @@ std::string FEIRStmtFieldLoad::DumpDotStringImpl() const { return ss.str(); } +// ---------- FEIRExprFieldLoadForC ---------- +FEIRExprFieldLoadForC::FEIRExprFieldLoadForC(UniqueFEIRVar argVarObj, UniqueFEIRVar argVarField, + MIRStructType *argStructType, + FieldID argFieldID) + : FEIRExpr(FEIRNodeKind::kExprFieldLoadForC), + varObj(std::move(argVarObj)), + varField(std::move(argVarField)), + structType(argStructType), + fieldID(argFieldID) {} + +BaseNode *FEIRExprFieldLoadForC::GenMIRNodeImpl(MIRBuilder &mirBuilder) const { + CHECK_NULL_FATAL(structType); + MIRType *ptrStructType = GlobalTables::GetTypeTable().GetOrCreatePointerType(*structType, PTY_ptr); + MIRType *fieldType = varField->GetType()->GenerateMIRType(); + UniqueFEIRExpr exprDReadObj = FEIRBuilder::CreateExprDRead(varObj->Clone()); + BaseNode *nodeObj = exprDReadObj->GenMIRNode(mirBuilder); + BaseNode *nodeVal = mirBuilder.CreateExprIread(*fieldType, *ptrStructType, fieldID, nodeObj); + return nodeVal; +} + +std::unique_ptr FEIRExprFieldLoadForC::CloneImpl() const { + UniqueFEIRVar uVarObj = varObj->Clone(); + UniqueFEIRVar uVarField = varField->Clone(); + return std::make_unique(std::move(uVarObj), std::move(uVarField), structType, fieldID); +} + // ---------- FEIRStmtCallAssign ---------- std::map FEIRStmtCallAssign::mapOpAssignToOp = FEIRStmtCallAssign::InitMapOpAssignToOp(); std::map FEIRStmtCallAssign::mapOpToOpAssign = FEIRStmtCallAssign::InitMapOpToOpAssign(); @@ -1664,7 +1749,11 @@ std::list FEIRStmtCallAssign::GenMIRStmtsImpl(MIRBuilder &mirBuilder) if (!methodInfo.IsReturnVoid() && var != nullptr) { retVarSym = var->GenerateLocalMIRSymbol(mirBuilder); } - stmtCall = mirBuilder.CreateStmtCallAssigned(puIdx, std::move(args), retVarSym, mirOp); + if (retVarSym == nullptr) { + stmtCall = mirBuilder.CreateStmtCall(puIdx, std::move(args), mirOp); + } else { + stmtCall = mirBuilder.CreateStmtCallAssigned(puIdx, std::move(args), retVarSym, mirOp); + } ans.push_back(stmtCall); return ans; } @@ -1882,6 +1971,15 @@ std::list FEIRStmtIntrinsicCallAssign::GenMIRStmtsImpl(MIRBuilder &mi } } stmtCall = mirBuilder.CreateStmtIntrinsicCall(INTRN_C_va_start, std::move(args), TyIdx(0)); + } else if (intrinsicId == INTRN_C_memset) { + MapleVector args(mirBuilder.GetCurrentFuncCodeMpAllocator()->Adapter()); + if (exprList != nullptr) { + for (const auto &expr : *exprList) { + BaseNode *node = expr->GenMIRNode(mirBuilder); + args.push_back(node); + } + } + stmtCall = mirBuilder.CreateStmtIntrinsicCall(INTRN_C_memset, std::move(args), TyIdx(0)); } #endif // other intrinsic call should be implemented @@ -2030,6 +2128,13 @@ FEIRExprConst::FEIRExprConst(uint64 val, PrimType argType) CheckRawValue2SetZero(); } +FEIRExprConst::FEIRExprConst(uint32 val) + : FEIRExpr(FEIRNodeKind::kExprConst) { + type->SetPrimType(PTY_u32); + value.u32 = val; + CheckRawValue2SetZero(); +} + FEIRExprConst::FEIRExprConst(float val) : FEIRExpr(FEIRNodeKind::kExprConst) { ASSERT(type != nullptr, "type is nullptr"); @@ -2063,6 +2168,7 @@ BaseNode *FEIRExprConst::GenMIRNodeImpl(MIRBuilder &mirBuilder) const { case PTY_u8: case PTY_u16: case PTY_u32: + return mirBuilder.CreateIntConst(value.u32, primType); case PTY_u64: case PTY_i8: case PTY_i16: @@ -2087,19 +2193,32 @@ void FEIRExprConst::CheckRawValue2SetZero() { } } +// ---------- FEIRExprSizeOfType ---------- +FEIRExprSizeOfType::FEIRExprSizeOfType(UniqueFEIRType ty) + : FEIRExpr(FEIRNodeKind::kExprSizeOfType, + std::make_unique(*GlobalTables::GetTypeTable().GetPrimType(PTY_u32))), + feirType(std::move(ty)) {} + +std::unique_ptr FEIRExprSizeOfType::CloneImpl() const { + std::unique_ptr expr = std::make_unique(feirType->Clone()); + return expr; +} + +BaseNode *FEIRExprSizeOfType::GenMIRNodeImpl(MIRBuilder &mirBuilder) const { +#ifndef USE_OPS + CHECK_FATAL(false, "Unsupported in NO OPS"); + return nullptr; +#else + return mirBuilder.CreateExprSizeoftype(*(feirType->GenerateMIRTypeAuto())); +#endif +} + // ---------- FEIRExprDRead ---------- FEIRExprDRead::FEIRExprDRead(std::unique_ptr argVarSrc) : FEIRExpr(FEIRNodeKind::kExprDRead) { SetVarSrc(std::move(argVarSrc)); } -FEIRExprDRead::FEIRExprDRead(std::unique_ptr argType, std::unique_ptr argVarSrc, - const std::string &argFieldName) - : FEIRExpr(FEIRNodeKind::kExprDRead, std::move(argType)), - fieldName(argFieldName) { - SetVarSrc(std::move(argVarSrc)); -} - FEIRExprDRead::FEIRExprDRead(std::unique_ptr argType, std::unique_ptr argVarSrc) : FEIRExpr(FEIRNodeKind::kExprDRead, std::move(argType)) { SetVarSrc(std::move(argVarSrc)); @@ -2107,8 +2226,9 @@ FEIRExprDRead::FEIRExprDRead(std::unique_ptr argType, std::unique_ptr< std::unique_ptr FEIRExprDRead::CloneImpl() const { std::unique_ptr expr = std::make_unique(type->Clone(), varSrc->Clone()); - expr->SetFieldType(fieldType); - expr->SetFieldName(fieldName); + if (fieldType != nullptr) { + expr->SetFieldType(fieldType->Clone()); + } expr->SetFieldID(fieldID); return expr; } @@ -2118,20 +2238,12 @@ BaseNode *FEIRExprDRead::GenMIRNodeImpl(MIRBuilder &mirBuilder) const { MIRSymbol *symbol = varSrc->GenerateMIRSymbol(mirBuilder); ASSERT(type != nullptr, "type is nullptr"); AddrofNode *node = mirBuilder.CreateExprDread(*type, *symbol); - FieldID fieldID = this->fieldID; - if ((type->GetKind() == MIRTypeKind::kTypeStruct || type->GetKind() == MIRTypeKind::kTypeUnion) && - (!fieldName.empty() || (fieldID != 0))) { - MIRType *tmpFieldType = nullptr; - if (fieldID == 0) { - fieldID = FEUtils::GetStructFieldID(mirBuilder, static_cast(type), fieldName); - FieldID tmpID = fieldID; - FieldPair fieldPair = static_cast(type)->TraverseToFieldRef(tmpID); - tmpFieldType = GlobalTables::GetTypeTable().GetTypeFromTyIdx(fieldPair.second.first); - } else { - CHECK_NULL_FATAL(fieldType); - tmpFieldType = fieldType; - } - node = mirBuilder.CreateExprDread(*tmpFieldType, fieldID, *symbol); + if (fieldID != 0) { + CHECK_FATAL((type->GetKind() == MIRTypeKind::kTypeStruct || type->GetKind() == MIRTypeKind::kTypeUnion), + "If fieldID is not 0, then the variable must be a structure"); + CHECK_NULL_FATAL(fieldType); + MIRType *fieldMIRType = fieldType->GenerateMIRTypeAuto(); + node = mirBuilder.CreateExprDread(*fieldMIRType, fieldID, *symbol); } return node; } @@ -2148,43 +2260,47 @@ std::vector FEIRExprDRead::GetVarUsesImpl() const { PrimType FEIRExprDRead::GetPrimTypeImpl() const { PrimType primType = type->GetPrimType(); - MIRType *mirType = GetFieldType(); - if (primType == PTY_agg && mirType != nullptr && (!fieldName.empty() || fieldID != 0)) { - return mirType->GetPrimType(); + if (primType == PTY_agg && fieldID != 0) { + CHECK_NULL_FATAL(fieldType); + return fieldType->GetPrimType(); } return primType; } +FEIRType *FEIRExprDRead::GetTypeImpl() const { + if (fieldID != 0) { + CHECK_NULL_FATAL(fieldType); + return fieldType.get(); + } + return type.get(); +} + +const FEIRType &FEIRExprDRead::GetTypeRefImpl() const { + return *GetTypeImpl(); +} + // ---------- FEIRExprIRead ---------- std::unique_ptr FEIRExprIRead::CloneImpl() const { - std::unique_ptr expr = std::make_unique(retType->Clone(), ptrType->Clone(), + std::unique_ptr expr = std::make_unique(type->Clone(), ptrType->Clone(), fieldID, subExpr->Clone()); - expr->SetFieldName(fieldName); return expr; } PrimType FEIRExprIRead::GetPrimTypeImpl() const { - CHECK_NULL_FATAL(retType); - return retType->GetPrimType(); + return type->GetPrimType(); } BaseNode *FEIRExprIRead::GenMIRNodeImpl(MIRBuilder &mirBuilder) const { - MIRType *returnType = retType->GenerateMIRTypeAuto(); + MIRType *returnType = type->GenerateMIRTypeAuto(); MIRType *pointerType = ptrType->GenerateMIRTypeAuto(); BaseNode *node = subExpr->GenMIRNode(mirBuilder); CHECK_FATAL(pointerType->IsMIRPtrType(), "Must be ptr type!"); MIRPtrType *mirPtrType = static_cast(pointerType); MIRType *pointedMirType = mirPtrType->GetPointedType(); - FieldID fieldID = this->fieldID; - if ((pointedMirType->GetKind() == MIRTypeKind::kTypeStruct || pointedMirType->GetKind() == MIRTypeKind::kTypeUnion) && - (!fieldName.empty() || fieldID != 0)) { - auto *structMirType = static_cast(pointedMirType); - if (fieldID == 0) { - fieldID = FEUtils::GetStructFieldID(mirBuilder, structMirType, fieldName); - } - FieldID tmpID = fieldID; - FieldPair fieldPair = structMirType->TraverseToFieldRef(tmpID); - returnType = GlobalTables::GetTypeTable().GetTypeFromTyIdx(fieldPair.second.first); + if (fieldID != 0) { + CHECK_FATAL((pointedMirType->GetKind() == MIRTypeKind::kTypeStruct || + pointedMirType->GetKind() == MIRTypeKind::kTypeUnion), + "If fieldID is not 0, then type must specify pointer to a structure"); } return mirBuilder.CreateExprIread(*returnType, *mirPtrType, fieldID, node); } @@ -2213,6 +2329,26 @@ BaseNode *FEIRExprAddrof::GenMIRNodeImpl(MIRBuilder &mirBuilder) const { return nodeAddrof; } +// ---------- FEIRExprIAddrof ---------- +std::unique_ptr FEIRExprIAddrof::CloneImpl() const { + return std::make_unique(ptrType->Clone(), fieldID, subExpr->Clone()); +} + +BaseNode *FEIRExprIAddrof::GenMIRNodeImpl(MIRBuilder &mirBuilder) const { + MIRType *returnType = GlobalTables::GetTypeTable().GetPtrType(); + MIRType *pointerType = ptrType->GenerateMIRTypeAuto(); + BaseNode *node = subExpr->GenMIRNode(mirBuilder); + CHECK_FATAL(pointerType->IsMIRPtrType(), "Must be ptr type!"); + MIRPtrType *mirPtrType = static_cast(pointerType); + MIRType *pointedMirType = mirPtrType->GetPointedType(); + if (fieldID != 0) { + CHECK_FATAL((pointedMirType->GetKind() == MIRTypeKind::kTypeStruct || + pointedMirType->GetKind() == MIRTypeKind::kTypeUnion), + "If fieldID is not 0, then type must specify pointer to a structure"); + } + return mirBuilder.CreateExprIaddrof(*returnType, *mirPtrType, fieldID, node); +} + // ---------- FEIRExprAddrofVar ---------- std::unique_ptr FEIRExprAddrofVar::CloneImpl() const { std::unique_ptr expr = std::make_unique(varSrc->Clone()); @@ -2226,17 +2362,21 @@ BaseNode *FEIRExprAddrofVar::GenMIRNodeImpl(MIRBuilder &mirBuilder) const { MIRSymbol *varSymbol = varSrc->GenerateMIRSymbol(mirBuilder); MIRType *type = varSrc->GetType()->GenerateMIRTypeAuto(); AddrofNode *node = mirBuilder.CreateExprAddrof(fieldID, *varSymbol); + FieldID fieldID = this->fieldID; if ((type->IsMIRStructType() || type->GetKind() == MIRTypeKind::kTypeUnion) && (!fieldName.empty() || (fieldID != 0))) { - FieldID fieldIdVar = fieldID; - if (fieldIdVar == 0) { - fieldIdVar = mirBuilder.GetStructFieldIDFromFieldName(*type, fieldName); + if (fieldID == 0) { + fieldID = FEUtils::GetStructFieldID(static_cast(type), fieldName); } - node = mirBuilder.CreateExprAddrof(fieldIdVar, *varSymbol); + node = mirBuilder.CreateExprAddrof(fieldID, *varSymbol); } return node; } +std::vector FEIRExprAddrofVar::GetVarUsesImpl() const { + return std::vector({ varSrc.get() }); +} + // ---------- FEIRExprAddrofFunc ---------- std::unique_ptr FEIRExprAddrofFunc::CloneImpl() const { CHECK_FATAL(false, "not support clone here"); @@ -2251,6 +2391,41 @@ BaseNode *FEIRExprAddrofFunc::GenMIRNodeImpl(MIRBuilder &mirBuilder) const { mirBuilder.GetMirModule().GetMemPool()); } +// ---------- FEIRExprAddrofArray ---------- +FEIRExprAddrofArray::FEIRExprAddrofArray(UniqueFEIRType argTypeNativeArray, UniqueFEIRExpr argExprArray, + std::string argArrayName, std::list &argExprIndexs) + : FEIRExpr(FEIRNodeKind::kExprAddrofArray), typeNativeArray(std::move(argTypeNativeArray)), + exprArray(std::move(argExprArray)), + arrayName(argArrayName) { + SetIndexsExprs(argExprIndexs); +} + +std::unique_ptr FEIRExprAddrofArray::CloneImpl() const { + UniqueFEIRType uTypeNativeArray = typeNativeArray->Clone(); + UniqueFEIRExpr uExprArray = exprArray->Clone(); + auto feirExprAddrofArray = std::make_unique(std::move(uTypeNativeArray), + std::move(uExprArray), arrayName, + exprIndexs); + feirExprAddrofArray->SetIndexsExprs(exprIndexs); + return feirExprAddrofArray; +} + +BaseNode *FEIRExprAddrofArray::GenMIRNodeImpl(MIRBuilder &mirBuilder) const { + MIRType *ptrMIRArrayType = typeNativeArray->GenerateMIRType(false); + std::unique_ptr tmpVar = std::make_unique(arrayName, typeNativeArray->Clone()); + std::vector nds; + uint32 fieldID = 0; + MIRSymbol *mirSymbol = tmpVar->GenerateLocalMIRSymbol(mirBuilder); + BaseNode *nodeAddrof = mirBuilder.CreateExprAddrof(fieldID, *mirSymbol); + nds.push_back(nodeAddrof); + for (auto &e : exprIndexs) { + BaseNode *no = e->GenMIRNode(mirBuilder); + nds.push_back(no); + } + BaseNode *arrayExpr = mirBuilder.CreateExprArray(*ptrMIRArrayType, nds); + return arrayExpr; +} + // ---------- FEIRExprRegRead ---------- FEIRExprRegRead::FEIRExprRegRead(PrimType pty, int32 regNumIn) : FEIRExpr(FEIRNodeKind::kExprRegRead), prmType(pty), regNum(regNumIn) {} @@ -3151,43 +3326,51 @@ bool FEIRExprJavaArrayLength::CalculateDefs4AllUsesImpl(FEIRStmtCheckPoint &chec // ---------- FEIRExprArrayStoreForC ---------- FEIRExprArrayStoreForC::FEIRExprArrayStoreForC(UniqueFEIRExpr argExprArray, std::list &argExprIndexs, - UniqueFEIRType argTypeNative) + UniqueFEIRType argTypeNative, std::string argArrayName) : FEIRExpr(FEIRNodeKind::kExprArrayStoreForC), exprArray(std::move(argExprArray)), - typeNative(std::move(argTypeNative)) { + typeNative(std::move(argTypeNative)), + arrayName(argArrayName) { SetIndexsExprs(argExprIndexs); } FEIRExprArrayStoreForC::FEIRExprArrayStoreForC(UniqueFEIRExpr argExprArray, std::list &argExprIndexs, UniqueFEIRType argArrayTypeNative, UniqueFEIRExpr argExprStruct, - UniqueFEIRType argStructTypeNative) + UniqueFEIRType argStructTypeNative, std::string argArrayName) : FEIRExpr(FEIRNodeKind::kExprArrayStoreForC), exprArray(std::move(argExprArray)), typeNative(std::move(argArrayTypeNative)), exprStruct(std::move(argExprStruct)), - typeNativeStruct(std::move(argStructTypeNative)) { + typeNativeStruct(std::move(argStructTypeNative)), + arrayName(argArrayName) { SetIndexsExprs(argExprIndexs); } // only ArraySubscriptExpr is right value, left not need BaseNode *FEIRExprArrayStoreForC::GenMIRNodeImpl(MIRBuilder &mirBuilder) const { - MIRType *ptrMIRArrayType = typeNative->GenerateMIRType(false); + MIRType *ptrMIRArrayType = typeNative->GenerateMIRTypeAuto(); std::vector nds; uint32 fieldID = 0; if (IsMember()) { - GStrIdx fieldNameIdx = GlobalTables::GetStrTable().GetOrCreateStrIdxFromName( - static_cast(exprArray.get())->GetFieldName()); - MIRType *ptrMIRStructType = typeNativeStruct->GenerateMIRType(false); + fieldID = static_cast(exprArray.get())->GetFieldID(); + MIRType *ptrMIRStructType = typeNativeStruct->GenerateMIRTypeAuto(); MIRStructType* mirStructType = static_cast(ptrMIRStructType); - FEManager::GetMIRBuilder().TraverseToNamedField(*mirStructType, fieldNameIdx, fieldID); + // for no init, create the struct symbol +#ifndef USE_OPS + (void)SymbolBuilder::Instance().GetOrCreateLocalSymbol(*mirStructType, arrayName, + *mirBuilder.GetCurrentFunction()); +#else + (void)mirBuilder.GetOrCreateLocalDecl(arrayName, *mirStructType); +#endif } BaseNode *nodeAddrof = nullptr; - if (exprArray->GetKind() == kExprDRead) { - MIRSymbol *mirSymbol = exprArray->GetVarUses().front()->GenerateMIRSymbol(mirBuilder); - nodeAddrof = mirBuilder.CreateExprAddrof(fieldID, *mirSymbol); - } else { + MIRSymbol *mirSymbol = exprArray->GetVarUses().front()->GenerateMIRSymbol(mirBuilder); + auto mirtype = mirSymbol->GetType(); + if (mirtype->GetKind() == kTypePointer) { nodeAddrof = exprArray->GenMIRNode(mirBuilder); + } else { + nodeAddrof = mirBuilder.CreateExprAddrof(fieldID, *mirSymbol); } nds.push_back(nodeAddrof); for (auto &e : exprIndexs) { @@ -3207,14 +3390,22 @@ BaseNode *FEIRExprArrayStoreForC::GenMIRNodeImpl(MIRBuilder &mirBuilder) const { } std::unique_ptr FEIRExprArrayStoreForC::CloneImpl() const { - CHECK_FATAL(false, "not support clone here"); - std::unique_ptr expr; - return expr; + if (exprStruct != nullptr) { + auto feirExprArrayStoreForC = std::make_unique(exprArray->Clone(), exprIndexs, + typeNative->Clone(), exprStruct->Clone(), typeNativeStruct->Clone(), arrayName); + feirExprArrayStoreForC->SetIndexsExprs(exprIndexs); + return feirExprArrayStoreForC; + } else { + auto feirExprArrayStoreForC = std::make_unique(exprArray->Clone(), exprIndexs, + typeNative->Clone(), arrayName); + feirExprArrayStoreForC->SetIndexsExprs(exprIndexs); + return feirExprArrayStoreForC; + } } PrimType FEIRExprArrayStoreForC::GetPrimTypeImpl() const { CHECK_NULL_FATAL(typeNative); - MIRType *ptrMIRArrayType = typeNative->GenerateMIRType(false); + MIRType *ptrMIRArrayType = typeNative->GenerateMIRTypeAuto(); if (isAddrOf) { return PTY_ptr; } else { @@ -3741,11 +3932,10 @@ std::list FEIRStmtIAssign::GenMIRStmtsImpl(MIRBuilder &mirBuilder) co BaseNode *addrNode = addrExpr->GenMIRNode(mirBuilder); BaseNode *baseNode = baseExpr->GenMIRNode(mirBuilder); auto *mirPtrType = static_cast(mirType); - FieldID fieldID = this->fieldID; - if ((mirPtrType->GetPointedType()->GetKind() == MIRTypeKind::kTypeStruct || - mirPtrType->GetPointedType()->GetKind() == MIRTypeKind::kTypeUnion) && !fieldName.empty() && fieldID == 0) { - auto *mirStructType = static_cast(mirPtrType->GetPointedType()); - fieldID = FEUtils::GetStructFieldID(mirBuilder, mirStructType, fieldName); + if (fieldID != 0) { + CHECK_FATAL((mirPtrType->GetPointedType()->GetKind() == MIRTypeKind::kTypeStruct || + mirPtrType->GetPointedType()->GetKind() == MIRTypeKind::kTypeUnion), + "If fieldID is not 0, then the computed address must correspond to a structure"); } IassignNode *iAssignNode = mirBuilder.CreateStmtIassign(*mirType, fieldID, addrNode, baseNode); ans.emplace_back(iAssignNode); diff --git a/src/mplfe/common/src/feir_var.cpp b/src/mplfe/common/src/feir_var.cpp index 959d27bd4858f003991fca140df12fc368a00ac1..9d1b07f19826d2b68f22efb28fd11dcc3967d58a 100644 --- a/src/mplfe/common/src/feir_var.cpp +++ b/src/mplfe/common/src/feir_var.cpp @@ -139,7 +139,15 @@ MIRSymbol *FEIRVar::GenerateLocalMIRSymbolImpl(MIRBuilder &builder) const { #ifndef USE_OPS return SymbolBuilder::Instance().GetOrCreateLocalSymbol(*mirType, name, *builder.GetCurrentFunction()); #else - return builder.GetOrCreateLocalDecl(name, *mirType); + MIRSymbol *mirSymbol = builder.GetOrCreateLocalDecl(name, *mirType); + if (genAttrs.GetAttr(GenericAttrKind::GENATTR_static)) { + auto attrs = TypeAttrs(); + attrs.SetAttr(ATTR_static); + mirSymbol->SetAttrs(attrs); + mirSymbol->SetStorageClass(MIRStorageClass::kScPstatic); + mirSymbol->SetKonst(mirConst); + } + return mirSymbol; #endif } diff --git a/src/mrt/deplibs/libmplandroid.so b/src/mrt/deplibs/libmplandroid.so index 48552d4c7d630b5a718984b1cd2a20c40f042154..69ce02e3388c0780bc66cfed65f426cc7e61ec6c 100755 Binary files a/src/mrt/deplibs/libmplandroid.so and b/src/mrt/deplibs/libmplandroid.so differ