diff --git a/src/BUILD.gn b/src/BUILD.gn index cab2a1b79d3541c98bbae37bddacb7b414c6771f..46814c8a0a935724d152f6fc3e416b40739b3fa1 100644 --- a/src/BUILD.gn +++ b/src/BUILD.gn @@ -1,7 +1,7 @@ config("mapleallcompilecfg") { cflags_cc = [] cflags_cc += [ - "-std=c++11", + "-std=c++14", "-Werror", ] @@ -18,7 +18,7 @@ config("mapleallcompilecfg") { ldflags = [] ldflags += [ "-fPIC", - "-std=c++11", + "-std=c++14", "-rdynamic", "-lpthread", "-Wl,-z,relro", diff --git a/src/bin/maple b/src/bin/maple index cb22709bac5c2e58aa095ff90b726450be0944b3..13c1eb330a95c85a8795f238c0c6a5adc3f39f25 100755 Binary files a/src/bin/maple and b/src/bin/maple differ diff --git a/src/bin/mplcg b/src/bin/mplcg index 65c234a17bc270545a2f0c5516772afb3761cf43..3a92cb8ca1d66ba44268d4d2a90ef6d84c8e49ea 100755 Binary files a/src/bin/mplcg and b/src/bin/mplcg differ diff --git a/src/mpl2mpl/include/java_intrn_lowering.h b/src/mpl2mpl/include/java_intrn_lowering.h index abb684374ba99d255520dc60c01938f4e71f9bd9..5cbf901aedbfcfe329ae70369aa620421aca998d 100644 --- a/src/mpl2mpl/include/java_intrn_lowering.h +++ b/src/mpl2mpl/include/java_intrn_lowering.h @@ -31,9 +31,9 @@ class JavaIntrnLowering : public FuncOptimizeImpl { private: void ProcessStmt(StmtNode *stmt) override; - void ProcessJavaIntrnMerge(StmtNode *assignNode, const IntrinsicopNode *intrinNode); + void ProcessJavaIntrnMerge(StmtNode &assignNode, const IntrinsicopNode &intrinNode); BaseNode *JavaIntrnMergeToCvtType(PrimType dtyp, PrimType styp, BaseNode *src); - void ProcessJavaIntrnFillNewArray(IntrinsiccallNode *intrinCall); + void ProcessJavaIntrnFillNewArray(IntrinsiccallNode &intrinCall); }; class DoJavaIntrnLowering : public ModulePhase { diff --git a/src/mpl2mpl/include/muid_replacement.h b/src/mpl2mpl/include/muid_replacement.h index 6d01d1256e95631f580194ac174930654b60d268..f8b8aa56162b16d6ab2a3505c6fe94f26b2a3236 100644 --- a/src/mpl2mpl/include/muid_replacement.h +++ b/src/mpl2mpl/include/muid_replacement.h @@ -109,23 +109,23 @@ class MUIDReplacement : public FuncOptimizeImpl { void GenericDataDefTable(); void GenericUnifiedUndefTable(); void GenericRangeTable(); - uint32 FindIndexFromDefTable(const MIRSymbol *mirSymbol, bool isFunc); - uint32 FindIndexFromUndefTable(const MIRSymbol *mirSymbol, bool isFunc); + uint32 FindIndexFromDefTable(const MIRSymbol &mirSymbol, bool isFunc); + uint32 FindIndexFromUndefTable(const MIRSymbol &mirSymbol, bool isFunc); void ReplaceAddroffuncConst(MIRConst *&entry, uint32 fieldId, bool isVtab); void ReplaceFuncTable(const std::string &name); void ReplaceAddrofConst(MIRConst *&entry); void ReplaceDataTable(const std::string &name); - void ReplaceDirectInvokeOrAddroffunc(MIRFunction *currentFunc, StmtNode *stmt); - void ReplaceDassign(MIRFunction *currentFunc, DassignNode *dassignNode); + void ReplaceDirectInvokeOrAddroffunc(MIRFunction ¤tFunc, StmtNode &stmt); + void ReplaceDassign(MIRFunction ¤tFunc, DassignNode &dassignNode); void ReplaceDreadStmt(MIRFunction *currentFunc, StmtNode *stmt); void ClearVtabItab(const std::string &name); BaseNode *ReplaceDreadExpr(MIRFunction *currentFunc, StmtNode *stmt, BaseNode *expr); - BaseNode *ReplaceDread(MIRFunction *currentFunc, StmtNode *stmt, BaseNode *opnd); - void CollectDread(MIRFunction *currentFunc, StmtNode *stmt, BaseNode *opnd); + BaseNode *ReplaceDread(MIRFunction ¤tFunc, StmtNode *stmt, BaseNode *opnd); + void CollectDread(MIRFunction ¤tFunc, StmtNode &stmt, BaseNode &opnd); void DumpMUIDFile(bool isFunc); void ReplaceStmts(); void GenericGlobalRootList(); - void CollectImplicitUndefClassInfo(StmtNode *stmt); + void CollectImplicitUndefClassInfo(StmtNode &stmt); void CollectFuncAndDataFromKlasses(); void CollectFuncAndDataFromGlobalTab(); void CollectFuncAndDataFromFuncList(); diff --git a/src/mpl2mpl/include/native_stub_func.h b/src/mpl2mpl/include/native_stub_func.h index 6c8b64dbdee95e06c3623ff935dca83b14a24a3e..f4cd76a4966755e5c7f070f3dd0765a7a2eb0b43 100644 --- a/src/mpl2mpl/include/native_stub_func.h +++ b/src/mpl2mpl/include/native_stub_func.h @@ -90,16 +90,16 @@ class GenericNativeStubFunc : public FuncOptimizeImpl { "MCC_CallSlowNative0", "MCC_CallSlowNative1", "MCC_CallSlowNative2", "MCC_CallSlowNative3", "MCC_CallSlowNative4", "MCC_CallSlowNative5", "MCC_CallSlowNative6", "MCC_CallSlowNative7", "MCC_CallSlowNative8" }; - MIRFunction *GetOrCreateDefaultNativeFunc(MIRFunction *stubFunc); - void GenericRegisteredNativeFuncCall(MIRFunction *func, const MIRFunction *nativeFunc, MapleVector &args, - const MIRSymbol *ret, bool needNativeCall, CallNode *prevNativeFuncCall, - CallNode *postNativeFuncCall); - StmtNode *CreateNativeWrapperCallNode(MIRFunction *func, BaseNode *funcPtr, MapleVector &args, + MIRFunction &GetOrCreateDefaultNativeFunc(MIRFunction &stubFunc); + void GenericRegisteredNativeFuncCall(MIRFunction &func, const MIRFunction &nativeFunc, MapleVector &args, + const MIRSymbol *ret, bool needNativeCall, CallNode &prevNativeFuncCall, + CallNode &postNativeFuncCall); + StmtNode *CreateNativeWrapperCallNode(MIRFunction &func, BaseNode *funcPtr, MapleVector &args, const MIRSymbol *ret); - void GenericNativeWrapperFuncCall(MIRFunction *func, const MIRFunction *nativeFunc, MapleVector &args, + void GenericNativeWrapperFuncCall(MIRFunction &func, const MIRFunction &nativeFunc, MapleVector &args, const MIRSymbol *ret); void GenericHelperFuncDecl(); - void GenericRegTabEntry(const MIRFunction *func); + void GenericRegTabEntry(const MIRFunction &func); void GenericRegTableEntryType(); void GenericRegTable(); void GenericRegFuncTabEntryType(); diff --git a/src/mpl2mpl/include/reflection_analysis.h b/src/mpl2mpl/include/reflection_analysis.h index 3477adc6f3dc7c822830ebff4860dece059ae625..40097032f4b0d2eea6ec15a5f6e9ba7dbff70dab 100644 --- a/src/mpl2mpl/include/reflection_analysis.h +++ b/src/mpl2mpl/include/reflection_analysis.h @@ -305,24 +305,24 @@ class ReflectionAnalysis : public AnalysisResult { std::unordered_map &baseNameMap, std::unordered_map &fullNameMap); void GenAllFieldHash(std::vector> &fieldV); - void GeneAnnotation(std::map &idxNumMap, std::string &annoArr, MIRClassType *classType, + void GeneAnnotation(std::map &idxNumMap, std::string &annoArr, MIRClassType &classType, PragmaKind paragKind, const std::string ¶gName, TyIdx fieldTypeIdx, std::map *paramNumArray = nullptr, int *paramIndex = nullptr); - void SetAnnoFieldConst(const MIRStructType *metadataRoType, MIRAggConst &newConst, uint32 fieldID, + void SetAnnoFieldConst(const MIRStructType &metadataRoType, MIRAggConst &newConst, uint32 fieldID, std::map &idxNumMap, const std::string &annoArr); bool IsAnonymousClass(const std::string &annotationString); - bool IsPrivateClass(MIRClassType *classType); - bool IsStaticClass(MIRClassType *classType); - void CheckPrivateInnerAndNoSubClass(Klass *clazz, const std::string &annoArr); + bool IsPrivateClass(MIRClassType &classType); + bool IsStaticClass(MIRClassType &classType); + void CheckPrivateInnerAndNoSubClass(Klass &clazz, const std::string &annoArr); void ConvertMapleClassName(const std::string &mplClassName, std::string &javaDsp); static void ConvertMethodSig(std::string &signature); int GetDeflateStringIdx(const std::string &subStr); uint32 GetAnnoCstrIndex(std::map &idxNumMap, const std::string &annoArr); - int16 GetMethodInVtabIndex(const Klass *clazz, const MIRFunction *func); - void GetSignatureTypeNames(const char *signature, std::vector &typeNames); - MIRSymbol *GetClinitFuncSymbol(const Klass *klass); - int SolveAnnotation(MIRClassType *classType, MIRFunction *func); - uint32 GetTypeNameIdxFromType(MIRType *type, const Klass *klass, const std::string &fieldName); + int16 GetMethodInVtabIndex(const Klass &clazz, const MIRFunction &func); + void GetSignatureTypeNames(const std::string &signature, std::vector &typeNames); + MIRSymbol *GetClinitFuncSymbol(const Klass &klass); + int SolveAnnotation(MIRClassType &classType, MIRFunction &func); + uint32 GetTypeNameIdxFromType(MIRType &type, const Klass &klass, const std::string &fieldName); private: MIRModule *mirModule; diff --git a/src/mpl2mpl/src/java_intrn_lowering.cpp b/src/mpl2mpl/src/java_intrn_lowering.cpp index cc7e31ccb854e590580d9fb1563c9ba315fd04c2..bed2d6a29967031a347eb12831b4f9f5da9a9d00 100644 --- a/src/mpl2mpl/src/java_intrn_lowering.cpp +++ b/src/mpl2mpl/src/java_intrn_lowering.cpp @@ -52,7 +52,7 @@ void JavaIntrnLowering::ProcessStmt(StmtNode *stmt) { if (rhs != nullptr && rhs->GetOpCode() == OP_intrinsicop) { IntrinsicopNode *intrinNode = static_cast(rhs); if (intrinNode->GetIntrinsic() == INTRN_JAVA_MERGE) { - ProcessJavaIntrnMerge(stmt, intrinNode); + ProcessJavaIntrnMerge(*stmt, *intrinNode); } } break; @@ -60,7 +60,7 @@ void JavaIntrnLowering::ProcessStmt(StmtNode *stmt) { case OP_intrinsiccallwithtypeassigned: { IntrinsiccallNode *intrinCall = static_cast(stmt); if (intrinCall->GetIntrinsic() == INTRN_JAVA_FILL_NEW_ARRAY) { - ProcessJavaIntrnFillNewArray(intrinCall); + ProcessJavaIntrnFillNewArray(*intrinCall); } break; } @@ -70,26 +70,26 @@ void JavaIntrnLowering::ProcessStmt(StmtNode *stmt) { } -void JavaIntrnLowering::ProcessJavaIntrnMerge(StmtNode *assignNode, const IntrinsicopNode *intrinNode) { - CHECK_FATAL(intrinNode->GetNumOpnds() == 1, "invalid JAVA_MERGE intrinsic node"); +void JavaIntrnLowering::ProcessJavaIntrnMerge(StmtNode &assignNode, const IntrinsicopNode &intrinNode) { + CHECK_FATAL(intrinNode.GetNumOpnds() == 1, "invalid JAVA_MERGE intrinsic node"); PrimType destType; DassignNode *dassign = nullptr; RegassignNode *regassign = nullptr; - if (assignNode->GetOpCode() == OP_dassign) { - dassign = static_cast(assignNode); + if (assignNode.GetOpCode() == OP_dassign) { + dassign = static_cast(&assignNode); MIRSymbol *dest = currFunc->GetLocalOrGlobalSymbol(dassign->GetStIdx()); destType = dest->GetType()->GetPrimType(); } else { - regassign = static_cast(assignNode); + regassign = static_cast(&assignNode); destType = regassign->GetPrimType(); } - BaseNode *resNode = intrinNode->Opnd(0); + BaseNode *resNode = intrinNode.Opnd(0); CHECK_FATAL(resNode != nullptr, "null ptr check"); PrimType srcType = resNode->GetPrimType(); if (destType != srcType) { resNode = JavaIntrnMergeToCvtType(destType, srcType, resNode); } - if (assignNode->GetOpCode() == OP_dassign) { + if (assignNode.GetOpCode() == OP_dassign) { CHECK_FATAL(dassign != nullptr, "null ptr check"); dassign->SetRHS(resNode); } else { @@ -144,10 +144,10 @@ BaseNode *JavaIntrnLowering::JavaIntrnMergeToCvtType(PrimType destType, PrimType } } -void JavaIntrnLowering::ProcessJavaIntrnFillNewArray(IntrinsiccallNode *intrinCall) { +void JavaIntrnLowering::ProcessJavaIntrnFillNewArray(IntrinsiccallNode &intrinCall) { // First create a new array. - CHECK_FATAL(intrinCall->GetReturnVec().size() == 1, "INTRN_JAVA_FILL_NEW_ARRAY should have 1 return value"); - CallReturnPair retPair = intrinCall->GetCallReturnPair(0); + CHECK_FATAL(intrinCall.GetReturnVec().size() == 1, "INTRN_JAVA_FILL_NEW_ARRAY should have 1 return value"); + CallReturnPair retPair = intrinCall.GetCallReturnPair(0); bool isReg = retPair.second.IsReg(); MIRType *retType = nullptr; if (!isReg) { @@ -161,7 +161,7 @@ void JavaIntrnLowering::ProcessJavaIntrnFillNewArray(IntrinsiccallNode *intrinCa } CHECK_FATAL(retType->GetKind() == kTypePointer, "Return type of INTRN_JAVA_FILL_NEW_ARRAY should point to a Jarray"); MIRType *arrayType = static_cast(retType)->GetPointedType(); - BaseNode *lenNode = builder->CreateIntConst(intrinCall->NumOpnds(), PTY_i32); + BaseNode *lenNode = builder->CreateIntConst(intrinCall.NumOpnds(), PTY_i32); JarrayMallocNode *newArrayNode = builder->CreateExprJarrayMalloc(OP_gcmallocjarray, retType, arrayType, lenNode); // Then fill each array element one by one. BaseNode *addrExpr = nullptr; @@ -169,21 +169,21 @@ void JavaIntrnLowering::ProcessJavaIntrnFillNewArray(IntrinsiccallNode *intrinCa if (!isReg) { MIRSymbol *retSym = currFunc->GetLocalOrGlobalSymbol(retPair.first); assignStmt = builder->CreateStmtDassign(retSym, retPair.second.GetFieldID(), newArrayNode); - currFunc->GetBody()->ReplaceStmt1WithStmt2(intrinCall, assignStmt); + currFunc->GetBody()->ReplaceStmt1WithStmt2(&intrinCall, assignStmt); addrExpr = builder->CreateExprDread(retSym); } else { PregIdx pregidx = retPair.second.GetPregIdx(); MIRPreg *mirpreg = currFunc->GetPregTab()->PregFromPregIdx(pregidx); assignStmt = builder->CreateStmtRegassign(mirpreg->GetPrimType(), pregidx, newArrayNode); - currFunc->GetBody()->ReplaceStmt1WithStmt2(intrinCall, assignStmt); + currFunc->GetBody()->ReplaceStmt1WithStmt2(&intrinCall, assignStmt); addrExpr = builder->CreateExprRegread(mirpreg->GetPrimType(), pregidx); } - assignStmt->SetSrcPos(intrinCall->GetSrcPos()); + assignStmt->SetSrcPos(intrinCall.GetSrcPos()); StmtNode *stmt = assignStmt; - for (int i = 0; i < intrinCall->NumOpnds(); i++) { + for (int i = 0; i < intrinCall.NumOpnds(); i++) { ArrayNode *arrayexpr = builder->CreateExprArray(arrayType, addrExpr, builder->CreateIntConst(i, PTY_i32)); arrayexpr->SetBoundsCheck(false); - StmtNode *storeStmt = builder->CreateStmtIassign(retType, 0, arrayexpr, intrinCall->Opnd(i)); + StmtNode *storeStmt = builder->CreateStmtIassign(retType, 0, arrayexpr, intrinCall.Opnd(i)); currFunc->GetBody()->InsertAfter(stmt, storeStmt); stmt = storeStmt; } diff --git a/src/mpl2mpl/src/muid_replacement.cpp b/src/mpl2mpl/src/muid_replacement.cpp index def95a4b65bcba8ef4120abd8722dd7282f1f7de..b0ea5e504c8637f6b5ebafec637e8568c48ad9a6 100644 --- a/src/mpl2mpl/src/muid_replacement.cpp +++ b/src/mpl2mpl/src/muid_replacement.cpp @@ -182,23 +182,23 @@ void MUIDReplacement::CollectFuncAndDataFromFuncList() { } } // Some stmt requires classinfo but is lowered in CG. Handle them here. - CollectImplicitUndefClassInfo(stmt); + CollectImplicitUndefClassInfo(*stmt); stmt = stmt->GetNext(); } } } -void MUIDReplacement::CollectImplicitUndefClassInfo(StmtNode *stmt) { +void MUIDReplacement::CollectImplicitUndefClassInfo(StmtNode &stmt) { BaseNode *rhs = nullptr; std::vector classTyVec; - if (stmt->GetOpCode() == OP_dassign) { - DassignNode *dnode = static_cast(stmt); + if (stmt.GetOpCode() == OP_dassign) { + DassignNode *dnode = static_cast(&stmt); rhs = dnode->GetRHS(); - } else if (stmt->GetOpCode() == OP_regassign) { - RegassignNode *rnode = static_cast(stmt); + } else if (stmt.GetOpCode() == OP_regassign) { + RegassignNode *rnode = static_cast(&stmt); rhs = rnode->Opnd(); - } else if (stmt->GetOpCode() == OP_catch) { - CatchNode *jnode = static_cast(stmt); + } else if (stmt.GetOpCode() == OP_catch) { + CatchNode *jnode = static_cast(&stmt); for (TyIdx typeIdx : jnode->GetExceptionTyIdxVec()) { MIRPtrType *pointerType = static_cast(GlobalTables::GetTypeTable().GetTypeFromTyIdx(typeIdx)); MIRType *type = pointerType->GetPointedType(); @@ -300,6 +300,7 @@ void MUIDReplacement::GenericFuncDefTable() { std::vector> funcDefArray; idx = 0; for (MIRFunction *mirFunc : GetModule()->GetFunctionList()) { + ASSERT(mirFunc != nullptr, "null ptr check!"); MUID muid = GetMUID(mirFunc->GetName()); MapleMap::iterator iter = funcDefMap.find(muid); if (mirFunc->GetBody() == nullptr || iter == funcDefMap.end()) { @@ -638,30 +639,28 @@ void MUIDReplacement::GenericRangeTable() { } } -uint32 MUIDReplacement::FindIndexFromDefTable(const MIRSymbol *mirSymbol, bool isFunc) { - ASSERT(mirSymbol, "Invalid MIRSymbol"); - MUID muid = GetMUID(mirSymbol->GetName()); +uint32 MUIDReplacement::FindIndexFromDefTable(const MIRSymbol &mirSymbol, bool isFunc) { + MUID muid = GetMUID(mirSymbol.GetName()); if (isFunc) { CHECK_FATAL(defMuidIdxMap.find(muid) != defMuidIdxMap.end(), "Local function %s not found in funcDefMap", - mirSymbol->GetName().c_str()); + mirSymbol.GetName().c_str()); return defMuidIdxMap[muid]; } else { CHECK_FATAL(dataDefMap.find(muid) != dataDefMap.end(), "Local variable %s not found in dataDefMap", - mirSymbol->GetName().c_str()); + mirSymbol.GetName().c_str()); return dataDefMap[muid].second; } } -uint32 MUIDReplacement::FindIndexFromUndefTable(const MIRSymbol *mirSymbol, bool isFunc) { - ASSERT(mirSymbol, "Invalid MIRSymbol"); - MUID muid = GetMUID(mirSymbol->GetName()); +uint32 MUIDReplacement::FindIndexFromUndefTable(const MIRSymbol &mirSymbol, bool isFunc) { + MUID muid = GetMUID(mirSymbol.GetName()); if (isFunc) { CHECK_FATAL(funcUndefMap.find(muid) != funcUndefMap.end(), "Extern function %s not found in funcUndefMap", - mirSymbol->GetName().c_str()); + mirSymbol.GetName().c_str()); return funcUndefMap[muid].second; } else { CHECK_FATAL(dataUndefMap.find(muid) != dataUndefMap.end(), "Extern variable %s not found in dataUndefMap", - mirSymbol->GetName().c_str()); + mirSymbol.GetName().c_str()); return dataUndefMap[muid].second; } } @@ -711,12 +710,13 @@ void MUIDReplacement::ReplaceAddroffuncConst(MIRConst *&entry, uint32 fieldId, b MIRType *voidType = GlobalTables::GetTypeTable().GetVoidPtr(); MIRAddroffuncConst *funcAddr = static_cast(entry); MIRFunction *func = GlobalTables::GetFunctionTable().GetFunctionFromPuidx(funcAddr->GetValue()); - ASSERT(func, "Invalid MIRFunction"); + ASSERT(func != nullptr, "Invalid MIRFunction"); uint64 offset = 0; MIRIntConst *constNode = nullptr; constexpr uint64 kReservedBits = 2u; if (func->GetBody()) { - offset = FindIndexFromDefTable(func->GetFuncSymbol(), true); + ASSERT(func->GetFuncSymbol() != nullptr, "null ptr check!"); + offset = FindIndexFromDefTable(*(func->GetFuncSymbol()), true); // Left shifting is needed because in itable 0 and 1 are reserved. // 0 marks no entry and 1 marks a conflict. // The second least significant bit is set to 1, indicating @@ -728,7 +728,8 @@ void MUIDReplacement::ReplaceAddroffuncConst(MIRConst *&entry, uint32 fieldId, b MIRType *type = GlobalTables::GetTypeTable().GetVoidPtr(); constNode = GetModule()->GetMemPool()->New(0, type); } else { - offset = FindIndexFromUndefTable(func->GetFuncSymbol(), true); + ASSERT(func->GetFuncSymbol() != nullptr, "null ptr check!"); + offset = FindIndexFromUndefTable(*(func->GetFuncSymbol()), true); // The second least significant bit is set to 0, indicating // this is an index into the funcUndefTab constNode = GetModule()->GetMemPool()->New((offset + 1) << kReservedBits, voidType); @@ -749,9 +750,11 @@ void MUIDReplacement::ReplaceDataTable(const std::string &name) { return; } for (MIRConst *&oldTabEntry : oldConst->GetConstVec()) { + ASSERT(oldTabEntry != nullptr, "null ptr check!"); if (oldTabEntry->GetKind() == kConstAggConst) { MIRAggConst *aggrC = static_cast(oldTabEntry); for (size_t i = 0; i < aggrC->GetConstVec().size(); i++) { + ASSERT(aggrC->GetConstVecItem(i) != nullptr, "null ptr check!"); ReplaceAddrofConst(aggrC->GetConstVecItem(i)); aggrC->GetConstVecItem(i)->SetFieldID(i + 1); } @@ -768,38 +771,38 @@ void MUIDReplacement::ReplaceAddrofConst(MIRConst *&entry) { MIRType *voidType = GlobalTables::GetTypeTable().GetVoidPtr(); MIRAddrofConst *addr = static_cast(entry); MIRSymbol *addrSym = GlobalTables::GetGsymTable().GetSymbolFromStidx(addr->GetSymbolIndex().Idx()); - ASSERT(addrSym, "Invalid MIRSymbol"); + ASSERT(addrSym != nullptr, "Invalid MIRSymbol"); if (!addrSym->IsReflectionClassInfo() && !addrSym->IsStatic()) { return; } uint64 offset = 0; MIRIntConst *constNode = nullptr; if (addrSym->GetStorageClass() != kScExtern) { - offset = FindIndexFromDefTable(addrSym, false); + offset = FindIndexFromDefTable(*addrSym, false); constNode = GetModule()->GetMemPool()->New(offset | kFromDefIndexMask, voidType); } else { - offset = FindIndexFromUndefTable(addrSym, false); + offset = FindIndexFromUndefTable(*addrSym, false); constNode = GetModule()->GetMemPool()->New(offset | kFromUndefIndexMask, voidType); } entry = constNode; } -void MUIDReplacement::ReplaceDirectInvokeOrAddroffunc(MIRFunction *currentFunc, StmtNode *stmt) { +void MUIDReplacement::ReplaceDirectInvokeOrAddroffunc(MIRFunction ¤tFunc, StmtNode &stmt) { PUIdx puidx; CallNode *callNode = nullptr; DassignNode *dassignNode = nullptr; RegassignNode *regassignNode = nullptr; - if (stmt->GetOpCode() == OP_callassigned || stmt->GetOpCode() == OP_call) { - callNode = static_cast(stmt); + if (stmt.GetOpCode() == OP_callassigned || stmt.GetOpCode() == OP_call) { + callNode = static_cast(&stmt); puidx = callNode->GetPUIdx(); - } else if (stmt->GetOpCode() == OP_dassign) { - dassignNode = static_cast(stmt); + } else if (stmt.GetOpCode() == OP_dassign) { + dassignNode = static_cast(&stmt); if (dassignNode->GetRHS()->GetOpCode() != OP_addroffunc) { return; } puidx = static_cast(dassignNode->GetRHS())->GetPUIdx(); - } else if (stmt->GetOpCode() == OP_regassign) { - regassignNode = static_cast(stmt); + } else if (stmt.GetOpCode() == OP_regassign) { + regassignNode = static_cast(&stmt); if (regassignNode->Opnd()->GetOpCode() != OP_addroffunc) { return; } @@ -808,7 +811,7 @@ void MUIDReplacement::ReplaceDirectInvokeOrAddroffunc(MIRFunction *currentFunc, CHECK_FATAL(false, "unexpected stmt type in ReplaceDirectInvokeOrAddroffunc"); } MIRFunction *calleeFunc = GlobalTables::GetFunctionTable().GetFunctionFromPuidx(puidx); - if (!calleeFunc || (!calleeFunc->IsJava() && calleeFunc->GetBaseClassName().empty())) { + if (calleeFunc == nullptr || (!calleeFunc->IsJava() && calleeFunc->GetBaseClassName().empty())) { return; } // Load the function pointer @@ -819,21 +822,23 @@ void MUIDReplacement::ReplaceDirectInvokeOrAddroffunc(MIRFunction *currentFunc, // Local function is accessed through funcDefTab // Add a comment to store the original function name std::string commentLabel = NameMangler::kMarkMuidFuncDefStr + calleeFunc->GetName(); - currentFunc->GetBody()->InsertBefore(stmt, builder->CreateStmtComment(commentLabel.c_str())); + currentFunc.GetBody()->InsertBefore(&stmt, builder->CreateStmtComment(commentLabel.c_str())); std::string moduleName = GetModule()->GetFileNameAsPostfix(); std::string baseName = calleeFunc->GetBaseClassName(); baseExpr = builder->CreateExprAddrof(0, funcDefTabSym, GetModule()->GetMemPool()); - index = FindIndexFromDefTable(calleeFunc->GetFuncSymbol(), true); + ASSERT(calleeFunc->GetFuncSymbol() != nullptr, "null ptr check!"); + index = FindIndexFromDefTable(*(calleeFunc->GetFuncSymbol()), true); arrayType = static_cast(funcDefTabSym->GetType()); } else { // External function is accessed through funcUndefTab // Add a comment to store the original function name std::string commentLabel = NameMangler::kMarkMuidFuncUndefStr + calleeFunc->GetName(); - currentFunc->GetBody()->InsertBefore(stmt, builder->CreateStmtComment(commentLabel.c_str())); + currentFunc.GetBody()->InsertBefore(&stmt, builder->CreateStmtComment(commentLabel.c_str())); baseExpr = builder->CreateExprAddrof(0, funcUndefTabSym, GetModule()->GetMemPool()); - index = FindIndexFromUndefTable(calleeFunc->GetFuncSymbol(), true); + ASSERT(calleeFunc->GetFuncSymbol() != nullptr, "null ptr check!"); + index = FindIndexFromUndefTable(*(calleeFunc->GetFuncSymbol()), true); arrayType = static_cast(funcUndefTabSym->GetType()); } ConstvalNode *offsetExpr = builder->CreateIntConst(index, PTY_i64); @@ -847,14 +852,14 @@ void MUIDReplacement::ReplaceDirectInvokeOrAddroffunc(MIRFunction *currentFunc, MIRSymbol *funcPtrSym = nullptr; BaseNode *readFuncPtr = nullptr; if (Options::usePreg) { - funcPtrPreg = currentFunc->GetPregTab()->CreatePreg(PTY_ptr); + funcPtrPreg = currentFunc.GetPregTab()->CreatePreg(PTY_ptr); RegassignNode *funcPtrPregAssign = builder->CreateStmtRegassign(PTY_ptr, funcPtrPreg, ireadPtrExpr); - currentFunc->GetBody()->InsertBefore(stmt, funcPtrPregAssign); + currentFunc.GetBody()->InsertBefore(&stmt, funcPtrPregAssign); readFuncPtr = builder->CreateExprRegread(PTY_ptr, funcPtrPreg); } else { funcPtrSym = builder->GetOrCreateLocalDecl(kMuidSymPtrStr, *GlobalTables::GetTypeTable().GetVoidPtr()); DassignNode *addrNode = builder->CreateStmtDassign(funcPtrSym, 0, ireadPtrExpr); - currentFunc->GetBody()->InsertBefore(stmt, addrNode); + currentFunc.GetBody()->InsertBefore(&stmt, addrNode); readFuncPtr = builder->CreateExprDread(funcPtrSym); } if (callNode != nullptr) { @@ -871,7 +876,7 @@ void MUIDReplacement::ReplaceDirectInvokeOrAddroffunc(MIRFunction *currentFunc, if (callNode->GetOpCode() == OP_callassigned) { icallNode->SetReturnVec(callNode->GetReturnVec()); } - currentFunc->GetBody()->ReplaceStmt1WithStmt2(callNode, icallNode); + currentFunc.GetBody()->ReplaceStmt1WithStmt2(callNode, icallNode); } else if (dassignNode != nullptr) { dassignNode->SetRHS(readFuncPtr); } else if (regassignNode != nullptr) { @@ -879,14 +884,15 @@ void MUIDReplacement::ReplaceDirectInvokeOrAddroffunc(MIRFunction *currentFunc, } } -void MUIDReplacement::ReplaceDassign(MIRFunction *currentFunc, DassignNode *dassignNode) { - MIRSymbol *mirSymbol = currentFunc->GetLocalOrGlobalSymbol(dassignNode->GetStIdx()); +void MUIDReplacement::ReplaceDassign(MIRFunction ¤tFunc, DassignNode &dassignNode) { + MIRSymbol *mirSymbol = currentFunc.GetLocalOrGlobalSymbol(dassignNode.GetStIdx()); + ASSERT(mirSymbol != nullptr, "null ptr check!"); if (!mirSymbol->IsStatic()) { return; } // Add a comment to store the original symbol name - currentFunc->GetBody()->InsertBefore(dassignNode, - builder->CreateStmtComment(("Assign to: " + mirSymbol->GetName()).c_str())); + currentFunc.GetBody()->InsertBefore(&dassignNode, + builder->CreateStmtComment(("Assign to: " + mirSymbol->GetName()).c_str())); // Load the symbol pointer AddrofNode *baseExpr = nullptr; uint32 index = 0; @@ -894,12 +900,12 @@ void MUIDReplacement::ReplaceDassign(MIRFunction *currentFunc, DassignNode *dass if (mirSymbol->GetStorageClass() != kScExtern) { // Local static member is accessed through dataDefTab baseExpr = builder->CreateExprAddrof(0, dataDefTabSym); - index = FindIndexFromDefTable(mirSymbol, false); + index = FindIndexFromDefTable(*mirSymbol, false); arrayType = static_cast(dataDefTabSym->GetType()); } else { // External static member is accessed through dataUndefTab baseExpr = builder->CreateExprAddrof(0, dataUndefTabSym); - index = FindIndexFromUndefTable(mirSymbol, false); + index = FindIndexFromUndefTable(*mirSymbol, false); arrayType = static_cast(dataUndefTabSym->GetType()); } ConstvalNode *offsetExpr = builder->CreateIntConst(index, PTY_i64); @@ -914,20 +920,20 @@ void MUIDReplacement::ReplaceDassign(MIRFunction *currentFunc, DassignNode *dass MIRSymbol *symPtrSym = nullptr; BaseNode *destExpr = nullptr; if (Options::usePreg) { - symPtrPreg = currentFunc->GetPregTab()->CreatePreg(PTY_ptr); + symPtrPreg = currentFunc.GetPregTab()->CreatePreg(PTY_ptr); RegassignNode *symPtrPregAssign = builder->CreateStmtRegassign(PTY_ptr, symPtrPreg, ireadPtrExpr); - currentFunc->GetBody()->InsertBefore(dassignNode, symPtrPregAssign); + currentFunc.GetBody()->InsertBefore(&dassignNode, symPtrPregAssign); destExpr = builder->CreateExprRegread(PTY_ptr, symPtrPreg); } else { symPtrSym = builder->GetOrCreateLocalDecl(kMuidFuncPtrStr, *mVoidPtr); DassignNode *addrNode = builder->CreateStmtDassign(symPtrSym, 0, ireadPtrExpr); - currentFunc->GetBody()->InsertBefore(dassignNode, addrNode); + currentFunc.GetBody()->InsertBefore(&dassignNode, addrNode); destExpr = builder->CreateExprDread(symPtrSym); } // Replace dassignNode with iassignNode MIRType *destPtrType = GlobalTables::GetTypeTable().GetOrCreatePointerType(mirSymbol->GetType()); - StmtNode *iassignNode = builder->CreateStmtIassign(destPtrType, 0, destExpr, dassignNode->Opnd(0)); - currentFunc->GetBody()->ReplaceStmt1WithStmt2(dassignNode, iassignNode); + StmtNode *iassignNode = builder->CreateStmtIassign(destPtrType, 0, destExpr, dassignNode.Opnd(0)); + currentFunc.GetBody()->ReplaceStmt1WithStmt2(&dassignNode, iassignNode); } @@ -968,7 +974,7 @@ void MUIDReplacement::ReplaceDreadStmt(MIRFunction *currentFunc, StmtNode *stmt) // Turn dread into iread BaseNode *MUIDReplacement::ReplaceDreadExpr(MIRFunction *currentFunc, StmtNode *stmt, BaseNode *expr) { - if (!currentFunc || !stmt || !expr) { + if (currentFunc == nullptr || stmt == nullptr || expr == nullptr) { return nullptr; } size_t i = 0; @@ -978,7 +984,7 @@ BaseNode *MUIDReplacement::ReplaceDreadExpr(MIRFunction *currentFunc, StmtNode * switch (expr->GetOpCode()) { case OP_dread: case OP_addrof: { - return ReplaceDread(currentFunc, stmt, expr); + return ReplaceDread(*currentFunc, stmt, expr); } case OP_select: { topnds = static_cast(expr); @@ -1007,18 +1013,18 @@ BaseNode *MUIDReplacement::ReplaceDreadExpr(MIRFunction *currentFunc, StmtNode * return expr; } -BaseNode *MUIDReplacement::ReplaceDread(MIRFunction *currentFunc, StmtNode *stmt, BaseNode *opnd) { - if (!opnd || (opnd->GetOpCode() != OP_dread && opnd->GetOpCode() != OP_addrof)) { +BaseNode *MUIDReplacement::ReplaceDread(MIRFunction ¤tFunc, StmtNode *stmt, BaseNode *opnd) { + if (opnd == nullptr || (opnd->GetOpCode() != OP_dread && opnd->GetOpCode() != OP_addrof)) { return opnd; } DreadNode *dreadNode = static_cast(opnd); - MIRSymbol *mirSymbol = currentFunc->GetLocalOrGlobalSymbol(dreadNode->GetStIdx()); + MIRSymbol *mirSymbol = currentFunc.GetLocalOrGlobalSymbol(dreadNode->GetStIdx()); + ASSERT(mirSymbol != nullptr, "null ptr check!"); if (!mirSymbol->IsStatic()) { return opnd; } // Add a comment to store the original symbol name - currentFunc->GetBody()->InsertBefore(stmt, - builder->CreateStmtComment(("Read from: " + mirSymbol->GetName()).c_str())); + currentFunc.GetBody()->InsertBefore(stmt, builder->CreateStmtComment(("Read from: " + mirSymbol->GetName()).c_str())); // Load the symbol pointer AddrofNode *baseExpr = nullptr; uint32 index = 0; @@ -1026,12 +1032,12 @@ BaseNode *MUIDReplacement::ReplaceDread(MIRFunction *currentFunc, StmtNode *stmt if (mirSymbol->GetStorageClass() != kScExtern) { // Local static member is accessed through dataDefTab baseExpr = builder->CreateExprAddrof(0, dataDefTabSym); - index = FindIndexFromDefTable(mirSymbol, false); + index = FindIndexFromDefTable(*mirSymbol, false); arrayType = static_cast(dataDefTabSym->GetType()); } else { // External static member is accessed through dataUndefTab baseExpr = builder->CreateExprAddrof(0, dataUndefTabSym); - index = FindIndexFromUndefTable(mirSymbol, false); + index = FindIndexFromUndefTable(*mirSymbol, false); arrayType = static_cast(dataUndefTabSym->GetType()); } ConstvalNode *offsetExpr = builder->CreateIntConst(index, PTY_i64); @@ -1051,6 +1057,7 @@ BaseNode *MUIDReplacement::ReplaceDread(MIRFunction *currentFunc, StmtNode *stmt void MUIDReplacement::ProcessFunc(MIRFunction *func) { // Libcore-all module is self-contained, so no need to do all these replacement + ASSERT(func != nullptr, "null ptr check!"); if (isLibcore || func->IsEmpty()) { return; } @@ -1062,12 +1069,13 @@ void MUIDReplacement::ProcessFunc(MIRFunction *func) { ReplaceDreadStmt(func, stmt); // Replace direct func invoke if (stmt->GetOpCode() == OP_callassigned || stmt->GetOpCode() == OP_call) { - ReplaceDirectInvokeOrAddroffunc(func, stmt); + ReplaceDirectInvokeOrAddroffunc(*func, *stmt); } else if (stmt->GetOpCode() == OP_dassign) { - ReplaceDirectInvokeOrAddroffunc(func, stmt); - ReplaceDassign(func, static_cast(stmt)); + ReplaceDirectInvokeOrAddroffunc(*func, *stmt); + DassignNode *dassignNode = static_cast(stmt); + ReplaceDassign(*func, *dassignNode); } else if (stmt->GetOpCode() == OP_regassign) { - ReplaceDirectInvokeOrAddroffunc(func, stmt); + ReplaceDirectInvokeOrAddroffunc(*func, *stmt); } stmt = next; } diff --git a/src/mpl2mpl/src/native_stub_func.cpp b/src/mpl2mpl/src/native_stub_func.cpp index b2d71f179025027802e2b297cdd66de4573c9319..61879c4d25c636a04d72917f9de662daeeab9565 100644 --- a/src/mpl2mpl/src/native_stub_func.cpp +++ b/src/mpl2mpl/src/native_stub_func.cpp @@ -38,15 +38,16 @@ GenericNativeStubFunc::GenericNativeStubFunc(MIRModule *mod, KlassHierarchy *kh, InitStaticBindingMethodList(); } -MIRFunction *GenericNativeStubFunc::GetOrCreateDefaultNativeFunc(MIRFunction *stubFunc) { +MIRFunction &GenericNativeStubFunc::GetOrCreateDefaultNativeFunc(MIRFunction &stubFunc) { // If only support dynamic binding , we won't stub any weak symbols - if (Options::regNativeDynamicOnly && !(IsStaticBindingListMode() && IsStaticBindingMethod(stubFunc->GetName()))) { + if (Options::regNativeDynamicOnly && !(IsStaticBindingListMode() && IsStaticBindingMethod(stubFunc.GetName()))) { return stubFunc; } - std::string nativeName = NameMangler::NativeJavaName(stubFunc->GetName().c_str()); + std::string nativeName = NameMangler::NativeJavaName(stubFunc.GetName().c_str()); // No need to create a default function with exact arguments here - MIRFunction *nativeFunc = builder->GetOrCreateFunction(nativeName.c_str(), stubFunc->GetReturnTyIdx()); - nativeFunc->GetSrcPosition().SetMplLineNum(stubFunc->GetSrcPosition().MplLineNum()); + MIRFunction *nativeFunc = builder->GetOrCreateFunction(nativeName.c_str(), stubFunc.GetReturnTyIdx()); + ASSERT(nativeFunc != nullptr, "null ptr check!"); + nativeFunc->GetSrcPosition().SetMplLineNum(stubFunc.GetSrcPosition().MplLineNum()); if (!nativeFunc->GetBody()) { builder->SetCurrentFunction(nativeFunc); nativeFunc->SetAttr(FUNCATTR_weak); @@ -57,11 +58,11 @@ MIRFunction *GenericNativeStubFunc::GetOrCreateDefaultNativeFunc(MIRFunction *st // It will throw java.lang.UnsatisfiedLinkError, while issue a runtime // warning on Qemu/arm64-server (because it lacks most of the required native libraries) MIRFunction *findNativeFunc = nullptr; - if (ReturnsJstr(stubFunc->GetReturnTyIdx())) { + if (ReturnsJstr(stubFunc.GetReturnTyIdx())) { // a dialet for string findNativeFunc = builder->GetOrCreateFunction("MCC_CannotFindNativeMethod_S", voidPointerType->GetTypeIndex()); } else { - MIRType *returnType = stubFunc->GetReturnType(); + MIRType *returnType = stubFunc.GetReturnType(); if ((returnType->GetKind() == kTypePointer) && ((static_cast(returnType))->GetPointedType()->GetKind() == kTypeJArray)) { // a dialet for array @@ -74,7 +75,7 @@ MIRFunction *GenericNativeStubFunc::GetOrCreateDefaultNativeFunc(MIRFunction *st } findNativeFunc->SetAttr(FUNCATTR_nosideeffect); // fatal message parameter - std::string nativeSymbolName = stubFunc->GetName().c_str(); + std::string nativeSymbolName = stubFunc.GetName().c_str(); UStrIdx strIdx = GlobalTables::GetUStrTable().GetOrCreateStrIdxFromName(nativeSymbolName); ConststrNode *signatureNode = nativeFunc->GetCodeMempool()->New(strIdx); signatureNode->SetPrimType(PTY_ptr); @@ -84,9 +85,9 @@ MIRFunction *GenericNativeStubFunc::GetOrCreateDefaultNativeFunc(MIRFunction *st builder->CreateStmtCallAssigned(findNativeFunc->GetPuidx(), args, nullptr, OP_callassigned); nativeFunc->GetBody()->AddStatement(callGetFindNativeFunc); GetModule()->AddFunction(nativeFunc); - builder->SetCurrentFunction(stubFunc); + builder->SetCurrentFunction(&stubFunc); } - return nativeFunc; + return *nativeFunc; } // The final order of statements inside of this stub function may need to be adjusted. @@ -103,6 +104,7 @@ MIRFunction *GenericNativeStubFunc::GetOrCreateDefaultNativeFunc(MIRFunction *st // callassigned &MCC_CheckThrowPendingException () {} void GenericNativeStubFunc::ProcessFunc(MIRFunction *func) { // FUNCATTR_bridge for function to exclude + ASSERT(func != nullptr, "null ptr check!"); if ((!func->GetAttr(FUNCATTR_native) && !func->GetAttr(FUNCATTR_fast_native) && !func->GetAttr(FUNCATTR_critical_native)) || func->GetAttr(FUNCATTR_bridge)) { @@ -218,16 +220,16 @@ void GenericNativeStubFunc::ProcessFunc(MIRFunction *func) { if (!voidRet) { stubFuncRet = builder->CreateSymbol(func->GetReturnTyIdx(), "retvar_stubfunc", kStVar, kScAuto, func, kScopeLocal); } - MIRFunction *nativeFunc = GetOrCreateDefaultNativeFunc(func); + MIRFunction &nativeFunc = GetOrCreateDefaultNativeFunc(*func); if (Options::regNativeFunc) { - GenericRegisteredNativeFuncCall(func, nativeFunc, allocCallArgs, stubFuncRet, needNativeCall, preFuncCall, - postFuncCall); + GenericRegisteredNativeFuncCall(*func, nativeFunc, allocCallArgs, stubFuncRet, needNativeCall, *preFuncCall, + *postFuncCall); } else if (Options::nativeWrapper) { - GenericNativeWrapperFuncCall(func, nativeFunc, allocCallArgs, stubFuncRet); + GenericNativeWrapperFuncCall(*func, nativeFunc, allocCallArgs, stubFuncRet); } else { CallNode *callAssign = - builder->CreateStmtCallAssigned(nativeFunc->GetPuidx(), allocCallArgs, stubFuncRet, OP_callassigned); + builder->CreateStmtCallAssigned(nativeFunc.GetPuidx(), allocCallArgs, stubFuncRet, OP_callassigned); func->GetBody()->AddStatement(callAssign); } if (func->GetReturnType()->GetPrimType() == PTY_ref) { @@ -310,10 +312,10 @@ void GenericNativeStubFunc::GenericRegFuncTab() { regFuncSymbol->SetKonst(regFuncTabConst); } -void GenericNativeStubFunc::GenericRegTabEntry(const MIRFunction *func) { - std::string tmp = func->GetName(); +void GenericNativeStubFunc::GenericRegTabEntry(const MIRFunction &func) { + std::string tmp = func.GetName(); tmp = NameMangler::DecodeName(tmp); - std::string base = func->GetBaseClassName(); + std::string base = func.GetBaseClassName(); base = NameMangler::DecodeName(base); if (tmp.length() > base.length() && tmp.find(base) != std::string::npos) { tmp.replace(tmp.find(base), base.length() + 1, ""); @@ -328,15 +330,15 @@ void GenericNativeStubFunc::GenericRegTabEntry(const MIRFunction *func) { regTableConst->GetConstVec().push_back(newConst); } -void GenericNativeStubFunc::GenericRegisteredNativeFuncCall(MIRFunction *func, const MIRFunction *nativeFunc, +void GenericNativeStubFunc::GenericRegisteredNativeFuncCall(MIRFunction &func, const MIRFunction &nativeFunc, MapleVector &args, const MIRSymbol *ret, - bool needNativeCall, CallNode *preNativeFuncCall, - CallNode *postNativeFuncCall) { + bool needNativeCall, CallNode &preNativeFuncCall, + CallNode &postNativeFuncCall) { // Generate registration table entry. GenericRegTabEntry(func); GenericRegFuncTabEntry(); - CallReturnVector nrets(func->GetCodeMempoolAllocator()->Adapter()); - if (ret) { + CallReturnVector nrets(func.GetCodeMempoolAllocator()->Adapter()); + if (ret != nullptr) { CHECK_FATAL((ret->GetStorageClass() == kScAuto || ret->GetStorageClass() == kScFormal || ret->GetStorageClass() == kScExtern || ret->GetStorageClass() == kScGlobal), "unknow classtype! check it!"); @@ -351,16 +353,16 @@ void GenericNativeStubFunc::GenericRegisteredNativeFuncCall(MIRFunction *func, c BaseNode *ireadExpr = builder->CreateExprIread(elemType, GlobalTables::GetTypeTable().GetOrCreatePointerType(elemType), 0, arrayExpr); // assign registered func ptr to a preg. - auto funcptrPreg = func->GetPregTab()->CreatePreg(PTY_ptr); + auto funcptrPreg = func.GetPregTab()->CreatePreg(PTY_ptr); RegassignNode *funcptrAssign = builder->CreateStmtRegassign(PTY_ptr, funcptrPreg, ireadExpr); // read func ptr from preg auto readFuncPtr = builder->CreateExprRegread(PTY_ptr, funcptrPreg); NativeFuncProperty funcProperty; bool needCheckThrowPendingExceptionFunc = - (!func->GetAttr(FUNCATTR_critical_native)) && (funcProperty.jniType == kJniTypeNormal); + (!func.GetAttr(FUNCATTR_critical_native)) && (funcProperty.jniType == kJniTypeNormal); // Get current native method function ptr from reg_jni_func_tab slot // and define a temp register for shift operation - auto funcptrshiftPreg = func->GetPregTab()->CreatePreg(PTY_ptr); + auto funcptrshiftPreg = func.GetPregTab()->CreatePreg(PTY_ptr); BaseNode *regreadExpr = builder->CreateExprRegread(PTY_ptr, funcptrPreg); constexpr int intConstLength = 56; BaseNode *shiftExpr = builder->CreateExprBinary(OP_lshr, GlobalTables::GetTypeTable().GetPtr(), regreadExpr, @@ -374,7 +376,7 @@ void GenericNativeStubFunc::GenericRegisteredNativeFuncCall(MIRFunction *func, c // get find_native_func function MIRType *voidPointerType = GlobalTables::GetTypeTable().GetVoidPtr(); // set parameter of find_native_func - MapleVector dynamicStubOpnds(func->GetCodeMempoolAllocator()->Adapter()); + MapleVector dynamicStubOpnds(func.GetCodeMempoolAllocator()->Adapter()); dynamicStubOpnds.push_back(arrayExpr); // Use native wrapper if required. if (Options::nativeWrapper) { @@ -382,17 +384,17 @@ void GenericNativeStubFunc::GenericRegisteredNativeFuncCall(MIRFunction *func, c // default mode, it will generate a weak function, which can link in compile time // dynamic only mode, it won't generate any weak function, it can't link in compile time // static binding list mode, it will generate a weak function only in list - if (IsStaticBindingListMode() && IsStaticBindingMethod(func->GetName())) { + if (IsStaticBindingListMode() && IsStaticBindingMethod(func.GetName())) { // Get current func_ptr (strong/weak symbol address) - auto *nativeFuncAddr = builder->CreateExprAddroffunc(nativeFunc->GetPuidx()); + auto *nativeFuncAddr = builder->CreateExprAddroffunc(nativeFunc.GetPuidx()); funcptrAssign = builder->CreateStmtRegassign(PTY_ptr, funcptrPreg, nativeFuncAddr); - func->GetBody()->AddStatement(funcptrAssign); + func.GetBody()->AddStatement(funcptrAssign); // Define wrapper function call StmtNode *wrapperCall = CreateNativeWrapperCallNode(func, readFuncPtr, args, ret); - func->GetBody()->AddStatement(wrapperCall); + func.GetBody()->AddStatement(wrapperCall); } else if (!Options::regNativeDynamicOnly) { - func->GetBody()->AddStatement(funcptrAssign); - func->GetBody()->AddStatement(funcptrshiftAssign); + func.GetBody()->AddStatement(funcptrAssign); + func.GetBody()->AddStatement(funcptrshiftAssign); // Get find_native_func function MIRFunction *findNativeFunc = builder->GetOrCreateFunction(kFindNativeFuncNoeh, voidPointerType->GetTypeIndex()); findNativeFunc->SetAttr(FUNCATTR_nosideeffect); @@ -402,9 +404,9 @@ void GenericNativeStubFunc::GenericRegisteredNativeFuncCall(MIRFunction *func, c // Check return value of dynamic linking stub MIRFunction *dummyNativeFunc = builder->GetOrCreateFunction(kDummyNativeFunc, voidPointerType->GetTypeIndex()); dummyNativeFunc->SetAttr(FUNCATTR_nosideeffect); - auto dummyFuncPreg = func->GetPregTab()->CreatePreg(PTY_ptr); + auto dummyFuncPreg = func.GetPregTab()->CreatePreg(PTY_ptr); auto readDummyFuncPtr = builder->CreateExprRegread(PTY_ptr, dummyFuncPreg); - MapleVector dummyFuncOpnds(func->GetCodeMempoolAllocator()->Adapter()); + MapleVector dummyFuncOpnds(func.GetCodeMempoolAllocator()->Adapter()); CallNode *callDummyNativeFunc = builder->CreateStmtCallRegassigned(dummyNativeFunc->GetPuidx(), dummyFuncOpnds, dummyFuncPreg, OP_callassigned); BaseNode *checkStubReturnExpr = @@ -412,7 +414,7 @@ void GenericNativeStubFunc::GenericRegisteredNativeFuncCall(MIRFunction *func, c GlobalTables::GetTypeTable().GetPtr(), readFuncPtr, readDummyFuncPtr); IfStmtNode *subIfStmt = static_cast(builder->CreateStmtIf(checkStubReturnExpr)); // Assign with address of strong/weak symbol - auto *nativeFuncAddr = builder->CreateExprAddroffunc(nativeFunc->GetPuidx()); + auto *nativeFuncAddr = builder->CreateExprAddroffunc(nativeFunc.GetPuidx()); funcptrAssign = builder->CreateStmtRegassign(PTY_ptr, funcptrPreg, nativeFuncAddr); subIfStmt->GetThenPart()->AddStatement(funcptrAssign); // Rewrite reg_jni_func_tab with current funcIdx_ptr(weak/strong symbol address) @@ -422,18 +424,18 @@ void GenericNativeStubFunc::GenericRegisteredNativeFuncCall(MIRFunction *func, c subIfStmt->GetThenPart()->AddStatement(nativeFuncTableEntry); // Add if-statement to function body if (!needNativeCall) { - ifStmt->GetThenPart()->AddStatement(preNativeFuncCall); + ifStmt->GetThenPart()->AddStatement(&preNativeFuncCall); } ifStmt->GetThenPart()->AddStatement(callGetFindNativeFunc); if (!needNativeCall) { - ifStmt->GetThenPart()->AddStatement(postNativeFuncCall); + ifStmt->GetThenPart()->AddStatement(&postNativeFuncCall); } ifStmt->GetThenPart()->AddStatement(callDummyNativeFunc); ifStmt->GetThenPart()->AddStatement(subIfStmt); if (needCheckThrowPendingExceptionFunc) { - func->GetBody()->AddStatement(ifStmt); + func.GetBody()->AddStatement(ifStmt); StmtNode *wrapperCall = CreateNativeWrapperCallNode(func, readFuncPtr, args, ret); - func->GetBody()->AddStatement(wrapperCall); + func.GetBody()->AddStatement(wrapperCall); } else { StmtNode *wrapperCall = CreateNativeWrapperCallNode(func, readFuncPtr, args, ret); ifStmt->GetThenPart()->AddStatement(wrapperCall); @@ -441,17 +443,17 @@ void GenericNativeStubFunc::GenericRegisteredNativeFuncCall(MIRFunction *func, c CallNode *callGetExceptFunc = builder->CreateStmtCallAssigned(MRTCheckThrowPendingExceptionFunc->GetPuidx(), opnds, nullptr, OP_callassigned); ifStmt->GetThenPart()->AddStatement(callGetExceptFunc); - BlockNode *elseBlock = func->GetCodeMempool()->New(); + BlockNode *elseBlock = func.GetCodeMempool()->New(); ifStmt->SetElsePart(elseBlock); constexpr uint32 kNumOfOpnds = 3u; ifStmt->SetNumOpnds(kNumOfOpnds); wrapperCall = CreateNativeWrapperCallNode(func, readFuncPtr, args, ret); elseBlock->AddStatement(wrapperCall); - func->GetBody()->AddStatement(ifStmt); + func.GetBody()->AddStatement(ifStmt); } } else { - func->GetBody()->AddStatement(funcptrAssign); - func->GetBody()->AddStatement(funcptrshiftAssign); + func.GetBody()->AddStatement(funcptrAssign); + func.GetBody()->AddStatement(funcptrshiftAssign); MIRFunction *findNativeFunc = builder->GetOrCreateFunction(kFindNativeFunc, voidPointerType->GetTypeIndex()); findNativeFunc->SetAttr(FUNCATTR_nosideeffect); // CallAssigned statement for unregistered situation @@ -459,11 +461,11 @@ void GenericNativeStubFunc::GenericRegisteredNativeFuncCall(MIRFunction *func, c funcptrPreg, OP_callassigned); // Add if-statement to function body if (!needNativeCall) { - ifStmt->GetThenPart()->AddStatement(preNativeFuncCall); + ifStmt->GetThenPart()->AddStatement(&preNativeFuncCall); } ifStmt->GetThenPart()->AddStatement(callGetFindNativeFunc); if (!needNativeCall) { - ifStmt->GetThenPart()->AddStatement(postNativeFuncCall); + ifStmt->GetThenPart()->AddStatement(&postNativeFuncCall); } if (!needCheckThrowPendingExceptionFunc) { MapleVector opnds(builder->GetCurrentFuncCodeMpAllocator()->Adapter()); @@ -471,14 +473,14 @@ void GenericNativeStubFunc::GenericRegisteredNativeFuncCall(MIRFunction *func, c opnds, nullptr, OP_callassigned); ifStmt->GetThenPart()->AddStatement(callGetExceptFunc); } - func->GetBody()->AddStatement(ifStmt); + func.GetBody()->AddStatement(ifStmt); StmtNode *wrapperCall = CreateNativeWrapperCallNode(func, readFuncPtr, args, ret); - func->GetBody()->AddStatement(wrapperCall); + func.GetBody()->AddStatement(wrapperCall); } return; } // Without native wrapper - IcallNode *icall = func->GetCodeMempool()->New(GetModule(), OP_icallassigned); + IcallNode *icall = func.GetCodeMempool()->New(GetModule(), OP_icallassigned); icall->SetNumOpnds(args.size() + 1); icall->GetNopnd().resize(icall->GetNumOpnds()); icall->SetReturnVec(nrets); @@ -486,7 +488,7 @@ void GenericNativeStubFunc::GenericRegisteredNativeFuncCall(MIRFunction *func, c icall->SetNOpndAt(i, args[i - 1]->CloneTree(GetModule()->GetCurFuncCodeMPAllocator())); } icall->SetNOpndAt(0, readFuncPtr); - icall->SetRetTyIdx(nativeFunc->GetReturnTyIdx()); + icall->SetRetTyIdx(nativeFunc.GetReturnTyIdx()); // Check if funcptr is Invalid MIRFunction *findNativeFunc = builder->GetOrCreateFunction(kFindNativeFunc, voidPointerType->GetTypeIndex()); findNativeFunc->SetAttr(FUNCATTR_nosideeffect); @@ -500,25 +502,25 @@ void GenericNativeStubFunc::GenericRegisteredNativeFuncCall(MIRFunction *func, c builder->CreateStmtCallAssigned(MRTCheckThrowPendingExceptionFunc->GetPuidx(), opnds, nullptr, OP_callassigned); ifStmt->GetThenPart()->AddStatement(callGetExceptFunc); } - func->GetBody()->AddStatement(ifStmt); - func->GetBody()->AddStatement(icall); + func.GetBody()->AddStatement(ifStmt); + func.GetBody()->AddStatement(icall); } -StmtNode *GenericNativeStubFunc::CreateNativeWrapperCallNode(MIRFunction *func, BaseNode *funcPtr, +StmtNode *GenericNativeStubFunc::CreateNativeWrapperCallNode(MIRFunction &func, BaseNode *funcPtr, MapleVector &args, const MIRSymbol *ret) { MIRFunction *wrapperFunc = nullptr; - MapleVector wrapperArgs(func->GetCodeMPAllocator().Adapter()); + MapleVector wrapperArgs(func.GetCodeMPAllocator().Adapter()); // The first arg is the natvie function pointer. wrapperArgs.push_back(funcPtr); // Is fast native? - auto isFast = (func->GetAttr(FUNCATTR_fast_native) || func->GetAttr(FUNCATTR_critical_native)); + auto isFast = (func.GetAttr(FUNCATTR_fast_native) || func.GetAttr(FUNCATTR_critical_native)); // Do not need native wrapper for critical natives // if num_of_args < 8 constexpr size_t kNumOfArgs = 8; - if (func->GetAttr(FUNCATTR_critical_native) && args.size() < kNumOfArgs) { - IcallNode *icall = func->GetCodeMempool()->New(GetModule(), OP_icallassigned); - CallReturnVector nrets(func->GetCodeMempoolAllocator()->Adapter()); - if (ret) { + if (func.GetAttr(FUNCATTR_critical_native) && args.size() < kNumOfArgs) { + IcallNode *icall = func.GetCodeMempool()->New(GetModule(), OP_icallassigned); + CallReturnVector nrets(func.GetCodeMempoolAllocator()->Adapter()); + if (ret != nullptr) { CHECK_FATAL((ret->GetStorageClass() == kScAuto || ret->GetStorageClass() == kScFormal || ret->GetStorageClass() == kScExtern || ret->GetStorageClass() == kScGlobal), "unknown classtype! check it!"); @@ -531,7 +533,7 @@ StmtNode *GenericNativeStubFunc::CreateNativeWrapperCallNode(MIRFunction *func, icall->SetNOpndAt(i, args[i - 1]->CloneTree(GetModule()->GetCurFuncCodeMPAllocator())); } icall->SetNOpndAt(0, funcPtr); - icall->SetRetTyIdx(func->GetReturnTyIdx()); + icall->SetRetTyIdx(func.GetReturnTyIdx()); return icall; } @@ -555,10 +557,10 @@ StmtNode *GenericNativeStubFunc::CreateNativeWrapperCallNode(MIRFunction *func, } } -void GenericNativeStubFunc::GenericNativeWrapperFuncCall(MIRFunction *func, const MIRFunction *nativeFunc, +void GenericNativeStubFunc::GenericNativeWrapperFuncCall(MIRFunction &func, const MIRFunction &nativeFunc, MapleVector &args, const MIRSymbol *ret) { - func->GetBody()->AddStatement( - CreateNativeWrapperCallNode(func, builder->CreateExprAddroffunc(nativeFunc->GetPuidx()), args, ret)); + func.GetBody()->AddStatement( + CreateNativeWrapperCallNode(func, builder->CreateExprAddroffunc(nativeFunc.GetPuidx()), args, ret)); } void GenericNativeStubFunc::GenericRegTableEntryType() { diff --git a/src/mpl2mpl/src/reflection_analysis.cpp b/src/mpl2mpl/src/reflection_analysis.cpp index 3f40f4cf162201db4ff8318ea15a8481066c2fda..ea622ed388db81ec142d681f2ae5632a99e0ec49 100644 --- a/src/mpl2mpl/src/reflection_analysis.cpp +++ b/src/mpl2mpl/src/reflection_analysis.cpp @@ -200,12 +200,12 @@ uint32 GetClassAccessFlags(MIRClassType *classType) { return 0; } -bool ReflectionAnalysis::IsStaticClass(MIRClassType *classType) { - return GetClassAccessFlags(classType) & 0x00000008; // # Modifier_Static 0x00000008; +bool ReflectionAnalysis::IsStaticClass(MIRClassType &classType) { + return GetClassAccessFlags(&classType) & 0x00000008; // # Modifier_Static 0x00000008; } -bool ReflectionAnalysis::IsPrivateClass(MIRClassType *classType) { - return GetClassAccessFlags(classType) & 0x00000002; // # Modifier_Private 0x00000002; +bool ReflectionAnalysis::IsPrivateClass(MIRClassType &classType) { + return GetClassAccessFlags(&classType) & 0x00000002; // # Modifier_Private 0x00000002; } static inline GStrIdx GetOrCreateGStrIdxFromName(const std::string &name) { @@ -229,16 +229,16 @@ static std::string GetSignatureFromFullName(const std::string &fullname) { } } -int ReflectionAnalysis::SolveAnnotation(MIRClassType *classType, MIRFunction *func) { +int ReflectionAnalysis::SolveAnnotation(MIRClassType &classType, MIRFunction &func) { std::string annoArray1; std::map idxNumMap; - GeneAnnotation(idxNumMap, annoArray1, classType, kPragmaFunc, func->GetName(), invalidIdx); + GeneAnnotation(idxNumMap, annoArray1, classType, kPragmaFunc, func.GetName(), invalidIdx); // Parameter annotation. std::string annoArray2; std::map paramNumArray; int paramIndex = 0; std::map paramIdxNumMap; - GeneAnnotation(paramIdxNumMap, annoArray2, classType, kPragmaParam, func->GetName(), invalidIdx, ¶mNumArray, + GeneAnnotation(paramIdxNumMap, annoArray2, classType, kPragmaParam, func.GetName(), invalidIdx, ¶mNumArray, ¶mIndex); std::string subStr = ""; if (idxNumMap.empty() && paramIdxNumMap.empty()) { @@ -268,16 +268,16 @@ int ReflectionAnalysis::SolveAnnotation(MIRClassType *classType, MIRFunction *fu return GetDeflateStringIdx(subStr); } -uint32 ReflectionAnalysis::GetTypeNameIdxFromType(MIRType *type, const Klass *klass, const std::string &fieldname) { +uint32 ReflectionAnalysis::GetTypeNameIdxFromType(MIRType &type, const Klass &klass, const std::string &fieldname) { uint32 typeNameIdx = 0; - switch (type->GetKind()) { + switch (type.GetKind()) { case kTypeScalar: { - std::string name(GetPrimTypeJavaName(type->GetPrimType())); + std::string name(GetPrimTypeJavaName(type.GetPrimType())); typeNameIdx = FindOrInsertReflectString(name); break; } case kTypePointer: { - MIRType *ptype = static_cast(type)->GetPointedType(); + MIRType *ptype = static_cast(&type)->GetPointedType(); if (ptype->GetKind() == kTypeArray || ptype->GetKind() == kTypeJArray) { CHECK_FATAL(dynamic_cast(ptype) != nullptr, "null ptr check"); std::string javaName = dynamic_cast(ptype)->GetJavaName(); @@ -292,31 +292,32 @@ uint32 ReflectionAnalysis::GetTypeNameIdxFromType(MIRType *type, const Klass *kl NameMangler::DecodeMapleNameToJavaDescriptor(javaName, klassJavaDescriptor); typeNameIdx = FindOrInsertReflectString(klassJavaDescriptor); } else { - CHECK_FATAL(false, "In class %s: field %s 's type is UNKNOWN", klass->GetKlassName().c_str(), + CHECK_FATAL(false, "In class %s: field %s 's type is UNKNOWN", klass.GetKlassName().c_str(), fieldname.c_str()); } break; } default: { - CHECK_FATAL(false, "In class %s: field %s 's type is UNKNOWN", klass->GetKlassName().c_str(), fieldname.c_str()); + CHECK_FATAL(false, "In class %s: field %s 's type is UNKNOWN", klass.GetKlassName().c_str(), fieldname.c_str()); } } return typeNameIdx; } -void ReflectionAnalysis::CheckPrivateInnerAndNoSubClass(Klass *clazz, const std::string &annoArr) { +void ReflectionAnalysis::CheckPrivateInnerAndNoSubClass(Klass &clazz, const std::string &annoArr) { // LMain_24A_3B `EC!`VL!24!LMain_3B!`IC!`AF!4!2!name!23!A! size_t pos = annoArr.find(kInnerClassPrefix, 0); if (pos == std::string::npos) { return; } - if (!IsPrivateClass(clazz->GetMIRClassType())) { + ASSERT(clazz.GetMIRClassType() != nullptr, "null ptr check!"); + if (!IsPrivateClass(*clazz.GetMIRClassType())) { return; // Check private. } - if (clazz->HasSubKlass()) { - clazz->SetPrivateInnerAndNoSubClass(false); + if (clazz.HasSubKlass()) { + clazz.SetPrivateInnerAndNoSubClass(false); } else { - clazz->SetPrivateInnerAndNoSubClass(true); + clazz.SetPrivateInnerAndNoSubClass(true); } } @@ -521,13 +522,13 @@ bool RtRetentionPolicyCheck(const MIRSymbol *clInfo) { return false; } -int16 ReflectionAnalysis::GetMethodInVtabIndex(const Klass *klass, const MIRFunction *func) { +int16 ReflectionAnalysis::GetMethodInVtabIndex(const Klass &klass, const MIRFunction &func) { int methodInVtabIndex = 0; bool findMethod = false; - MIRClassType *classType = klass->GetMIRClassType(); + MIRClassType *classType = klass.GetMIRClassType(); MIRSymbol *vtableSymbol = GlobalTables::GetGsymTable().GetSymbolFromStrIdx( - GlobalTables::GetStrTable().GetStrIdxFromName(VTAB_PREFIX_STR + klass->GetKlassName())); - if (klass->IsClass() && vtableSymbol != nullptr) { + GlobalTables::GetStrTable().GetStrIdxFromName(VTAB_PREFIX_STR + klass.GetKlassName())); + if (klass.IsClass() && vtableSymbol != nullptr) { MIRAggConst *vtableConst = dynamic_cast(vtableSymbol->GetKonst()); for (MIRConstPtr &node : vtableConst->GetConstVec()) { if (node->GetKind() == kConstAddrofFunc) { @@ -539,19 +540,19 @@ int16 ReflectionAnalysis::GetMethodInVtabIndex(const Klass *klass, const MIRFunc // interface) in the vtable. Therefore, we cannot compare methods by // their GetNameStrIdx() (which includes package+class+method+descriptor), // because otherwise we may not find the exact method. - if (func->GetBaseFuncNameWithTypeStrIdx() == vtableFunc->GetBaseFuncNameWithTypeStrIdx()) { + if (func.GetBaseFuncNameWithTypeStrIdx() == vtableFunc->GetBaseFuncNameWithTypeStrIdx()) { findMethod = true; break; } } methodInVtabIndex++; } - } else if (klass->IsInterface()) { + } else if (klass.IsInterface()) { methodInVtabIndex = 0; for (MethodPair &methodPair : classType->GetMethods()) { MIRSymbol *currSym = GlobalTables::GetGsymTable().GetSymbolFromStidx(methodPair.first.Idx()); MIRFunction *currFunc = currSym->GetFunction(); - if (func->GetNameStrIdx() == currFunc->GetNameStrIdx()) { + if (func.GetNameStrIdx() == currFunc->GetNameStrIdx()) { findMethod = true; break; } @@ -569,10 +570,10 @@ int16 ReflectionAnalysis::GetMethodInVtabIndex(const Klass *klass, const MIRFunc return static_cast(methodInVtabIndex); } -void ReflectionAnalysis::GetSignatureTypeNames(const char *signature, std::vector &typeNames) { - int sigLen = strlen(signature); +void ReflectionAnalysis::GetSignatureTypeNames(const std::string &signature, std::vector &typeNames) { + int sigLen = signature.length(); int i = 0; - const char *methodSignature = signature; + const char *methodSignature = signature.c_str(); i++; while (i < sigLen && methodSignature[i] != ')') { std::string descriptor; @@ -690,7 +691,8 @@ MIRSymbol *ReflectionAnalysis::GenMethodsMetaData(const Klass *klass) { uint16 hash = func->GetHashCode(); flag |= (hash << kNoHashBits); // hash 10 bit // @method_in_vtable_index - uint32 methodInVtabIndex = static_cast(static_cast(GetMethodInVtabIndex(klass, func))); + uint32 methodInVtabIndex = 0u; + methodInVtabIndex = static_cast(static_cast(GetMethodInVtabIndex(*klass, *func))); methodInVtabIndex &= 0xFFFF; mirBuilder.AddIntFieldConst(*methodsInfoType, *newconst, fieldID++, methodInVtabIndex); @@ -720,7 +722,8 @@ MIRSymbol *ReflectionAnalysis::GenMethodsMetaData(const Klass *klass) { uint32 signatureIdx = FindOrInsertReflectString(signature); mirBuilder.AddIntFieldConst(*methodsInfoType, *newconst, fieldID++, signatureIdx); // @annotation - int annotationIdx = SolveAnnotation(classType, func); + int annotationIdx = 0; + annotationIdx = SolveAnnotation(*classType, *func); mirBuilder.AddIntFieldConst(*methodsInfoType, *newconst, fieldID++, annotationIdx); mirBuilder.AddIntFieldConst(*methodsInfoType, *newconst, fieldID++, flag); // @argsize: Number of arguments. @@ -866,7 +869,8 @@ MIRSymbol *ReflectionAnalysis::GenFieldsMetaData(const Klass *klass) { mirBuilder.AddIntFieldConst(*fieldsInfoType, *newconst, fieldID++, GetFieldModifier(fa)); ConvertFieldName(fieldname, staticfield); uint32 fieldname32Idx = FindOrInsertReflectString(fieldname); - uint32 typeNameIdx = GetTypeNameIdxFromType(ty, klass, fieldname); + uint32 typeNameIdx = 0u; + typeNameIdx = GetTypeNameIdxFromType(*ty, *klass, fieldname); // @flag uint16 hash = GetFieldHash(fieldHashvec, fieldP); uint16 flag = (hash << kNoHashBits); // Hash 10 bit. @@ -882,7 +886,7 @@ MIRSymbol *ReflectionAnalysis::GenFieldsMetaData(const Klass *klass) { // @annotation std::string annoArr; std::map idxNumMap; - GeneAnnotation(idxNumMap, annoArr, classType, kPragmaVar, fieldname, ty->GetTypeIndex()); + GeneAnnotation(idxNumMap, annoArr, *classType, kPragmaVar, fieldname, ty->GetTypeIndex()); uint32 annotationIdx = GetAnnoCstrIndex(idxNumMap, annoArr); mirBuilder.AddIntFieldConst(*fieldsInfoType, *newconst, fieldID++, annotationIdx); // @declaring class @@ -1103,8 +1107,8 @@ uint32 ReflectionAnalysis::FindOrInsertReflectString(const std::string &str) { return ReflectionAnalysis::FindOrInsertRepeatString(str, false, hotType); } -MIRSymbol *ReflectionAnalysis::GetClinitFuncSymbol(const Klass *klass) { - MIRClassType *classType = klass->GetMIRClassType(); +MIRSymbol *ReflectionAnalysis::GetClinitFuncSymbol(const Klass &klass) { + MIRClassType *classType = klass.GetMIRClassType(); if (!classType || classType->GetMethods().empty()) { return nullptr; } @@ -1124,6 +1128,7 @@ MIRSymbol *ReflectionAnalysis::GetClinitFuncSymbol(const Klass *klass) { void ReflectionAnalysis::GenClassMetaData(Klass *klass) { ASSERT(klass != nullptr, "null ptr check!"); MIRClassType *classType = klass->GetMIRClassType(); + ASSERT(classType != nullptr, "null ptr check!"); if (!classType->IsLocal()) { // External class. return; @@ -1145,6 +1150,7 @@ void ReflectionAnalysis::GenClassMetaData(Klass *klass) { uint32 fieldID = 1; // @classname uint32 nameIdx = FindOrInsertReflectString(klassJavaDescriptor); + ASSERT(classMetadataROType != nullptr, "null ptr check!"); mirBuilder.AddIntFieldConst(*classMetadataROType, *newconst, fieldID++, nameIdx); // @iFields: All instance fields. int numOfFields = 0; @@ -1217,9 +1223,9 @@ void ReflectionAnalysis::GenClassMetaData(Klass *klass) { // Do annotation. std::string annoArray; std::map idxNumMap; - GeneAnnotation(idxNumMap, annoArray, classType, kPragmaClass, klass->GetKlassName(), invalidIdx); + GeneAnnotation(idxNumMap, annoArray, *classType, kPragmaClass, klass->GetKlassName(), invalidIdx); bool isAnonymous = IsAnonymousClass(annoArray); - CheckPrivateInnerAndNoSubClass(klass, annoArray); + CheckPrivateInnerAndNoSubClass(*klass, annoArray); #ifndef USE_32BIT_REF // @flag @@ -1237,9 +1243,9 @@ void ReflectionAnalysis::GenClassMetaData(Klass *klass) { uint32 modifier = GetClassAccessFlags(classType); mirBuilder.AddIntFieldConst(*classMetadataROType, *newconst, fieldID++, modifier); // @annotation: Set annotation field. - SetAnnoFieldConst(classMetadataROType, *newconst, fieldID++, idxNumMap, annoArray); + SetAnnoFieldConst(*classMetadataROType, *newconst, fieldID++, idxNumMap, annoArray); // @ClinitFuncAddr - MIRSymbol *clinitFuncSym = GetClinitFuncSymbol(klass); + MIRSymbol *clinitFuncSym = GetClinitFuncSymbol(*klass); if (clinitFuncSym != nullptr) { mirBuilder.AddAddroffuncFieldConst(*classMetadataROType, *newconst, fieldID++, *clinitFuncSym); } else { @@ -1318,13 +1324,13 @@ void ReflectionAnalysis::GenClassMetaData(Klass *klass) { classTab.push_back(classSt); } -void ReflectionAnalysis::SetAnnoFieldConst(const MIRStructType *metadataRoType, MIRAggConst &newconst, uint32 fieldid, +void ReflectionAnalysis::SetAnnoFieldConst(const MIRStructType &metadataRoType, MIRAggConst &newconst, uint32 fieldid, std::map &idxNumMap, const std::string &annoArr) { size_t annoNum = idxNumMap.size(); if (annoNum == 0) { std::string subStr = "0!0"; uint32 signatureIdx = FindOrInsertReflectString(subStr); - mirBuilder.AddIntFieldConst(*metadataRoType, newconst, fieldid, signatureIdx); + mirBuilder.AddIntFieldConst(metadataRoType, newconst, fieldid, signatureIdx); } else { std::string subStr = std::to_string(annoNum); subStr += "!"; @@ -1334,17 +1340,17 @@ void ReflectionAnalysis::SetAnnoFieldConst(const MIRStructType *metadataRoType, }); subStr += annoArr; uint32 signatureIdx = GetDeflateStringIdx(subStr); - mirBuilder.AddIntFieldConst(*metadataRoType, newconst, fieldid, signatureIdx); + mirBuilder.AddIntFieldConst(metadataRoType, newconst, fieldid, signatureIdx); } } -void ReflectionAnalysis::GeneAnnotation(std::map &idxNumMap, std::string &annoArr, MIRClassType *classType, +void ReflectionAnalysis::GeneAnnotation(std::map &idxNumMap, std::string &annoArr, MIRClassType &classType, PragmaKind paragKind, const std::string ¶gName, TyIdx fieldTypeIdx, std::map *paramnumArray, int *paramIndex) { int annoNum = 0; std::string cmpString = ""; - for (MIRPragma *prag : classType->GetPragmVec()) { + for (MIRPragma *prag : classType.GetPragmVec()) { if (paragKind == kPragmaVar) { cmpString = NameMangler::DecodeName(GlobalTables::GetStrTable().GetStringFromStrIdx(prag->GetStrIdx())); } else { @@ -1372,7 +1378,7 @@ void ReflectionAnalysis::GeneAnnotation(std::map &idxNumMap, std::stri ReflectionAnalysis::CompressHighFrequencyStr(klassJavaDescriptor); annoArr += klassJavaDescriptor; annoArr += "!"; - if (paramnumArray) { + if (paramnumArray != nullptr) { CHECK_FATAL(paramIndex, "null ptr check"); (*paramnumArray)[(*paramIndex)++] = prag->GetParamNum(); }