diff --git a/src/mapleall/maple_me/BUILD.gn b/src/mapleall/maple_me/BUILD.gn index c0eef6269fb0f6e0b5951c7a107cc0aaba418f6a..e057b67da8540aede7ecb42f8893af23ec5adeaf 100644 --- a/src/mapleall/maple_me/BUILD.gn +++ b/src/mapleall/maple_me/BUILD.gn @@ -84,7 +84,6 @@ src_libmplmewpo = [ "src/irmap.cpp", "src/irmap_build.cpp", "src/irmap_emit.cpp", - "src/me_builder.cpp", "src/me_ir.cpp", "src/orig_symbol.cpp", "src/ssa.cpp", diff --git a/src/mapleall/maple_me/include/irmap.h b/src/mapleall/maple_me/include/irmap.h old mode 100755 new mode 100644 index 60f8c3e30205f6abe48f514794d6bb65a420bf89..3b31c8e91acecd101f3e8703cc3c38e81a3d9ede --- a/src/mapleall/maple_me/include/irmap.h +++ b/src/mapleall/maple_me/include/irmap.h @@ -18,7 +18,6 @@ #include "ver_symbol.h" #include "ssa_tab.h" #include "me_ir.h" -#include "me_builder.h" namespace maple { class IRMapBuild; // circular dependency exists, no other choice @@ -35,8 +34,7 @@ class IRMap : public AnalysisResult { hashTable(mapHashLength, nullptr, irMapAlloc.Adapter()), vst2MeExprTable(ssaTab.GetVersionStTableSize(), nullptr, irMapAlloc.Adapter()), lpreTmps(irMapAlloc.Adapter()), - vst2Decrefs(irMapAlloc.Adapter()), - meBuilder(irMapAlloc) {} + vst2Decrefs(irMapAlloc.Adapter()) {} virtual ~IRMap() = default; virtual BB *GetBB(BBId id) = 0; @@ -102,6 +100,8 @@ class IRMap : public AnalysisResult { MeExpr *CreateMeExprCompare(Opcode, PrimType, PrimType, MeExpr&, MeExpr&); MeExpr *CreateMeExprSelect(PrimType, MeExpr&, MeExpr&, MeExpr&); MeExpr *CreateMeExprTypeCvt(PrimType, PrimType, MeExpr&); + UnaryMeStmt *CreateUnaryMeStmt(Opcode op, MeExpr *opnd); + UnaryMeStmt *CreateUnaryMeStmt(Opcode op, MeExpr *opnd, BB *bb, const SrcPosition *src); IntrinsiccallMeStmt *CreateIntrinsicCallMeStmt(MIRIntrinsicID idx, std::vector &opnds, TyIdx tyIdx = TyIdx()); IntrinsiccallMeStmt *CreateIntrinsicCallAssignedMeStmt(MIRIntrinsicID idx, std::vector &opnds, MeExpr *ret, @@ -217,7 +217,6 @@ class IRMap : public AnalysisResult { bool needAnotherPass = false; // set to true if CFG has changed bool dumpStmtNum = false; BB *curBB = nullptr; // current maple_me::BB being visited - MeBuilder meBuilder; bool ReplaceMeExprStmtOpnd(uint32, MeStmt&, const MeExpr&, MeExpr&); void PutToBucket(uint32, MeExpr&); diff --git a/src/mapleall/maple_me/include/irmap_build.h b/src/mapleall/maple_me/include/irmap_build.h index e478927df5c3d92f7aa2805cc507dfdf3d42d05e..1b72df86c3ee411a104668f96f10ded6832b4f94 100644 --- a/src/mapleall/maple_me/include/irmap_build.h +++ b/src/mapleall/maple_me/include/irmap_build.h @@ -28,8 +28,8 @@ class IRMapBuild { ssaTab(irMap->GetSSATab()), dominance(*dom), curBB(nullptr) { - static const auto stmtBuildPolicyLoader = InitMeStmtFactory(); - (void)stmtBuildPolicyLoader; + InitMeExprBuildFactory(); + InitMeStmtFactory(); } ~IRMapBuild() {} void BuildBB(BB &bb, std::vector &bbIRMapProcessed); @@ -45,7 +45,34 @@ class IRMapBuild { void BuildMuList(TypeOfMayUseList&, MapleMap&); void BuildPhiMeNode(BB&); void SetMeExprOpnds(MeExpr &meExpr, BaseNode &mirNode); - static bool InitMeStmtFactory(); + + OpMeExpr *BuildOpMeExpr(BaseNode &mirNode) const { + OpMeExpr *meExpr = new OpMeExpr(kInvalidExprID, mirNode.GetOpCode(), mirNode.GetPrimType(), mirNode.GetNumOpnds()); + return meExpr; + } + MeExpr *BuildAddrofMeExpr(BaseNode &mirNode) const; + MeExpr *BuildAddroffuncMeExpr(BaseNode &mirNode) const; + MeExpr *BuildGCMallocMeExpr(BaseNode &mirNode) const; + MeExpr *BuildSizeoftypeMeExpr(BaseNode &mirNode) const; + MeExpr *BuildFieldsDistMeExpr(BaseNode &mirNode) const; + MeExpr *BuildIvarMeExpr(BaseNode &mirNode) const; + MeExpr *BuildConstMeExpr(BaseNode &mirNode) const; + MeExpr *BuildConststrMeExpr(BaseNode &mirNode) const; + MeExpr *BuildConststr16MeExpr(BaseNode &mirNode) const; + MeExpr *BuildOpMeExprForCompare(BaseNode &mirNode) const; + MeExpr *BuildOpMeExprForTypeCvt(BaseNode &mirNode) const; + MeExpr *BuildOpMeExprForRetype(BaseNode &mirNode) const; + MeExpr *BuildOpMeExprForIread(BaseNode &mirNode) const; + MeExpr *BuildOpMeExprForExtractbits(BaseNode &mirNode) const; + MeExpr *BuildOpMeExprForJarrayMalloc(BaseNode &mirNode) const; + MeExpr *BuildOpMeExprForResolveFunc(BaseNode &mirNode) const; + MeExpr *BuildNaryMeExprForArray(BaseNode &mirNode) const; + MeExpr *BuildNaryMeExprForIntrinsicop(BaseNode &mirNode) const; + MeExpr *BuildNaryMeExprForIntrinsicWithType(BaseNode &mirNode) const; + MeExpr *BuildExpr(BaseNode&); + static void InitMeExprBuildFactory(); + + MeStmt *BuildMeStmtWithNoSSAPart(StmtNode &stmt); MeStmt *BuildDassignMeStmt(StmtNode &stmt, AccessSSANodes &ssaPart); MeStmt *BuildRegassignMeStmt(StmtNode &stmt, AccessSSANodes &ssaPart); MeStmt *BuildIassignMeStmt(StmtNode &stmt, AccessSSANodes &ssaPart); @@ -57,9 +84,8 @@ class IRMapBuild { MeStmt *BuildGosubMeStmt(StmtNode &stmt, AccessSSANodes &ssaPart); MeStmt *BuildThrowMeStmt(StmtNode &stmt, AccessSSANodes &ssaPart); MeStmt *BuildSyncMeStmt(StmtNode &stmt, AccessSSANodes &ssaPart); - MeStmt *BuildMeStmtWithNoSSAPart(StmtNode &stmt); MeStmt *BuildMeStmt(StmtNode&); - MeExpr *BuildExpr(BaseNode&); + static void InitMeStmtFactory(); IRMap *irMap; MIRModule &mirModule; diff --git a/src/mapleall/maple_me/include/me_analyze_rc.h b/src/mapleall/maple_me/include/me_analyze_rc.h index 6e3d6c231ca87911a119a5d62a3492c9199fc2f1..a0fda5b7450b4fc4ec632a57f2fcb0f0e547c979 100644 --- a/src/mapleall/maple_me/include/me_analyze_rc.h +++ b/src/mapleall/maple_me/include/me_analyze_rc.h @@ -55,7 +55,6 @@ class AnalyzeRC { aliasClass(ac), analyzeRCMp(memPool), analyzeRCAllocator(memPool), - meBuilder(irMap.GetIRMapAlloc()), rcItemsMap(std::less(), analyzeRCAllocator.Adapter()), skipLocalRefVars(false) {} @@ -88,7 +87,6 @@ class AnalyzeRC { AliasClass &aliasClass; MemPool *analyzeRCMp; MapleAllocator analyzeRCAllocator; - MeBuilder meBuilder; MapleMap rcItemsMap; bool skipLocalRefVars; }; diff --git a/src/mapleall/maple_me/include/me_builder.h b/src/mapleall/maple_me/include/me_builder.h deleted file mode 100644 index eccd25ffbc0c54a210acc6759d69879070f6fc26..0000000000000000000000000000000000000000 --- a/src/mapleall/maple_me/include/me_builder.h +++ /dev/null @@ -1,76 +0,0 @@ -/* - * Copyright (c) [2019-2021] Huawei Technologies Co.,Ltd.All rights reserved. - * - * OpenArkCompiler is licensed under Mulan PSL v2. - * You can use this software according to the terms and conditions of the Mulan PSL v2. - * You may obtain a copy of Mulan PSL v2 at: - * - * http://license.coscl.org.cn/MulanPSL2 - * - * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER - * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR - * FIT FOR A PARTICULAR PURPOSE. - * See the Mulan PSL v2 for more details. - */ -#ifndef MAPLE_ME_INCLUDE_MEBUILDER_H -#define MAPLE_ME_INCLUDE_MEBUILDER_H -#include "me_ir.h" - -namespace maple { -class MeBuilder { - public: - explicit MeBuilder(MapleAllocator &allocator) : allocator(allocator) { - (void)InitMeExprBuildFactory(); - } - - virtual ~MeBuilder() = default; - - MeExpr &CreateMeExpr(int32 exprId, MeExpr &meExpr) const; - MeExpr *BuildMeExpr(BaseNode &mirNode) const; - VarMeExpr *BuildVarMeExpr(int32 exprID, OStIdx oStIdx, size_t vStIdx, PrimType pType, FieldID fieldID) const; - - UnaryMeStmt &BuildUnaryMeStmt(Opcode op, MeExpr &opnd, BB &bb, const SrcPosition &src) const; - UnaryMeStmt &BuildUnaryMeStmt(Opcode op, MeExpr &opnd, BB &bb) const; - UnaryMeStmt &BuildUnaryMeStmt(Opcode op, MeExpr &opnd) const; - - private: - template - T *NewInPool(Arguments&&... args) const { - return allocator.GetMemPool()->New(&allocator, std::forward(args)...); - } - - template - T *New(Arguments&&... args) const { - return allocator.GetMemPool()->New(std::forward(args)...); - } - - OpMeExpr *BuildOpMeExpr(BaseNode &mirNode) const { - OpMeExpr *meExpr = New(kInvalidExprID, mirNode.GetOpCode(), mirNode.GetPrimType(), mirNode.GetNumOpnds()); - return meExpr; - } - - static bool InitMeExprBuildFactory(); - MeExpr *BuildAddrofMeExpr(BaseNode &mirNode) const; - MeExpr *BuildAddroffuncMeExpr(BaseNode &mirNode) const; - MeExpr *BuildGCMallocMeExpr(BaseNode &mirNode) const; - MeExpr *BuildSizeoftypeMeExpr(BaseNode &mirNode) const; - MeExpr *BuildFieldsDistMeExpr(BaseNode &mirNode) const; - MeExpr *BuildIvarMeExpr(BaseNode &mirNode) const; - MeExpr *BuildConstMeExpr(BaseNode &mirNode) const; - MeExpr *BuildConststrMeExpr(BaseNode &mirNode) const; - MeExpr *BuildConststr16MeExpr(BaseNode &mirNode) const; - MeExpr *BuildOpMeExprForCompare(BaseNode &mirNode) const; - MeExpr *BuildOpMeExprForTypeCvt(BaseNode &mirNode) const; - MeExpr *BuildOpMeExprForRetype(BaseNode &mirNode) const; - MeExpr *BuildOpMeExprForIread(BaseNode &mirNode) const; - MeExpr *BuildOpMeExprForExtractbits(BaseNode &mirNode) const; - MeExpr *BuildOpMeExprForJarrayMalloc(BaseNode &mirNode) const; - MeExpr *BuildOpMeExprForResolveFunc(BaseNode &mirNode) const; - MeExpr *BuildNaryMeExprForArray(BaseNode &mirNode) const; - MeExpr *BuildNaryMeExprForIntrinsicop(BaseNode &mirNode) const; - MeExpr *BuildNaryMeExprForIntrinsicWithType(BaseNode &mirNode) const; - - MapleAllocator &allocator; -}; -} // namespace maple -#endif // MAPLE_ME_INCLUDE_MEBUILDER_H diff --git a/src/mapleall/maple_me/src/irmap.cpp b/src/mapleall/maple_me/src/irmap.cpp old mode 100755 new mode 100644 index b089f378f5c746a5f220460870673cdb012767dd..b0ba280370d143f66f3e33c29fefd783aacb3ef9 --- a/src/mapleall/maple_me/src/irmap.cpp +++ b/src/mapleall/maple_me/src/irmap.cpp @@ -77,7 +77,8 @@ MeExpr *IRMap::CreateIvarMeExpr(MeExpr &expr, TyIdx tyIdx, MeExpr &base) { } VarMeExpr *IRMap::CreateNewVarMeExpr(OStIdx ostIdx, PrimType pType, FieldID fieldID) { - VarMeExpr *varMeExpr = meBuilder.BuildVarMeExpr(exprID++, ostIdx, vst2MeExprTable.size(), pType, fieldID); + VarMeExpr *varMeExpr = New(&GetIRMapAlloc(), exprID++, ostIdx, vst2MeExprTable.size(), pType); + varMeExpr->SetFieldID(fieldID); PushBackVerst2MeExprTable(varMeExpr); return varMeExpr; } @@ -253,7 +254,50 @@ MeExpr *IRMap::HashMeExpr(MeExpr &meExpr) { } if (resultExpr == nullptr) { - resultExpr = &meBuilder.CreateMeExpr(exprID++, meExpr); + switch (meExpr.GetMeOp()) { + case kMeOpIvar: + resultExpr = New(exprID, static_cast(meExpr)); + break; + case kMeOpOp: + resultExpr = New(static_cast(meExpr), exprID); + break; + case kMeOpConst: + resultExpr = New(exprID, static_cast(meExpr).GetConstVal(), meExpr.GetPrimType()); + break; + case kMeOpConststr: + resultExpr = New(exprID, static_cast(meExpr).GetStrIdx(), meExpr.GetPrimType()); + break; + case kMeOpConststr16: + resultExpr = New(exprID, static_cast(meExpr).GetStrIdx(), meExpr.GetPrimType()); + break; + case kMeOpSizeoftype: + resultExpr = New(exprID, meExpr.GetPrimType(), static_cast(meExpr).GetTyIdx()); + break; + case kMeOpFieldsDist: { + auto &expr = static_cast(meExpr); + resultExpr = New(exprID, meExpr.GetPrimType(), expr.GetTyIdx(), expr.GetFieldID1(), expr.GetFieldID2()); + break; + } + case kMeOpAddrof: + resultExpr = New(exprID, meExpr.GetPrimType(), static_cast(meExpr).GetOstIdx()); + static_cast(resultExpr)->SetFieldID(static_cast(meExpr).GetFieldID()); + break; + case kMeOpNary: + resultExpr = NewInPool(exprID, static_cast(meExpr)); + break; + case kMeOpAddroffunc: + resultExpr = New(exprID, static_cast(meExpr).GetPuIdx()); + break; + case kMeOpGcmalloc: + resultExpr = New(exprID, meExpr.GetOp(), meExpr.GetPrimType(), static_cast(meExpr).GetTyIdx()); + break; + default: + CHECK_FATAL(false, "not yet implement"); + } + exprID++; + if (meExpr.GetMeOp() == kMeOpOp || meExpr.GetMeOp() == kMeOpNary) { + resultExpr->UpdateDepth(); + } PutToBucket(hashIdx, *resultExpr); } return resultExpr; @@ -472,6 +516,19 @@ MeExpr *IRMap::CreateMeExprTypeCvt(PrimType pType, PrimType opndptyp, MeExpr &op return HashMeExpr(opMeExpr); } +UnaryMeStmt *IRMap::CreateUnaryMeStmt(Opcode op, MeExpr *opnd) { + UnaryMeStmt *unaryMeStmt = New(op); + unaryMeStmt->SetMeStmtOpndValue(opnd); + return unaryMeStmt; +} + +UnaryMeStmt *IRMap::CreateUnaryMeStmt(Opcode op, MeExpr *opnd, BB *bb, const SrcPosition *src) { + UnaryMeStmt *unaryMeStmt = CreateUnaryMeStmt(op, opnd); + unaryMeStmt->SetBB(bb); + unaryMeStmt->SetSrcPos(*src); + return unaryMeStmt; +} + IntrinsiccallMeStmt *IRMap::CreateIntrinsicCallMeStmt(MIRIntrinsicID idx, std::vector &opnds, TyIdx tyIdx) { auto *meStmt = NewInPool(tyIdx == 0u ? OP_intrinsiccall : OP_intrinsiccallwithtype, idx, tyIdx); diff --git a/src/mapleall/maple_me/src/irmap_build.cpp b/src/mapleall/maple_me/src/irmap_build.cpp index 240394410a2a641d31190715215873621232171f..0b34fdb9c972e5e34159dd9fb2dfddfc25ee1509 100644 --- a/src/mapleall/maple_me/src/irmap_build.cpp +++ b/src/mapleall/maple_me/src/irmap_build.cpp @@ -19,6 +19,7 @@ // Methods to convert Maple IR to MeIR namespace maple { +using MeExprBuildFactory = FunctionFactory; using MeStmtFactory = FunctionFactory; VarMeExpr *IRMapBuild::GetOrCreateVarFromVerSt(const VersionSt &vst) { @@ -156,6 +157,125 @@ void IRMapBuild::SetMeExprOpnds(MeExpr &meExpr, BaseNode &mirNode) { } } +MeExpr *IRMapBuild::BuildAddrofMeExpr(BaseNode &mirNode) const { + auto &addrofNode = static_cast(mirNode); + AddrofMeExpr *meExpr = new AddrofMeExpr(kInvalidExprID, addrofNode.GetPrimType(), addrofNode.GetSSAVar()->GetOrigSt()->GetIndex()); + meExpr->SetFieldID(addrofNode.GetFieldID()); + return meExpr; +} + +MeExpr *IRMapBuild::BuildAddroffuncMeExpr(BaseNode &mirNode) const { + AddroffuncMeExpr *meExpr = new AddroffuncMeExpr(kInvalidExprID, static_cast(mirNode).GetPUIdx()); + return meExpr; +} + +MeExpr *IRMapBuild::BuildGCMallocMeExpr(BaseNode &mirNode) const { + GcmallocMeExpr *meExpr = new GcmallocMeExpr(kInvalidExprID, mirNode.GetOpCode(), mirNode.GetPrimType(), static_cast(mirNode).GetTyIdx()); + return meExpr; +} + +MeExpr *IRMapBuild::BuildSizeoftypeMeExpr(BaseNode &mirNode) const { + SizeoftypeMeExpr *meExpr = new SizeoftypeMeExpr(kInvalidExprID, mirNode.GetPrimType(), static_cast(mirNode).GetTyIdx()); + return meExpr; +} + +MeExpr *IRMapBuild::BuildFieldsDistMeExpr(BaseNode &mirNode) const { + auto &fieldsDistNode = static_cast(mirNode); + FieldsDistMeExpr *meExpr = new FieldsDistMeExpr(kInvalidExprID, mirNode.GetPrimType(), fieldsDistNode.GetTyIdx(), + fieldsDistNode.GetFiledID1(), fieldsDistNode.GetFiledID2()); + return meExpr; +} + +MeExpr *IRMapBuild::BuildIvarMeExpr(BaseNode &mirNode) const { + auto &ireadSSANode = static_cast(mirNode); + IvarMeExpr *meExpr = new IvarMeExpr(kInvalidExprID, mirNode.GetPrimType(), ireadSSANode.GetTyIdx(), ireadSSANode.GetFieldID()); + return meExpr; +} + +MeExpr *IRMapBuild::BuildConstMeExpr(BaseNode &mirNode) const { + auto &constvalNode = static_cast(mirNode); + ConstMeExpr *meExpr = new ConstMeExpr(kInvalidExprID, constvalNode.GetConstVal(), mirNode.GetPrimType()); + meExpr->SetOp(OP_constval); + return meExpr; +} + +MeExpr *IRMapBuild::BuildConststrMeExpr(BaseNode &mirNode) const { + ConststrMeExpr *meExpr = new ConststrMeExpr(kInvalidExprID, static_cast(mirNode).GetStrIdx(), mirNode.GetPrimType()); + return meExpr; +} + +MeExpr *IRMapBuild::BuildConststr16MeExpr(BaseNode &mirNode) const { + Conststr16MeExpr *meExpr = new Conststr16MeExpr(kInvalidExprID, static_cast(mirNode).GetStrIdx(), mirNode.GetPrimType()); + return meExpr; +} + +MeExpr *IRMapBuild::BuildOpMeExprForCompare(BaseNode &mirNode) const { + OpMeExpr *meExpr = BuildOpMeExpr(mirNode); + meExpr->SetOpndType(static_cast(mirNode).GetOpndType()); + return meExpr; +} + +MeExpr *IRMapBuild::BuildOpMeExprForTypeCvt(BaseNode &mirNode) const { + OpMeExpr *meExpr = BuildOpMeExpr(mirNode); + meExpr->SetOpndType(static_cast(mirNode).FromType()); + return meExpr; +} + +MeExpr *IRMapBuild::BuildOpMeExprForRetype(BaseNode &mirNode) const { + OpMeExpr *meExpr = BuildOpMeExpr(mirNode); + auto &retypeNode = static_cast(mirNode); + meExpr->SetOpndType(retypeNode.FromType()); + meExpr->SetTyIdx(retypeNode.GetTyIdx()); + return meExpr; +} + +MeExpr *IRMapBuild::BuildOpMeExprForIread(BaseNode &mirNode) const { + OpMeExpr *meExpr = BuildOpMeExpr(mirNode); + auto &ireadNode = static_cast(mirNode); + meExpr->SetTyIdx(ireadNode.GetTyIdx()); + meExpr->SetFieldID(ireadNode.GetFieldID()); + return meExpr; +} + +MeExpr *IRMapBuild::BuildOpMeExprForExtractbits(BaseNode &mirNode) const { + OpMeExpr *meExpr = BuildOpMeExpr(mirNode); + auto &extractbitsNode = static_cast(mirNode); + meExpr->SetBitsOffSet(extractbitsNode.GetBitsOffset()); + meExpr->SetBitsSize(extractbitsNode.GetBitsSize()); + return meExpr; +} + +MeExpr *IRMapBuild::BuildOpMeExprForJarrayMalloc(BaseNode &mirNode) const { + OpMeExpr *meExpr = BuildOpMeExpr(mirNode); + meExpr->SetTyIdx(static_cast(mirNode).GetTyIdx()); + return meExpr; +} + +MeExpr *IRMapBuild::BuildOpMeExprForResolveFunc(BaseNode &mirNode) const { + OpMeExpr *meExpr = BuildOpMeExpr(mirNode); + meExpr->SetFieldID(static_cast(mirNode).GetPuIdx()); + return meExpr; +} + +MeExpr *IRMapBuild::BuildNaryMeExprForArray(BaseNode &mirNode) const { + auto &arrayNode = static_cast(mirNode); + NaryMeExpr *meExpr = + new NaryMeExpr(&irMap->irMapAlloc, kInvalidExprID, mirNode.GetOpCode(), mirNode.GetPrimType(), mirNode.GetNumOpnds(), arrayNode.GetTyIdx(), INTRN_UNDEFINED, arrayNode.GetBoundsCheck()); + return meExpr; +} + +MeExpr *IRMapBuild::BuildNaryMeExprForIntrinsicop(BaseNode &mirNode) const { + NaryMeExpr *meExpr = + new NaryMeExpr(&irMap->irMapAlloc, kInvalidExprID, mirNode.GetOpCode(), mirNode.GetPrimType(), mirNode.GetNumOpnds(), TyIdx(0), static_cast(mirNode).GetIntrinsic(), false); + return meExpr; +} + +MeExpr *IRMapBuild::BuildNaryMeExprForIntrinsicWithType(BaseNode &mirNode) const { + auto &intrinNode = static_cast(mirNode); + NaryMeExpr *meExpr = new NaryMeExpr(&irMap->irMapAlloc, kInvalidExprID, mirNode.GetOpCode(), mirNode.GetPrimType(), mirNode.GetNumOpnds(), intrinNode.GetTyIdx(), intrinNode.GetIntrinsic(), false); + return meExpr; +} + MeExpr *IRMapBuild::BuildExpr(BaseNode &mirNode) { Opcode op = mirNode.GetOpCode(); if (op == OP_dread) { @@ -176,7 +296,9 @@ MeExpr *IRMapBuild::BuildExpr(BaseNode &mirNode) { return regMeExpr; } - MeExpr *meExpr = irMap->meBuilder.BuildMeExpr(mirNode); + auto func = CreateProductFunction(mirNode.GetOpCode()); + ASSERT(func != nullptr, "NIY BuildExpe"); + MeExpr *meExpr = func(this, mirNode); SetMeExprOpnds(*meExpr, mirNode); if (op == OP_iread) { @@ -191,6 +313,7 @@ MeExpr *IRMapBuild::BuildExpr(BaseNode &mirNode) { } MeExpr *retMeExpr = irMap->HashMeExpr(*meExpr); + delete meExpr; if (op == OP_iread) { ASSERT(static_cast(retMeExpr)->GetMu() != nullptr, "BuildExpr: ivar node cannot have mu == nullptr"); @@ -199,6 +322,69 @@ MeExpr *IRMapBuild::BuildExpr(BaseNode &mirNode) { return retMeExpr; } +void IRMapBuild::InitMeExprBuildFactory() { + RegisterFactoryFunction(OP_addrof, &IRMapBuild::BuildAddrofMeExpr); + RegisterFactoryFunction(OP_addroffunc, &IRMapBuild::BuildAddroffuncMeExpr); + RegisterFactoryFunction(OP_gcmalloc, &IRMapBuild::BuildGCMallocMeExpr); + RegisterFactoryFunction(OP_gcpermalloc, &IRMapBuild::BuildGCMallocMeExpr); + RegisterFactoryFunction(OP_sizeoftype, &IRMapBuild::BuildSizeoftypeMeExpr); + RegisterFactoryFunction(OP_fieldsdist, &IRMapBuild::BuildFieldsDistMeExpr); + RegisterFactoryFunction(OP_iread, &IRMapBuild::BuildIvarMeExpr); + RegisterFactoryFunction(OP_constval, &IRMapBuild::BuildConstMeExpr); + RegisterFactoryFunction(OP_conststr, &IRMapBuild::BuildConststrMeExpr); + RegisterFactoryFunction(OP_conststr16, &IRMapBuild::BuildConststr16MeExpr); + RegisterFactoryFunction(OP_eq, &IRMapBuild::BuildOpMeExprForCompare); + RegisterFactoryFunction(OP_ne, &IRMapBuild::BuildOpMeExprForCompare); + RegisterFactoryFunction(OP_lt, &IRMapBuild::BuildOpMeExprForCompare); + RegisterFactoryFunction(OP_gt, &IRMapBuild::BuildOpMeExprForCompare); + RegisterFactoryFunction(OP_le, &IRMapBuild::BuildOpMeExprForCompare); + RegisterFactoryFunction(OP_ge, &IRMapBuild::BuildOpMeExprForCompare); + RegisterFactoryFunction(OP_cmpg, &IRMapBuild::BuildOpMeExprForCompare); + RegisterFactoryFunction(OP_cmpl, &IRMapBuild::BuildOpMeExprForCompare); + RegisterFactoryFunction(OP_cmp, &IRMapBuild::BuildOpMeExprForCompare); + RegisterFactoryFunction(OP_ceil, &IRMapBuild::BuildOpMeExprForTypeCvt); + RegisterFactoryFunction(OP_cvt, &IRMapBuild::BuildOpMeExprForTypeCvt); + RegisterFactoryFunction(OP_floor, &IRMapBuild::BuildOpMeExprForTypeCvt); + RegisterFactoryFunction(OP_round, &IRMapBuild::BuildOpMeExprForTypeCvt); + RegisterFactoryFunction(OP_trunc, &IRMapBuild::BuildOpMeExprForTypeCvt); + RegisterFactoryFunction(OP_retype, &IRMapBuild::BuildOpMeExprForRetype); + RegisterFactoryFunction(OP_abs, &IRMapBuild::BuildOpMeExpr); + RegisterFactoryFunction(OP_bnot, &IRMapBuild::BuildOpMeExpr); + RegisterFactoryFunction(OP_lnot, &IRMapBuild::BuildOpMeExpr); + RegisterFactoryFunction(OP_neg, &IRMapBuild::BuildOpMeExpr); + RegisterFactoryFunction(OP_recip, &IRMapBuild::BuildOpMeExpr); + RegisterFactoryFunction(OP_sqrt, &IRMapBuild::BuildOpMeExpr); + RegisterFactoryFunction(OP_alloca, &IRMapBuild::BuildOpMeExpr); + RegisterFactoryFunction(OP_malloc, &IRMapBuild::BuildOpMeExpr); + RegisterFactoryFunction(OP_iaddrof, &IRMapBuild::BuildOpMeExprForIread); + RegisterFactoryFunction(OP_sext, &IRMapBuild::BuildOpMeExprForExtractbits); + RegisterFactoryFunction(OP_zext, &IRMapBuild::BuildOpMeExprForExtractbits); + RegisterFactoryFunction(OP_extractbits, &IRMapBuild::BuildOpMeExprForExtractbits); + RegisterFactoryFunction(OP_gcmallocjarray, &IRMapBuild::BuildOpMeExprForJarrayMalloc); + RegisterFactoryFunction(OP_gcpermallocjarray, &IRMapBuild::BuildOpMeExprForJarrayMalloc); + RegisterFactoryFunction(OP_resolveinterfacefunc, &IRMapBuild::BuildOpMeExprForResolveFunc); + RegisterFactoryFunction(OP_resolvevirtualfunc, &IRMapBuild::BuildOpMeExprForResolveFunc); + RegisterFactoryFunction(OP_sub, &IRMapBuild::BuildOpMeExpr); + RegisterFactoryFunction(OP_mul, &IRMapBuild::BuildOpMeExpr); + RegisterFactoryFunction(OP_div, &IRMapBuild::BuildOpMeExpr); + RegisterFactoryFunction(OP_rem, &IRMapBuild::BuildOpMeExpr); + RegisterFactoryFunction(OP_ashr, &IRMapBuild::BuildOpMeExpr); + RegisterFactoryFunction(OP_lshr, &IRMapBuild::BuildOpMeExpr); + RegisterFactoryFunction(OP_shl, &IRMapBuild::BuildOpMeExpr); + RegisterFactoryFunction(OP_max, &IRMapBuild::BuildOpMeExpr); + RegisterFactoryFunction(OP_min, &IRMapBuild::BuildOpMeExpr); + RegisterFactoryFunction(OP_band, &IRMapBuild::BuildOpMeExpr); + RegisterFactoryFunction(OP_bior, &IRMapBuild::BuildOpMeExpr); + RegisterFactoryFunction(OP_bxor, &IRMapBuild::BuildOpMeExpr); + RegisterFactoryFunction(OP_land, &IRMapBuild::BuildOpMeExpr); + RegisterFactoryFunction(OP_lior, &IRMapBuild::BuildOpMeExpr); + RegisterFactoryFunction(OP_add, &IRMapBuild::BuildOpMeExpr); + RegisterFactoryFunction(OP_select, &IRMapBuild::BuildOpMeExpr); + RegisterFactoryFunction(OP_array, &IRMapBuild::BuildNaryMeExprForArray); + RegisterFactoryFunction(OP_intrinsicop, &IRMapBuild::BuildNaryMeExprForIntrinsicop); + RegisterFactoryFunction(OP_intrinsicopwithtype, &IRMapBuild::BuildNaryMeExprForIntrinsicWithType); +} + MeStmt *IRMapBuild::BuildMeStmtWithNoSSAPart(StmtNode &stmt) { Opcode op = stmt.GetOpCode(); switch (op) { @@ -373,7 +559,7 @@ MeStmt *IRMapBuild::BuildMeStmt(StmtNode &stmt) { return func(this, stmt, *ssaPart); } -bool IRMapBuild::InitMeStmtFactory() { +void IRMapBuild::InitMeStmtFactory() { RegisterFactoryFunction(OP_dassign, &IRMapBuild::BuildDassignMeStmt); RegisterFactoryFunction(OP_regassign, &IRMapBuild::BuildRegassignMeStmt); RegisterFactoryFunction(OP_iassign, &IRMapBuild::BuildIassignMeStmt); @@ -407,7 +593,6 @@ bool IRMapBuild::InitMeStmtFactory() { RegisterFactoryFunction(OP_throw, &IRMapBuild::BuildThrowMeStmt); RegisterFactoryFunction(OP_syncenter, &IRMapBuild::BuildSyncMeStmt); RegisterFactoryFunction(OP_syncexit, &IRMapBuild::BuildSyncMeStmt); - return true; } // recursively invoke itself in a pre-order traversal of the dominator tree of diff --git a/src/mapleall/maple_me/src/me_analyze_rc.cpp b/src/mapleall/maple_me/src/me_analyze_rc.cpp old mode 100755 new mode 100644 index 25c744721aab932304ca79c85a6b037107331ca7..454921f966006de2bc99349283160b1f8063311a --- a/src/mapleall/maple_me/src/me_analyze_rc.cpp +++ b/src/mapleall/maple_me/src/me_analyze_rc.cpp @@ -153,18 +153,16 @@ void AnalyzeRC::IdentifyRCStmts() { // this part for inserting decref if (lhsRef->GetMeOp() == kMeOpVar) { // insert a decref statement - UnaryMeStmt &decrefStmt = meBuilder.BuildUnaryMeStmt( - OP_decref, *GetZeroVersionVarMeExpr(static_cast(*lhsRef)), bb, stmt.GetSrcPosition()); + UnaryMeStmt *decrefStmt = irMap.CreateUnaryMeStmt( + OP_decref, GetZeroVersionVarMeExpr(static_cast(*lhsRef)), &bb, &stmt.GetSrcPosition()); // insertion position is before stmt - bb.InsertMeStmtBefore(&stmt, &decrefStmt); + bb.InsertMeStmtBefore(&stmt, decrefStmt); } else { auto *lhsIvar = static_cast(lhsRef); { // insert a decref statement - IvarMeExpr &ivarMeExpr = utils::ToRef(safe_cast( - meBuilder.CreateMeExpr(kInvalidExprID, *lhsIvar))); - ivarMeExpr.SetDefStmt(nullptr); - ivarMeExpr.SetMuVal(nullptr); + IvarMeExpr ivarMeExpr(-1, lhsIvar->GetPrimType(), lhsIvar->GetTyIdx(), lhsIvar->GetFieldID()); + ivarMeExpr.SetBase(lhsIvar->GetBase()); // form mu from chiList auto &iass = static_cast(stmt); MapleMap::iterator xit = iass.GetChiList()->begin(); @@ -176,11 +174,11 @@ void AnalyzeRC::IdentifyRCStmts() { } } ASSERT(xit != iass.GetChiList()->end(), "IdentifyRCStmts: failed to find corresponding chi node"); - UnaryMeStmt &decrefStmt = meBuilder.BuildUnaryMeStmt( - OP_decref, *irMap.HashMeExpr(ivarMeExpr), bb, stmt.GetSrcPosition()); + UnaryMeStmt *decrefStmt = irMap.CreateUnaryMeStmt( + OP_decref, irMap.HashMeExpr(ivarMeExpr), &bb, &stmt.GetSrcPosition()); // insertion position is before stmt - bb.InsertMeStmtBefore(&stmt, &decrefStmt); - ost = GetOriginalSt(*decrefStmt.GetOpnd()); + bb.InsertMeStmtBefore(&stmt, decrefStmt); + ost = GetOriginalSt(*decrefStmt->GetOpnd()); ASSERT(ost != nullptr, "IdentifyRCStmts: cannot get SymbolOriginalSt"); (void)FindOrCreateRCItem(*ost); } @@ -295,7 +293,7 @@ DassignMeStmt *AnalyzeRC::CreateDassignInit(OriginalSt &ost, BB &bb) { } UnaryMeStmt *AnalyzeRC::CreateIncrefZeroVersion(const OriginalSt &ost) { - return &meBuilder.BuildUnaryMeStmt(OP_incref, *irMap.GetOrCreateZeroVersionVarMeExpr(ost)); + return irMap.CreateUnaryMeStmt(OP_incref, irMap.GetOrCreateZeroVersionVarMeExpr(ost)); } void AnalyzeRC::OptimizeRC() { diff --git a/src/mapleall/maple_me/src/me_builder.cpp b/src/mapleall/maple_me/src/me_builder.cpp deleted file mode 100644 index d21b82133b54d1494a0c93a65b8c42e434d35e9c..0000000000000000000000000000000000000000 --- a/src/mapleall/maple_me/src/me_builder.cpp +++ /dev/null @@ -1,296 +0,0 @@ -/* - * Copyright (c) [2019-2021] Huawei Technologies Co.,Ltd.All rights reserved. - * - * OpenArkCompiler is licensed under Mulan PSL v2. - * You can use this software according to the terms and conditions of the Mulan PSL v2. - * You may obtain a copy of Mulan PSL v2 at: - * - * http://license.coscl.org.cn/MulanPSL2 - * - * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER - * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR - * FIT FOR A PARTICULAR PURPOSE. - * See the Mulan PSL v2 for more details. - */ -#include "me_builder.h" -#include "ssa_mir_nodes.h" -#include "factory.h" - -namespace maple { -using MeExprBuildFactory = FunctionFactory; - -MeExpr &MeBuilder::CreateMeExpr(int32 exprId, MeExpr &meExpr) const { - MeExpr *resultExpr = nullptr; - switch (meExpr.GetMeOp()) { - case kMeOpIvar: - resultExpr = New(exprId, static_cast(meExpr)); - break; - case kMeOpOp: - resultExpr = New(static_cast(meExpr), exprId); - break; - case kMeOpConst: - resultExpr = New(exprId, static_cast(meExpr).GetConstVal(), meExpr.GetPrimType()); - break; - case kMeOpConststr: - resultExpr = New(exprId, static_cast(meExpr).GetStrIdx(), meExpr.GetPrimType()); - break; - case kMeOpConststr16: - resultExpr = New(exprId, static_cast(meExpr).GetStrIdx(), - meExpr.GetPrimType()); - break; - case kMeOpSizeoftype: - resultExpr = New(exprId, meExpr.GetPrimType(), - static_cast(meExpr).GetTyIdx()); - break; - case kMeOpFieldsDist: { - auto &expr = static_cast(meExpr); - resultExpr = New(exprId, meExpr.GetPrimType(), expr.GetTyIdx(), - expr.GetFieldID1(), expr.GetFieldID2()); - break; - } - case kMeOpAddrof: - resultExpr = New(exprId, meExpr.GetPrimType(), static_cast(meExpr).GetOstIdx()); - static_cast(resultExpr)->SetFieldID(static_cast(meExpr).GetFieldID()); - break; - case kMeOpNary: - resultExpr = NewInPool(exprId, static_cast(meExpr)); - break; - case kMeOpAddroffunc: - resultExpr = New(exprId, static_cast(meExpr).GetPuIdx()); - break; - case kMeOpGcmalloc: - resultExpr = New(exprId, meExpr.GetOp(), meExpr.GetPrimType(), - static_cast(meExpr).GetTyIdx()); - break; - default: - CHECK_FATAL(false, "not yet implement"); - } - if (meExpr.GetMeOp() == kMeOpOp || meExpr.GetMeOp() == kMeOpNary) { - resultExpr->UpdateDepth(); - } - return *resultExpr; -} - -VarMeExpr *MeBuilder::BuildVarMeExpr(int32 exprID, OStIdx oStIdx, size_t vStIdx, - PrimType pType, FieldID fieldID) const { - VarMeExpr *varMeExpr = New(&allocator, exprID, oStIdx, vStIdx, pType); - varMeExpr->SetFieldID(fieldID); - return varMeExpr; -} - -MeExpr *MeBuilder::BuildMeExpr(BaseNode &mirNode) const { - auto func = CreateProductFunction(mirNode.GetOpCode()); - ASSERT(func != nullptr, "NIY BuildExpe"); - return func(this, mirNode); -} - -MeExpr *MeBuilder::BuildAddrofMeExpr(BaseNode &mirNode) const { - auto &addrofNode = static_cast(mirNode); - auto meExpr = New(kInvalidExprID, addrofNode.GetPrimType(), - addrofNode.GetSSAVar()->GetOrigSt()->GetIndex()); - meExpr->SetFieldID(addrofNode.GetFieldID()); - return meExpr; -} - -MeExpr *MeBuilder::BuildAddroffuncMeExpr(BaseNode &mirNode) const { - AddroffuncMeExpr &meExpr = *New(kInvalidExprID, static_cast(mirNode).GetPUIdx()); - return &meExpr; -} - -MeExpr *MeBuilder::BuildGCMallocMeExpr(BaseNode &mirNode) const { - auto meExpr = New(kInvalidExprID, mirNode.GetOpCode(), mirNode.GetPrimType(), - static_cast(mirNode).GetTyIdx()); - return meExpr; -} - -MeExpr *MeBuilder::BuildSizeoftypeMeExpr(BaseNode &mirNode) const { - auto meExpr = New(kInvalidExprID, mirNode.GetPrimType(), - static_cast(mirNode).GetTyIdx()); - return meExpr; -} - -MeExpr *MeBuilder::BuildFieldsDistMeExpr(BaseNode &mirNode) const { - auto &fieldsDistNode = static_cast(mirNode); - FieldsDistMeExpr &meExpr = *New(kInvalidExprID, mirNode.GetPrimType(), fieldsDistNode.GetTyIdx(), - fieldsDistNode.GetFiledID1(), fieldsDistNode.GetFiledID2()); - return &meExpr; -} - -MeExpr *MeBuilder::BuildIvarMeExpr(BaseNode &mirNode) const { - auto &ireadSSANode = static_cast(mirNode); - auto meExpr = New(kInvalidExprID, mirNode.GetPrimType(), - ireadSSANode.GetTyIdx(), ireadSSANode.GetFieldID()); - return meExpr; -} - -MeExpr *MeBuilder::BuildConstMeExpr(BaseNode &mirNode) const { - auto &constvalNode = static_cast(mirNode); - ConstMeExpr &meExpr = *New(kInvalidExprID, constvalNode.GetConstVal(), mirNode.GetPrimType()); - meExpr.SetOp(OP_constval); - return &meExpr; -} - -MeExpr *MeBuilder::BuildConststrMeExpr(BaseNode &mirNode) const { - auto meExpr = New(kInvalidExprID, static_cast(mirNode).GetStrIdx(), - mirNode.GetPrimType()); - return meExpr; -} - -MeExpr *MeBuilder::BuildConststr16MeExpr(BaseNode &mirNode) const { - auto meExpr = New(kInvalidExprID, static_cast(mirNode).GetStrIdx(), - mirNode.GetPrimType()); - return meExpr; -} - -MeExpr *MeBuilder::BuildOpMeExprForCompare(BaseNode &mirNode) const { - OpMeExpr *meExpr = BuildOpMeExpr(mirNode); - meExpr->SetOpndType(static_cast(mirNode).GetOpndType()); - return meExpr; -} - -MeExpr *MeBuilder::BuildOpMeExprForTypeCvt(BaseNode &mirNode) const { - OpMeExpr *meExpr = BuildOpMeExpr(mirNode); - meExpr->SetOpndType(static_cast(mirNode).FromType()); - return meExpr; -} - -MeExpr *MeBuilder::BuildOpMeExprForRetype(BaseNode &mirNode) const { - auto &retypeNode = static_cast(mirNode); - OpMeExpr *meExpr = BuildOpMeExpr(mirNode); - meExpr->SetOpndType(retypeNode.FromType()); - meExpr->SetTyIdx(retypeNode.GetTyIdx()); - return meExpr; -} - -MeExpr *MeBuilder::BuildOpMeExprForIread(BaseNode &mirNode) const { - auto &ireadNode = static_cast(mirNode); - OpMeExpr *meExpr = BuildOpMeExpr(mirNode); - meExpr->SetTyIdx(ireadNode.GetTyIdx()); - meExpr->SetFieldID(ireadNode.GetFieldID()); - return meExpr; -} - -MeExpr *MeBuilder::BuildOpMeExprForExtractbits(BaseNode &mirNode) const { - auto &extractbitsNode = static_cast(mirNode); - OpMeExpr *meExpr = BuildOpMeExpr(mirNode); - meExpr->SetBitsOffSet(extractbitsNode.GetBitsOffset()); - meExpr->SetBitsSize(extractbitsNode.GetBitsSize()); - return meExpr; -} - -MeExpr *MeBuilder::BuildOpMeExprForJarrayMalloc(BaseNode &mirNode) const { - OpMeExpr *meExpr = BuildOpMeExpr(mirNode); - meExpr->SetTyIdx(static_cast(mirNode).GetTyIdx()); - return meExpr; -} - -MeExpr *MeBuilder::BuildOpMeExprForResolveFunc(BaseNode &mirNode) const { - OpMeExpr *meExpr = BuildOpMeExpr(mirNode); - meExpr->SetFieldID(static_cast(mirNode).GetPuIdx()); - return meExpr; -} - -MeExpr *MeBuilder::BuildNaryMeExprForArray(BaseNode &mirNode) const { - auto &arrayNode = static_cast(mirNode); - auto meExpr = - NewInPool(kInvalidExprID, mirNode.GetOpCode(), mirNode.GetPrimType(), mirNode.GetNumOpnds(), - arrayNode.GetTyIdx(), INTRN_UNDEFINED, arrayNode.GetBoundsCheck()); - return meExpr; -} - -MeExpr *MeBuilder::BuildNaryMeExprForIntrinsicop(BaseNode &mirNode) const { - auto meExpr = - NewInPool(kInvalidExprID, mirNode.GetOpCode(), mirNode.GetPrimType(), mirNode.GetNumOpnds(), - TyIdx(0), static_cast(mirNode).GetIntrinsic(), false); - return meExpr; -} - -MeExpr *MeBuilder::BuildNaryMeExprForIntrinsicWithType(BaseNode &mirNode) const { - auto &intrinNode = static_cast(mirNode); - auto meExpr = NewInPool(kInvalidExprID, mirNode.GetOpCode(), mirNode.GetPrimType(), - mirNode.GetNumOpnds(), intrinNode.GetTyIdx(), intrinNode.GetIntrinsic(), false); - return meExpr; -} - -UnaryMeStmt &MeBuilder::BuildUnaryMeStmt(Opcode op, MeExpr &opnd, BB &bb, const SrcPosition &src) const { - UnaryMeStmt &unaryMeStmt = BuildUnaryMeStmt(op, opnd, bb); - unaryMeStmt.SetSrcPos(src); - return unaryMeStmt; -} - -UnaryMeStmt &MeBuilder::BuildUnaryMeStmt(Opcode op, MeExpr &opnd, BB &bb) const { - UnaryMeStmt &unaryMeStmt = BuildUnaryMeStmt(op, opnd); - unaryMeStmt.SetBB(&bb); - return unaryMeStmt; -} - -UnaryMeStmt &MeBuilder::BuildUnaryMeStmt(Opcode op, MeExpr &opnd) const { - UnaryMeStmt &unaryMeStmt = *New(op); - unaryMeStmt.SetMeStmtOpndValue(&opnd); - return unaryMeStmt; -} - -bool MeBuilder::InitMeExprBuildFactory() { - RegisterFactoryFunction(OP_addrof, &MeBuilder::BuildAddrofMeExpr); - RegisterFactoryFunction(OP_addroffunc, &MeBuilder::BuildAddroffuncMeExpr); - RegisterFactoryFunction(OP_gcmalloc, &MeBuilder::BuildGCMallocMeExpr); - RegisterFactoryFunction(OP_gcpermalloc, &MeBuilder::BuildGCMallocMeExpr); - RegisterFactoryFunction(OP_sizeoftype, &MeBuilder::BuildSizeoftypeMeExpr); - RegisterFactoryFunction(OP_fieldsdist, &MeBuilder::BuildFieldsDistMeExpr); - RegisterFactoryFunction(OP_iread, &MeBuilder::BuildIvarMeExpr); - RegisterFactoryFunction(OP_constval, &MeBuilder::BuildConstMeExpr); - RegisterFactoryFunction(OP_conststr, &MeBuilder::BuildConststrMeExpr); - RegisterFactoryFunction(OP_conststr16, &MeBuilder::BuildConststr16MeExpr); - RegisterFactoryFunction(OP_eq, &MeBuilder::BuildOpMeExprForCompare); - RegisterFactoryFunction(OP_ne, &MeBuilder::BuildOpMeExprForCompare); - RegisterFactoryFunction(OP_lt, &MeBuilder::BuildOpMeExprForCompare); - RegisterFactoryFunction(OP_gt, &MeBuilder::BuildOpMeExprForCompare); - RegisterFactoryFunction(OP_le, &MeBuilder::BuildOpMeExprForCompare); - RegisterFactoryFunction(OP_ge, &MeBuilder::BuildOpMeExprForCompare); - RegisterFactoryFunction(OP_cmpg, &MeBuilder::BuildOpMeExprForCompare); - RegisterFactoryFunction(OP_cmpl, &MeBuilder::BuildOpMeExprForCompare); - RegisterFactoryFunction(OP_cmp, &MeBuilder::BuildOpMeExprForCompare); - RegisterFactoryFunction(OP_ceil, &MeBuilder::BuildOpMeExprForTypeCvt); - RegisterFactoryFunction(OP_cvt, &MeBuilder::BuildOpMeExprForTypeCvt); - RegisterFactoryFunction(OP_floor, &MeBuilder::BuildOpMeExprForTypeCvt); - RegisterFactoryFunction(OP_round, &MeBuilder::BuildOpMeExprForTypeCvt); - RegisterFactoryFunction(OP_trunc, &MeBuilder::BuildOpMeExprForTypeCvt); - RegisterFactoryFunction(OP_retype, &MeBuilder::BuildOpMeExprForRetype); - RegisterFactoryFunction(OP_abs, &MeBuilder::BuildOpMeExpr); - RegisterFactoryFunction(OP_bnot, &MeBuilder::BuildOpMeExpr); - RegisterFactoryFunction(OP_lnot, &MeBuilder::BuildOpMeExpr); - RegisterFactoryFunction(OP_neg, &MeBuilder::BuildOpMeExpr); - RegisterFactoryFunction(OP_recip, &MeBuilder::BuildOpMeExpr); - RegisterFactoryFunction(OP_sqrt, &MeBuilder::BuildOpMeExpr); - RegisterFactoryFunction(OP_alloca, &MeBuilder::BuildOpMeExpr); - RegisterFactoryFunction(OP_malloc, &MeBuilder::BuildOpMeExpr); - RegisterFactoryFunction(OP_iaddrof, &MeBuilder::BuildOpMeExprForIread); - RegisterFactoryFunction(OP_sext, &MeBuilder::BuildOpMeExprForExtractbits); - RegisterFactoryFunction(OP_zext, &MeBuilder::BuildOpMeExprForExtractbits); - RegisterFactoryFunction(OP_extractbits, &MeBuilder::BuildOpMeExprForExtractbits); - RegisterFactoryFunction(OP_gcmallocjarray, &MeBuilder::BuildOpMeExprForJarrayMalloc); - RegisterFactoryFunction(OP_gcpermallocjarray, &MeBuilder::BuildOpMeExprForJarrayMalloc); - RegisterFactoryFunction(OP_resolveinterfacefunc, &MeBuilder::BuildOpMeExprForResolveFunc); - RegisterFactoryFunction(OP_resolvevirtualfunc, &MeBuilder::BuildOpMeExprForResolveFunc); - RegisterFactoryFunction(OP_sub, &MeBuilder::BuildOpMeExpr); - RegisterFactoryFunction(OP_mul, &MeBuilder::BuildOpMeExpr); - RegisterFactoryFunction(OP_div, &MeBuilder::BuildOpMeExpr); - RegisterFactoryFunction(OP_rem, &MeBuilder::BuildOpMeExpr); - RegisterFactoryFunction(OP_ashr, &MeBuilder::BuildOpMeExpr); - RegisterFactoryFunction(OP_lshr, &MeBuilder::BuildOpMeExpr); - RegisterFactoryFunction(OP_shl, &MeBuilder::BuildOpMeExpr); - RegisterFactoryFunction(OP_max, &MeBuilder::BuildOpMeExpr); - RegisterFactoryFunction(OP_min, &MeBuilder::BuildOpMeExpr); - RegisterFactoryFunction(OP_band, &MeBuilder::BuildOpMeExpr); - RegisterFactoryFunction(OP_bior, &MeBuilder::BuildOpMeExpr); - RegisterFactoryFunction(OP_bxor, &MeBuilder::BuildOpMeExpr); - RegisterFactoryFunction(OP_land, &MeBuilder::BuildOpMeExpr); - RegisterFactoryFunction(OP_lior, &MeBuilder::BuildOpMeExpr); - RegisterFactoryFunction(OP_add, &MeBuilder::BuildOpMeExpr); - RegisterFactoryFunction(OP_select, &MeBuilder::BuildOpMeExpr); - RegisterFactoryFunction(OP_array, &MeBuilder::BuildNaryMeExprForArray); - RegisterFactoryFunction(OP_intrinsicop, &MeBuilder::BuildNaryMeExprForIntrinsicop); - RegisterFactoryFunction(OP_intrinsicopwithtype, &MeBuilder::BuildNaryMeExprForIntrinsicWithType); - return true; -} -} // namespace maple