diff --git a/src/bin/jbc2mpl b/src/bin/jbc2mpl index 406735d79e82bc14f8557bb1660dcb756f73d89b..9115a9e8354b7379d82af153d9272c9453e6ebc6 100755 Binary files a/src/bin/jbc2mpl and b/src/bin/jbc2mpl differ diff --git a/src/bin/maple b/src/bin/maple index 5663533a6776f33f54dfdaecc1d7e447d5a7fe63..b88212d42f9b87180e21cd9f90dd77cf1c5cb8f7 100755 Binary files a/src/bin/maple and b/src/bin/maple differ diff --git a/src/bin/mplcg b/src/bin/mplcg index ab4b3a8bc170b512dcba9b3b625e5b2d81fe5d4b..ce1f88af2ffa83a4309bae1b5f6293dfaf0141f6 100755 Binary files a/src/bin/mplcg and b/src/bin/mplcg differ diff --git a/src/maple_ir/include/bin_mpl_export.h b/src/maple_ir/include/bin_mpl_export.h index 96dc481e9f5d4b6fb2b3006af41c64cbd7626a29..e8e2c42df5d6b19243581de43e02e52376e5189b 100644 --- a/src/maple_ir/include/bin_mpl_export.h +++ b/src/maple_ir/include/bin_mpl_export.h @@ -89,21 +89,21 @@ class BinaryMplExport { void OutputType(const TyIdx &tyIdx); void OutputTypeAttrs(const TypeAttrs &ta); void OutputPragmaElement(const MIRPragmaElement &e); - void OutputPragma(const MIRPragma *p); + void OutputPragma(const MIRPragma &p); void OutputFieldPair(const FieldPair &fp); void OutputMethodPair(const MethodPair &memPool); void OutputFieldsOfStruct(const FieldVector &fields); void OutputMethodsOfStruct(const MethodVector &methods); - void OutputStructTypeData(MIRStructType *type); + void OutputStructTypeData(MIRStructType &type); void OutputImplementedInterfaces(const std::vector &interfaces); void OutputInfoIsString(const std::vector &infoIsString); void OutputInfo(const std::vector &info, const std::vector &infoIsString); void OutputPragmaVec(const std::vector &pragmaVec); - void OutputClassTypeData(MIRClassType *type); - void OutputInterfaceTypeData(MIRInterfaceType *type); + void OutputClassTypeData(MIRClassType &type); + void OutputInterfaceTypeData(MIRInterfaceType &type); void OutputSymbol(const MIRSymbol *sym); void OutputFunction(PUIdx puIdx); - void OutWords(uint8 *typeTagged, int64 targetTag, uint16 size); + void OutWords(uint8 &typeTagged, int64 targetTag, uint16 size); void Write(uint8 b); void WriteInt(int32 x); uint8 Read(); diff --git a/src/maple_ir/include/mir_builder.h b/src/maple_ir/include/mir_builder.h index b4f439898f718db7f52d45abd3dd9a9c47a1aa9b..ba85075c475181e207ff8930d60f247c3ca0f55a 100644 --- a/src/maple_ir/include/mir_builder.h +++ b/src/maple_ir/include/mir_builder.h @@ -129,7 +129,7 @@ class MIRBuilder { return fun->GetFormal(index); } - MIRFunction *CreateFunction(const std::string &name, const MIRType *returnType, const ArgVector &arguments, + MIRFunction *CreateFunction(const std::string &name, const MIRType &returnType, const ArgVector &arguments, bool isvarg = false, bool createBody = true); MIRFunction *CreateFunction(const StIdx stIdx, bool addToTable = true); virtual void UpdateFunction(MIRFunction *func, MIRType *returnType, const ArgVector &arguments) { @@ -140,7 +140,7 @@ class MIRBuilder { virtual MIRSymbol *GetOrCreateLocalDecl(const std::string &str, MIRType &type); MIRSymbol *GetLocalDecl(const std::string &str); MIRSymbol *CreateLocalDecl(const std::string &str, const MIRType &type); - MIRSymbol *GetOrCreateGlobalDecl(const std::string &str, const MIRType *type); + MIRSymbol *GetOrCreateGlobalDecl(const std::string &str, const MIRType &type); MIRSymbol *GetGlobalDecl(const std::string &str); MIRSymbol *GetDecl(const std::string &str); MIRSymbol *CreateGlobalDecl(const std::string &str, const MIRType *type, MIRStorageClass sc = kScGlobal); @@ -150,7 +150,7 @@ class MIRBuilder { ConstvalNode *CreateFloatConst(float val); ConstvalNode *CreateDoubleConst(double val); ConstvalNode *CreateFloat128Const(const uint64 *val); - ConstvalNode *GetConstInt(MemPool *memPool, int i); + ConstvalNode *GetConstInt(MemPool &memPool, int i); ConstvalNode *GetConstInt(int i) { return CreateIntConst(i, PTY_i32); } @@ -176,41 +176,41 @@ class MIRBuilder { } ConstvalNode *GetConstArray(MIRType*, BaseNode*, uint32 length); - ConstvalNode *CreateAddrofConst(BaseNode*); - ConstvalNode *CreateAddroffuncConst(const BaseNode*); - ConstvalNode *CreateStrConst(const BaseNode*); - ConstvalNode *CreateStr16Const(const BaseNode*); - SizeoftypeNode *CreateExprSizeoftype(const MIRType *type); - FieldsDistNode *CreateExprFieldsDist(const MIRType *type, FieldID field1, FieldID field2); - AddrofNode *CreateExprAddrof(FieldID fieldID, const MIRSymbol *symbol, MemPool *memPool = nullptr); + ConstvalNode *CreateAddrofConst(BaseNode&); + ConstvalNode *CreateAddroffuncConst(const BaseNode&); + ConstvalNode *CreateStrConst(const BaseNode&); + ConstvalNode *CreateStr16Const(const BaseNode&); + SizeoftypeNode *CreateExprSizeoftype(const MIRType &type); + FieldsDistNode *CreateExprFieldsDist(const MIRType &type, FieldID field1, FieldID field2); + AddrofNode *CreateExprAddrof(FieldID fieldID, const MIRSymbol &symbol, MemPool *memPool = nullptr); AddrofNode *CreateExprAddrof(FieldID fieldID, StIdx symbolStIdx, MemPool *memPool = nullptr); AddroffuncNode *CreateExprAddroffunc(PUIdx, MemPool *memPool = nullptr); - AddrofNode *CreateExprDread(const MIRType *type, FieldID fieldID, const MIRSymbol *symbol); - virtual AddrofNode *CreateExprDread(MIRType *type, MIRSymbol *symbol); - virtual AddrofNode *CreateExprDread(MIRSymbol *symbol); + AddrofNode *CreateExprDread(const MIRType &type, FieldID fieldID, const MIRSymbol &symbol); + virtual AddrofNode *CreateExprDread(MIRType &type, MIRSymbol &symbol); + virtual AddrofNode *CreateExprDread(MIRSymbol &symbol); AddrofNode *CreateExprDread(PregIdx pregID, PrimType pty); - AddrofNode *CreateExprDread(MIRSymbol*, uint16); + AddrofNode *CreateExprDread(MIRSymbol&, uint16); RegreadNode *CreateExprRegread(PrimType pty, PregIdx regIdx); - IreadNode *CreateExprIread(const MIRType *returnType, const MIRType *ptrType, FieldID fieldID, BaseNode *addr); + IreadNode *CreateExprIread(const MIRType &returnType, const MIRType &ptrType, FieldID fieldID, BaseNode *addr); IreadNode *CreateExprIread(TyIdx *returnTypeIdx, TyIdx *ptrTypeIdx, FieldID fieldID, BaseNode *addr); IreadoffNode *CreateExprIreadoff(PrimType pty, int32 offset, BaseNode *opnd0); IreadFPoffNode *CreateExprIreadFPoff(PrimType pty, int32 offset); - IaddrofNode *CreateExprIaddrof(const MIRType *returnType, const MIRType *ptrType, FieldID fieldID, BaseNode *addr); + IaddrofNode *CreateExprIaddrof(const MIRType &returnType, const MIRType &ptrType, FieldID fieldID, BaseNode *addr); IaddrofNode *CreateExprIaddrof(PrimType returnTypePty, TyIdx ptrTypeIdx, FieldID fieldID, BaseNode *addr); - BinaryNode *CreateExprBinary(Opcode opcode, const MIRType *type, BaseNode *opnd0, BaseNode *opnd1); - TernaryNode *CreateExprTernary(Opcode opcode, const MIRType *type, BaseNode *opnd0, BaseNode *opnd1, BaseNode *opnd2); - CompareNode *CreateExprCompare(Opcode opcode, const MIRType *type, const MIRType *opndType, BaseNode *opnd0, + BinaryNode *CreateExprBinary(Opcode opcode, const MIRType &type, BaseNode *opnd0, BaseNode *opnd1); + TernaryNode *CreateExprTernary(Opcode opcode, const MIRType &type, BaseNode *opnd0, BaseNode *opnd1, BaseNode *opnd2); + CompareNode *CreateExprCompare(Opcode opcode, const MIRType &type, const MIRType &opndType, BaseNode *opnd0, BaseNode *opnd1); - UnaryNode *CreateExprUnary(Opcode opcode, const MIRType *type, BaseNode *opnd); - GCMallocNode *CreateExprGCMalloc(Opcode opcode, const MIRType *ptype, const MIRType *type); - JarrayMallocNode *CreateExprJarrayMalloc(Opcode opcode, const MIRType *ptype, const MIRType *type, BaseNode *opnd); - TypeCvtNode *CreateExprTypeCvt(Opcode o, const MIRType *type, const MIRType *fromtype, BaseNode *opnd); - ExtractbitsNode *CreateExprExtractbits(Opcode o, const MIRType *type, uint32 bOffset, uint32 bsize, BaseNode *opnd); - RetypeNode *CreateExprRetype(const MIRType *type, const MIRType *fromType, BaseNode *opnd); - ArrayNode *CreateExprArray(const MIRType *arrayType); - ArrayNode *CreateExprArray(const MIRType *arrayType, BaseNode *op); - ArrayNode *CreateExprArray(const MIRType *arrayType, BaseNode *op1, BaseNode *op2); - IntrinsicopNode *CreateExprIntrinsicop(MIRIntrinsicID idx, Opcode opCode, const MIRType *type, + UnaryNode *CreateExprUnary(Opcode opcode, const MIRType &type, BaseNode *opnd); + GCMallocNode *CreateExprGCMalloc(Opcode opcode, const MIRType &ptype, const MIRType &type); + JarrayMallocNode *CreateExprJarrayMalloc(Opcode opcode, const MIRType &ptype, const MIRType &type, BaseNode *opnd); + TypeCvtNode *CreateExprTypeCvt(Opcode o, const MIRType &type, const MIRType &fromtype, BaseNode *opnd); + ExtractbitsNode *CreateExprExtractbits(Opcode o, const MIRType &type, uint32 bOffset, uint32 bsize, BaseNode *opnd); + RetypeNode *CreateExprRetype(const MIRType &type, const MIRType &fromType, BaseNode *opnd); + ArrayNode *CreateExprArray(const MIRType &arrayType); + ArrayNode *CreateExprArray(const MIRType &arrayType, BaseNode *op); + ArrayNode *CreateExprArray(const MIRType &arrayType, BaseNode *op1, BaseNode *op2); + IntrinsicopNode *CreateExprIntrinsicop(MIRIntrinsicID idx, Opcode opCode, const MIRType &type, const MapleVector &ops); // for creating Statement. NaryStmtNode *CreateStmtReturn(BaseNode *rVal); @@ -218,10 +218,10 @@ class MIRBuilder { NaryStmtNode *CreateStmtNary(Opcode op, const MapleVector &rVals); UnaryStmtNode *CreateStmtUnary(Opcode op, BaseNode *rVal); UnaryStmtNode *CreateStmtThrow(BaseNode *rVal); - DassignNode *CreateStmtDassign(const MIRSymbol *var, FieldID fieldID, BaseNode *src); + DassignNode *CreateStmtDassign(const MIRSymbol &var, FieldID fieldID, BaseNode *src); DassignNode *CreateStmtDassign(StIdx sIdx, FieldID fieldID, BaseNode *src); RegassignNode *CreateStmtRegassign(PrimType pty, PregIdx regIdx, BaseNode *src); - IassignNode *CreateStmtIassign(const MIRType *type, FieldID fieldID, BaseNode *addr, BaseNode *src); + IassignNode *CreateStmtIassign(const MIRType &type, FieldID fieldID, BaseNode *addr, BaseNode *src); IassignoffNode *CreateStmtIassignoff(PrimType pty, int32 offset, BaseNode *opnd0, BaseNode *src); IassignFPoffNode *CreateStmtIassignFPoff(PrimType pty, int32 offset, BaseNode *src); CallNode *CreateStmtCall(PUIdx puIdx, const MapleVector &args, Opcode opCode = OP_call); @@ -264,22 +264,22 @@ class MIRBuilder { TryNode *CreateStmtTry(const MapleVector &cLabIdxs); CatchNode *CreateStmtCatch(const MapleVector &tyIdxVec); LabelIdx GetOrCreateMIRLabel(const std::string &name); - LabelIdx CreateLabIdx(MIRFunction *mirfunc); + LabelIdx CreateLabIdx(MIRFunction &mirfunc); LabelNode *CreateStmtLabel(LabelIdx labIdx); StmtNode *CreateStmtComment(const std::string &cmnt); CondGotoNode *CreateStmtCondGoto(BaseNode *cond, Opcode op, LabelIdx labIdx); - void AddStmtInCurrentFunctionBody(StmtNode *stmt); - MIRSymbol *GetSymbol(TyIdx, const std::string&, MIRSymKind, MIRStorageClass, MIRFunction*, uint8, bool); - MIRSymbol *GetSymbol(TyIdx, GStrIdx, MIRSymKind, MIRStorageClass, MIRFunction*, uint8, bool); + void AddStmtInCurrentFunctionBody(StmtNode &stmt); + MIRSymbol *GetSymbol(TyIdx, const std::string&, MIRSymKind, MIRStorageClass, uint8, bool); + MIRSymbol *GetSymbol(TyIdx, GStrIdx, MIRSymKind, MIRStorageClass, uint8, bool); MIRSymbol *GetOrCreateSymbol(TyIdx, const std::string&, MIRSymKind, MIRStorageClass, MIRFunction*, uint8, bool); MIRSymbol *GetOrCreateSymbol(TyIdx, GStrIdx, MIRSymKind, MIRStorageClass, MIRFunction*, uint8, bool); - MIRSymbol *CreatePregFormalSymbol(TyIdx, PregIdx, MIRFunction*); + MIRSymbol *CreatePregFormalSymbol(TyIdx, PregIdx, MIRFunction&); // for creating symbol MIRSymbol *CreateSymbol(TyIdx, const std::string&, MIRSymKind, MIRStorageClass, MIRFunction*, uint8); MIRSymbol *CreateSymbol(TyIdx, GStrIdx, MIRSymKind, MIRStorageClass, MIRFunction*, uint8); // for creating nodes - AddrofNode *CreateAddrof(const MIRSymbol *st, PrimType pty = PTY_ptr); - AddrofNode *CreateDread(const MIRSymbol *st, PrimType pty); + AddrofNode *CreateAddrof(const MIRSymbol &st, PrimType pty = PTY_ptr); + AddrofNode *CreateDread(const MIRSymbol &st, PrimType pty); virtual MemPool *GetCurrentFuncCodeMp(); virtual MapleAllocator *GetCurrentFuncCodeMpAllocator(); diff --git a/src/maple_ir/include/mir_lower.h b/src/maple_ir/include/mir_lower.h index 45badc3bc79c8cf45a55bca39549f5fa68953c03..f02dd3dca82a05c50644e67528c79aa3d4fa5c8b 100644 --- a/src/maple_ir/include/mir_lower.h +++ b/src/maple_ir/include/mir_lower.h @@ -39,12 +39,11 @@ class MIRLower { public: static const std::set kSetArrayHotFunc; - public: MIRLower(MIRModule &mod, MIRFunction *f) : mirModule(mod), mirFunc(f), mirBuilder(nullptr), lowerPhase(0) {} - virtual ~MIRLower() {} + virtual ~MIRLower() = default; - MIRFunction *GetMirFunc() { + MIRFunction *GetMirFunc() const { return mirFunc; } diff --git a/src/maple_ir/include/mir_module.h b/src/maple_ir/include/mir_module.h index ac010c0864b1154a98b12ceac4fd310968cfe591..4c86e9dcb83feb4cc3f97ef1a4aa0dfb461f2c6e 100644 --- a/src/maple_ir/include/mir_module.h +++ b/src/maple_ir/include/mir_module.h @@ -122,7 +122,6 @@ class MIRModule { const MemPool *GetMemPool() const { return memPool; } - MemPool *GetMemPool() { return memPool; } @@ -130,7 +129,6 @@ class MIRModule { const MapleAllocator &GetMPAllocator() const { return memPoolAllocator; } - MapleAllocator &GetMPAllocator() { return memPoolAllocator; } @@ -138,17 +136,15 @@ class MIRModule { const MapleVector &GetFunctionList() const { return functionList; } - MapleVector &GetFunctionList() { return functionList; } - const MIRFunction *GetFunctionList(int cnt) const { + const MIRFunction *GetFunction(int cnt) const { CHECK_FATAL(cnt < functionList.size(), "array index out of range"); return functionList[cnt]; } - - MIRFunction *GetFunctionList(int cnt) { + MIRFunction *GetFunction(int cnt) { CHECK_FATAL(cnt < functionList.size(), "array index out of range"); return functionList[cnt]; } @@ -157,22 +153,28 @@ class MIRModule { return compilationList; } - MapleVector &GetImportedMplt() { + const MapleVector &GetImportedMplt() const { return importedMplt; } + void PushbackImportedMplt(std::string importFileName) { + importedMplt.push_back(std::move(importFileName)); + } MIRTypeNameTable *GetTypeNameTab() { return typeNameTab; } - MapleVector &GetTypeDefOrder() { + const MapleVector &GetTypeDefOrder() const { return typeDefOrder; } + void PushbackTypeDefOrder(GStrIdx gstrIdx) { + typeDefOrder.push_back(gstrIdx); + } void AddClass(TyIdx t); void RemoveClass(TyIdx t); - inline void SetCurFunction(MIRFunction * const f) { + void SetCurFunction(MIRFunction *f) { curFunction = f; } @@ -180,23 +182,18 @@ class MIRModule { return srcLang; } - MapleSet &GetExternStructTypeSet() { - return externStructTypeSet; - } - - MapleSet &GetSymbolSet() { + const MapleSet &GetSymbolSet() const { return symbolSet; } - MapleVector &GetSymbolDefOrder() { - return symbolDefOrder; - } - void SetSomeSymbolNeedForDecl(bool s) { someSymbolNeedForwDecl = s; } - MIRFunction *CurFunction(void) const; + MIRFunction *CurFunction(void) const { + return curFunction; + } + MemPool *CurFuncCodeMemPool(void) const; MapleAllocator *CurFuncCodeMemPoolAllocator(void) const; MapleAllocator &GetCurFuncCodeMPAllocator(void) const; @@ -209,28 +206,20 @@ class MIRModule { compilationList.push_back(pf); } - MIRFloatConst *GetOrCreateFloatConst(float); // get the const from float_const_table_ or create a new one - MIRDoubleConst *GetOrCreateDoubleConst(double); // get the const from double_const_table_ or create a new one - void InitInfo(); - void DumpInfo(); - void DumpGlobals(bool emitStructureType = true); - void Dump(bool emitStructureType = true); - void DumpToFile(const std::string &fileNameStr, bool emitStructureType = true); - void DumpInlineCandidateToFile(const std::string &fileNameStr); - const std::string &GetFileNameFromFileNum(uint32 fileNum); - - void DumpClassToFile(const char *path); - void DumpFunctionList(bool skipBody = false); - void DumpGlobalArraySymbol(); - void Emit(const std::string &outfileName); + void DumpGlobals(bool emitStructureType = true) const; + void Dump(bool emitStructureType = true) const; + void DumpToFile(const std::string &fileNameStr, bool emitStructureType = true) const; + void DumpInlineCandidateToFile(const std::string &fileNameStr) const; + const std::string &GetFileNameFromFileNum(uint32 fileNum) const; + + void DumpClassToFile(const char *path) const; + void DumpFunctionList(bool skipBody = false) const; + void DumpGlobalArraySymbol() const; + void Emit(const std::string &outfileName) const; uint32 GetAndIncFloatNum() { return floatNum++; } - MIRFunction *GetLastFunction() const { - return functionList.back(); - } - void SetEntryFunction(MIRFunction *f) { entryFunc = f; } @@ -260,16 +249,16 @@ class MIRModule { return srcLang == kSrcLangC || srcLang == kSrcLangCPlusPlus; } - inline void addSuperCall(const std::string &func) { + void addSuperCall(const std::string &func) { superCallSet.insert(func); } - inline bool findSuperCall(const std::string &func) { + bool findSuperCall(const std::string &func) const { return superCallSet.find(func) != superCallSet.end(); } void SetFuncInfoPrinted() const; - size_t GetOptFuncsSize() { + size_t GetOptFuncsSize() const { return optimizedFuncs.size(); } @@ -277,9 +266,12 @@ class MIRModule { return optimizedFuncs.push_back(func); } - MapleMap*> &GetPuIdxFieldInitializedMap() { + const MapleMap*> &GetPuIdxFieldInitializedMap() const { return puIdxFieldInitializedMap; } + void SetPuIdxFieldSet(PUIdx puIdx, MapleSet *fieldIDSet) { + puIdxFieldInitializedMap[puIdx] = fieldIDSet; + } MapleSet *GetPUIdxFieldInitializedMapItem(PUIdx first) { return puIdxFieldInitializedMap[first]; @@ -296,27 +288,20 @@ class MIRModule { const std::string &GetEntryFuncName() const { return entryFuncName; } - - std::string &GetEntryFuncName() { - return entryFuncName; + void SetEntryFuncName(std::string entryFunctionName) { + entryFuncName = std::move(entryFunctionName); } - void SetEntryFuncName(const std::string &entryFunctionName) { - entryFuncName = entryFunctionName; - } - - const TyIdx &GetThrowableTyIdx() const { + TyIdx GetThrowableTyIdx() const { return throwableTyIdx; } - void SetThrowableTyIdx(TyIdx throwableTypeIndex) { throwableTyIdx = throwableTypeIndex; } - bool GetWithProfileInfo() { + bool GetWithProfileInfo() const { return withProfileInfo; } - void SetWithProfileInfo(bool withProfInfo) { withProfileInfo = withProfInfo; } @@ -324,47 +309,54 @@ class MIRModule { BinaryMplt *GetBinMplt() { return binMplt; } - void SetBinMplt(BinaryMplt *binaryMplt) { binMplt = binaryMplt; } - bool IsInIPA() { + bool IsInIPA() const { return inIPA; } - void SetInIPA(bool isInIPA) { inIPA = isInIPA; } - MIRInfoVector &GetFileInfo() { + const MIRInfoVector &GetFileInfo() const { return fileInfo; } - + void PushFileInfoPair(MIRInfoPair pair) { + fileInfo.push_back(pair); + } void SetFileInfo(MIRInfoVector fileInf) { fileInfo = fileInf; } - MapleVector &GetFileInfoIsString() { + const MapleVector &GetFileInfoIsString() const { return fileInfoIsString; } - void SetFileInfoIsString(MapleVector fileInfoIsStr) { fileInfoIsString = fileInfoIsStr; } + void PushFileInfoIsString(bool isString) { + fileInfoIsString.push_back(isString); + } - MIRDataVector &GetFileData() { + const MIRDataVector &GetFileData() const { return fileData; } + void PushbackFileData(MIRDataPair pair) { + fileData.push_back(pair); + } - MIRInfoVector &GetSrcFileInfo() { + const MIRInfoVector &GetSrcFileInfo() const { return srcFileInfo; } + void PushbackFileInfo(const MIRInfoPair &pair) { + srcFileInfo.push_back(pair); + } const MIRFlavor &GetFlavor() const { return flavor; } - void SetFlavor(MIRFlavor flv) { flavor = flv; } @@ -377,10 +369,9 @@ class MIRModule { id = num; } - uint32 GetGlobalMemSize() { + uint32 GetGlobalMemSize() const { return globalMemSize; } - void SetGlobalMemSize(uint32 globalMemberSize) { globalMemSize = globalMemberSize; } @@ -388,7 +379,6 @@ class MIRModule { uint8 *GetGlobalBlockMap() { return globalBlkMap; } - void SetGlobalBlockMap(uint8 *globalBlockMap) { globalBlkMap = globalBlockMap; } @@ -396,7 +386,6 @@ class MIRModule { uint8 *GetGlobalWordsTypeTagged() { return globalWordsTypeTagged; } - void SetGlobalWordsTypeTagged(uint8 *globalWordsTyTagged) { globalWordsTypeTagged = globalWordsTyTagged; } @@ -404,7 +393,6 @@ class MIRModule { uint8 *GetGlobalWordsRefCounted() { return globalWordsRefCounted; } - void SetGlobalWordsRefCounted(uint8 *counted) { globalWordsRefCounted = counted; } @@ -417,19 +405,19 @@ class MIRModule { return importFiles; } - MapleVector &GetImportPaths() { - return importPaths; + void PushbackImportPath(GStrIdx path) { + importPaths.push_back(path); } - MapleSet &GetClassList() { + const MapleSet &GetClassList() const { return classList; } - std::map> &GetMethod2TargetMap() { + const std::map> &GetMethod2TargetMap() const { return method2TargetMap; } - std::vector &GetMemFromMethod2TargetMap(const PUIdx methodPuIdx) { + std::vector &GetMemFromMethod2TargetMap(PUIdx methodPuIdx) { return method2TargetMap[methodPuIdx]; } @@ -437,28 +425,29 @@ class MIRModule { method2TargetMap = map; } - void AddMemToMethod2TargetMap(const PUIdx idx, const std::vector &callSite) { + void AddMemToMethod2TargetMap(PUIdx idx, const std::vector &callSite) { method2TargetMap[idx] = callSite; } - std::map> &GetMethod2TargetHash() { - return method2TargetHash; - } - - std::unordered_set &GetValueFromMethod2TargetHash(const PUIdx idx) { - return method2TargetHash[idx]; + bool HasTargetHash(PUIdx idx, uint64 key) const { + auto it = method2TargetHash.find(idx); + if (it == method2TargetHash.end()) { + return false; + } + return it->second.find(key) != it->second.end(); } - - void SetMethod2TargetHash(const std::map> &map) { - method2TargetHash = map; + void InsertTargetHash(PUIdx idx, uint64 key) { + method2TargetHash[idx].insert(key); } - - void AddValueToMethod2TargetHash(const PUIdx idx, const std::unordered_set &value) { + void AddValueToMethod2TargetHash(PUIdx idx, const std::unordered_set &value) { method2TargetHash[idx] = value; } - std::map &GetEASummary() { - return EASummary; + const std::map &GetEASummary() const { + return eaSummary; + } + void SetEAConnectionGraph(GStrIdx funcNameIdx, EAConnectionGraph *eaCg) { + eaSummary[funcNameIdx] = eaCg; } private: @@ -474,48 +463,48 @@ class MIRModule { MapleSet externStructTypeSet; MapleSet symbolSet; MapleVector symbolDefOrder; - bool someSymbolNeedForwDecl; // some symbols' addressses used in initialization + bool someSymbolNeedForwDecl = false; // some symbols' addressses used in initialization std::ostream &out; MIRBuilder *mirBuilder; - std::string entryFuncName; // name of the entry function + std::string entryFuncName = ""; // name of the entry function std::string fileName; - TyIdx throwableTyIdx; // a special type that is the base of java exception type. only used for java - bool withProfileInfo; + TyIdx throwableTyIdx{0}; // a special type that is the base of java exception type. only used for java + bool withProfileInfo = false; // for cg in mplt - BinaryMplt *binMplt; - bool inIPA; + BinaryMplt *binMplt = nullptr; + bool inIPA = false; MIRInfoVector fileInfo; // store info provided under fileInfo keyword MapleVector fileInfoIsString; // tells if an entry has string value MIRDataVector fileData; MIRInfoVector srcFileInfo; // store info provided under srcFileInfo keyword - MIRFlavor flavor; - MIRSrcLang srcLang; // the source language - uint16 id; - uint32 globalMemSize; // size of storage space for all global variables - uint8 *globalBlkMap; // the memory map of the block containing all the + MIRFlavor flavor = kFlavorUnknown; + MIRSrcLang srcLang = kSrcLangUnknown; // the source language + uint16 id = 0xffff; + uint32 globalMemSize = 0; // size of storage space for all global variables + uint8 *globalBlkMap = nullptr; // the memory map of the block containing all the // globals, for specifying static initializations - uint8 *globalWordsTypeTagged; // bit vector where the Nth bit tells whether + uint8 *globalWordsTypeTagged = nullptr; // bit vector where the Nth bit tells whether // the Nth word in globalBlkMap has typetag; // if yes, the typetag is the N+1th word; the // bitvector's size is given by // BlockSize2BitvectorSize(globalMemSize) - uint8 *globalWordsRefCounted; // bit vector where the Nth bit tells whether + uint8 *globalWordsRefCounted = nullptr; // bit vector where the Nth bit tells whether // the Nth word points to a reference-counted // dynamic memory block; the bitvector's size // is given by BlockSize2BitvectorSize(globalMemSize) - uint32 numFuncs; // because puIdx 0 is reserved, numFuncs is also the highest puIdx + uint32 numFuncs = 0; // because puIdx 0 is reserved, numFuncs is also the highest puIdx MapleVector importFiles; MapleVector importPaths; MapleSet classList; std::map> method2TargetMap; std::map> method2TargetHash; - std::map EASummary; + std::map eaSummary; - MIRFunction *entryFunc; - uint32 floatNum; - MIRFunction *curFunction; + MIRFunction *entryFunc = nullptr; + uint32 floatNum = 0; + MIRFunction *curFunction = nullptr; MapleVector optimizedFuncs; // Add the field for decouple optimization std::unordered_set superCallSet; diff --git a/src/maple_ir/include/mir_nodes.h b/src/maple_ir/include/mir_nodes.h index f4c93f2bfbf57ac9b68246e76f7d303ad41fc09f..27cbb40d70ae7b7847e150456f8d31fd21e64dab 100644 --- a/src/maple_ir/include/mir_nodes.h +++ b/src/maple_ir/include/mir_nodes.h @@ -27,6 +27,7 @@ namespace maple { class MIRPregTable; class TypeTable; + struct RegFieldPair { public: RegFieldPair() : fieldID(0), pregIdx(0) {} @@ -103,7 +104,7 @@ class BaseNode { LogInfo::MapleLogger() << std::endl; } - virtual uint8 SizeOfInstr() { + virtual uint8 SizeOfInstr() const { return kOpcodeInfo.GetTableItemAt(GetOpCode()).instrucSize; } @@ -146,7 +147,7 @@ class BaseNode { ASSERT(0, "This should not happen"); } - virtual bool IsLeaf(void) { + virtual bool IsLeaf(void) const { return true; } @@ -158,11 +159,11 @@ class BaseNode { return nullptr; } - virtual bool IsUnaryNode(void) { + virtual bool IsUnaryNode(void) const { return false; } - virtual bool IsBinaryNode(void) { + virtual bool IsBinaryNode(void) const { return false; } @@ -215,11 +216,11 @@ class UnaryNode : public BaseNode { uOpnd = node; } - bool IsLeaf(void) { + bool IsLeaf(void) const { return false; } - bool IsUnaryNode(void) { + bool IsUnaryNode(void) const { return true; } @@ -520,26 +521,26 @@ class BinaryOpnds { virtual void Dump(const MIRModule &mod, int32 indent) const; BaseNode *GetBOpnd(int32 i) const { - CHECK_FATAL(i >= 0 && i < 2, "Invalid operand idx in BinaryOpnds"); + CHECK_FATAL(i >= 0 && i < kOperandNumBinary, "Invalid operand idx in BinaryOpnds"); return bOpnd[i]; } void SetBOpnd(BaseNode *node, int32 i) { - CHECK_FATAL(i >= 0 && i < 2, "Invalid operand idx in BinaryOpnds"); + CHECK_FATAL(i >= 0 && i < kOperandNumBinary, "Invalid operand idx in BinaryOpnds"); bOpnd[i] = node; } private: - BaseNode *bOpnd[2]; + BaseNode *bOpnd[kOperandNumBinary]; }; class BinaryNode : public BaseNode, public BinaryOpnds { public: - explicit BinaryNode(Opcode o) : BaseNode(o, 2) {} + explicit BinaryNode(Opcode o) : BaseNode(o, kOperandNumBinary) {} - BinaryNode(Opcode o, PrimType typ) : BaseNode(o, typ, 2) {} + BinaryNode(Opcode o, PrimType typ) : BaseNode(o, typ, kOperandNumBinary) {} - BinaryNode(Opcode o, PrimType typ, BaseNode *l, BaseNode *r) : BaseNode(o, typ, 2) { + BinaryNode(Opcode o, PrimType typ, BaseNode *l, BaseNode *r) : BaseNode(o, typ, kOperandNumBinary) { SetBOpnd(l, 0); SetBOpnd(r, 1); } @@ -573,24 +574,24 @@ class BinaryNode : public BaseNode, public BinaryOpnds { } BaseNode *Opnd(size_t i) const { - ASSERT(i < 2, "invalid operand idx in BinaryNode"); + ASSERT(i < kOperandNumBinary, "invalid operand idx in BinaryNode"); ASSERT(i >= 0, "invalid operand idx in BinaryNode"); return GetBOpnd(i); } uint8 NumOpnds(void) const { - return 2; + return kOperandNumBinary; } void SetOpnd(BaseNode *node, size_t i = 0) { SetBOpnd(node, i); } - bool IsLeaf(void) { + bool IsLeaf(void) const { return false; } - bool IsBinaryNode(void) { + bool IsBinaryNode(void) const { return true; } }; @@ -718,19 +719,19 @@ class ResolveFuncNode : public BinaryNode { class TernaryNode : public BaseNode { public: - explicit TernaryNode(Opcode o) : BaseNode(o, kOprandNumTernary) { + explicit TernaryNode(Opcode o) : BaseNode(o, kOperandNumTernary) { topnd[0] = nullptr; topnd[1] = nullptr; topnd[2] = nullptr; } - TernaryNode(Opcode o, PrimType typ) : BaseNode(o, typ, kOprandNumTernary) { + TernaryNode(Opcode o, PrimType typ) : BaseNode(o, typ, kOperandNumTernary) { topnd[0] = nullptr; topnd[1] = nullptr; topnd[2] = nullptr; } - TernaryNode(Opcode o, PrimType typ, BaseNode *e0, BaseNode *e1, BaseNode *e2) : BaseNode(o, typ, kOprandNumTernary) { + TernaryNode(Opcode o, PrimType typ, BaseNode *e0, BaseNode *e1, BaseNode *e2) : BaseNode(o, typ, kOperandNumTernary) { topnd[0] = e0; topnd[1] = e1; topnd[2] = e2; @@ -750,25 +751,25 @@ class TernaryNode : public BaseNode { } BaseNode *Opnd(size_t i) const { - CHECK_FATAL(i < 3, "array index out of range"); + CHECK_FATAL(i < kOperandNumTernary, "array index out of range"); return topnd[i]; } uint8 NumOpnds(void) const { - return kOprandNumTernary; + return kOperandNumTernary; } void SetOpnd(BaseNode *node, size_t i = 0) { - CHECK_FATAL(i < kOprandNumTernary, "array index out of range"); + CHECK_FATAL(i < kOperandNumTernary, "array index out of range"); topnd[i] = node; } - bool IsLeaf(void) { + bool IsLeaf(void) const { return false; } private: - BaseNode *topnd[kOprandNumTernary]; + BaseNode *topnd[kOperandNumTernary]; }; class NaryOpnds { @@ -853,7 +854,7 @@ class NaryNode : public BaseNode, public NaryOpnds { SetNOpndAt(i, node); } - bool IsLeaf(void) { + bool IsLeaf(void) const { return false; } @@ -864,10 +865,10 @@ class NaryNode : public BaseNode, public NaryOpnds { class IntrinsicopNode : public NaryNode { public: - explicit IntrinsicopNode(MapleAllocator &allocator, Opcode o, TyIdx typeIdx = TyIdx()) + IntrinsicopNode(MapleAllocator &allocator, Opcode o, TyIdx typeIdx = TyIdx()) : NaryNode(allocator, o), intrinsic(INTRN_UNDEFINED), tyIdx(typeIdx) {} - explicit IntrinsicopNode(const MIRModule &mod, Opcode o, TyIdx typeIdx = TyIdx()) + IntrinsicopNode(const MIRModule &mod, Opcode o, TyIdx typeIdx = TyIdx()) : IntrinsicopNode(mod.GetCurFuncCodeMPAllocator(), o, typeIdx) {} IntrinsicopNode(MapleAllocator &allocator, Opcode o, PrimType typ, TyIdx typeIdx = TyIdx()) @@ -914,9 +915,8 @@ class IntrinsicopNode : public NaryNode { tyIdx = idx; } - MIRIntrinsicID intrinsic; - private: + MIRIntrinsicID intrinsic; TyIdx tyIdx; }; @@ -1209,9 +1209,9 @@ using DreadNode = AddrofNode; class RegreadNode : public BaseNode { public: - explicit RegreadNode() : BaseNode(OP_regread), regIdx(0) {} + RegreadNode() : BaseNode(OP_regread), regIdx(0) {} - RegreadNode(PregIdx pIdx) : BaseNode(OP_regread), regIdx(pIdx) {} + explicit RegreadNode(PregIdx pIdx) : BaseNode(OP_regread), regIdx(pIdx) {} RegreadNode(PrimType primType, PregIdx pIdx) : RegreadNode(pIdx) { ptyp = primType; @@ -1443,7 +1443,7 @@ class IassignNode : public StmtNode { IassignNode(TyIdx tyIdx, FieldID fieldID, BaseNode *addrOpnd, BaseNode *rhsOpnd) : StmtNode(OP_iassign), tyIdx(tyIdx), fieldID(fieldID), addrExpr(addrOpnd), rhs(rhsOpnd) { - SetNumOpnds(kOprandNumBinary); + SetNumOpnds(kOperandNumBinary); } ~IassignNode() = default; @@ -1472,7 +1472,7 @@ class IassignNode : public StmtNode { } uint8 NumOpnds(void) const { - return 2; + return kOperandNumBinary; } void SetOpnd(BaseNode *node, size_t i) { @@ -1595,7 +1595,7 @@ class TryNode : public StmtNode { public: explicit TryNode(MapleAllocator &allocator) : StmtNode(OP_try), offsets(allocator.Adapter()) {} - TryNode(const MapleVector &offsets) : StmtNode(OP_try), offsets(offsets) {} + explicit TryNode(const MapleVector &offsets) : StmtNode(OP_try), offsets(offsets) {} explicit TryNode(const MIRModule &mod) : TryNode(mod.GetCurFuncCodeMPAllocator()) {} @@ -1663,7 +1663,7 @@ class CatchNode : public StmtNode { public: explicit CatchNode(MapleAllocator &allocator) : StmtNode(OP_catch), exceptionTyIdxVec(allocator.Adapter()) {} - CatchNode(const MapleVector &tyIdxVec) + explicit CatchNode(const MapleVector &tyIdxVec) : StmtNode(OP_catch), exceptionTyIdxVec(tyIdxVec) {} explicit CatchNode(const MIRModule &mod) : CatchNode(mod.GetCurFuncCodeMPAllocator()) {} @@ -1789,7 +1789,7 @@ class SwitchNode : public StmtNode { return switchTable; } - CasePair GetCasePair(size_t idx) { + CasePair GetCasePair(size_t idx) const { ASSERT(idx < switchTable.size(), "out of range in SwitchNode::GetCasePair"); return switchTable.at(idx); } @@ -1899,7 +1899,7 @@ class UnaryStmtNode : public StmtNode { return nd; } - bool IsLeaf(void) { + bool IsLeaf(void) const { return false; } @@ -2045,7 +2045,7 @@ class CondGotoNode : public UnaryStmtNode { explicit CondGotoNode(Opcode o) : CondGotoNode(o, 0, nullptr) {} CondGotoNode(Opcode o, uint32 offset, BaseNode *opnd) : UnaryStmtNode(o, kPtyInvalid, opnd), offset(offset) { - SetNumOpnds(kOprandNumUnary); + SetNumOpnds(kOperandNumUnary); } ~CondGotoNode() = default; @@ -2116,7 +2116,7 @@ class RangegotoNode : public UnaryStmtNode { rangegotoTable.push_back(SmallCasePair(tag, idx)); } - int32 GetTagOffset() { + int32 GetTagOffset() const { return tagOffset; } @@ -2234,7 +2234,7 @@ class BlockNode : public StmtNode { class IfStmtNode : public UnaryStmtNode { public: IfStmtNode() : UnaryStmtNode(OP_if), thenPart(nullptr), elsePart(nullptr) { - numOpnds = kOprandNumBinary; + numOpnds = kOperandNumBinary; } ~IfStmtNode() = default; @@ -2260,7 +2260,7 @@ class IfStmtNode : public UnaryStmtNode { return thenPart; } else if (i == 2) { ASSERT(elsePart != nullptr, "IfStmtNode has wrong numOpnds field, the elsePart is nullptr"); - ASSERT(numOpnds == kOprandNumTernary, "IfStmtNode has wrong numOpnds field, the elsePart is nullptr"); + ASSERT(numOpnds == kOperandNumTernary, "IfStmtNode has wrong numOpnds field, the elsePart is nullptr"); return elsePart; } ASSERT(false, "IfStmtNode has wrong numOpnds field: %u", NumOpnds()); @@ -2296,7 +2296,7 @@ class IfStmtNode : public UnaryStmtNode { class WhileStmtNode : public UnaryStmtNode { public: explicit WhileStmtNode(Opcode o) : UnaryStmtNode(o), body(nullptr) { - SetNumOpnds(kOprandNumBinary); + SetNumOpnds(kOperandNumBinary); } ~WhileStmtNode() = default; @@ -2329,7 +2329,7 @@ class DoloopNode : public StmtNode { DoloopNode() : DoloopNode(StIdx(), false, nullptr, nullptr, nullptr, nullptr) {} DoloopNode(StIdx doVarStIdx, bool isPReg, BaseNode *startExp, BaseNode *contExp, BaseNode *incrExp, BlockNode *doBody) - : StmtNode(OP_doloop, 4), + : StmtNode(OP_doloop, kOperandNumDoloop), doVarStIdx(doVarStIdx), isPreg(isPReg), startExpr(startExp), @@ -2419,7 +2419,7 @@ class DoloopNode : public StmtNode { } uint8 NumOpnds(void) const { - return 4; + return kOperandNumDoloop; } void SetOpnd(BaseNode *node, size_t i) { @@ -2437,6 +2437,7 @@ class DoloopNode : public StmtNode { } private: + static constexpr int kOperandNumDoloop = 4; StIdx doVarStIdx; // must be local; cast to PregIdx for preg bool isPreg; BaseNode *startExpr; @@ -2448,7 +2449,7 @@ class DoloopNode : public StmtNode { class ForeachelemNode : public StmtNode { public: ForeachelemNode() : StmtNode(OP_foreachelem), loopBody(nullptr) { - SetNumOpnds(kOprandNumUnary); + SetNumOpnds(kOperandNumUnary); } ~ForeachelemNode() = default; @@ -2503,7 +2504,7 @@ class ForeachelemNode : public StmtNode { // used by assertge, assertlt class BinaryStmtNode : public StmtNode, public BinaryOpnds { public: - explicit BinaryStmtNode(Opcode o) : StmtNode(o, 2) {} + explicit BinaryStmtNode(Opcode o) : StmtNode(o, kOperandNumBinary) {} ~BinaryStmtNode() = default; @@ -2518,28 +2519,26 @@ class BinaryStmtNode : public StmtNode, public BinaryOpnds { } BaseNode *Opnd(size_t i) const { - ASSERT(i < 2, "Invalid operand idx in BinaryStmtNode"); + ASSERT(i < kOperandNumBinary, "Invalid operand idx in BinaryStmtNode"); ASSERT(i >= 0, "Invalid operand idx in BinaryStmtNode"); return GetBOpnd(i); } uint8 NumOpnds(void) const { - return 2; + return kOperandNumBinary; } void SetOpnd(BaseNode *node, size_t i) { SetBOpnd(node, i); } - bool IsLeaf(void) { + bool IsLeaf(void) const { return false; } }; class IassignoffNode : public BinaryStmtNode { public: - int32 offset; - IassignoffNode() : BinaryStmtNode(OP_iassignoff), offset(0) {} explicit IassignoffNode(int32 ofst) : BinaryStmtNode(OP_iassignoff), offset(ofst) {} @@ -2562,6 +2561,17 @@ class IassignoffNode : public BinaryStmtNode { nd->SetBOpnd(GetBOpnd(1)->CloneTree(allocator), 1); return nd; } + + int32 GetOffset() const { + return offset; + } + + void SetOffset(int32 newOffset) { + offset = newOffset; + } + + private: + int32 offset; }; class IassignFPoffNode : public UnaryStmtNode { @@ -2732,7 +2742,7 @@ class CallNode : public NaryStmtNode { return returnValues; } - CallReturnPair GetReturnPair(size_t idx) { + CallReturnPair GetReturnPair(size_t idx) const { ASSERT(idx < returnValues.size(), "out of range in CallNode::GetReturnPair"); return returnValues.at(idx); } @@ -2778,12 +2788,12 @@ class IcallNode : public NaryStmtNode { public: IcallNode(MapleAllocator &allocator, Opcode o) : NaryStmtNode(allocator, o), retTyIdx(0), returnValues(allocator.Adapter()) { - SetNumOpnds(kOprandNumUnary); + SetNumOpnds(kOperandNumUnary); } IcallNode(MapleAllocator &allocator, Opcode o, TyIdx idx) : NaryStmtNode(allocator, o), retTyIdx(idx), returnValues(allocator.Adapter()) { - SetNumOpnds(kOprandNumUnary); + SetNumOpnds(kOperandNumUnary); } IcallNode(const MIRModule &mod, Opcode o) : IcallNode(mod.GetCurFuncCodeMPAllocator(), o) {} diff --git a/src/maple_ir/include/mir_parser.h b/src/maple_ir/include/mir_parser.h index a06b751fcd9e4bdb4952848360ca5b0ae5b6e341..2f04a3629a3de8978a2dc06d43e2a2e671c8350d 100644 --- a/src/maple_ir/include/mir_parser.h +++ b/src/maple_ir/include/mir_parser.h @@ -68,7 +68,7 @@ class MIRParser { PrimType GetPrimitiveType(TokenKind tk) const; MIRIntrinsicID GetIntrinsicId(TokenKind tk) const; bool ParseScalarValue(MIRConstPtr&, MIRType*); - bool ParseConstAddrLeafExpr(MIRConstPtr&, MIRType*); + bool ParseConstAddrLeafExpr(MIRConstPtr&, MIRType&); bool ParseInitValue(MIRConstPtr&, TyIdx); bool ParseDeclaredSt(StIdx&); bool ParseDeclaredFunc(PUIdx&); @@ -173,7 +173,7 @@ class MIRParser { bool ParseExprConststr16(BaseNodePtr &expr); bool ParseExprSizeoftype(BaseNodePtr &expr); bool ParseExprFieldsDist(BaseNodePtr &expr); - bool ParseExprIreadIaddrof(IreadNode *expr); + bool ParseExprIreadIaddrof(IreadNode &expr); bool ParseExprIread(BaseNodePtr &expr); bool ParseExprIreadoff(BaseNodePtr &expr); bool ParseExprIreadFPoff(BaseNodePtr &expr); @@ -194,7 +194,7 @@ class MIRParser { bool ParseTypedef(); bool ParseJavaClassInterface(MIRSymbol&, bool); - bool ParseIntrinsicId(IntrinsicopNode*); + bool ParseIntrinsicId(IntrinsicopNode&); void Error(const std::string&); void Warning(const std::string&); void FixupForwardReferencedTypeByMap(); diff --git a/src/maple_ir/include/mir_pragma.h b/src/maple_ir/include/mir_pragma.h index 60b57a4b18a17bf03a02e888454bde7bebfd729e..97e587f460d1072c127e96496eba92a8dab4d9bf 100644 --- a/src/maple_ir/include/mir_pragma.h +++ b/src/maple_ir/include/mir_pragma.h @@ -78,8 +78,8 @@ class MIRPragmaElement { ~MIRPragmaElement() = default; void Dump(int indent); - void PushSubElemVec(MIRPragmaElement *elem) { - subElemVec.push_back(elem); + void PushSubElemVec(MIRPragmaElement &elem) { + subElemVec.push_back(&elem); } const MapleVector &GetSubElemVec() const { @@ -188,8 +188,8 @@ class MIRPragma { ~MIRPragma() = default; MIRPragmaElement *GetPragmaElemFromSignature(const std::string &signature); void Dump(int indent); - void PushElementVector(MIRPragmaElement *elem) { - elementVec.push_back(elem); + void PushElementVector(MIRPragmaElement &elem) { + elementVec.push_back(&elem); } void ClearElementVector() { diff --git a/src/maple_ir/include/types_def.h b/src/maple_ir/include/types_def.h index c243e18970b807d645a6f2470fd882573c829ba8..c957440cdfe52847be622d2b13f988ec29095728 100644 --- a/src/maple_ir/include/types_def.h +++ b/src/maple_ir/include/types_def.h @@ -269,8 +269,8 @@ class U16StrIdx { // user string table index (from the conststr opcode) private: uint32 idx; }; -constexpr int kOprandNumUnary = 1; -constexpr int kOprandNumBinary = 2; -constexpr int kOprandNumTernary = 3; +constexpr int kOperandNumUnary = 1; +constexpr int kOperandNumBinary = 2; +constexpr int kOperandNumTernary = 3; } // namespace maple #endif // MAPLE_IR_INCLUDE_TYPES_DEF_H diff --git a/src/maple_ir/src/bin_mpl_export.cpp b/src/maple_ir/src/bin_mpl_export.cpp index 6782775b48304e975e9754297423f2845346628f..32aab6487cee23f05a7c43541fed2553ddf75757 100644 --- a/src/maple_ir/src/bin_mpl_export.cpp +++ b/src/maple_ir/src/bin_mpl_export.cpp @@ -26,90 +26,90 @@ namespace { using namespace maple; -using OutputConstFactory = FunctionFactory; -using OutputTypeFactory = FunctionFactory; +using OutputConstFactory = FunctionFactory; +using OutputTypeFactory = FunctionFactory; -void OutputConstInt(MIRConst *constVal, BinaryMplExport *mplExport) { - mplExport->WriteNum(kBinKindConstInt); - mplExport->OutputConstBase(*constVal); - mplExport->WriteNum(static_cast(constVal)->GetValue()); +void OutputConstInt(MIRConst &constVal, BinaryMplExport &mplExport) { + mplExport.WriteNum(kBinKindConstInt); + mplExport.OutputConstBase(constVal); + mplExport.WriteNum(static_cast(&constVal)->GetValue()); } -void OutputConstAddrof(MIRConst *constVal, BinaryMplExport *mplExport) { - mplExport->WriteNum(kBinKindConstAddrof); - mplExport->OutputConstBase(*constVal); - MIRAddrofConst *addrof = static_cast(constVal); - mplExport->OutputSymbol(mplExport->GetMIRModule().CurFunction()->GetLocalOrGlobalSymbol(addrof->GetSymbolIndex())); - mplExport->WriteNum(addrof->GetFieldID()); +void OutputConstAddrof(MIRConst &constVal, BinaryMplExport &mplExport) { + mplExport.WriteNum(kBinKindConstAddrof); + mplExport.OutputConstBase(constVal); + MIRAddrofConst *addrof = static_cast(&constVal); + mplExport.OutputSymbol(mplExport.GetMIRModule().CurFunction()->GetLocalOrGlobalSymbol(addrof->GetSymbolIndex())); + mplExport.WriteNum(addrof->GetFieldID()); } -void OutputConstAddrofFunc(MIRConst *constVal, BinaryMplExport *mplExport) { - mplExport->WriteNum(kBinKindConstAddrofFunc); - mplExport->OutputConstBase(*constVal); - MIRAddroffuncConst *addrfunc = static_cast(constVal); - mplExport->OutputFunction(addrfunc->GetValue()); +void OutputConstAddrofFunc(MIRConst &constVal, BinaryMplExport &mplExport) { + mplExport.WriteNum(kBinKindConstAddrofFunc); + mplExport.OutputConstBase(constVal); + MIRAddroffuncConst *addrfunc = static_cast(&constVal); + mplExport.OutputFunction(addrfunc->GetValue()); } -void OutputConstLbl(MIRConst *constVal, BinaryMplExport *mplExport) { +void OutputConstLbl(MIRConst &constVal, BinaryMplExport &mplExport) { ASSERT(false, "NYI"); } -void OutputConstStr(MIRConst *constVal, BinaryMplExport *mplExport) { - mplExport->WriteNum(kBinKindConstStr); - mplExport->OutputConstBase(*constVal); - MIRStrConst *strc = static_cast(constVal); - mplExport->OutputUsrStr(strc->GetValue()); +void OutputConstStr(MIRConst &constVal, BinaryMplExport &mplExport) { + mplExport.WriteNum(kBinKindConstStr); + mplExport.OutputConstBase(constVal); + MIRStrConst *strc = static_cast(&constVal); + mplExport.OutputUsrStr(strc->GetValue()); } -void OutputConstStr16(MIRConst *constVal, BinaryMplExport *mplExport) { - mplExport->WriteNum(kBinKindConstStr16); - mplExport->OutputConstBase(*constVal); - MIRStr16Const *mirStr16 = static_cast(constVal); +void OutputConstStr16(MIRConst &constVal, BinaryMplExport &mplExport) { + mplExport.WriteNum(kBinKindConstStr16); + mplExport.OutputConstBase(constVal); + MIRStr16Const *mirStr16 = static_cast(&constVal); std::u16string str16 = GlobalTables::GetU16StrTable().GetStringFromStrIdx(mirStr16->GetValue()); std::string str; NameMangler::UTF16ToUTF8(str, str16); - mplExport->WriteNum(str.length()); + mplExport.WriteNum(str.length()); for (uint64 i = 0; i < str.length(); i++) { - mplExport->Write(static_cast(str[i])); + mplExport.Write(static_cast(str[i])); } } -void OutputConstFloat(MIRConst *constVal, BinaryMplExport *mplExport) { - mplExport->WriteNum(kBinKindConstFloat); - MIRFloatConst *fconst = static_cast(constVal); - mplExport->WriteNum(fconst->GetIntValue()); +void OutputConstFloat(MIRConst &constVal, BinaryMplExport &mplExport) { + mplExport.WriteNum(kBinKindConstFloat); + MIRFloatConst *fconst = static_cast(&constVal); + mplExport.WriteNum(fconst->GetIntValue()); } -void OutputConstDouble(MIRConst *constVal, BinaryMplExport *mplExport) { - mplExport->WriteNum(kBinKindConstDouble); - MIRDoubleConst *dconst = static_cast(constVal); - mplExport->WriteNum(dconst->GetIntValue()); +void OutputConstDouble(MIRConst &constVal, BinaryMplExport &mplExport) { + mplExport.WriteNum(kBinKindConstDouble); + MIRDoubleConst *dconst = static_cast(&constVal); + mplExport.WriteNum(dconst->GetIntValue()); } -void OutputConstAgg(MIRConst *constVal, BinaryMplExport *mplExport) { - mplExport->WriteNum(kBinKindConstAgg); - mplExport->OutputConstBase(*constVal); - MIRAggConst *aggConst = static_cast(constVal); +void OutputConstAgg(MIRConst &constVal, BinaryMplExport &mplExport) { + mplExport.WriteNum(kBinKindConstAgg); + mplExport.OutputConstBase(constVal); + MIRAggConst *aggConst = static_cast(&constVal); size_t size = aggConst->GetConstVec().size(); - mplExport->WriteNum(size); + mplExport.WriteNum(size); for (size_t i = 0; i < size; i++) { - mplExport->OutputConst(aggConst->GetConstVecItem(i)); + mplExport.OutputConst(aggConst->GetConstVecItem(i)); } } -void OutputConstSt(MIRConst *constVal, BinaryMplExport *mplExport) { - mplExport->WriteNum(kBinKindConstSt); - mplExport->OutputConstBase(*constVal); - MIRStConst *stConst = static_cast(constVal); +void OutputConstSt(MIRConst &constVal, BinaryMplExport &mplExport) { + mplExport.WriteNum(kBinKindConstSt); + mplExport.OutputConstBase(constVal); + MIRStConst *stConst = static_cast(&constVal); size_t size = stConst->GetStVec().size(); - mplExport->WriteNum(size); + mplExport.WriteNum(size); for (size_t i = 0; i < size; i++) { - mplExport->OutputSymbol(stConst->GetStVecItem(i)); + mplExport.OutputSymbol(stConst->GetStVecItem(i)); } size = stConst->GetStOffsetVec().size(); - mplExport->WriteNum(size); + mplExport.WriteNum(size); for (size_t i = 0; i < size; i++) { - mplExport->WriteNum(stConst->GetStOffsetVecItem(i)); + mplExport.WriteNum(stConst->GetStOffsetVecItem(i)); } } @@ -126,144 +126,144 @@ void InitOutputConstFactory() { RegisterFactoryFunction(kConstStConst, OutputConstSt); } -void OutputTypeScalar(MIRType *ty, BinaryMplExport *mplExport) { - mplExport->WriteNum(kBinKindTypeScalar); - mplExport->OutputTypeBase(*ty); +void OutputTypeScalar(MIRType &ty, BinaryMplExport &mplExport) { + mplExport.WriteNum(kBinKindTypeScalar); + mplExport.OutputTypeBase(ty); } -void OutputTypePointer(MIRType *ty, BinaryMplExport *mplExport) { - MIRPtrType *type = static_cast(ty); - mplExport->WriteNum(kBinKindTypePointer); - mplExport->OutputTypeBase(*type); - mplExport->OutputType(type->GetPointedTyIdx()); +void OutputTypePointer(MIRType &ty, BinaryMplExport &mplExport) { + MIRPtrType *type = static_cast(&ty); + mplExport.WriteNum(kBinKindTypePointer); + mplExport.OutputTypeBase(*type); + mplExport.OutputType(type->GetPointedTyIdx()); } -void OutputTypeByName(MIRType *ty, BinaryMplExport *mplExport) { - MIRTypeByName *type = static_cast(ty); - mplExport->WriteNum(kBinKindTypeByName); - mplExport->OutputTypeBase(*type); +void OutputTypeByName(MIRType &ty, BinaryMplExport &mplExport) { + MIRTypeByName *type = static_cast(&ty); + mplExport.WriteNum(kBinKindTypeByName); + mplExport.OutputTypeBase(*type); } -void OutputTypeFArray(MIRType *ty, BinaryMplExport *mplExport) { - MIRFarrayType *type = static_cast(ty); - mplExport->WriteNum(kBinKindTypeFArray); - mplExport->OutputTypeBase(*type); - mplExport->OutputType(type->GetElemTyIdx()); +void OutputTypeFArray(MIRType &ty, BinaryMplExport &mplExport) { + MIRFarrayType *type = static_cast(&ty); + mplExport.WriteNum(kBinKindTypeFArray); + mplExport.OutputTypeBase(*type); + mplExport.OutputType(type->GetElemTyIdx()); } -void OutputTypeJArray(MIRType *ty, BinaryMplExport *mplExport) { - MIRJarrayType *type = static_cast(ty); - mplExport->WriteNum(kBinKindTypeJarray); - mplExport->OutputTypeBase(*type); - mplExport->OutputType(type->GetElemTyIdx()); +void OutputTypeJArray(MIRType &ty, BinaryMplExport &mplExport) { + MIRJarrayType *type = static_cast(&ty); + mplExport.WriteNum(kBinKindTypeJarray); + mplExport.OutputTypeBase(*type); + mplExport.OutputType(type->GetElemTyIdx()); } -void OutputTypeArray(MIRType *ty, BinaryMplExport *mplExport) { - MIRArrayType *type = static_cast(ty); - mplExport->WriteNum(kBinKindTypeArray); - mplExport->OutputTypeBase(*type); - mplExport->WriteNum(type->GetDim()); +void OutputTypeArray(MIRType &ty, BinaryMplExport &mplExport) { + MIRArrayType *type = static_cast(&ty); + mplExport.WriteNum(kBinKindTypeArray); + mplExport.OutputTypeBase(*type); + mplExport.WriteNum(type->GetDim()); for (int i = 0; i < type->GetDim(); i++) { - mplExport->WriteNum(type->GetSizeArrayItem(i)); + mplExport.WriteNum(type->GetSizeArrayItem(i)); } - mplExport->OutputType(type->GetElemTyIdx()); + mplExport.OutputType(type->GetElemTyIdx()); } -void OutputTypeFunction(MIRType *ty, BinaryMplExport *mplExport) { - MIRFuncType *type = static_cast(ty); - mplExport->WriteNum(kBinKindTypeFunction); - mplExport->OutputTypeBase(*type); - mplExport->OutputType(type->GetRetTyIdx()); - mplExport->WriteNum(type->IsVarargs()); +void OutputTypeFunction(MIRType &ty, BinaryMplExport &mplExport) { + MIRFuncType *type = static_cast(&ty); + mplExport.WriteNum(kBinKindTypeFunction); + mplExport.OutputTypeBase(*type); + mplExport.OutputType(type->GetRetTyIdx()); + mplExport.WriteNum(type->IsVarargs()); size_t size = type->GetParamTypeList().size(); - mplExport->WriteNum(size); + mplExport.WriteNum(size); for (size_t i = 0; i < size; i++) { - mplExport->OutputType(type->GetParamTypeList()[i]); + mplExport.OutputType(type->GetParamTypeList()[i]); } size = type->GetParamAttrsList().size(); - mplExport->WriteNum(size); + mplExport.WriteNum(size); for (size_t i = 0; i < size; i++) { - mplExport->OutputTypeAttrs(type->GetParamAttrsList()[i]); + mplExport.OutputTypeAttrs(type->GetParamAttrsList()[i]); } } -void OutputTypeParam(MIRType *ty, BinaryMplExport *mplExport) { - MIRTypeParam *type = static_cast(ty); - mplExport->WriteNum(kBinKindTypeParam); - mplExport->OutputTypeBase(*type); +void OutputTypeParam(MIRType &ty, BinaryMplExport &mplExport) { + MIRTypeParam *type = static_cast(&ty); + mplExport.WriteNum(kBinKindTypeParam); + mplExport.OutputTypeBase(*type); } -void OutputTypeInstantVector(MIRType *ty, BinaryMplExport *mplExport) { - MIRInstantVectorType *type = static_cast(ty); - mplExport->WriteNum(kBinKindTypeInstantVector); - mplExport->OutputTypeBase(*type); - mplExport->WriteNum(ty->GetKind()); - mplExport->OutputTypePairs(*type); +void OutputTypeInstantVector(MIRType &ty, BinaryMplExport &mplExport) { + MIRInstantVectorType *type = static_cast(&ty); + mplExport.WriteNum(kBinKindTypeInstantVector); + mplExport.OutputTypeBase(*type); + mplExport.WriteNum(ty.GetKind()); + mplExport.OutputTypePairs(*type); } -void OutputTypeGenericInstant(MIRType *ty, BinaryMplExport *mplExport) { - MIRGenericInstantType *type = static_cast(ty); - mplExport->WriteNum(kBinKindTypeGenericInstant); - mplExport->OutputTypeBase(*type); - mplExport->OutputTypePairs(*type); - mplExport->OutputType(type->GetGenericTyIdx()); +void OutputTypeGenericInstant(MIRType &ty, BinaryMplExport &mplExport) { + MIRGenericInstantType *type = static_cast(&ty); + mplExport.WriteNum(kBinKindTypeGenericInstant); + mplExport.OutputTypeBase(*type); + mplExport.OutputTypePairs(*type); + mplExport.OutputType(type->GetGenericTyIdx()); } -void OutputTypeBitField(MIRType *ty, BinaryMplExport *mplExport) { - MIRBitFieldType *type = static_cast(ty); - mplExport->WriteNum(kBinKindTypeBitField); - mplExport->OutputTypeBase(*type); - mplExport->WriteNum(type->GetFieldSize()); +void OutputTypeBitField(MIRType &ty, BinaryMplExport &mplExport) { + MIRBitFieldType *type = static_cast(&ty); + mplExport.WriteNum(kBinKindTypeBitField); + mplExport.OutputTypeBase(*type); + mplExport.WriteNum(type->GetFieldSize()); } // for Struct/StructIncomplete/Union -void OutputTypeStruct(MIRType *ty, BinaryMplExport *mplExport) { - MIRStructType *type = static_cast(ty); - mplExport->WriteNum(kBinKindTypeStruct); - mplExport->OutputTypeBase(*type); - MIRTypeKind kind = ty->GetKind(); +void OutputTypeStruct(MIRType &ty, BinaryMplExport &mplExport) { + MIRStructType *type = static_cast(&ty); + mplExport.WriteNum(kBinKindTypeStruct); + mplExport.OutputTypeBase(*type); + MIRTypeKind kind = ty.GetKind(); if (type->IsImported()) { - CHECK_FATAL(ty->GetKind() != kTypeUnion, "must be"); + CHECK_FATAL(ty.GetKind() != kTypeUnion, "must be"); kind = kTypeStructIncomplete; } - mplExport->WriteNum(kind); + mplExport.WriteNum(kind); if (kind != kTypeStructIncomplete) { - mplExport->OutputStructTypeData(type); + mplExport.OutputStructTypeData(*type); } } -void OutputTypeClass(MIRType *ty, BinaryMplExport *mplExport) { - MIRClassType *type = static_cast(ty); - mplExport->WriteNum(kBinKindTypeClass); - mplExport->OutputTypeBase(*type); - MIRTypeKind kind = ty->GetKind(); +void OutputTypeClass(MIRType &ty, BinaryMplExport &mplExport) { + MIRClassType *type = static_cast(&ty); + mplExport.WriteNum(kBinKindTypeClass); + mplExport.OutputTypeBase(*type); + MIRTypeKind kind = ty.GetKind(); if (type->IsImported()) { kind = kTypeClassIncomplete; } - mplExport->WriteNum(kind); + mplExport.WriteNum(kind); if (kind != kTypeClassIncomplete) { - mplExport->OutputStructTypeData(type); - mplExport->OutputClassTypeData(type); + mplExport.OutputStructTypeData(*type); + mplExport.OutputClassTypeData(*type); } } -void OutputTypeInterface(MIRType *ty, BinaryMplExport *mplExport) { - MIRInterfaceType *type = static_cast(ty); - mplExport->WriteNum(kBinKindTypeInterface); - mplExport->OutputTypeBase(*type); - MIRTypeKind kind = ty->GetKind(); +void OutputTypeInterface(MIRType &ty, BinaryMplExport &mplExport) { + MIRInterfaceType *type = static_cast(&ty); + mplExport.WriteNum(kBinKindTypeInterface); + mplExport.OutputTypeBase(*type); + MIRTypeKind kind = ty.GetKind(); if (type->IsImported()) { kind = kTypeInterfaceIncomplete; } - mplExport->WriteNum(kind); + mplExport.WriteNum(kind); if (kind != kTypeInterfaceIncomplete) { - mplExport->OutputStructTypeData(type); - mplExport->OutputInterfaceTypeData(type); + mplExport.OutputStructTypeData(*type); + mplExport.OutputInterfaceTypeData(*type); } } -void OutputTypeConstString(MIRType *ty, BinaryMplExport *mplExport) { - ASSERT(false, "Type's kind not yet implemented: %d", ty->GetKind()); +void OutputTypeConstString(MIRType &ty, BinaryMplExport &mplExport) { + ASSERT(false, "Type's kind not yet implemented: %d", ty.GetKind()); } void InitOutputTypeFactory() { @@ -384,7 +384,7 @@ void BinaryMplExport::OutputConst(MIRConst *constVal) { } else { auto func = CreateProductFunction(constVal->GetKind()); if (func != nullptr) { - func(constVal, this); + func(*constVal, *this); } } } @@ -444,18 +444,17 @@ void BinaryMplExport::OutputPragmaElement(const MIRPragmaElement &e) { } } -void BinaryMplExport::OutputPragma(const MIRPragma *p) { - ASSERT(p != nullptr, "MIRPragma is null."); - WriteNum(p->GetKind()); - WriteNum(p->GetVisibility()); - OutputStr(p->GetStrIdx()); - OutputType(p->GetTyIdx()); - OutputType(p->GetTyIdxEx()); - WriteNum(p->GetParamNum()); - size_t size = p->GetElementVector().size(); +void BinaryMplExport::OutputPragma(const MIRPragma &p) { + WriteNum(p.GetKind()); + WriteNum(p.GetVisibility()); + OutputStr(p.GetStrIdx()); + OutputType(p.GetTyIdx()); + OutputType(p.GetTyIdxEx()); + WriteNum(p.GetParamNum()); + size_t size = p.GetElementVector().size(); WriteNum(size); for (size_t i = 0; i < size; i++) { - OutputPragmaElement(*(p->GetNthElement(i))); + OutputPragmaElement(*(p.GetNthElement(i))); } } @@ -507,12 +506,11 @@ void BinaryMplExport::OutputMethodsOfStruct(const MethodVector &methods) { } } -void BinaryMplExport::OutputStructTypeData(MIRStructType *type) { - ASSERT(type != nullptr, "MIRStructType is null."); - OutputFieldsOfStruct(type->GetFields()); - OutputFieldsOfStruct(type->GetStaticFields()); - OutputFieldsOfStruct(type->GetParentFields()); - OutputMethodsOfStruct(type->GetMethods()); +void BinaryMplExport::OutputStructTypeData(MIRStructType &type) { + OutputFieldsOfStruct(type.GetFields()); + OutputFieldsOfStruct(type.GetStaticFields()); + OutputFieldsOfStruct(type.GetParentFields()); + OutputMethodsOfStruct(type.GetMethods()); } void BinaryMplExport::OutputImplementedInterfaces(const std::vector &interfaces) { @@ -545,25 +543,23 @@ void BinaryMplExport::OutputInfo(const std::vector &info, const std void BinaryMplExport::OutputPragmaVec(const std::vector &pragmaVec) { WriteNum(pragmaVec.size()); for (MIRPragma *pragma : pragmaVec) { - OutputPragma(pragma); + OutputPragma(*pragma); } } -void BinaryMplExport::OutputClassTypeData(MIRClassType *type) { - ASSERT(type != nullptr, "MIRClassType is null."); - OutputType(type->GetParentTyIdx()); - OutputImplementedInterfaces(type->GetInerfaceImplemented()); - OutputInfoIsString(type->GetInfoIsString()); - OutputInfo(type->GetInfo(), type->GetInfoIsString()); - OutputPragmaVec(type->GetPragmVec()); +void BinaryMplExport::OutputClassTypeData(MIRClassType &type) { + OutputType(type.GetParentTyIdx()); + OutputImplementedInterfaces(type.GetInerfaceImplemented()); + OutputInfoIsString(type.GetInfoIsString()); + OutputInfo(type.GetInfo(), type.GetInfoIsString()); + OutputPragmaVec(type.GetPragmVec()); } -void BinaryMplExport::OutputInterfaceTypeData(MIRInterfaceType *type) { - ASSERT(type != nullptr, "MIRInterfaceType is null."); - OutputImplementedInterfaces(type->GetParentsTyIdx()); - OutputInfoIsString(type->GetInfoIsString()); - OutputInfo(type->GetInfo(), type->GetInfoIsString()); - OutputPragmaVec(type->GetPragmVec()); +void BinaryMplExport::OutputInterfaceTypeData(MIRInterfaceType &type) { + OutputImplementedInterfaces(type.GetParentsTyIdx()); + OutputInfoIsString(type.GetInfoIsString()); + OutputInfo(type.GetInfo(), type.GetInfoIsString()); + OutputPragmaVec(type.GetPragmVec()); } void BinaryMplExport::Init() { @@ -762,7 +758,7 @@ void BinaryMplExport::OutputType(const TyIdx &tyIdx) { auto func = CreateProductFunction(ty->GetKind()); if (func != nullptr) { - func(ty, this); + func(*ty, *this); } else { ASSERT(false, "Type's kind not yet implemented: %d", ty->GetKind()); } diff --git a/src/maple_ir/src/bin_mpl_import.cpp b/src/maple_ir/src/bin_mpl_import.cpp index 49d21352a76b4fcbd520ec26cdcc8a07fe050865..85eff3cd4e67cd94a97bb108aa27e38ee0adbcfc 100644 --- a/src/maple_ir/src/bin_mpl_import.cpp +++ b/src/maple_ir/src/bin_mpl_import.cpp @@ -229,7 +229,7 @@ MIRPragmaElement *BinaryMplImport::ImportPragmaElement() { } int64 size = ReadNum(); for (int64 i = 0; i < size; i++) { - element->PushSubElemVec(ImportPragmaElement()); + element->PushSubElemVec(*ImportPragmaElement()); } return element; } @@ -244,7 +244,7 @@ MIRPragma *BinaryMplImport::ImportPragma() { p->SetParamNum(ReadNum()); int64 size = ReadNum(); for (int64 i = 0; i < size; i++) { - p->PushElementVector(ImportPragmaElement()); + p->PushElementVector(*ImportPragmaElement()); } return p; } @@ -705,7 +705,7 @@ MIRType &BinaryMplImport::InsertInTypeTables(MIRType &type) { if (IsObject(*resultTypePtr)) { mod.GetTypeNameTab()->SetGStrIdxToTyIdx(stridx, tyIdx); mod.AddClass(tyIdx); - mod.GetTypeDefOrder().push_back(stridx); + mod.PushbackTypeDefOrder(stridx); if (!IsIncomplete(*resultTypePtr)) { GlobalTables::GetTypeNameTable().SetGStrIdxToTyIdx(stridx, tyIdx); } diff --git a/src/maple_ir/src/driver.cpp b/src/maple_ir/src/driver.cpp index dc419978344303aa5b9fc998c54d540583a94df7..ca5f9f4e146325b1c0eda691ddf54d4e9ec761f5 100644 --- a/src/maple_ir/src/driver.cpp +++ b/src/maple_ir/src/driver.cpp @@ -26,8 +26,8 @@ using namespace maple; void ConstantFoldModule(maple::MIRModule &module) { MapleVector &funcList = module.GetFunctionList(); for (auto it = funcList.begin(); it != funcList.end(); it++) { - maple::MIRFunction *curfun = *it; - module.SetCurFunction(curfun); + maple::MIRFunction *curFunc = *it; + module.SetCurFunction(curFunc); } } @@ -52,32 +52,32 @@ int main(int argc, char **argv) { while (i < argc) { maple::MIRModule module{ argv[i] }; if (flag == '\0') { - maple::MIRParser theparser(module); - if (theparser.ParseMIR()) { + maple::MIRParser theParser(module); + if (theParser.ParseMIR()) { ConstantFoldModule(module); module.OutputAsciiMpl(".irb"); } else { - theparser.EmitError(module.GetFileName().c_str()); + theParser.EmitError(module.GetFileName().c_str()); return 1; } } else if (flag == 'e') { - maple::MIRParser theparser(module); - if (theparser.ParseMIR()) { + maple::MIRParser theParser(module); + if (theParser.ParseMIR()) { ConstantFoldModule(module); - BinaryMplt binmplt(module); - std::string modid = module.GetFileName(); - binmplt.Export("bin." + modid); + BinaryMplt binMplt(module); + std::string modID = module.GetFileName(); + binMplt.Export("bin." + modID); } else { - theparser.EmitError(module.GetFileName().c_str()); + theParser.EmitError(module.GetFileName().c_str()); return 1; } } else if (flag == 'i') { module.SetFlavor(kFeProduced); module.SetSrcLang(kSrcLangJava); - BinaryMplImport binmplt(module); - binmplt.SetImported(false); - std::string modid = module.GetFileName(); - binmplt.Import(modid, true); + BinaryMplImport binMplt(module); + binMplt.SetImported(false); + std::string modID = module.GetFileName(); + binMplt.Import(modID, true); module.OutputAsciiMpl(".irb"); } i++; diff --git a/src/maple_ir/src/global_tables.cpp b/src/maple_ir/src/global_tables.cpp index 24c26ce620135dbf4a8cf98cf6a2ad8744ccff8a..f46460725e698415b1720638a84f553810160060 100644 --- a/src/maple_ir/src/global_tables.cpp +++ b/src/maple_ir/src/global_tables.cpp @@ -148,7 +148,7 @@ MIRType *TypeTable::GetOrCreateStructOrUnion(const std::string &name, const Fiel TyIdx tyidx = GetOrCreateMIRType(&type); // Global? module.GetTypeNameTab()->SetGStrIdxToTyIdx(stridx, tyidx); - module.GetTypeDefOrder().push_back(stridx); + module.PushbackTypeDefOrder(stridx); ASSERT(tyidx.GetIdx() < typeTable.size(), "index out of range in TypeTable::GetOrCreateStructOrUnion"); return typeTable.at(tyidx.GetIdx()); } @@ -169,7 +169,7 @@ MIRType *TypeTable::GetOrCreateClassOrInterface(const std::string &name, MIRModu MIRInterfaceType type(kTypeInterfaceIncomplete, stridx); // for interface type tyidx = GetOrCreateMIRType(&type); } - module.GetTypeDefOrder().push_back(stridx); + module.PushbackTypeDefOrder(stridx); module.GetTypeNameTab()->SetGStrIdxToTyIdx(stridx, tyidx); if (typeTable[tyidx.GetIdx()]->GetNameStrIdx() == 0) { typeTable[tyidx.GetIdx()]->SetNameStrIdx(stridx); diff --git a/src/maple_ir/src/mir_builder.cpp b/src/maple_ir/src/mir_builder.cpp index 0301679f6b9d3e7c6bdcbecf747667559e563c29..8b890935533635ead647a0b6a1ebe9fc2731ff2a 100644 --- a/src/maple_ir/src/mir_builder.cpp +++ b/src/maple_ir/src/mir_builder.cpp @@ -26,7 +26,7 @@ void MIRBuilder::AddIntFieldConst(const MIRStructType &sType, MIRAggConst &newCo // This is for compiler-generated metadata 1-level struct void MIRBuilder::AddAddrofFieldConst(const MIRStructType &structType, MIRAggConst &newConst, uint32 fieldID, const MIRSymbol &fieldSymbol) { - AddrofNode *fieldExpr = CreateExprAddrof(0, &fieldSymbol, mirModule->GetMemPool()); + AddrofNode *fieldExpr = CreateExprAddrof(0, fieldSymbol, mirModule->GetMemPool()); MIRConst *fieldConst = mirModule->GetMemPool()->New(fieldExpr->GetStIdx(), fieldExpr->GetFieldID(), structType.GetElemType(fieldID - 1)); fieldConst->SetFieldID(fieldID); @@ -411,9 +411,9 @@ MIRSymbol *MIRBuilder::CreateGlobalDecl(const std::string &str, const MIRType *t return st; } -MIRSymbol *MIRBuilder::GetOrCreateGlobalDecl(const std::string &str, const MIRType *type) { +MIRSymbol *MIRBuilder::GetOrCreateGlobalDecl(const std::string &str, const MIRType &type) { bool isCreated = false; - MIRSymbol *st = GetOrCreateGlobalDecl(str, type->GetTypeIndex(), isCreated); + MIRSymbol *st = GetOrCreateGlobalDecl(str, type.GetTypeIndex(), isCreated); if (isCreated) { st->SetStorageClass(kScGlobal); st->SetSKind(kStVar); @@ -457,42 +457,42 @@ ConstvalNode *MIRBuilder::CreateFloat128Const(const uint64 *val) { return GetCurrentFuncCodeMp()->New(PTY_f128, mirConst); } -ConstvalNode *MIRBuilder::GetConstInt(MemPool *memPool, int i) { - MIRIntConst *mirConst = memPool->New(i, GlobalTables::GetTypeTable().GetInt64()); - return memPool->New(PTY_i32, mirConst); +ConstvalNode *MIRBuilder::GetConstInt(MemPool &memPool, int i) { + MIRIntConst *mirConst = memPool.New(i, GlobalTables::GetTypeTable().GetInt64()); + return memPool.New(PTY_i32, mirConst); } -ConstvalNode *MIRBuilder::CreateAddrofConst(BaseNode *e) { - ASSERT(e->GetOpCode() == OP_addrof, "illegal op for addrof const"); +ConstvalNode *MIRBuilder::CreateAddrofConst(BaseNode &e) { + ASSERT(e.GetOpCode() == OP_addrof, "illegal op for addrof const"); MIRFunction *currentFunctionInner = GetCurrentFunctionNotNull(); // determine the type of 'e' and create a pointer type, accordingly - AddrofNode *aNode = static_cast(e); - MIRSymbol *var = currentFunctionInner->GetLocalOrGlobalSymbol(aNode->GetStIdx()); + AddrofNode &aNode = static_cast(e); + MIRSymbol *var = currentFunctionInner->GetLocalOrGlobalSymbol(aNode.GetStIdx()); TyIdx ptyIdx = var->GetTyIdx(); MIRPtrType ptrType(ptyIdx); ptyIdx = GlobalTables::GetTypeTable().GetOrCreateMIRType(&ptrType); MIRType *exprty = GlobalTables::GetTypeTable().GetTypeFromTyIdx(ptyIdx); - MIRAddrofConst *temp = mirModule->GetMemPool()->New(aNode->GetStIdx(), aNode->GetFieldID(), exprty); + MIRAddrofConst *temp = mirModule->GetMemPool()->New(aNode.GetStIdx(), aNode.GetFieldID(), exprty); return GetCurrentFuncCodeMp()->New(PTY_ptr, temp); } -ConstvalNode *MIRBuilder::CreateAddroffuncConst(const BaseNode *e) { - ASSERT(e->GetOpCode() == OP_addroffunc, "illegal op for addroffunc const"); +ConstvalNode *MIRBuilder::CreateAddroffuncConst(const BaseNode &e) { + ASSERT(e.GetOpCode() == OP_addroffunc, "illegal op for addroffunc const"); - const AddroffuncNode *aNode = static_cast(e); - MIRFunction *f = GlobalTables::GetFunctionTable().GetFunctionFromPuidx(aNode->GetPUIdx()); + const AddroffuncNode &aNode = static_cast(e); + MIRFunction *f = GlobalTables::GetFunctionTable().GetFunctionFromPuidx(aNode.GetPUIdx()); TyIdx ptyIdx = f->GetFuncSymbol()->GetTyIdx(); MIRPtrType ptrType(ptyIdx); ptyIdx = GlobalTables::GetTypeTable().GetOrCreateMIRType(&ptrType); MIRType *exprty = GlobalTables::GetTypeTable().GetTypeFromTyIdx(ptyIdx); - MIRAddroffuncConst *mirConst = mirModule->GetMemPool()->New(aNode->GetPUIdx(), exprty); + MIRAddroffuncConst *mirConst = mirModule->GetMemPool()->New(aNode.GetPUIdx(), exprty); return GetCurrentFuncCodeMp()->New(PTY_ptr, mirConst); } -ConstvalNode *MIRBuilder::CreateStrConst(const BaseNode *e) { - ASSERT(e->GetOpCode() == OP_conststr, "illegal op for conststr const"); - UStrIdx strIdx = static_cast(e)->GetStrIdx(); +ConstvalNode *MIRBuilder::CreateStrConst(const BaseNode &e) { + ASSERT(e.GetOpCode() == OP_conststr, "illegal op for conststr const"); + UStrIdx strIdx = static_cast(e).GetStrIdx(); CHECK_FATAL(PTY_u8 < GlobalTables::GetTypeTable().GetTypeTable().size(), "index is out of range in MIRBuilder::CreateStrConst"); TyIdx ptyidx = GlobalTables::GetTypeTable().GetTypeFromTyIdx(TyIdx(PTY_u8))->GetTypeIndex(); @@ -503,9 +503,9 @@ ConstvalNode *MIRBuilder::CreateStrConst(const BaseNode *e) { return GetCurrentFuncCodeMp()->New(PTY_ptr, mirConst); } -ConstvalNode *MIRBuilder::CreateStr16Const(const BaseNode *e) { - ASSERT(e->GetOpCode() == OP_conststr16, "illegal op for conststr16 const"); - U16StrIdx strIdx = static_cast(e)->GetStrIdx(); +ConstvalNode *MIRBuilder::CreateStr16Const(const BaseNode &e) { + ASSERT(e.GetOpCode() == OP_conststr16, "illegal op for conststr16 const"); + U16StrIdx strIdx = static_cast(e).GetStrIdx(); CHECK_FATAL(PTY_u16 < GlobalTables::GetTypeTable().GetTypeTable().size(), "index out of range in MIRBuilder::CreateStr16Const"); TyIdx ptyIdx = GlobalTables::GetTypeTable().GetTypeFromTyIdx(TyIdx(PTY_u16))->GetTypeIndex(); @@ -531,13 +531,13 @@ MIRSymbol *MIRBuilder::GetSymbolFromEnclosingScope(StIdx stIdx) { } MIRSymbol *MIRBuilder::GetSymbol(TyIdx tyIdx, const std::string &name, MIRSymKind mClass, MIRStorageClass sClass, - MIRFunction *func, uint8 scpID, bool sameType = false) { - return GetSymbol(tyIdx, GetOrCreateStringIndex(name), mClass, sClass, func, scpID, sameType); + uint8 scpID, bool sameType = false) { + return GetSymbol(tyIdx, GetOrCreateStringIndex(name), mClass, sClass, scpID, sameType); } // when sametype is true, it means match everything the of the symbol MIRSymbol *MIRBuilder::GetSymbol(TyIdx tyIdx, GStrIdx strIdx, MIRSymKind mClass, MIRStorageClass sClass, - MIRFunction *func, uint8 scpID, bool sameType = false) { + uint8 scpID, bool sameType = false) { if (scpID != kScopeGlobal) { ERR(kLncErr, "not yet implemented"); return nullptr; @@ -569,7 +569,7 @@ MIRSymbol *MIRBuilder::GetOrCreateSymbol(TyIdx tyIdx, const std::string &name, M MIRSymbol *MIRBuilder::GetOrCreateSymbol(TyIdx tyIdx, GStrIdx strIdx, MIRSymKind mClass, MIRStorageClass sClass, MIRFunction *func, uint8 scpID, bool sameType = false) { - if (MIRSymbol *st = GetSymbol(tyIdx, strIdx, mClass, sClass, func, scpID, sameType)) { + if (MIRSymbol *st = GetSymbol(tyIdx, strIdx, mClass, sClass, scpID, sameType)) { return st; } return CreateSymbol(tyIdx, strIdx, mClass, sClass, func, scpID); @@ -603,18 +603,18 @@ MIRSymbol *MIRBuilder::CreateSymbol(TyIdx tyIdx, GStrIdx strIdx, MIRSymKind mCla return st; } -MIRSymbol *MIRBuilder::CreatePregFormalSymbol(TyIdx tyIdx, PregIdx pRegIdx, MIRFunction *func) { - MIRSymbol *st = func->GetSymTab()->CreateSymbol(kScopeLocal); +MIRSymbol *MIRBuilder::CreatePregFormalSymbol(TyIdx tyIdx, PregIdx pRegIdx, MIRFunction &func) { + MIRSymbol *st = func.GetSymTab()->CreateSymbol(kScopeLocal); CHECK_FATAL(st != nullptr, "Failed to create MIRSymbol"); st->SetStorageClass(kScFormal); st->SetSKind(kStPreg); st->SetTyIdx(tyIdx); - MIRPregTable *pRegTab = func->GetPregTab(); + MIRPregTable *pRegTab = func.GetPregTab(); st->SetPreg(pRegTab->PregFromPregIdx(pRegIdx)); return st; } -MIRFunction *MIRBuilder::CreateFunction(const std::string &name, const MIRType *returnType, const ArgVector &arguments, +MIRFunction *MIRBuilder::CreateFunction(const std::string &name, const MIRType &returnType, const ArgVector &arguments, bool isVarg, bool createBody) { MIRSymbol *funcSymbol = GlobalTables::GetGsymTable().CreateSymbol(kScopeGlobal); CHECK_FATAL(funcSymbol != nullptr, "Failed to create MIRSymbol"); @@ -644,7 +644,7 @@ MIRFunction *MIRBuilder::CreateFunction(const std::string &name, const MIRType * funcVecAttrs.push_back(TypeAttrs()); } funcSymbol->SetTyIdx(GlobalTables::GetTypeTable().GetOrCreateFunctionType( - *mirModule, returnType->GetTypeIndex(), funcVecType, funcVecAttrs, isVarg)->GetTypeIndex()); + *mirModule, returnType.GetTypeIndex(), funcVecType, funcVecAttrs, isVarg)->GetTypeIndex()); MIRFuncType *funcType = dynamic_cast(funcSymbol->GetType()); fn->SetMIRFuncType(funcType); funcSymbol->SetFunction(fn); @@ -667,16 +667,16 @@ MIRFunction *MIRBuilder::CreateFunction(const StIdx stIdx, bool addToTable) { return fn; } -SizeoftypeNode *MIRBuilder::CreateExprSizeoftype(const MIRType *type) { - return GetCurrentFuncCodeMp()->New(PTY_u32, type->GetTypeIndex()); +SizeoftypeNode *MIRBuilder::CreateExprSizeoftype(const MIRType &type) { + return GetCurrentFuncCodeMp()->New(PTY_u32, type.GetTypeIndex()); } -FieldsDistNode *MIRBuilder::CreateExprFieldsDist(const MIRType *type, FieldID field1, FieldID field2) { - return GetCurrentFuncCodeMp()->New(PTY_i32, type->GetTypeIndex(), field1, field2); +FieldsDistNode *MIRBuilder::CreateExprFieldsDist(const MIRType &type, FieldID field1, FieldID field2) { + return GetCurrentFuncCodeMp()->New(PTY_i32, type.GetTypeIndex(), field1, field2); } -AddrofNode *MIRBuilder::CreateExprAddrof(FieldID fieldID, const MIRSymbol *symbol, MemPool *memPool) { - return CreateExprAddrof(fieldID, symbol->GetStIdx(), memPool); +AddrofNode *MIRBuilder::CreateExprAddrof(FieldID fieldID, const MIRSymbol &symbol, MemPool *memPool) { + return CreateExprAddrof(fieldID, symbol.GetStIdx(), memPool); } AddrofNode *MIRBuilder::CreateExprAddrof(FieldID fieldID, StIdx symbolStIdx, MemPool *memPool) { @@ -693,11 +693,11 @@ AddroffuncNode *MIRBuilder::CreateExprAddroffunc(PUIdx puIdx, MemPool *memPool) return memPool->New(PTY_ptr, puIdx); } -AddrofNode *MIRBuilder::CreateExprDread(const MIRType *type, FieldID fieldID, const MIRSymbol *symbol) { - AddrofNode *drn = GetCurrentFuncCodeMp()->New(OP_dread, kPtyInvalid, symbol->GetStIdx(), fieldID); - CHECK(type->GetTypeIndex().GetIdx() < GlobalTables::GetTypeTable().GetTypeTable().size(), +AddrofNode *MIRBuilder::CreateExprDread(const MIRType &type, FieldID fieldID, const MIRSymbol &symbol) { + AddrofNode *drn = GetCurrentFuncCodeMp()->New(OP_dread, kPtyInvalid, symbol.GetStIdx(), fieldID); + CHECK(type.GetTypeIndex().GetIdx() < GlobalTables::GetTypeTable().GetTypeTable().size(), "index out of range in MIRBuilder::CreateExprDread"); - drn->SetPrimType(GlobalTables::GetTypeTable().GetPrimTypeFromTyIdx(type->GetTypeIndex())); + drn->SetPrimType(GlobalTables::GetTypeTable().GetPrimTypeFromTyIdx(type.GetTypeIndex())); return drn; } @@ -705,11 +705,11 @@ RegreadNode *MIRBuilder::CreateExprRegread(PrimType pty, PregIdx regIdx) { return GetCurrentFuncCodeMp()->New(pty, regIdx); } -AddrofNode *MIRBuilder::CreateExprDread(MIRType *type, MIRSymbol *symbol) { +AddrofNode *MIRBuilder::CreateExprDread(MIRType &type, MIRSymbol &symbol) { return CreateExprDread(type, 0, symbol); } -AddrofNode *MIRBuilder::CreateExprDread(MIRSymbol *symbol, uint16 fieldID) { +AddrofNode *MIRBuilder::CreateExprDread(MIRSymbol &symbol, uint16 fieldID) { if (fieldID == 0) { return CreateExprDread(symbol); } @@ -717,8 +717,8 @@ AddrofNode *MIRBuilder::CreateExprDread(MIRSymbol *symbol, uint16 fieldID) { return nullptr; } -AddrofNode *MIRBuilder::CreateExprDread(MIRSymbol *symbol) { - return CreateExprDread(symbol->GetType(), 0, symbol); +AddrofNode *MIRBuilder::CreateExprDread(MIRSymbol &symbol) { + return CreateExprDread(*symbol.GetType(), 0, symbol); } AddrofNode *MIRBuilder::CreateExprDread(PregIdx pregID, PrimType pty) { @@ -727,15 +727,15 @@ AddrofNode *MIRBuilder::CreateExprDread(PregIdx pregID, PrimType pty) { return dread; } -IreadNode *MIRBuilder::CreateExprIread(const MIRType *returnType, const MIRType *ptrType, FieldID fieldID, +IreadNode *MIRBuilder::CreateExprIread(const MIRType &returnType, const MIRType &ptrType, FieldID fieldID, BaseNode *addr) { - TyIdx returnTypeIdx = returnType->GetTypeIndex(); + TyIdx returnTypeIdx = returnType.GetTypeIndex(); ASSERT(returnTypeIdx.GetIdx() < GlobalTables::GetTypeTable().GetTypeTable().size(), "index out of range in MIRBuilder::CreateExprIread"); - ASSERT(fieldID != 0 || ptrType->GetPrimType() != PTY_agg, + ASSERT(fieldID != 0 || ptrType.GetPrimType() != PTY_agg, "Error: Fieldid should not be 0 when trying to iread a field from type "); PrimType type = GlobalTables::GetTypeTable().GetPrimTypeFromTyIdx(returnTypeIdx); - return GetCurrentFuncCodeMp()->New(OP_iread, type, ptrType->GetTypeIndex(), fieldID, addr); + return GetCurrentFuncCodeMp()->New(OP_iread, type, ptrType.GetTypeIndex(), fieldID, addr); } IreadoffNode *MIRBuilder::CreateExprIreadoff(PrimType pty, int32 offset, BaseNode *opnd0) { @@ -746,7 +746,7 @@ IreadFPoffNode *MIRBuilder::CreateExprIreadFPoff(PrimType pty, int32 offset) { return GetCurrentFuncCodeMp()->New(pty, offset); } -IaddrofNode *MIRBuilder::CreateExprIaddrof(const MIRType *returnType, const MIRType *ptrType, FieldID fieldID, +IaddrofNode *MIRBuilder::CreateExprIaddrof(const MIRType &returnType, const MIRType &ptrType, FieldID fieldID, BaseNode *addr) { IaddrofNode *iAddrOfNode = CreateExprIread(returnType, ptrType, fieldID, addr); iAddrOfNode->SetOpCode(OP_iaddrof); @@ -757,49 +757,49 @@ IaddrofNode *MIRBuilder::CreateExprIaddrof(PrimType returnTypePty, TyIdx ptrType return GetCurrentFuncCodeMp()->New(OP_iaddrof, returnTypePty, ptrTypeIdx, fieldID, addr); } -UnaryNode *MIRBuilder::CreateExprUnary(Opcode opcode, const MIRType *type, BaseNode *opnd) { - return GetCurrentFuncCodeMp()->New(opcode, type->GetPrimType(), opnd); +UnaryNode *MIRBuilder::CreateExprUnary(Opcode opcode, const MIRType &type, BaseNode *opnd) { + return GetCurrentFuncCodeMp()->New(opcode, type.GetPrimType(), opnd); } -GCMallocNode *MIRBuilder::CreateExprGCMalloc(Opcode opcode, const MIRType *ptype, const MIRType *type) { - return GetCurrentFuncCodeMp()->New(opcode, ptype->GetPrimType(), type->GetTypeIndex()); +GCMallocNode *MIRBuilder::CreateExprGCMalloc(Opcode opcode, const MIRType &ptype, const MIRType &type) { + return GetCurrentFuncCodeMp()->New(opcode, ptype.GetPrimType(), type.GetTypeIndex()); } -JarrayMallocNode *MIRBuilder::CreateExprJarrayMalloc(Opcode opcode, const MIRType *ptype, const MIRType *type, +JarrayMallocNode *MIRBuilder::CreateExprJarrayMalloc(Opcode opcode, const MIRType &ptype, const MIRType &type, BaseNode *opnd) { - return GetCurrentFuncCodeMp()->New(opcode, ptype->GetPrimType(), type->GetTypeIndex(), opnd); + return GetCurrentFuncCodeMp()->New(opcode, ptype.GetPrimType(), type.GetTypeIndex(), opnd); } -TypeCvtNode *MIRBuilder::CreateExprTypeCvt(Opcode o, const MIRType *type, const MIRType *fromType, BaseNode *opnd) { - return GetCurrentFuncCodeMp()->New(o, type->GetPrimType(), fromType->GetPrimType(), opnd); +TypeCvtNode *MIRBuilder::CreateExprTypeCvt(Opcode o, const MIRType &type, const MIRType &fromType, BaseNode *opnd) { + return GetCurrentFuncCodeMp()->New(o, type.GetPrimType(), fromType.GetPrimType(), opnd); } -ExtractbitsNode *MIRBuilder::CreateExprExtractbits(Opcode o, const MIRType *type, uint32 bOffset, uint32 bsize, +ExtractbitsNode *MIRBuilder::CreateExprExtractbits(Opcode o, const MIRType &type, uint32 bOffset, uint32 bsize, BaseNode *opnd) { - return GetCurrentFuncCodeMp()->New(o, type->GetPrimType(), bOffset, bsize, opnd); + return GetCurrentFuncCodeMp()->New(o, type.GetPrimType(), bOffset, bsize, opnd); } -RetypeNode *MIRBuilder::CreateExprRetype(const MIRType *type, const MIRType *fromType, BaseNode *opnd) { - return GetCurrentFuncCodeMp()->New(type->GetPrimType(), fromType->GetPrimType(), - type->GetTypeIndex(), opnd); +RetypeNode *MIRBuilder::CreateExprRetype(const MIRType &type, const MIRType &fromType, BaseNode *opnd) { + return GetCurrentFuncCodeMp()->New(type.GetPrimType(), fromType.GetPrimType(), + type.GetTypeIndex(), opnd); } -BinaryNode *MIRBuilder::CreateExprBinary(Opcode opcode, const MIRType *type, BaseNode *opnd0, BaseNode *opnd1) { - return GetCurrentFuncCodeMp()->New(opcode, type->GetPrimType(), opnd0, opnd1); +BinaryNode *MIRBuilder::CreateExprBinary(Opcode opcode, const MIRType &type, BaseNode *opnd0, BaseNode *opnd1) { + return GetCurrentFuncCodeMp()->New(opcode, type.GetPrimType(), opnd0, opnd1); } -TernaryNode *MIRBuilder::CreateExprTernary(Opcode opcode, const MIRType *type, BaseNode *opnd0, BaseNode *opnd1, +TernaryNode *MIRBuilder::CreateExprTernary(Opcode opcode, const MIRType &type, BaseNode *opnd0, BaseNode *opnd1, BaseNode *opnd2) { - return GetCurrentFuncCodeMp()->New(opcode, type->GetPrimType(), opnd0, opnd1, opnd2); + return GetCurrentFuncCodeMp()->New(opcode, type.GetPrimType(), opnd0, opnd1, opnd2); } -CompareNode *MIRBuilder::CreateExprCompare(Opcode opcode, const MIRType *type, const MIRType *opndType, BaseNode *opnd0, +CompareNode *MIRBuilder::CreateExprCompare(Opcode opcode, const MIRType &type, const MIRType &opndType, BaseNode *opnd0, BaseNode *opnd1) { - return GetCurrentFuncCodeMp()->New(opcode, type->GetPrimType(), opndType->GetPrimType(), opnd0, opnd1); + return GetCurrentFuncCodeMp()->New(opcode, type.GetPrimType(), opndType.GetPrimType(), opnd0, opnd1); } -ArrayNode *MIRBuilder::CreateExprArray(const MIRType *arrayType) { - MIRType *addrType = GlobalTables::GetTypeTable().GetOrCreatePointerType(*arrayType); +ArrayNode *MIRBuilder::CreateExprArray(const MIRType &arrayType) { + MIRType *addrType = GlobalTables::GetTypeTable().GetOrCreatePointerType(arrayType); ASSERT(addrType != nullptr, "addrType is null"); ArrayNode *arrayNode = GetCurrentFuncCodeMp()->New(*GetCurrentFuncCodeMpAllocator(), addrType->GetPrimType(), addrType->GetTypeIndex()); @@ -807,35 +807,35 @@ ArrayNode *MIRBuilder::CreateExprArray(const MIRType *arrayType) { return arrayNode; } -ArrayNode *MIRBuilder::CreateExprArray(const MIRType *arrayType, BaseNode *op) { +ArrayNode *MIRBuilder::CreateExprArray(const MIRType &arrayType, BaseNode *op) { ArrayNode *arrayNode = CreateExprArray(arrayType); arrayNode->GetNopnd().push_back(op); arrayNode->SetNumOpnds(1); return arrayNode; } -ArrayNode *MIRBuilder::CreateExprArray(const MIRType *arrayType, BaseNode *op1, BaseNode *op2) { +ArrayNode *MIRBuilder::CreateExprArray(const MIRType &arrayType, BaseNode *op1, BaseNode *op2) { ArrayNode *arrayNode = CreateExprArray(arrayType, op1); arrayNode->GetNopnd().push_back(op2); arrayNode->SetNumOpnds(2); return arrayNode; } -IntrinsicopNode *MIRBuilder::CreateExprIntrinsicop(MIRIntrinsicID idx, Opcode opCode, const MIRType *type, +IntrinsicopNode *MIRBuilder::CreateExprIntrinsicop(MIRIntrinsicID idx, Opcode opCode, const MIRType &type, const MapleVector &ops) { IntrinsicopNode *expr = - GetCurrentFuncCodeMp()->New(*GetCurrentFuncCodeMpAllocator(), opCode, type->GetPrimType()); + GetCurrentFuncCodeMp()->New(*GetCurrentFuncCodeMpAllocator(), opCode, type.GetPrimType()); expr->SetIntrinsic(idx); expr->SetNOpnd(ops); expr->SetNumOpnds(ops.size()); if (opCode == OP_intrinsicopwithtype) { - expr->SetTyIdx(type->GetTypeIndex()); + expr->SetTyIdx(type.GetTypeIndex()); } return expr; } -DassignNode *MIRBuilder::CreateStmtDassign(const MIRSymbol *symbol, FieldID fieldID, BaseNode *src) { - return GetCurrentFuncCodeMp()->New(src, symbol->GetStIdx(), fieldID); +DassignNode *MIRBuilder::CreateStmtDassign(const MIRSymbol &symbol, FieldID fieldID, BaseNode *src) { + return GetCurrentFuncCodeMp()->New(src, symbol.GetStIdx(), fieldID); } RegassignNode *MIRBuilder::CreateStmtRegassign(PrimType pty, PregIdx regIdx, BaseNode *src) { @@ -846,8 +846,8 @@ DassignNode *MIRBuilder::CreateStmtDassign(StIdx sIdx, FieldID fieldID, BaseNode return GetCurrentFuncCodeMp()->New(src, sIdx, fieldID); } -IassignNode *MIRBuilder::CreateStmtIassign(const MIRType *type, FieldID fieldID, BaseNode *addr, BaseNode *src) { - return GetCurrentFuncCodeMp()->New(type->GetTypeIndex(), fieldID, addr, src); +IassignNode *MIRBuilder::CreateStmtIassign(const MIRType &type, FieldID fieldID, BaseNode *addr, BaseNode *src) { + return GetCurrentFuncCodeMp()->New(type.GetTypeIndex(), fieldID, addr, src); } IassignoffNode *MIRBuilder::CreateStmtIassignoff(PrimType pty, int32 offset, BaseNode *addr, BaseNode *src) { @@ -1072,9 +1072,9 @@ LabelIdx MIRBuilder::GetOrCreateMIRLabel(const std::string &name) { return labidx; } -LabelIdx MIRBuilder::CreateLabIdx(MIRFunction *mirFunc) { - LabelIdx lidx = mirFunc->GetLabelTab()->CreateLabel(); - mirFunc->GetLabelTab()->AddToStringLabelMap(lidx); +LabelIdx MIRBuilder::CreateLabIdx(MIRFunction &mirFunc) { + LabelIdx lidx = mirFunc.GetLabelTab()->CreateLabel(); + mirFunc.GetLabelTab()->AddToStringLabelMap(lidx); return lidx; } @@ -1086,18 +1086,18 @@ StmtNode *MIRBuilder::CreateStmtComment(const std::string &cmnt) { return GetCurrentFuncCodeMp()->New(*GetCurrentFuncCodeMpAllocator(), cmnt); } -void MIRBuilder::AddStmtInCurrentFunctionBody(StmtNode *stmt) { +void MIRBuilder::AddStmtInCurrentFunctionBody(StmtNode &stmt) { MIRFunction *fun = GetCurrentFunctionNotNull(); - stmt->GetSrcPos().CondSetLineNum(lineNum); - fun->GetBody()->AddStatement(stmt); + stmt.GetSrcPos().CondSetLineNum(lineNum); + fun->GetBody()->AddStatement(&stmt); } -AddrofNode *MIRBuilder::CreateAddrof(const MIRSymbol *st, PrimType pty) { - return GetCurrentFuncCodeMp()->New(OP_addrof, pty, st->GetStIdx(), 0); +AddrofNode *MIRBuilder::CreateAddrof(const MIRSymbol &st, PrimType pty) { + return GetCurrentFuncCodeMp()->New(OP_addrof, pty, st.GetStIdx(), 0); } -AddrofNode *MIRBuilder::CreateDread(const MIRSymbol *st, PrimType pty) { - return GetCurrentFuncCodeMp()->New(OP_dread, pty, st->GetStIdx(), 0); +AddrofNode *MIRBuilder::CreateDread(const MIRSymbol &st, PrimType pty) { + return GetCurrentFuncCodeMp()->New(OP_dread, pty, st.GetStIdx(), 0); } CondGotoNode *MIRBuilder::CreateStmtCondGoto(BaseNode *cond, Opcode op, LabelIdx labIdx) { diff --git a/src/maple_ir/src/mir_lower.cpp b/src/maple_ir/src/mir_lower.cpp index 17b961d3edddc2802ee45b915908a4698c231fc6..ae16c8f0fcedc1e2ed164f0b1fdb877a7444f409 100644 --- a/src/maple_ir/src/mir_lower.cpp +++ b/src/maple_ir/src/mir_lower.cpp @@ -129,7 +129,6 @@ BlockNode *MIRLower::LowerWhileStmt(WhileStmtNode &whileStmt) { LabelNode *lableStmt = mirModule.CurFuncCodeMemPool()->New(); lableStmt->SetLabelIdx(bodyLableIdx); blk->AddStatement(lableStmt); - ASSERT(whileStmt.GetBody(), "null ptr check"); blk->AppendStatementsFromBlock(whileStmt.GetBody()); CondGotoNode *brTrueStmt = mirModule.CurFuncCodeMemPool()->New(OP_brtrue); brTrueStmt->SetOpnd(whileStmt.Opnd()->CloneTree(mirModule.GetCurFuncCodeMPAllocator())); @@ -183,7 +182,6 @@ BlockNode *MIRLower::LowerDoloopStmt(DoloopNode &doloop) { LabelNode *labelStmt = mirModule.CurFuncCodeMemPool()->New(); labelStmt->SetLabelIdx(bodyLabelIdx); blk->AddStatement(labelStmt); - ASSERT(doloop.GetDoBody(), "null ptr check "); blk->AppendStatementsFromBlock(doloop.GetDoBody()); if (doloop.IsPreg()) { PregIdx regIdx = (PregIdx)doloop.GetDoVarStIdx().FullIdx(); @@ -236,7 +234,6 @@ BlockNode *MIRLower::LowerDowhileStmt(WhileStmtNode &doWhileStmt) { LabelNode *labelStmt = mirModule.CurFuncCodeMemPool()->New(); labelStmt->SetLabelIdx(lIdx); blk->AddStatement(labelStmt); - ASSERT(doWhileStmt.GetBody(), "null ptr check "); blk->AppendStatementsFromBlock(doWhileStmt.GetBody()); CondGotoNode *brTrueStmt = mirModule.CurFuncCodeMemPool()->New(OP_brtrue); brTrueStmt->SetOpnd(doWhileStmt.Opnd()); @@ -259,7 +256,7 @@ BlockNode *MIRLower::LowerBlock(BlockNode &block) { switch (stmt->GetOpCode()) { case OP_if: tmp = LowerIfStmt(static_cast(*stmt), true); - ASSERT(tmp, "null ptr check"); + ASSERT(tmp != nullptr, "null ptr check"); newBlock->AppendStatementsFromBlock(tmp); break; case OP_while: @@ -273,7 +270,7 @@ BlockNode *MIRLower::LowerBlock(BlockNode &block) { break; case OP_block: tmp = LowerBlock(static_cast(*stmt)); - ASSERT(tmp, "null ptr check "); + ASSERT(tmp != nullptr, "null ptr check "); newBlock->AppendStatementsFromBlock(tmp); break; default: @@ -295,9 +292,9 @@ void MIRLower::LowerBrCondition(BlockNode &block) { StmtNode *stmt = nextStmt; nextStmt = stmt->GetNext(); if (stmt->IsCondBr()) { - CondGotoNode *condGoto = static_cast(stmt); + auto *condGoto = static_cast(stmt); if (condGoto->Opnd()->GetOpCode() == OP_cand || condGoto->Opnd()->GetOpCode() == OP_cior) { - BinaryNode *cond = static_cast(condGoto->Opnd()); + auto *cond = static_cast(condGoto->Opnd()); if ((stmt->GetOpCode() == OP_brfalse && cond->GetOpCode() == OP_cand) || (stmt->GetOpCode() == OP_brtrue && cond->GetOpCode() == OP_cior)) { // short-circuit target label is same as original condGoto stmt @@ -385,7 +382,7 @@ void MIRLower::AddArrayMrtMpl(BaseNode &exp, BlockNode &newBlock) { AddArrayMrtMpl(*exp.Opnd(i), newBlock); } if (exp.GetOpCode() == OP_array) { - ArrayNode *arrayNode = static_cast(&exp); + auto *arrayNode = static_cast(&exp); if (arrayNode->GetBoundsCheck()) { BaseNode *arrAddr = arrayNode->Opnd(0); BaseNode *index = arrayNode->Opnd(1); @@ -395,24 +392,24 @@ void MIRLower::AddArrayMrtMpl(BaseNode &exp, BlockNode &newBlock) { newBlock.AddStatement(nullCheck); #if DO_LT_0_CHECK ConstvalNode *indexZero = builder->GetConstUInt32(0); - CompareNode *lessZero = builder->CreateExprCompare(OP_lt, GlobalTables::GetTypeTable().GetUInt1(), - GlobalTables::GetTypeTable().GetUInt32(), index, indexZero); + CompareNode *lessZero = builder->CreateExprCompare(OP_lt, *GlobalTables::GetTypeTable().GetUInt1(), + *GlobalTables::GetTypeTable().GetUInt32(), index, indexZero); #endif MIRType *infoLenType = GlobalTables::GetTypeTable().GetInt32(); MapleVector arguments(builder->GetCurrentFuncCodeMpAllocator()->Adapter()); arguments.push_back(arrAddr); BaseNode *arrLen = builder->CreateExprIntrinsicop(INTRN_JAVA_ARRAY_LENGTH, OP_intrinsicop, - infoLenType, arguments); + *infoLenType, arguments); BaseNode *cpmIndex = index; if (arrLen->GetPrimType() != index->GetPrimType()) { - cpmIndex = builder->CreateExprTypeCvt(OP_cvt, infoLenType, indexType, index); + cpmIndex = builder->CreateExprTypeCvt(OP_cvt, *infoLenType, *indexType, index); } - CompareNode *largeLen = builder->CreateExprCompare(OP_ge, GlobalTables::GetTypeTable().GetUInt1(), - GlobalTables::GetTypeTable().GetUInt32(), cpmIndex, arrLen); + CompareNode *largeLen = builder->CreateExprCompare(OP_ge, *GlobalTables::GetTypeTable().GetUInt1(), + *GlobalTables::GetTypeTable().GetUInt32(), cpmIndex, arrLen); // maybe should use cior #if DO_LT_0_CHECK BinaryNode *indexCon = - builder->CreateExprBinary(OP_lior, GlobalTables::GetTypeTable().GetUInt1(), lessZero, largeLen); + builder->CreateExprBinary(OP_lior, *GlobalTables::GetTypeTable().GetUInt1(), lessZero, largeLen); #endif MapleVector args(builder->GetCurrentFuncCodeMpAllocator()->Adapter()); #if DO_LT_0_CHECK diff --git a/src/maple_ir/src/mir_module.cpp b/src/maple_ir/src/mir_module.cpp index af4885045369983853f4aa57573d617844953717..b3965a955504e2d7af64f4dece6a406ded2b79bb 100644 --- a/src/maple_ir/src/mir_module.cpp +++ b/src/maple_ir/src/mir_module.cpp @@ -38,11 +38,8 @@ MIRModule::MIRModule(const char *fn) externStructTypeSet(std::less(), memPoolAllocator.Adapter()), symbolSet(std::less(), memPoolAllocator.Adapter()), symbolDefOrder(memPoolAllocator.Adapter()), - someSymbolNeedForwDecl(false), out(LogInfo::MapleLogger()), - entryFuncName(""), fileName(fn), - throwableTyIdx(0), fileInfo(memPoolAllocator.Adapter()), fileInfoIsString(memPoolAllocator.Adapter()), fileData(memPoolAllocator.Adapter()), @@ -50,26 +47,12 @@ MIRModule::MIRModule(const char *fn) importFiles(memPoolAllocator.Adapter()), importPaths(memPoolAllocator.Adapter()), classList(memPoolAllocator.Adapter()), - entryFunc(nullptr), - floatNum(0), optimizedFuncs(memPoolAllocator.Adapter()), puIdxFieldInitializedMap(std::less(), memPoolAllocator.Adapter()) { - flavor = kFlavorUnknown; - srcLang = kSrcLangUnknown; - id = 0xffff; - globalMemSize = 0; - globalBlkMap = nullptr; - globalWordsTypeTagged = nullptr; - globalWordsRefCounted = nullptr; - numFuncs = 0; - withProfileInfo = false; GlobalTables::GetGsymTable().SetModule(this); typeNameTab = memPool->New(&memPoolAllocator); mirBuilder = memPool->New(this); IntrinDesc::InitMIRModule(this); - binMplt = nullptr; - curFunction = nullptr; - inIPA = false; } MIRModule::~MIRModule() { @@ -79,10 +62,6 @@ MIRModule::~MIRModule() { } } -MIRFunction *MIRModule::CurFunction(void) const { - return curFunction; -} - MemPool *MIRModule::CurFuncCodeMemPool(void) const { return CurFunction()->GetCodeMempool(); } @@ -117,7 +96,7 @@ void MIRModule::AddSymbol(const MIRSymbol *s) { AddSymbol(s->GetStIdx()); } -void MIRModule::DumpGlobals(bool emitStructureType) { +void MIRModule::DumpGlobals(bool emitStructureType) const { if (flavor != kFlavorUnknown) { LogInfo::MapleLogger() << "flavor " << flavor << std::endl; } @@ -289,12 +268,12 @@ void MIRModule::DumpGlobals(bool emitStructureType) { } } -void MIRModule::Dump(bool emitStructureType) { +void MIRModule::Dump(bool emitStructureType) const { DumpGlobals(emitStructureType); DumpFunctionList(); } -void MIRModule::DumpGlobalArraySymbol() { +void MIRModule::DumpGlobalArraySymbol() const { MapleSet::iterator sit = symbolSet.begin(); for (; sit != symbolSet.end(); sit++) { MIRSymbol *s = GlobalTables::GetGsymTable().GetSymbolFromStidx((*sit).Idx()); @@ -306,7 +285,7 @@ void MIRModule::DumpGlobalArraySymbol() { } } -void MIRModule::Emit(const std::string &outfileName) { +void MIRModule::Emit(const std::string &outfileName) const { std::ofstream file; // Change cout's buffer to file. std::streambuf *backup = LogInfo::MapleLogger().rdbuf(); @@ -321,7 +300,7 @@ void MIRModule::Emit(const std::string &outfileName) { file.close(); } -void MIRModule::DumpFunctionList(bool skipBody) { +void MIRModule::DumpFunctionList(bool skipBody) const { for (auto it = functionList.begin(); it != functionList.end(); it++) { (*it)->Dump(skipBody); } @@ -352,11 +331,12 @@ void MIRModule::OutputFunctionListAsciiMpl(const char *phaseName) { return; } -void MIRModule::DumpToFile(const std::string &fileNameStr, bool emitStructureType) { +void MIRModule::DumpToFile(const std::string &fileNameStr, bool emitStructureType) const { std::ofstream file; file.open(fileNameStr.c_str(), std::ios::trunc); if (!file.is_open()) { - std::cerr << "Cannot open " << fileNameStr << std::endl; + ERR(kLncErr, "Cannot open %s", fileNameStr.c_str()); + return; } // Change cout's buffer to file. std::streambuf *backup = LogInfo::MapleLogger().rdbuf(); @@ -366,7 +346,7 @@ void MIRModule::DumpToFile(const std::string &fileNameStr, bool emitStructureTyp LogInfo::MapleLogger().rdbuf(backup); } -void MIRModule::DumpInlineCandidateToFile(const std::string &fileNameStr) { +void MIRModule::DumpInlineCandidateToFile(const std::string &fileNameStr) const { if (optimizedFuncs.empty()) { return; } @@ -385,7 +365,7 @@ void MIRModule::DumpInlineCandidateToFile(const std::string &fileNameStr) { } // This is not efficient. Only used in debug mode for now. -const std::string &MIRModule::GetFileNameFromFileNum(uint32 fileNum) { +const std::string &MIRModule::GetFileNameFromFileNum(uint32 fileNum) const { GStrIdx nameIdx = GStrIdx(0); for (auto &info : srcFileInfo) { if (info.second == fileNum) { @@ -396,7 +376,7 @@ const std::string &MIRModule::GetFileNameFromFileNum(uint32 fileNum) { } -void MIRModule::DumpClassToFile(const char *path) { +void MIRModule::DumpClassToFile(const char *path) const { ASSERT(path != nullptr, "null ptr check"); std::string spath(path); spath.append("/"); diff --git a/src/maple_ir/src/mir_parser.cpp b/src/maple_ir/src/mir_parser.cpp index 48a789bcd9c9fd93962f51a1b5cad9404b753ea5..1e62afb2fffe0a11a00030e912f95416c1736769 100644 --- a/src/maple_ir/src/mir_parser.cpp +++ b/src/maple_ir/src/mir_parser.cpp @@ -149,7 +149,7 @@ bool MIRParser::ParseStmtIassignoff(StmtNodePtr &stmt) { Error("expect offset but get "); return false; } - iassignoff->offset = lexer.GetTheIntVal(); + iassignoff->SetOffset(lexer.GetTheIntVal()); lexer.NextToken(); BaseNode *addr = nullptr; BaseNode *rhs = nullptr; @@ -2055,7 +2055,7 @@ bool MIRParser::ParseExprDepositbits(BaseNodePtr &expr) { return true; } -bool MIRParser::ParseExprIreadIaddrof(IreadNode *expr) { +bool MIRParser::ParseExprIreadIaddrof(IreadNode &expr) { // syntax : iread/iaddrof () if (!IsPrimitiveType(lexer.NextToken())) { Error("expect primitive type but get "); @@ -2065,22 +2065,22 @@ bool MIRParser::ParseExprIreadIaddrof(IreadNode *expr) { if (!ParsePrimType(tyidx)) { return false; } - expr->SetPrimType(GlobalTables::GetTypeTable().GetPrimTypeFromTyIdx(tyidx)); + expr.SetPrimType(GlobalTables::GetTypeTable().GetPrimTypeFromTyIdx(tyidx)); tyidx = TyIdx(0); if (!ParseDerivedType(tyidx)) { Error("ParseExprIreadIaddrof failed when paring derived type"); return false; } - expr->SetTyIdx(tyidx); + expr.SetTyIdx(tyidx); if (lexer.GetTokenKind() == kTkIntconst) { - expr->SetFieldID(lexer.theIntVal); + expr.SetFieldID(lexer.theIntVal); lexer.NextToken(); } BaseNode *opnd0 = nullptr; if (!ParseExprOneOperand(opnd0)) { return false; } - expr->SetOpnd(opnd0); + expr.SetOpnd(opnd0); lexer.NextToken(); return true; } @@ -2088,7 +2088,7 @@ bool MIRParser::ParseExprIreadIaddrof(IreadNode *expr) { bool MIRParser::ParseExprIread(BaseNodePtr &expr) { // syntax : iread () IreadNode *iexpr = mod.CurFuncCodeMemPool()->New(OP_iread); - if (!ParseExprIreadIaddrof(iexpr)) { + if (!ParseExprIreadIaddrof(*iexpr)) { Error("ParseExprIread failed when trying to parse addof"); return false; } @@ -2099,7 +2099,7 @@ bool MIRParser::ParseExprIread(BaseNodePtr &expr) { bool MIRParser::ParseExprIaddrof(BaseNodePtr &expr) { // syntax : iaddrof () IreadNode *iexpr = mod.CurFuncCodeMemPool()->New(OP_iaddrof); - if (!ParseExprIreadIaddrof(iexpr)) { + if (!ParseExprIreadIaddrof(*iexpr)) { Error("ParseExprIaddrof failed when trying to parse addof"); return false; } @@ -2529,13 +2529,13 @@ bool MIRParser::ParseExprArray(BaseNodePtr &expr) { return true; } -bool MIRParser::ParseIntrinsicId(IntrinsicopNode *intrnopnode) { +bool MIRParser::ParseIntrinsicId(IntrinsicopNode &intrnopnode) { MIRIntrinsicID intrinid = GetIntrinsicId(lexer.GetTokenKind()); if (intrinid <= INTRN_UNDEFINED || intrinid >= INTRN_LAST) { Error("wrong intrinsic id "); return false; } - intrnopnode->SetIntrinsic(intrinid); + intrnopnode.SetIntrinsic(intrinid); return true; } @@ -2565,7 +2565,7 @@ bool MIRParser::ParseExprIntrinsicop(BaseNodePtr &expr) { IntrinsicopNode *intrnopnode = mod.CurFuncCodeMemPool()->New( mod, opCode, GlobalTables::GetTypeTable().GetPrimTypeFromTyIdx(pTyIdx), tyIdx); expr = intrnopnode; - if (!ParseIntrinsicId(intrnopnode)) { + if (!ParseIntrinsicId(*intrnopnode)) { return false; } // number of operand can not be zero @@ -2609,7 +2609,7 @@ bool MIRParser::ParseScalarValue(MIRConstPtr &stype, MIRType *type) { return true; } -bool MIRParser::ParseConstAddrLeafExpr(MIRConstPtr &cexpr, MIRType *type) { +bool MIRParser::ParseConstAddrLeafExpr(MIRConstPtr &cexpr, MIRType &type) { BaseNode *expr = nullptr; if (!ParseExpression(expr)) { return false; diff --git a/src/maple_ir/src/mir_pragma.cpp b/src/maple_ir/src/mir_pragma.cpp index aaefeda10525492c8511ee1075617d68e89deaaf..438aa157b5a62e9f79f7c10a189c55f2ca0f4a4d 100644 --- a/src/maple_ir/src/mir_pragma.cpp +++ b/src/maple_ir/src/mir_pragma.cpp @@ -154,7 +154,7 @@ MIRPragmaElement *MIRPragma::GetPragmaElemFromSignature(const std::string &signa case 1: { MIRPragmaElement *etmp = mod->GetMemPool()->New(mod); etmp->SetType(kValueArray); - elemStack.top()->PushSubElemVec(etmp); + elemStack.top()->PushSubElemVec(*etmp); elemStack.push(etmp); break; } @@ -163,7 +163,7 @@ MIRPragmaElement *MIRPragma::GetPragmaElemFromSignature(const std::string &signa etmp->SetType(kValueType); std::string typeStr = signature.substr(start, end - start); etmp->SetU64Val(static_cast(GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(typeStr).GetIdx())); - elemStack.top()->PushSubElemVec(etmp); + elemStack.top()->PushSubElemVec(*etmp); break; } case 3: { @@ -171,7 +171,7 @@ MIRPragmaElement *MIRPragma::GetPragmaElemFromSignature(const std::string &signa etmp->SetType(kValueType); std::string typeStr = signature.substr(start, end - start) + ";"; etmp->SetU64Val(static_cast(GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(typeStr).GetIdx())); - elemStack.top()->PushSubElemVec(etmp); + elemStack.top()->PushSubElemVec(*etmp); break; } case 4: diff --git a/src/maple_ir/src/parser.cpp b/src/maple_ir/src/parser.cpp index d70f586cffc520555468e39e2d98d2316e9facb1..59616455cb88db2d870fb787c8100cf385b075d6 100644 --- a/src/maple_ir/src/parser.cpp +++ b/src/maple_ir/src/parser.cpp @@ -458,7 +458,7 @@ bool MIRParser::ParsePragmaElementForArray(MIRPragmaElement &elem) { Error("parsing pragma error type "); return false; } - elem.PushSubElemVec(e0); + elem.PushSubElemVec(*e0); tk = lexer.NextToken(); if (tk != kTkComa && tk != kTkRbrack) { Error("parsing pragma error: expecting , or ] but get "); @@ -511,7 +511,7 @@ bool MIRParser::ParsePragmaElementForAnnotation(MIRPragmaElement &elem) { Error("parsing pragma error type "); return false; } - elem.PushSubElemVec(e0); + elem.PushSubElemVec(*e0); tk = lexer.NextToken(); if (tk != kTkComa && tk != kTkRbrack) { Error("parsing pragma error: expecting , or ] but get "); @@ -569,7 +569,7 @@ bool MIRParser::ParsePragma(MIRStructType &type) { Error("parsing pragma error type "); return false; } - p->PushElementVector(e); + p->PushElementVector(*e); tk = lexer.NextToken(); if (tk != kTkRbrace && tk != kTkComa) { Error("parsing pragma error syntax "); @@ -1514,7 +1514,7 @@ bool MIRParser::ParseTypedef() { } else { prevTyIdx = mod.GetTypeNameTab()->GetTyIdxFromGStrIdx(strIdx); mod.GetTypeNameTab()->SetGStrIdxToTyIdx(strIdx, tyIdx); - mod.GetTypeDefOrder().push_back(strIdx); + mod.PushbackTypeDefOrder(strIdx); ASSERT(GlobalTables::GetTypeTable().GetTypeTable().empty() == false, "container check"); if (GlobalTables::GetTypeTable().GetTypeFromTyIdx(tyIdx)->GetNameStrIdx() == 0) { GlobalTables::GetTypeTable().GetTypeFromTyIdx(tyIdx)->SetNameStrIdx(strIdx); @@ -1954,7 +1954,7 @@ bool MIRParser::ParseInitValue(MIRConstPtr &theConst, TyIdx tyIdx) { } lexer.NextToken(); } else if (IsConstAddrExpr(tokenKind)) { - if (!ParseConstAddrLeafExpr(mirConst, type)) { + if (!ParseConstAddrLeafExpr(mirConst, *type)) { Error("ParseInitValue expect const addr expr"); return false; } @@ -1985,7 +1985,7 @@ bool MIRParser::ParseInitValue(MIRConstPtr &theConst, TyIdx tyIdx) { } lexer.NextToken(); } else if (IsConstAddrExpr(tokenKind)) { - if (!ParseConstAddrLeafExpr(subConst, type)) { + if (!ParseConstAddrLeafExpr(subConst, *type)) { Error("ParseInitValue expect const addr expr"); return false; } @@ -2059,7 +2059,7 @@ bool MIRParser::ParseInitValue(MIRConstPtr &theConst, TyIdx tyIdx) { } lexer.NextToken(); } else if (IsConstAddrExpr(tokenKind)) { - if (!ParseConstAddrLeafExpr(subConst, type)) { + if (!ParseConstAddrLeafExpr(subConst, *type)) { Error("ParseInitValue expect const addr expr"); return false; } @@ -2512,12 +2512,12 @@ bool MIRParser::ParseMIRForFileInfo() { tk = lexer.NextToken(); if (tk == kTkIntconst) { uint32 fieldval = lexer.GetTheIntVal(); - mod.GetFileInfo().push_back(MIRInfoPair(stridx, fieldval)); - mod.GetFileInfoIsString().push_back(false); + mod.PushFileInfoPair(MIRInfoPair(stridx, fieldval)); + mod.PushFileInfoIsString(false); } else if (tk == kTkString) { GStrIdx litstridx = GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(lexer.GetName()); - mod.GetFileInfo().push_back(MIRInfoPair(stridx, litstridx.GetIdx())); - mod.GetFileInfoIsString().push_back(true); + mod.PushFileInfoPair(MIRInfoPair(stridx, litstridx.GetIdx())); + mod.PushFileInfoIsString(true); } else { Error("illegal value after fileInfo field name at "); return false; @@ -2554,7 +2554,7 @@ bool MIRParser::ParseMIRForFileData() { data.push_back(fieldval); tk = lexer.NextToken(); } - mod.GetFileData().push_back(MIRDataPair(stridx, data)); + mod.PushbackFileData(MIRDataPair(stridx, data)); if (tk == kTkComa) { tk = lexer.NextToken(); } else if (tk == kTkRbrace) { @@ -2581,7 +2581,7 @@ bool MIRParser::ParseMIRForSrcFileInfo() { tk = lexer.NextToken(); if (tk == kTkString) { GStrIdx stridx = GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(lexer.GetName()); - mod.GetSrcFileInfo().push_back(MIRInfoPair(stridx, fieldval)); + mod.PushbackFileInfo(MIRInfoPair(stridx, fieldval)); } else { Error("illegal value after srcfileinfo field name at "); return false; @@ -2654,7 +2654,7 @@ bool MIRParser::ParseMIRForImport() { auto it = mod.GetImportFiles().begin(); mod.GetImportFiles().insert(it, strIdx); // record the imported file for later reading summary info, if exists - mod.GetImportedMplt().push_back(importFileName); + mod.PushbackImportedMplt(importFileName); lexer.NextToken(); return true; } @@ -2666,7 +2666,7 @@ bool MIRParser::ParseMIRForImportPath() { return false; } GStrIdx litStrIdx = GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(lexer.GetName()); - mod.GetImportPaths().push_back(litStrIdx); + mod.PushbackImportPath(litStrIdx); lexer.NextToken(); return true; } diff --git a/src/maple_me/include/me_ir.h b/src/maple_me/include/me_ir.h index f4221f7edf27134e3323e002d06f7538f7dc4451..ae21b716d95ff67092b47398ecc335443dbe116e 100644 --- a/src/maple_me/include/me_ir.h +++ b/src/maple_me/include/me_ir.h @@ -331,13 +331,13 @@ class VarMeExpr final : public MeExpr { class MeVarPhiNode { public: explicit MeVarPhiNode(MapleAllocator *alloc) - : lhs(nullptr), opnds(kOprandNumBinary, nullptr, alloc->Adapter()), isLive(true), defBB(nullptr) { + : lhs(nullptr), opnds(kOperandNumBinary, nullptr, alloc->Adapter()), isLive(true), defBB(nullptr) { opnds.pop_back(); opnds.pop_back(); } MeVarPhiNode(VarMeExpr *var, MapleAllocator *alloc) - : lhs(var), opnds(kOprandNumBinary, nullptr, alloc->Adapter()), isLive(true), defBB(nullptr) { + : lhs(var), opnds(kOperandNumBinary, nullptr, alloc->Adapter()), isLive(true), defBB(nullptr) { var->SetDefPhi(*this); var->SetDefBy(kDefByPhi); opnds.pop_back(); @@ -507,7 +507,7 @@ class RegMeExpr : public MeExpr { class MeRegPhiNode { public: explicit MeRegPhiNode(MapleAllocator *alloc) - : lhs(nullptr), opnds(kOprandNumBinary, nullptr, alloc->Adapter()), isLive(true), defBB(nullptr) { + : lhs(nullptr), opnds(kOperandNumBinary, nullptr, alloc->Adapter()), isLive(true), defBB(nullptr) { opnds.pop_back(); opnds.pop_back(); } @@ -807,12 +807,12 @@ class OpMeExpr : public MeExpr { bool IsUseSameSymbol(const MeExpr &) const override; BaseNode &EmitExpr(SSATab &) override; MeExpr *GetOpnd(size_t i) const override { - CHECK_FATAL(i < kOprandNumTernary, "OpMeExpr cannot have more than 3 operands"); + CHECK_FATAL(i < kOperandNumTernary, "OpMeExpr cannot have more than 3 operands"); return opnds[i]; } void SetOpnd(uint32 idx, MeExpr *opndsVal) { - CHECK_FATAL(idx < kOprandNumTernary, "out of range in OpMeExpr::SetOpnd"); + CHECK_FATAL(idx < kOperandNumTernary, "out of range in OpMeExpr::SetOpnd"); opnds[idx] = opndsVal; } @@ -869,7 +869,7 @@ class OpMeExpr : public MeExpr { } private: - std::array opnds = { nullptr }; // kid + std::array opnds = { nullptr }; // kid PrimType opndType = kPtyInvalid; // from type uint8 bitsOffset = 0; uint8 bitsSize = 0; @@ -888,7 +888,7 @@ class IvarMeExpr : public MeExpr { fieldID(0), maybeNull(true), mu(nullptr) { - SetNumOpnds(kOprandNumUnary); + SetNumOpnds(kOperandNumUnary); } IvarMeExpr(int32 exprid, const IvarMeExpr &ivarme) @@ -1438,7 +1438,7 @@ class DassignMeStmt : public MeStmt { ~DassignMeStmt() = default; size_t NumMeStmtOpnds() const { - return kOprandNumUnary; + return kOperandNumUnary; } MeExpr *GetOpnd(size_t) const { @@ -1563,7 +1563,7 @@ class RegassignMeStmt : public MeStmt { ~RegassignMeStmt() = default; size_t NumMeStmtOpnds() const { - return kOprandNumUnary; + return kOperandNumUnary; } MeExpr *GetOpnd(size_t) const { @@ -1629,7 +1629,7 @@ class MaydassignMeStmt : public MeStmt { ~MaydassignMeStmt() = default; size_t NumMeStmtOpnds() const { - return kOprandNumUnary; + return kOperandNumUnary; } MeExpr *GetOpnd(size_t) const { @@ -1753,7 +1753,7 @@ class IassignMeStmt : public MeStmt { } size_t NumMeStmtOpnds() const { - return kOprandNumBinary; + return kOperandNumBinary; } MeExpr *GetOpnd(size_t idx) const { @@ -2252,7 +2252,7 @@ class UnaryMeStmt : public MeStmt { virtual ~UnaryMeStmt() = default; size_t NumMeStmtOpnds() const { - return kOprandNumUnary; + return kOperandNumUnary; } MeExpr *GetOpnd(size_t idx) const { @@ -2462,7 +2462,7 @@ class ThrowMeStmt : public WithMuMeStmt { ~ThrowMeStmt() = default; size_t NumMeStmtOpnds() const { - return kOprandNumUnary; + return kOperandNumUnary; } MeExpr *GetOpnd(size_t idx) const { @@ -2539,12 +2539,12 @@ class AssertMeStmt : public MeStmt { } void SetOpnd(uint32 i, MeExpr *opnd) { - CHECK_FATAL(i < kOprandNumBinary, "AssertMeStmt has two opnds"); + CHECK_FATAL(i < kOperandNumBinary, "AssertMeStmt has two opnds"); opnds[i] = opnd; } MeExpr *GetOpnd(size_t i) const { - CHECK_FATAL(i < kOprandNumBinary, "AssertMeStmt has two opnds"); + CHECK_FATAL(i < kOperandNumBinary, "AssertMeStmt has two opnds"); return opnds[i]; } @@ -2552,7 +2552,7 @@ class AssertMeStmt : public MeStmt { StmtNode &EmitStmt(SSATab &ssatab); private: - MeExpr *opnds[kOprandNumBinary]; + MeExpr *opnds[kOperandNumBinary]; AssertMeStmt &operator=(const AssertMeStmt &assmestmt) { if (&assmestmt == this) { return *this; diff --git a/src/maple_me/include/ssa.h b/src/maple_me/include/ssa.h index 92832b96a1299c56d297e52c5f32b5fbc344fb90..54ab62007c44b7a1e5942588e17fb15ada79ce44 100644 --- a/src/maple_me/include/ssa.h +++ b/src/maple_me/include/ssa.h @@ -26,7 +26,7 @@ class VersionStTable; class SSATab; class PhiNode { public: - PhiNode(MapleAllocator *alloc, VersionSt *vsym) : result(vsym), phiOpnds(kNumOpnds, nullptr, alloc->Adapter()) { + PhiNode(MapleAllocator &alloc, VersionSt &vsym) : result(&vsym), phiOpnds(kNumOpnds, nullptr, alloc.Adapter()) { phiOpnds.pop_back(); phiOpnds.pop_back(); } @@ -39,8 +39,8 @@ class PhiNode { return result; } - void SetResult(VersionSt *resultPara) { - result = resultPara; + void SetResult(VersionSt &resultPara) { + result = &resultPara; } MapleVector &GetPhiOpnds() { @@ -52,9 +52,9 @@ class PhiNode { return phiOpnds.at(index); } - void SetPhiOpnd(size_t index, VersionSt *opnd) { + void SetPhiOpnd(size_t index, VersionSt &opnd) { CHECK_FATAL(index < phiOpnds.size(), "out of range in PhiNode::SetPhiOpnd"); - phiOpnds[index] = opnd; + phiOpnds[index] = &opnd; } void SetPhiOpnds(MapleVector phiOpndsPara) { @@ -69,12 +69,12 @@ class PhiNode { class SSA { public: - SSA(MemPool *memPool, SSATab *stab) - : ssaAlloc(memPool), + SSA(MemPool &memPool, SSATab &stab) + : ssaAlloc(&memPool), vstStacks(ssaAlloc.Adapter()), vstVersions(ssaAlloc.Adapter()), bbRenamed(ssaAlloc.Adapter()), - ssaTab(stab) {} + ssaTab(&stab) {} virtual ~SSA() = default; diff --git a/src/maple_me/src/bb.cpp b/src/maple_me/src/bb.cpp index f19f444209348680e54df732c24b5fea055cb535..22bc1721766f907413018d67ad0b432637182c6c 100644 --- a/src/maple_me/src/bb.cpp +++ b/src/maple_me/src/bb.cpp @@ -113,7 +113,7 @@ const PhiNode *BB::PhiofVerStInserted(const VersionSt &versionSt) const { } void BB::InsertPhi(MapleAllocator *alloc, VersionSt *versionSt) { - PhiNode phiNode(alloc, versionSt); + PhiNode phiNode(*alloc, *versionSt); for (auto prevIt = pred.begin(); prevIt != pred.end(); prevIt++) { phiNode.GetPhiOpnds().push_back(versionSt); } diff --git a/src/maple_me/src/irmap.cpp b/src/maple_me/src/irmap.cpp index cecf8cfcfc446065aa16c8fa05f40651744ba7de..8966c4402736dfc8994945d23b43ae1a0dfc4ae1 100644 --- a/src/maple_me/src/irmap.cpp +++ b/src/maple_me/src/irmap.cpp @@ -1067,7 +1067,7 @@ MeExpr *IRMap::ReplaceMeExprExpr(MeExpr &origExpr, MeExpr &meExpr, MeExpr &repEx OpMeExpr &opMeExpr = static_cast(origExpr); OpMeExpr newMeExpr(opMeExpr, kInvalidExprID); bool needRehash = false; - for (uint32 i = 0; i < kOprandNumTernary; i++) { + for (uint32 i = 0; i < kOperandNumTernary; i++) { if (!opMeExpr.GetOpnd(i)) { continue; } @@ -1292,7 +1292,7 @@ MeExpr *IRMap::CreateMeExprBinary(Opcode op, PrimType ptyp, MeExpr &expr0, MeExp OpMeExpr opmeexpr(kInvalidExprID); opmeexpr.SetOpnd(0, &expr0); opmeexpr.SetOpnd(1, &expr1); - opmeexpr.InitBase(op, ptyp, kOprandNumBinary); + opmeexpr.InitBase(op, ptyp, kOperandNumBinary); return HashMeExpr(opmeexpr); } @@ -1301,7 +1301,7 @@ MeExpr *IRMap::CreateMeExprSelect(PrimType ptyp, MeExpr &expr0, MeExpr &expr1, M opmeexpr.SetOpnd(0, &expr0); opmeexpr.SetOpnd(1, &expr1); opmeexpr.SetOpnd(2, &expr2); - opmeexpr.InitBase(OP_select, ptyp, kOprandNumTernary); + opmeexpr.InitBase(OP_select, ptyp, kOperandNumTernary); return HashMeExpr(opmeexpr); } @@ -1309,7 +1309,7 @@ MeExpr *IRMap::CreateMeExprCompare(Opcode op, PrimType resptyp, PrimType opndpty OpMeExpr opmeexpr(kInvalidExprID); opmeexpr.SetOpnd(0, &opnd0); opmeexpr.SetOpnd(1, &opnd1); - opmeexpr.InitBase(op, resptyp, kOprandNumBinary); + opmeexpr.InitBase(op, resptyp, kOperandNumBinary); opmeexpr.SetOpndType(opndptyp); MeExpr *retmeexpr = HashMeExpr(opmeexpr); static_cast(retmeexpr)->SetOpndType(opndptyp); @@ -1319,7 +1319,7 @@ MeExpr *IRMap::CreateMeExprCompare(Opcode op, PrimType resptyp, PrimType opndpty MeExpr *IRMap::CreateMeExprTypeCvt(PrimType ptyp, PrimType opndptyp, MeExpr &opnd0) { OpMeExpr opmeexpr(kInvalidExprID); opmeexpr.SetOpnd(0, &opnd0); - opmeexpr.InitBase(OP_cvt, ptyp, kOprandNumUnary); + opmeexpr.InitBase(OP_cvt, ptyp, kOperandNumUnary); opmeexpr.SetOpndType(opndptyp); return HashMeExpr(opmeexpr); } diff --git a/src/maple_me/src/me_cfg.cpp b/src/maple_me/src/me_cfg.cpp index 737603264238c5e9e0d3010a18d46a2cd41f6d7e..a826b8e4b7efd571a54f0bb78139782432f59dfb 100644 --- a/src/maple_me/src/me_cfg.cpp +++ b/src/maple_me/src/me_cfg.cpp @@ -324,7 +324,7 @@ void MeCFG::FixMirCFG() { targetSt->ResetIsDeleted(); if (stmt->GetOpCode() == OP_dassign) { BaseNode *rhs = static_cast(stmt)->GetRHS(); - StmtNode *dassign = builder->CreateStmtDassign(targetSt, 0, rhs); + StmtNode *dassign = builder->CreateStmtDassign(*targetSt, 0, rhs); bb->ReplaceStmt(stmt, dassign); stmt = dassign; } else { @@ -333,7 +333,7 @@ void MeCFG::FixMirCFG() { retPair.first = targetSt->GetStIdx(); cnode->SetReturnPair(retPair, 0); } - StmtNode *dassign = builder->CreateStmtDassign(sym, 0, builder->CreateExprDread(targetSt)); + StmtNode *dassign = builder->CreateStmtDassign(*sym, 0, builder->CreateExprDread(*targetSt)); if (stmt->GetNext() != nullptr) { bb->InsertStmtBefore(stmt->GetNext(), dassign); } else { @@ -466,10 +466,10 @@ void MeCFG::ConvertPhis2IdentityAssigns(BB &meBB) const { if (ost->IsSymbolOst() && ost->GetIndirectLev() == 0) { const MIRSymbol *st = ost->GetMIRSymbol(); MIRType *type = GlobalTables::GetTypeTable().GetTypeFromTyIdx(st->GetTyIdx()); - AddrofNode *dread = func.GetMIRModule().GetMIRBuilder()->CreateDread(st, GetRegPrimType(type->GetPrimType())); + AddrofNode *dread = func.GetMIRModule().GetMIRBuilder()->CreateDread(*st, GetRegPrimType(type->GetPrimType())); AddrofSSANode *dread2 = func.GetMirFunc()->GetCodeMemPool()->New(dread); dread2->SetSSAVar((*phiIt).second.GetPhiOpnd(0)); - DassignNode *dassign = func.GetMIRModule().GetMIRBuilder()->CreateStmtDassign(st, 0, dread2); + DassignNode *dassign = func.GetMIRModule().GetMIRBuilder()->CreateStmtDassign(*st, 0, dread2); func.GetMeSSATab()->GetStmtsSSAPart().SetSSAPartOf( *dassign, func.GetMeSSATab()->GetStmtsSSAPart().GetSSAPartMp()->New( &func.GetMeSSATab()->GetStmtsSSAPart().GetSSAPartAlloc())); diff --git a/src/maple_me/src/me_ir.cpp b/src/maple_me/src/me_ir.cpp index 5d57421aae26a53048f88b8fe1d7f9271846eedf..56974f117faa8b71eb471f687b352429db0d8e55 100644 --- a/src/maple_me/src/me_ir.cpp +++ b/src/maple_me/src/me_ir.cpp @@ -427,7 +427,7 @@ bool OpMeExpr::IsUseSameSymbol(const MeExpr &expr) const { return false; } auto &opMeExpr = static_cast(expr); - for (uint32 i = 0; i < kOprandNumTernary; i++) { + for (uint32 i = 0; i < kOperandNumTernary; i++) { if (opnds[i]) { if (!opMeExpr.opnds[i]) { return false; diff --git a/src/maple_me/src/me_rc_lowering.cpp b/src/maple_me/src/me_rc_lowering.cpp index 79eb0920b072e283cde264ef51123ddb73d5b139..4c37e11977f4ac47976eedcf4e5aa9921bb12e13 100644 --- a/src/maple_me/src/me_rc_lowering.cpp +++ b/src/maple_me/src/me_rc_lowering.cpp @@ -70,7 +70,7 @@ void RCLowering::MarkAllRefOpnds() { continue; } if (lhsRef->GetMeOp() == kMeOpVar) { - VarMeExpr *var = static_cast(lhsRef); + auto *var = static_cast(lhsRef); cleanUpVars[var->GetOStIdx()] = var; ssaTab.UpdateVarOstMap(var->GetOStIdx(), varOStMap); } @@ -138,7 +138,7 @@ MIRIntrinsicID RCLowering::PrepareVolatileCall(MeStmt &stmt, MIRIntrinsicID intr } IntrinsiccallMeStmt *RCLowering::GetVarRHSHandleStmt(MeStmt &stmt) { - VarMeExpr *var = static_cast(stmt.GetRHS()); + auto *var = static_cast(stmt.GetRHS()); const MIRSymbol *sym = ssaTab.GetMIRSymbolFromID(var->GetOStIdx()); if (!sym->IsGlobal() || sym->IsFinal()) { return nullptr; @@ -157,7 +157,7 @@ IntrinsiccallMeStmt *RCLowering::GetVarRHSHandleStmt(MeStmt &stmt) { } IntrinsiccallMeStmt *RCLowering::GetIvarRHSHandleStmt(MeStmt &stmt) { - IvarMeExpr *ivar = static_cast(stmt.GetRHS()); + auto *ivar = static_cast(stmt.GetRHS()); if (ivar->IsFinal()) { return nullptr; } @@ -221,7 +221,7 @@ void RCLowering::HandleCallAssignedMeStmt(MeStmt &stmt, MeExpr *pendingDec) { if (lhs->GetMeOp() != kMeOpVar) { return; } - OriginalSt *ost = ssaTab.GetOriginalStFromID(static_cast(lhs)->GetOStIdx()); + auto *ost = ssaTab.GetOriginalStFromID(static_cast(lhs)->GetOStIdx()); if (!ost->IsSymbolOst()) { return; } @@ -275,7 +275,7 @@ bool RCLowering::RCFirst(MeExpr &rhs) { if (rhs.GetMeOp() == kMeOpConst) { return static_cast(rhs).IsZero(); } else if (rhs.GetMeOp() == kMeOpVar) { - VarMeExpr &rhsVar = static_cast(rhs); + auto &rhsVar = static_cast(rhs); const MIRSymbol *sym = ssaTab.GetMIRSymbolFromID(rhsVar.GetOStIdx()); return sym->IsLocal(); } @@ -400,20 +400,20 @@ bool RCLowering::IsInitialized(IvarMeExpr &ivar) { return true; } MIRType *baseType = GlobalTables::GetTypeTable().GetTypeFromTyIdx(ivar.GetTyIdx()); - ASSERT(dynamic_cast(baseType), "unexpected type"); - MIRType *ptype = static_cast(baseType)->GetPointedType(); + ASSERT(dynamic_cast(baseType) != nullptr, "unexpected type"); + auto *ptype = static_cast(baseType)->GetPointedType(); MIRClassType *classType = dynamic_cast(ptype); return classType == nullptr || !classType->IsOwnField(fieldID); } void RCLowering::HandleAssignMeStmtIvarLHS(MeStmt &stmt) { - IassignMeStmt &iassign = static_cast(stmt); + auto &iassign = static_cast(stmt); IvarMeExpr *lhsInner = iassign.GetLHSVal(); FieldID fieldID = lhsInner->GetFieldID(); MIRType *baseType = GlobalTables::GetTypeTable().GetTypeFromTyIdx(lhsInner->GetTyIdx()); - ASSERT(dynamic_cast(baseType), "unexpected type"); - MIRType *ptype = static_cast(baseType)->GetPointedType(); - MIRClassType *classType = dynamic_cast(ptype); + ASSERT(dynamic_cast(baseType) != nullptr, "unexpected type"); + auto *ptype = static_cast(baseType)->GetPointedType(); + auto *classType = dynamic_cast(ptype); // skip RC operation if the field is unowned if (classType != nullptr && classType->IsFieldRCUnownedRef(fieldID)) { return; @@ -507,7 +507,7 @@ void RCLowering::InitializedObjectFields(MeStmt &stmt) { if (stmt.GetOp() != OP_callassigned) { return; } - CallMeStmt &call = static_cast(stmt); + auto &call = static_cast(stmt); MIRFunction *callee = GlobalTables::GetFunctionTable().GetFunctionFromPuidx(call.GetPUIdx()); if (call.NumMeStmtOpnds() == 0 || call.GetOpnd(0)->GetMeOp() != kMeOpVar) { return; @@ -567,7 +567,7 @@ IntrinsiccallMeStmt *FindCleanupIntrinsic(MeStmt &ret) { auto &meStmts = ret.GetBB()->GetMeStmts(); for (auto iter = meStmts.rbegin(); iter != meStmts.rend(); ++iter) { if (CheckOp(to_ptr(iter), OP_intrinsiccall)) { - IntrinsiccallMeStmt *intrinsicCall = static_cast(to_ptr(iter)); + auto *intrinsicCall = static_cast(to_ptr(iter)); if (intrinsicCall->GetIntrinsic() == INTRN_MPL_CLEANUP_LOCALREFVARS) { return intrinsicCall; } @@ -577,7 +577,7 @@ IntrinsiccallMeStmt *FindCleanupIntrinsic(MeStmt &ret) { } void RCLowering::HandleReturnVar(RetMeStmt &ret) { - VarMeExpr *retVar = static_cast(ret.GetOpnd(0)); + auto *retVar = static_cast(ret.GetOpnd(0)); CHECK_FATAL(retVar != nullptr, "retVal null ptr check"); MIRSymbol *sym = ssaTab.GetMIRSymbolFromID(retVar->GetOStIdx()); if (sym != nullptr && sym->IgnoreRC()) { @@ -600,7 +600,7 @@ void RCLowering::HandleReturnVar(RetMeStmt &ret) { void RCLowering::HandleReturnGlobal(RetMeStmt &ret) { BB *bb = ret.GetBB(); CHECK_FATAL(bb != nullptr, "bb null ptr check"); - VarMeExpr *retVar = static_cast(ret.GetOpnd(0)); + auto *retVar = static_cast(ret.GetOpnd(0)); CHECK_FATAL(retVar != nullptr, "retVal null ptr check"); std::vector opnds = { irMap.CreateAddrofMeExpr(*retVar) }; IntrinsiccallMeStmt *loadCall = CreateRCIntrinsic(INTRN_MCCLoadRefS, ret, opnds, true); @@ -611,7 +611,7 @@ void RCLowering::HandleReturnGlobal(RetMeStmt &ret) { void RCLowering::HandleReturnRegread(RetMeStmt &ret) { BB *bb = ret.GetBB(); CHECK_FATAL(bb != nullptr, "bb null ptr check"); - VarMeExpr *retVar = static_cast(ret.GetOpnd(0)); + auto *retVar = static_cast(ret.GetOpnd(0)); CHECK_FATAL(retVar != nullptr, "retVal null ptr check"); IntrinsiccallMeStmt *cleanup = FindCleanupIntrinsic(ret); if (cleanup == nullptr) { @@ -635,7 +635,7 @@ void RCLowering::HandleReturnRegread(RetMeStmt &ret) { void RCLowering::HandleReturnFormal(RetMeStmt &ret) { BB *bb = ret.GetBB(); CHECK_FATAL(bb != nullptr, "bb null ptr check"); - VarMeExpr *retVar = static_cast(ret.GetOpnd(0)); + auto *retVar = static_cast(ret.GetOpnd(0)); CHECK_FATAL(retVar != nullptr, "retVal null ptr check"); std::vector opnds = { retVar }; IntrinsiccallMeStmt *increfStmt = CreateRCIntrinsic(INTRN_MCCIncRef, ret, opnds, true); @@ -650,7 +650,7 @@ void RCLowering::HandleReturnFormal(RetMeStmt &ret) { void RCLowering::HandleReturnIvar(RetMeStmt &ret) { // insert calls - IvarMeExpr *retIvar = static_cast(ret.GetOpnd(0)); + auto *retIvar = static_cast(ret.GetOpnd(0)); if (retIvar->IsVolatile()) { std::vector opnds = { &retIvar->GetBase()->GetAddrExprBase(), irMap.CreateAddrofMeExpr(*retIvar) }; IntrinsiccallMeStmt *loadCall = CreateRCIntrinsic(PrepareVolatileCall(ret, INTRN_MCCLoadRefVol), ret, opnds, true); @@ -669,7 +669,7 @@ void RCLowering::HandleReturnReg(RetMeStmt &ret) { * if the register with ref value is defined by callassigned or gcmalloc * return incref should have been delegated and not needed. */ - RegMeExpr *regRet = static_cast(ret.GetOpnd(0)); + auto *regRet = static_cast(ret.GetOpnd(0)); if (regRet->GetDefBy() == kDefByMustDef) { return; } @@ -688,7 +688,7 @@ void RCLowering::HandleReturnReg(RetMeStmt &ret) { void RCLowering::HandleReturnWithCleanup() { for (auto *stmt : rets) { - RetMeStmt *ret = static_cast(stmt); + auto *ret = static_cast(stmt); IntrinsiccallMeStmt *cleanup = FindCleanupIntrinsic(*ret); if (cleanup != nullptr && !tmpLocalRefVars.empty()) { // new localrefvar introduced in this phase for (auto tmpVar : tmpLocalRefVars) { @@ -728,7 +728,7 @@ void RCLowering::HandleReturnNeedBackup() { * temp with the temp being returned */ for (auto *stmt : rets) { - RetMeStmt *ret = static_cast(stmt); + auto *ret = static_cast(stmt); if (ret->NumMeStmtOpnds() == 0) { continue; } @@ -834,10 +834,10 @@ VarMeExpr *RCLowering::CreateNewTmpVarMeExpr(bool isLocalrefvar) { } AnalysisResult *MeDoRCLowering::Run(MeFunction *func, MeFuncResultMgr *m, ModuleResultMgr *mrm) { - KlassHierarchy *kh = static_cast(mrm->GetAnalysisResult(MoPhase_CHA, &func->GetMIRModule())); + auto *kh = static_cast(mrm->GetAnalysisResult(MoPhase_CHA, &func->GetMIRModule())); ASSERT(kh != nullptr, "KlassHierarchy has problem"); if (func->GetIRMap() == nullptr) { - MeIRMap *hmap = static_cast(m->GetAnalysisResult(MeFuncPhase_IRMAP, func)); + auto *hmap = static_cast(m->GetAnalysisResult(MeFuncPhase_IRMAP, func)); CHECK_FATAL(hmap != nullptr, "hssamap has problem"); func->SetIRMap(hmap); } diff --git a/src/maple_me/src/me_ssa.cpp b/src/maple_me/src/me_ssa.cpp index 061602e4f2026e9abc1b2ac9f9ad2aea9c6f04d2..c80f2bf939aeec4fa79470165fd54805905822d6 100644 --- a/src/maple_me/src/me_ssa.cpp +++ b/src/maple_me/src/me_ssa.cpp @@ -144,7 +144,7 @@ void MeSSA::InsertPhiNode() { } MeSSA::MeSSA(MeFunction *func, Dominance *dom, MemPool *memPool) - : SSA(memPool, func->GetMeSSATab()), AnalysisResult(memPool), func(func), dom(dom) {} + : SSA(*memPool, *func->GetMeSSATab()), AnalysisResult(memPool), func(func), dom(dom) {} void MeSSA::RenameBB(BB &bb) { if (GetBBRenamed(bb.GetBBId().idx)) { diff --git a/src/maple_me/src/ssa.cpp b/src/maple_me/src/ssa.cpp index 0bd50e87c6631369d1bfcec2991309e54330b4a0..dcc4214b1a8bb4e0967e848911a35f151f14bda1 100644 --- a/src/maple_me/src/ssa.cpp +++ b/src/maple_me/src/ssa.cpp @@ -54,7 +54,7 @@ void SSA::RenamePhi(BB &bb) { return; } VersionSt *newVersionSym = CreateNewVersion(*vsym, bb); - (*phiIt).second.SetResult(newVersionSym); + (*phiIt).second.SetResult(*newVersionSym); newVersionSym->SetDefType(VersionSt::kPhi); newVersionSym->SetPhi(&(*phiIt).second); } @@ -178,7 +178,7 @@ void SSA::RenamePhiUseInSucc(BB &bb) { for (auto phiIt = succBB->GetPhiList().begin(); phiIt != succBB->GetPhiList().end(); phiIt++) { PhiNode &phiNode = phiIt->second; ASSERT(phiNode.GetPhiOpnd(index)->GetOrigIdx().idx < vstStacks.size(), "out of range SSA::RenamePhiUseInSucc"); - phiNode.SetPhiOpnd(index, vstStacks.at(phiNode.GetPhiOpnd(index)->GetOrigIdx().idx)->top()); + phiNode.SetPhiOpnd(index, *vstStacks.at(phiNode.GetPhiOpnd(index)->GetOrigIdx().idx)->top()); } } } diff --git a/src/maple_util/include/ptr_list_ref.h b/src/maple_util/include/ptr_list_ref.h index 5bd4003b3d4187dbc035f4241f46a5b1af749751..1f58e60e04362c26c64053b81a629ae8fc5076c8 100644 --- a/src/maple_util/include/ptr_list_ref.h +++ b/src/maple_util/include/ptr_list_ref.h @@ -405,7 +405,7 @@ class PtrListRef { this->last = nullptr; } else if (_Where == this->begin()) { this->first = _Where->GetNext(); - ASSERT(this->first, "null ptr check"); + ASSERT(this->first != nullptr, "null ptr check"); this->first->SetPrev(nullptr); } else if (_Where == this->rbegin().base()) { pop_back(); diff --git a/src/mpl2mpl/src/class_init.cpp b/src/mpl2mpl/src/class_init.cpp index 9764f77af3be289ec5fafd0e1fe2bf16b56157ae..bf91120ff6c29ea1482a49591ff78c7f6b9be331 100644 --- a/src/mpl2mpl/src/class_init.cpp +++ b/src/mpl2mpl/src/class_init.cpp @@ -41,7 +41,7 @@ void ClassInit::GenClassInitCheckProfile(MIRFunction &func, MIRSymbol &classinfo void ClassInit::GenPreClassInitCheck(MIRFunction &func, const MIRSymbol &classinfo, StmtNode *clinit) { MIRFunction *preClinit = builder->GetOrCreateFunction(kMCCPreClinitCheck, (TyIdx)(PTY_void)); - BaseNode *classInfoNode = builder->CreateExprAddrof(0, &classinfo); + BaseNode *classInfoNode = builder->CreateExprAddrof(0, classinfo); MapleVector args(builder->GetCurrentFuncCodeMpAllocator()->Adapter()); args.push_back(classInfoNode); CallNode *callPreclinit = builder->CreateStmtCall(preClinit->GetPuidx(), args); @@ -50,7 +50,7 @@ void ClassInit::GenPreClassInitCheck(MIRFunction &func, const MIRSymbol &classin void ClassInit::GenPostClassInitCheck(MIRFunction &func, const MIRSymbol &classinfo, StmtNode *clinit) { MIRFunction *postClinit = builder->GetOrCreateFunction(kMCCPostClinitCheck, (TyIdx)(PTY_void)); - BaseNode *classInfoNode = builder->CreateExprAddrof(0, &classinfo); + BaseNode *classInfoNode = builder->CreateExprAddrof(0, classinfo); MapleVector args(builder->GetCurrentFuncCodeMpAllocator()->Adapter()); args.push_back(classInfoNode); CallNode *callPostclinit = builder->CreateStmtCall(postClinit->GetPuidx(), args); @@ -97,7 +97,7 @@ void ClassInit::ProcessFunc(MIRFunction *func) { CHECK_FATAL(klass != nullptr, "klass is nullptr in ClassInit::ProcessFunc"); if (klass->GetClinit() && func != klass->GetClinit()) { MIRSymbol *classInfo = GetClassInfo(className); - BaseNode *classInfoNode = builder->CreateExprAddrof(0, classInfo); + BaseNode *classInfoNode = builder->CreateExprAddrof(0, *classInfo); if (trace) { LogInfo::MapleLogger() << "\t- low-cost clinit - insert check in static method " << func->GetName() << "clasname " << className << std::endl; @@ -137,7 +137,7 @@ void ClassInit::ProcessFunc(MIRFunction *func) { } if (doClinitCheck) { MIRSymbol *classInfo = GetClassInfo(className); - AddrofNode *classInfoNode = builder->CreateExprAddrof(0, classInfo); + AddrofNode *classInfoNode = builder->CreateExprAddrof(0, *classInfo); MapleVector args(builder->GetCurrentFuncCodeMpAllocator()->Adapter()); args.push_back(classInfoNode); StmtNode *mplIntrinsicCall = builder->CreateStmtIntrinsicCall(INTRN_MPL_CLINIT_CHECK, args); @@ -161,7 +161,7 @@ MIRSymbol *ClassInit::GetClassInfo(const std::string &classname) { const std::string &classInfoName = CLASSINFO_PREFIX_STR + classname; MIRType *classInfoType = GlobalTables::GetTypeTable().GetOrCreateClassType(NameMangler::kClassMetadataTypeName, *GetModule()); - MIRSymbol *classInfo = builder->GetOrCreateGlobalDecl(classInfoName.c_str(), classInfoType); + MIRSymbol *classInfo = builder->GetOrCreateGlobalDecl(classInfoName.c_str(), *classInfoType); Klass *klass = klassHierarchy->GetKlassFromName(classname); if (klass == nullptr || !klass->GetMIRStructType()->IsLocal()) { classInfo->SetStorageClass(kScExtern); diff --git a/src/mpl2mpl/src/gen_check_cast.cpp b/src/mpl2mpl/src/gen_check_cast.cpp index a8d0471b04d965559f169231686ad9098eea132c..87e6dbdb0bcd689ffa47715547e21f7cbf1d2a54 100644 --- a/src/mpl2mpl/src/gen_check_cast.cpp +++ b/src/mpl2mpl/src/gen_check_cast.cpp @@ -104,7 +104,7 @@ void CheckCastGenerator::GenCheckCast(BaseNode &stmt) { if (callNode->GetNopndAt(0)->GetPrimType() != PTY_ref && callNode->GetNopndAt(0)->GetPrimType() != PTY_ptr) { // If source = Ljava_2Flang_2FObject_3B, sub = primitive type then throw CastException. MIRSymbol *classSt = GetOrCreateClassInfoSymbol(checkKlass->GetKlassName()); - BaseNode *valueExpr = builder->CreateExprAddrof(0, classSt); + BaseNode *valueExpr = builder->CreateExprAddrof(0, *classSt); MapleVector args(builder->GetCurrentFuncCodeMpAllocator()->Adapter()); args.push_back(valueExpr); args.push_back(callNode->GetNopndAt(0)); @@ -114,21 +114,21 @@ void CheckCastGenerator::GenCheckCast(BaseNode &stmt) { } } else { MIRSymbol *classSt = GetOrCreateClassInfoSymbol(checkKlass->GetKlassName()); - BaseNode *valueExpr = builder->CreateExprAddrof(0, classSt); + BaseNode *valueExpr = builder->CreateExprAddrof(0, *classSt); BaseNode *nullPtr = builder->CreateIntConst(0, PTY_ptr); const size_t callNodeNopndSize2 = callNode->GetNopndSize(); CHECK_FATAL(callNodeNopndSize2 > 0, "container check"); BaseNode *cond = - builder->CreateExprCompare(OP_ne, GlobalTables::GetTypeTable().GetUInt1(), - GlobalTables::GetTypeTable().GetPtr(), callNode->GetNopndAt(0), nullPtr); + builder->CreateExprCompare(OP_ne, *GlobalTables::GetTypeTable().GetUInt1(), + *GlobalTables::GetTypeTable().GetPtr(), callNode->GetNopndAt(0), nullPtr); IfStmtNode *ifStmt = static_cast(builder->CreateStmtIf(cond)); MIRType *mVoidPtr = GlobalTables::GetTypeTable().GetVoidPtr(); CHECK_FATAL(mVoidPtr != nullptr, "builder->GetVoidPtr() is null in CheckCastGenerator::GenCheckCast"); BaseNode *opnd = callNode->GetNopndAt(0); BaseNode *ireadExpr = GetObjectShadow(opnd); - BaseNode *innerCond = builder->CreateExprCompare(OP_ne, GlobalTables::GetTypeTable().GetUInt1(), - GlobalTables::GetTypeTable().GetPtr(), valueExpr, ireadExpr); + BaseNode *innerCond = builder->CreateExprCompare(OP_ne, *GlobalTables::GetTypeTable().GetUInt1(), + *GlobalTables::GetTypeTable().GetPtr(), valueExpr, ireadExpr); IfStmtNode *innerIfStmt = static_cast(builder->CreateStmtIf(innerCond)); MapleVector args(builder->GetCurrentFuncCodeMpAllocator()->Adapter()); args.push_back(valueExpr); @@ -164,7 +164,7 @@ void CheckCastGenerator::GenCheckCast(BaseNode &stmt) { } else { elemClassSt = GetOrCreateClassInfoSymbol(elementName); } - BaseNode *valueExpr = builder->CreateExprAddrof(0, elemClassSt); + BaseNode *valueExpr = builder->CreateExprAddrof(0, *elemClassSt); UStrIdx stridx = GlobalTables::GetUStrTable().GetOrCreateStrIdxFromName(jarrayType->GetJavaName()); ConststrNode *signatureNode = currFunc->GetCodeMempool()->New(stridx); signatureNode->SetPrimType(PTY_ptr); @@ -269,7 +269,8 @@ void CheckCastGenerator::GenAllCheckCast() { BaseNode *CheckCastGenerator::GetObjectShadow(BaseNode *opnd) { FieldID fieldID = builder->GetStructFieldIDFromFieldNameParentFirst(WKTypes::Util::GetJavaLangObjectType(), NameMangler::kShadowClassName); - BaseNode *ireadExpr = builder->CreateExprIread(GlobalTables::GetTypeTable().GetPtr(), pointerObjType, fieldID, opnd); + BaseNode *ireadExpr = + builder->CreateExprIread(*GlobalTables::GetTypeTable().GetPtr(), *pointerObjType, fieldID, opnd); return ireadExpr; } diff --git a/src/mpl2mpl/src/java_eh_lower.cpp b/src/mpl2mpl/src/java_eh_lower.cpp index 5bd9f987fe42d4b885036bc0c84c15d71fa34564..795283a97cfd5a4f4135b6c622954a95fecda238 100644 --- a/src/mpl2mpl/src/java_eh_lower.cpp +++ b/src/mpl2mpl/src/java_eh_lower.cpp @@ -53,9 +53,9 @@ BaseNode *JavaEHLowerer::DoLowerDiv(BinaryNode *expr, BlockNode *blknode) { } else { MIRSymbol *divOpndSymbol = mirBuilder->CreateSymbol(TyIdx(ptype), opnd1name.c_str(), kStVar, kScAuto, GetModule()->CurFunction(), kScopeLocal); - DassignNode *dssDivNode = mirBuilder->CreateStmtDassign(divOpndSymbol, 0, divOpnd); + DassignNode *dssDivNode = mirBuilder->CreateStmtDassign(*divOpndSymbol, 0, divOpnd); blknode->AddStatement(dssDivNode); - divOpnd = mirBuilder->CreateExprDread(divOpndSymbol); + divOpnd = mirBuilder->CreateExprDread(*divOpndSymbol); } expr->SetBOpnd(divOpnd, 1); } @@ -71,13 +71,13 @@ BaseNode *JavaEHLowerer::DoLowerDiv(BinaryNode *expr, BlockNode *blknode) { MIRSymbol *divResSymbol = mirBuilder->CreateSymbol(TyIdx(ptype), resName.c_str(), kStVar, kScAuto, GetModule()->CurFunction(), kScopeLocal); // Put expr result to dssnode. - divStmt = mirBuilder->CreateStmtDassign(divResSymbol, 0, expr); - retExprNode = GetModule()->GetMIRBuilder()->CreateExprDread(divResSymbol, 0); + divStmt = mirBuilder->CreateStmtDassign(*divResSymbol, 0, expr); + retExprNode = GetModule()->GetMIRBuilder()->CreateExprDread(*divResSymbol, 0); } // Check if the second operand of the div expression is 0. // Inser if statement for high level ir. - CompareNode *cmpNode = mirBuilder->CreateExprCompare(OP_eq, GlobalTables::GetTypeTable().GetInt32(), - GlobalTables::GetTypeTable().GetTypeFromTyIdx((TyIdx)ptype), + CompareNode *cmpNode = mirBuilder->CreateExprCompare(OP_eq, *GlobalTables::GetTypeTable().GetInt32(), + *GlobalTables::GetTypeTable().GetTypeFromTyIdx((TyIdx)ptype), divOpnd, mirBuilder->CreateIntConst(0, ptype)); IfStmtNode *ifStmtNode = mirBuilder->CreateStmtIf(cmpNode); blknode->AddStatement(ifStmtNode); diff --git a/src/mpl2mpl/src/java_intrn_lowering.cpp b/src/mpl2mpl/src/java_intrn_lowering.cpp index bed2d6a29967031a347eb12831b4f9f5da9a9d00..84339e502d70a4e082a3c36d506742509cad09ae 100644 --- a/src/mpl2mpl/src/java_intrn_lowering.cpp +++ b/src/mpl2mpl/src/java_intrn_lowering.cpp @@ -114,18 +114,18 @@ BaseNode *JavaIntrnLowering::JavaIntrnMergeToCvtType(PrimType destType, PrimType MIRType *fromType = GlobalTables::GetTypeTable().GetPrimType(srcType); if (IsPrimitiveInteger(srcType) && IsPrimitiveFloat(destType)) { if (GetPrimTypeBitSize(srcType) == GetPrimTypeBitSize(destType)) { - return builder->CreateExprRetype(toType, fromType, src); + return builder->CreateExprRetype(*toType, *fromType, src); } else { - return builder->CreateExprTypeCvt(OP_cvt, toType, fromType, src); + return builder->CreateExprTypeCvt(OP_cvt, *toType, *fromType, src); } } else if (IsPrimitiveInteger(srcType) && IsPrimitiveInteger(destType)) { if (GetPrimTypeBitSize(srcType) >= GetPrimTypeBitSize(destType)) { if (destType == PTY_u1) { // e.g., type _Bool. - return builder->CreateExprCompare(OP_ne, toType, fromType, src, builder->CreateIntConst(0, srcType)); + return builder->CreateExprCompare(OP_ne, *toType, *fromType, src, builder->CreateIntConst(0, srcType)); } else if (GetPrimTypeBitSize(srcType) > GetPrimTypeBitSize(destType)) { - return builder->CreateExprTypeCvt(OP_cvt, toType, fromType, src); + return builder->CreateExprTypeCvt(OP_cvt, *toType, *fromType, src); } else if (IsSignedInteger(srcType) != IsSignedInteger(destType)) { - return builder->CreateExprTypeCvt(OP_cvt, toType, fromType, src); + return builder->CreateExprTypeCvt(OP_cvt, *toType, *fromType, src); } else { src->SetPrimType(destType); return src; @@ -133,7 +133,7 @@ BaseNode *JavaIntrnLowering::JavaIntrnMergeToCvtType(PrimType destType, PrimType // Force type cvt here because we currently do not run constant folding // or contanst propagation before CG. We may revisit this decision later. } else if (GetPrimTypeBitSize(srcType) < GetPrimTypeBitSize(destType)) { - return builder->CreateExprTypeCvt(OP_cvt, toType, fromType, src); + return builder->CreateExprTypeCvt(OP_cvt, *toType, *fromType, src); } else if (IsConstvalZero(src)) { return builder->CreateIntConst(0, destType); } else { @@ -162,15 +162,15 @@ 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); - JarrayMallocNode *newArrayNode = builder->CreateExprJarrayMalloc(OP_gcmallocjarray, retType, arrayType, lenNode); + JarrayMallocNode *newArrayNode = builder->CreateExprJarrayMalloc(OP_gcmallocjarray, *retType, *arrayType, lenNode); // Then fill each array element one by one. BaseNode *addrExpr = nullptr; StmtNode *assignStmt = nullptr; if (!isReg) { MIRSymbol *retSym = currFunc->GetLocalOrGlobalSymbol(retPair.first); - assignStmt = builder->CreateStmtDassign(retSym, retPair.second.GetFieldID(), newArrayNode); + assignStmt = builder->CreateStmtDassign(*retSym, retPair.second.GetFieldID(), newArrayNode); currFunc->GetBody()->ReplaceStmt1WithStmt2(&intrinCall, assignStmt); - addrExpr = builder->CreateExprDread(retSym); + addrExpr = builder->CreateExprDread(*retSym); } else { PregIdx pregidx = retPair.second.GetPregIdx(); MIRPreg *mirpreg = currFunc->GetPregTab()->PregFromPregIdx(pregidx); @@ -181,9 +181,9 @@ void JavaIntrnLowering::ProcessJavaIntrnFillNewArray(IntrinsiccallNode &intrinCa assignStmt->SetSrcPos(intrinCall.GetSrcPos()); StmtNode *stmt = assignStmt; for (int i = 0; i < intrinCall.NumOpnds(); i++) { - ArrayNode *arrayexpr = builder->CreateExprArray(arrayType, addrExpr, builder->CreateIntConst(i, PTY_i32)); + 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 f23ac07b883af7e151f6c0255ffea092feea6fd8..f49efebf91e4f415ac7488a1f5061ae8a3930ee6 100644 --- a/src/mpl2mpl/src/muid_replacement.cpp +++ b/src/mpl2mpl/src/muid_replacement.cpp @@ -826,7 +826,7 @@ void MUIDReplacement::ReplaceDirectInvokeOrAddroffunc(MIRFunction ¤tFunc, std::string moduleName = GetModule()->GetFileNameAsPostfix(); std::string baseName = calleeFunc->GetBaseClassName(); - baseExpr = builder->CreateExprAddrof(0, funcDefTabSym, GetModule()->GetMemPool()); + baseExpr = builder->CreateExprAddrof(0, *funcDefTabSym, GetModule()->GetMemPool()); ASSERT(calleeFunc->GetFuncSymbol() != nullptr, "null ptr check!"); index = FindIndexFromDefTable(*(calleeFunc->GetFuncSymbol()), true); arrayType = static_cast(funcDefTabSym->GetType()); @@ -836,18 +836,18 @@ void MUIDReplacement::ReplaceDirectInvokeOrAddroffunc(MIRFunction ¤tFunc, std::string commentLabel = NameMangler::kMarkMuidFuncUndefStr + calleeFunc->GetName(); currentFunc.GetBody()->InsertBefore(&stmt, builder->CreateStmtComment(commentLabel.c_str())); - baseExpr = builder->CreateExprAddrof(0, funcUndefTabSym, GetModule()->GetMemPool()); + baseExpr = builder->CreateExprAddrof(0, *funcUndefTabSym, GetModule()->GetMemPool()); ASSERT(calleeFunc->GetFuncSymbol() != nullptr, "null ptr check!"); index = FindIndexFromUndefTable(*(calleeFunc->GetFuncSymbol()), true); arrayType = static_cast(funcUndefTabSym->GetType()); } ConstvalNode *offsetExpr = builder->CreateIntConst(index, PTY_i64); - ArrayNode *arrayExpr = builder->CreateExprArray(arrayType, baseExpr, offsetExpr); + ArrayNode *arrayExpr = builder->CreateExprArray(*arrayType, baseExpr, offsetExpr); arrayExpr->SetBoundsCheck(false); MIRType *elemType = arrayType->GetElemType(); BaseNode *ireadPtrExpr = - builder->CreateExprIread(GlobalTables::GetTypeTable().GetVoidPtr(), - GlobalTables::GetTypeTable().GetOrCreatePointerType(*elemType), 1, arrayExpr); + builder->CreateExprIread(*GlobalTables::GetTypeTable().GetVoidPtr(), + *GlobalTables::GetTypeTable().GetOrCreatePointerType(*elemType), 1, arrayExpr); PregIdx funcPtrPreg = 0; MIRSymbol *funcPtrSym = nullptr; BaseNode *readFuncPtr = nullptr; @@ -858,9 +858,9 @@ void MUIDReplacement::ReplaceDirectInvokeOrAddroffunc(MIRFunction ¤tFunc, readFuncPtr = builder->CreateExprRegread(PTY_ptr, funcPtrPreg); } else { funcPtrSym = builder->GetOrCreateLocalDecl(kMuidSymPtrStr, *GlobalTables::GetTypeTable().GetVoidPtr()); - DassignNode *addrNode = builder->CreateStmtDassign(funcPtrSym, 0, ireadPtrExpr); + DassignNode *addrNode = builder->CreateStmtDassign(*funcPtrSym, 0, ireadPtrExpr); currentFunc.GetBody()->InsertBefore(&stmt, addrNode); - readFuncPtr = builder->CreateExprDread(funcPtrSym); + readFuncPtr = builder->CreateExprDread(*funcPtrSym); } if (callNode != nullptr) { // Create icallNode to replace callNode @@ -899,23 +899,23 @@ void MUIDReplacement::ReplaceDassign(MIRFunction ¤tFunc, DassignNode &dass MIRArrayType *arrayType = nullptr; if (mirSymbol->GetStorageClass() != kScExtern) { // Local static member is accessed through dataDefTab - baseExpr = builder->CreateExprAddrof(0, dataDefTabSym); + baseExpr = builder->CreateExprAddrof(0, *dataDefTabSym); index = FindIndexFromDefTable(*mirSymbol, false); arrayType = static_cast(dataDefTabSym->GetType()); } else { // External static member is accessed through dataUndefTab - baseExpr = builder->CreateExprAddrof(0, dataUndefTabSym); + baseExpr = builder->CreateExprAddrof(0, *dataUndefTabSym); index = FindIndexFromUndefTable(*mirSymbol, false); arrayType = static_cast(dataUndefTabSym->GetType()); } ConstvalNode *offsetExpr = builder->CreateIntConst(index, PTY_i64); - ArrayNode *arrayExpr = builder->CreateExprArray(arrayType, baseExpr, offsetExpr); + ArrayNode *arrayExpr = builder->CreateExprArray(*arrayType, baseExpr, offsetExpr); arrayExpr->SetBoundsCheck(false); MIRType *elemType = arrayType->GetElemType(); MIRType *mVoidPtr = GlobalTables::GetTypeTable().GetVoidPtr(); CHECK_FATAL(mVoidPtr != nullptr, "null ptr check"); BaseNode *ireadPtrExpr = - builder->CreateExprIread(mVoidPtr, GlobalTables::GetTypeTable().GetOrCreatePointerType(*elemType), 1, arrayExpr); + builder->CreateExprIread(*mVoidPtr, *GlobalTables::GetTypeTable().GetOrCreatePointerType(*elemType), 1, arrayExpr); PregIdx symPtrPreg = 0; MIRSymbol *symPtrSym = nullptr; BaseNode *destExpr = nullptr; @@ -926,13 +926,13 @@ void MUIDReplacement::ReplaceDassign(MIRFunction ¤tFunc, DassignNode &dass destExpr = builder->CreateExprRegread(PTY_ptr, symPtrPreg); } else { symPtrSym = builder->GetOrCreateLocalDecl(kMuidFuncPtrStr, *mVoidPtr); - DassignNode *addrNode = builder->CreateStmtDassign(symPtrSym, 0, ireadPtrExpr); + DassignNode *addrNode = builder->CreateStmtDassign(*symPtrSym, 0, ireadPtrExpr); currentFunc.GetBody()->InsertBefore(&dassignNode, addrNode); - destExpr = builder->CreateExprDread(symPtrSym); + 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)); + StmtNode *iassignNode = builder->CreateStmtIassign(*destPtrType, 0, destExpr, dassignNode.Opnd(0)); currentFunc.GetBody()->ReplaceStmt1WithStmt2(&dassignNode, iassignNode); } @@ -1031,28 +1031,28 @@ BaseNode *MUIDReplacement::ReplaceDread(MIRFunction ¤tFunc, StmtNode *stmt MIRArrayType *arrayType = nullptr; if (mirSymbol->GetStorageClass() != kScExtern) { // Local static member is accessed through dataDefTab - baseExpr = builder->CreateExprAddrof(0, dataDefTabSym); + baseExpr = builder->CreateExprAddrof(0, *dataDefTabSym); index = FindIndexFromDefTable(*mirSymbol, false); arrayType = static_cast(dataDefTabSym->GetType()); } else { // External static member is accessed through dataUndefTab - baseExpr = builder->CreateExprAddrof(0, dataUndefTabSym); + baseExpr = builder->CreateExprAddrof(0, *dataUndefTabSym); index = FindIndexFromUndefTable(*mirSymbol, false); arrayType = static_cast(dataUndefTabSym->GetType()); } ConstvalNode *offsetExpr = builder->CreateIntConst(index, PTY_i64); - ArrayNode *arrayExpr = builder->CreateExprArray(arrayType, baseExpr, offsetExpr); + ArrayNode *arrayExpr = builder->CreateExprArray(*arrayType, baseExpr, offsetExpr); arrayExpr->SetBoundsCheck(false); MIRType *elemType = arrayType->GetElemType(); BaseNode *ireadPtrExpr = - builder->CreateExprIread(GlobalTables::GetTypeTable().GetVoidPtr(), - GlobalTables::GetTypeTable().GetOrCreatePointerType(*elemType), 1, arrayExpr); + builder->CreateExprIread(*GlobalTables::GetTypeTable().GetVoidPtr(), + *GlobalTables::GetTypeTable().GetOrCreatePointerType(*elemType), 1, arrayExpr); if (opnd->GetOpCode() == OP_addrof) { return ireadPtrExpr; } MIRType *destType = mirSymbol->GetType(); MIRType *destPtrType = GlobalTables::GetTypeTable().GetOrCreatePointerType(*destType); - return builder->CreateExprIread(destType, destPtrType, 0, ireadPtrExpr); + return builder->CreateExprIread(*destType, *destPtrType, 0, ireadPtrExpr); } void MUIDReplacement::ProcessFunc(MIRFunction *func) { diff --git a/src/mpl2mpl/src/native_stub_func.cpp b/src/mpl2mpl/src/native_stub_func.cpp index 198f48d1b44ac76a70a364148657d68281a3f9e8..c89437766ae08ec1d3d6a21991f32c5ae79e73f1 100644 --- a/src/mpl2mpl/src/native_stub_func.cpp +++ b/src/mpl2mpl/src/native_stub_func.cpp @@ -134,7 +134,7 @@ void GenericNativeStubFunc::ProcessFunc(MIRFunction *func) { BaseNode *monitor = nullptr; if (func->GetAttr(FUNCATTR_static)) { // Grab class object - monitor = builder->CreateExprAddrof(0, classObjSymbol); + monitor = builder->CreateExprAddrof(0, *classObjSymbol); } else { // Grab _this pointer const size_t funcFormalsSize = func->GetFormalCount(); @@ -145,7 +145,7 @@ void GenericNativeStubFunc::ProcessFunc(MIRFunction *func) { builder->CreateExprRegread(formal0St->GetType()->GetPrimType(), func->GetPregTab()->GetPregIdxFromPregno(formal0St->GetPreg()->GetPregNo())); else { - monitor = builder->CreateExprDread(formal0St); + monitor = builder->CreateExprDread(*formal0St); } } NaryStmtNode *synCenter = builder->CreateStmtNary(OP_syncenter, monitor); @@ -165,7 +165,7 @@ void GenericNativeStubFunc::ProcessFunc(MIRFunction *func) { BaseNode *callerObj = nullptr; // it will be used by PreNativeCall, and might be used by syncenter if (func->GetAttr(FUNCATTR_static)) { // Grab class object - callerObj = builder->CreateExprAddrof(0, classObjSymbol); + callerObj = builder->CreateExprAddrof(0, *classObjSymbol); } else { // Grab _this pointer MIRSymbol *formal0St = func->GetFormal(0); @@ -174,7 +174,7 @@ void GenericNativeStubFunc::ProcessFunc(MIRFunction *func) { builder->CreateExprRegread(formal0St->GetType()->GetPrimType(), func->GetPregTab()->GetPregIdxFromPregno(formal0St->GetPreg()->GetPregNo())); else { - callerObj = builder->CreateExprDread(formal0St); + callerObj = builder->CreateExprDread(*formal0St); } } MapleVector args(builder->GetCurrentFuncCodeMpAllocator()->Adapter()); @@ -186,7 +186,7 @@ void GenericNativeStubFunc::ProcessFunc(MIRFunction *func) { // Generate a MRT call for extra work after calling the native MapleVector postArgs(func->GetCodeMempoolAllocator()->Adapter()); postArgs.push_back(Options::usePreg ? (static_cast(builder->CreateExprRegread(PTY_ptr, envPregIdx))) - : (static_cast(builder->CreateExprDread(envPtrSym)))); + : (static_cast(builder->CreateExprDread(*envPtrSym)))); CallNode *postFuncCall = builder->CreateStmtCallAssigned(MRTPostNativeFunc->GetPuidx(), postArgs, nullptr, OP_callassigned); @@ -198,10 +198,10 @@ void GenericNativeStubFunc::ProcessFunc(MIRFunction *func) { // set up env allocCallArgs.push_back(Options::usePreg ? (static_cast(builder->CreateExprRegread(PTY_ptr, envPregIdx))) - : (static_cast(builder->CreateExprDread(envPtrSym)))); + : (static_cast(builder->CreateExprDread(*envPtrSym)))); // set up class if (func->GetAttr(FUNCATTR_static)) { - allocCallArgs.push_back(builder->CreateExprAddrof(0, classObjSymbol)); + allocCallArgs.push_back(builder->CreateExprAddrof(0, *classObjSymbol)); } } for (uint32 i = 0; i < func->GetFormalCount(); i++) { @@ -211,7 +211,7 @@ void GenericNativeStubFunc::ProcessFunc(MIRFunction *func) { argExpr = builder->CreateExprRegread(argSt->GetType()->GetPrimType(), func->GetPregTab()->GetPregIdxFromPregno(argSt->GetPreg()->GetPregNo())); else { - argExpr = builder->CreateExprDread(argSt); + argExpr = builder->CreateExprDread(*argSt); } allocCallArgs.push_back(argExpr); } @@ -236,7 +236,7 @@ void GenericNativeStubFunc::ProcessFunc(MIRFunction *func) { // Generate a MRT call to decode the tagged pointer MapleVector decodeArgs(func->GetCodeMempoolAllocator()->Adapter()); CHECK_FATAL(stubFuncRet != nullptr, "stubfunc_ret is nullptr"); - decodeArgs.push_back(builder->CreateExprDread(stubFuncRet)); + decodeArgs.push_back(builder->CreateExprDread(*stubFuncRet)); CallNode *decodeFuncCall = builder->CreateStmtCallAssigned(MRTDecodeRefFunc->GetPuidx(), decodeArgs, stubFuncRet, OP_callassigned); func->GetBody()->AddStatement(decodeFuncCall); @@ -250,7 +250,7 @@ void GenericNativeStubFunc::ProcessFunc(MIRFunction *func) { BaseNode *monitor = nullptr; if (func->GetAttr(FUNCATTR_static)) { // Grab class object - monitor = builder->CreateExprAddrof(0, classObjSymbol); + monitor = builder->CreateExprAddrof(0, *classObjSymbol); } else { // Grab _this pointer MIRSymbol *formal0St = func->GetFormal(0); @@ -259,7 +259,7 @@ void GenericNativeStubFunc::ProcessFunc(MIRFunction *func) { builder->CreateExprRegread(formal0St->GetType()->GetPrimType(), func->GetPregTab()->GetPregIdxFromPregno(formal0St->GetPreg()->GetPregNo())); else { - monitor = builder->CreateExprDread(formal0St); + monitor = builder->CreateExprDread(*formal0St); } } NaryStmtNode *syncExit = builder->CreateStmtNary(OP_syncexit, monitor); @@ -281,7 +281,7 @@ void GenericNativeStubFunc::ProcessFunc(MIRFunction *func) { func->GetBody()->AddStatement(callSetFrameStatusFunc); } if (!voidRet) { - StmtNode *stmt = builder->CreateStmtReturn(builder->CreateExprDread(stubFuncRet)); + StmtNode *stmt = builder->CreateStmtReturn(builder->CreateExprDread(*stubFuncRet)); func->GetBody()->AddStatement(stmt); } } @@ -346,12 +346,13 @@ void GenericNativeStubFunc::GenericRegisteredNativeFuncCall(MIRFunction &func, c } size_t loc = regFuncTabConst->GetConstVec().size(); MIRArrayType *regArrayType = static_cast(regFuncTabConst->GetType()); - AddrofNode *regFuncExpr = builder->CreateExprAddrof(0, regFuncSymbol); - ArrayNode *arrayExpr = builder->CreateExprArray(regArrayType, regFuncExpr, builder->CreateIntConst(loc - 1, PTY_i32)); + AddrofNode *regFuncExpr = builder->CreateExprAddrof(0, *regFuncSymbol); + ArrayNode *arrayExpr = + builder->CreateExprArray(*regArrayType, regFuncExpr, builder->CreateIntConst(loc - 1, PTY_i32)); arrayExpr->SetBoundsCheck(false); MIRType *elemType = static_cast(regArrayType)->GetElemType(); BaseNode *ireadExpr = - builder->CreateExprIread(elemType, GlobalTables::GetTypeTable().GetOrCreatePointerType(*elemType), 0, arrayExpr); + builder->CreateExprIread(*elemType, *GlobalTables::GetTypeTable().GetOrCreatePointerType(*elemType), 0, arrayExpr); // assign registered func ptr to a preg. auto funcptrPreg = func.GetPregTab()->CreatePreg(PTY_ptr); RegassignNode *funcptrAssign = builder->CreateStmtRegassign(PTY_ptr, funcptrPreg, ireadExpr); @@ -365,12 +366,13 @@ void GenericNativeStubFunc::GenericRegisteredNativeFuncCall(MIRFunction &func, c 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, + BaseNode *shiftExpr = builder->CreateExprBinary(OP_lshr, *GlobalTables::GetTypeTable().GetPtr(), regreadExpr, builder->CreateIntConst(intConstLength, PTY_u64)); RegassignNode *funcptrshiftAssign = builder->CreateStmtRegassign(PTY_ptr, funcptrshiftPreg, shiftExpr); auto readFuncptrshift = builder->CreateExprRegread(PTY_ptr, funcptrshiftPreg); BaseNode *checkRegExpr = - builder->CreateExprCompare(OP_eq, GlobalTables::GetTypeTable().GetUInt1(), GlobalTables::GetTypeTable().GetPtr(), + builder->CreateExprCompare(OP_eq, *GlobalTables::GetTypeTable().GetUInt1(), + *GlobalTables::GetTypeTable().GetPtr(), readFuncptrshift, builder->CreateIntConst(kInvalidCode, PTY_ptr)); IfStmtNode *ifStmt = static_cast(builder->CreateStmtIf(checkRegExpr)); // get find_native_func function @@ -410,8 +412,8 @@ void GenericNativeStubFunc::GenericRegisteredNativeFuncCall(MIRFunction &func, c CallNode *callDummyNativeFunc = builder->CreateStmtCallRegassigned(dummyNativeFunc->GetPuidx(), dummyFuncOpnds, dummyFuncPreg, OP_callassigned); BaseNode *checkStubReturnExpr = - builder->CreateExprCompare(OP_eq, GlobalTables::GetTypeTable().GetUInt1(), - GlobalTables::GetTypeTable().GetPtr(), readFuncPtr, readDummyFuncPtr); + builder->CreateExprCompare(OP_eq, *GlobalTables::GetTypeTable().GetUInt1(), + *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()); @@ -420,7 +422,7 @@ void GenericNativeStubFunc::GenericRegisteredNativeFuncCall(MIRFunction &func, c // Rewrite reg_jni_func_tab with current funcIdx_ptr(weak/strong symbol address) auto nativeMethodPtr = builder->CreateExprRegread(PTY_ptr, funcptrPreg); IassignNode *nativeFuncTableEntry = builder->CreateStmtIassign( - GlobalTables::GetTypeTable().GetOrCreatePointerType(*elemType), 0, arrayExpr, nativeMethodPtr); + *GlobalTables::GetTypeTable().GetOrCreatePointerType(*elemType), 0, arrayExpr, nativeMethodPtr); subIfStmt->GetThenPart()->AddStatement(nativeFuncTableEntry); // Add if-statement to function body if (!needNativeCall) { @@ -584,31 +586,31 @@ void GenericNativeStubFunc::GenericHelperFuncDecl() { // MRT_PreNativeCall ArgVector preArgs(GetModule()->GetMPAllocator().Adapter()); preArgs.push_back(ArgPair("caller", refType)); - MRTPreNativeFunc = builder->CreateFunction(kPreNativeFunc, voidPointerType, preArgs); + MRTPreNativeFunc = builder->CreateFunction(kPreNativeFunc, *voidPointerType, preArgs); CHECK_FATAL(MRTPreNativeFunc, "MRTPreNativeFunc is null in GenericNativeStubFunc::GenericHelperFuncDecl"); MRTPreNativeFunc->SetBody(nullptr); // MRT_PostNativeCall ArgVector postArgs(GetModule()->GetMPAllocator().Adapter()); postArgs.push_back(ArgPair("env", voidPointerType)); - MRTPostNativeFunc = builder->CreateFunction(kPostNativeFunc, voidType, postArgs); + MRTPostNativeFunc = builder->CreateFunction(kPostNativeFunc, *voidType, postArgs); CHECK_FATAL(MRTPostNativeFunc, "MRTPostNativeFunc is null in GenericNativeStubFunc::GenericHelperFuncDecl"); MRTPostNativeFunc->SetBody(nullptr); // MRT_DecodeReference ArgVector decodeArgs(GetModule()->GetMPAllocator().Adapter()); decodeArgs.push_back(ArgPair("obj", refType)); - MRTDecodeRefFunc = builder->CreateFunction(kDecodeRefFunc, refType, decodeArgs); + MRTDecodeRefFunc = builder->CreateFunction(kDecodeRefFunc, *refType, decodeArgs); CHECK_FATAL(MRTDecodeRefFunc, "MRTDecodeRefFunc is null in GenericNativeStubFunc::GenericHelperFuncDecl"); MRTDecodeRefFunc->SetAttr(FUNCATTR_nosideeffect); MRTDecodeRefFunc->SetBody(nullptr); // MCC_CallFastNative ArgVector callArgs(GetModule()->GetMPAllocator().Adapter()); callArgs.push_back(ArgPair("func", voidPointerType)); - MRTCallFastNativeFunc = builder->CreateFunction(kCallFastNativeFunc, voidPointerType, callArgs); + MRTCallFastNativeFunc = builder->CreateFunction(kCallFastNativeFunc, *voidPointerType, callArgs); CHECK_FATAL(MRTCallFastNativeFunc, "MRTCallFastNativeFunc is null in GenericNativeStubFunc::GenericHelperFuncDecl"); MRTCallFastNativeFunc->SetBody(nullptr); // MCC_CallSlowNative for (int i = 0; i < kSlownativeFuncnum; i++) { - MRTCallSlowNativeFunc[i] = builder->CreateFunction(kCallSlowNativeFuncs[i], voidPointerType, callArgs); + MRTCallSlowNativeFunc[i] = builder->CreateFunction(kCallSlowNativeFuncs[i], *voidPointerType, callArgs); CHECK_FATAL(MRTCallSlowNativeFunc[i], "MRTCallSlowNativeFunc is null in GenericNativeStubFunc::GenericHelperFuncDecl"); MRTCallSlowNativeFunc[i]->SetBody(nullptr); @@ -616,12 +618,12 @@ void GenericNativeStubFunc::GenericHelperFuncDecl() { // MCC_CallFastNativeExt ArgVector callExtArgs(GetModule()->GetMPAllocator().Adapter()); callExtArgs.push_back(ArgPair("func", voidPointerType)); - MRTCallFastNativeExtFunc = builder->CreateFunction(kCallFastNativeExtFunc, voidPointerType, callExtArgs); + MRTCallFastNativeExtFunc = builder->CreateFunction(kCallFastNativeExtFunc, *voidPointerType, callExtArgs); CHECK_FATAL(MRTCallFastNativeExtFunc != nullptr, "MRTCallFastNativeExtFunc is null in GenericNativeStubFunc::GenericHelperFuncDecl"); MRTCallFastNativeExtFunc->SetBody(nullptr); // MCC_CallSlowNativeExt - MRTCallSlowNativeExtFunc = builder->CreateFunction(kCallSlowNativeExtFunc, voidPointerType, callExtArgs); + MRTCallSlowNativeExtFunc = builder->CreateFunction(kCallSlowNativeExtFunc, *voidPointerType, callExtArgs); CHECK_FATAL(MRTCallSlowNativeExtFunc != nullptr, "MRTCallSlowNativeExtFunc is null in GenericNativeStubFunc::GenericHelperFuncDecl"); MRTCallSlowNativeExtFunc->SetBody(nullptr); diff --git a/src/mpl2mpl/src/reflection_analysis.cpp b/src/mpl2mpl/src/reflection_analysis.cpp index 9bee02476a354bfa647e9446748be157fae5b15c..24383f1aa2dd373882fd42b7c146056c82150e88 100644 --- a/src/mpl2mpl/src/reflection_analysis.cpp +++ b/src/mpl2mpl/src/reflection_analysis.cpp @@ -99,15 +99,15 @@ BaseNode *ReflectionAnalysis::GenClassInfoAddr(BaseNode *obj, MIRBuilder *builde MIRClassType *objectType = static_cast(WKTypes::Util::GetJavaLangObjectType()); BaseNode *classinfoAddress = nullptr; if (objectType != nullptr && objectType->GetKind() != kTypeClassIncomplete) { - classinfoAddress = builder->CreateExprIread(GlobalTables::GetTypeTable().GetRef(), - GlobalTables::GetTypeTable().GetOrCreatePointerType(*objectType), + classinfoAddress = builder->CreateExprIread(*GlobalTables::GetTypeTable().GetRef(), + *GlobalTables::GetTypeTable().GetOrCreatePointerType(*objectType), OBJ_KLASS_FIELDID, obj); } else { // If java.lang.Object type is not defined, fall back to use the classinfo struct to retrieve the first field. MIRStructType *classMetadataType = static_cast( GlobalTables::GetTypeTable().GetTypeFromTyIdx(ReflectionAnalysis::classMetadataTyIdx)); - classinfoAddress = builder->CreateExprIread(GlobalTables::GetTypeTable().GetRef(), - GlobalTables::GetTypeTable().GetOrCreatePointerType(*classMetadataType), + classinfoAddress = builder->CreateExprIread(*GlobalTables::GetTypeTable().GetRef(), + *GlobalTables::GetTypeTable().GetOrCreatePointerType(*classMetadataType), METADATA_KLASS_FIELDID, obj); } return classinfoAddress; @@ -1315,7 +1315,7 @@ void ReflectionAnalysis::GenClassMetaData(Klass *klass) { } else { MIRType *clinitState = GlobalTables::GetTypeTable().GetUInt64(); // The class initialization state is modified to classStateInitialized. - MIRSymbol *classInfo = mirBuilder.GetOrCreateGlobalDecl(kClassStateInitializedStr, clinitState); + MIRSymbol *classInfo = mirBuilder.GetOrCreateGlobalDecl(kClassStateInitializedStr, *clinitState); mirBuilder.AddAddrofFieldConst(*classMetadataType, *newconst, fieldID++, *classInfo); } // Finally generate class metadata here. @@ -1454,7 +1454,7 @@ TyIdx ReflectionAnalysis::GenMetaStructType(MIRModule *mirModule, MIRStructType TyIdx tyidx = GlobalTables::GetTypeTable().GetOrCreateMIRType(&metatype); // Global? mirModule->GetTypeNameTab()->SetGStrIdxToTyIdx(stridx, tyidx); - mirModule->GetTypeDefOrder().push_back(stridx); + mirModule->PushbackTypeDefOrder(stridx); const size_t globalTypeTableSize = GlobalTables::GetTypeTable().GetTypeTable().size(); CHECK_FATAL(globalTypeTableSize > tyidx.GetIdx(), "null ptr check"); if (GlobalTables::GetTypeTable().GetTypeTable()[tyidx.GetIdx()]->GetNameStrIdx() == 0) { @@ -1594,7 +1594,7 @@ void ReflectionAnalysis::GenClassHashMetaData() { return; } for (MIRSymbol *classSt : classTab) { - AddrofNode *classExpr = mirBuilder.CreateExprAddrof(0, classSt); + AddrofNode *classExpr = mirBuilder.CreateExprAddrof(0, *classSt); MIRType *ptrType = GlobalTables::GetTypeTable().GetTypeTable()[PTY_ptr]; MIRConst *classConst = mirModule->GetMemPool()->New(classExpr->GetStIdx(), classExpr->GetFieldID(), ptrType); diff --git a/src/mpl2mpl/src/vtable_analysis.cpp b/src/mpl2mpl/src/vtable_analysis.cpp index f02699d8c2058445d565977e6c5a97dd89dfd649..2dfe874953efcb554d444c9ed3fa3c8c8d289b41 100644 --- a/src/mpl2mpl/src/vtable_analysis.cpp +++ b/src/mpl2mpl/src/vtable_analysis.cpp @@ -412,7 +412,7 @@ BaseNode *VtableAnalysis::GenVtabItabBaseAddr(BaseNode *obj, bool isVirtual) { BaseNode *classInfoAddress = ReflectionAnalysis::GenClassInfoAddr(obj, builder); MIRStructType *classMetadataType = static_cast( GlobalTables::GetTypeTable().GetTypeFromTyIdx(ReflectionAnalysis::GetClassMetaDataTyIdx())); - return builder->CreateExprIread(voidPtrType, GlobalTables::GetTypeTable().GetOrCreatePointerType(*classMetadataType), + return builder->CreateExprIread(*voidPtrType, *GlobalTables::GetTypeTable().GetOrCreatePointerType(*classMetadataType), (isVirtual ? KLASS_VTAB_FIELDID : KLASS_ITAB_FIELDID), classInfoAddress); } @@ -452,10 +452,10 @@ void VtableAnalysis::ReplaceVirtualInvoke(CallNode *stmt) { CHECK_FATAL(!stmt->GetNopnd().empty(), "container check"); BaseNode *tabBaseAddress = GenVtabItabBaseAddr(stmt->GetNopndAt(0), true); BaseNode *addrNode = - builder->CreateExprBinary(OP_add, GlobalTables::GetTypeTable().GetPtr(), tabBaseAddress, offsetNode); + builder->CreateExprBinary(OP_add, *GlobalTables::GetTypeTable().GetPtr(), tabBaseAddress, offsetNode); BaseNode *readFuncPtr = builder->CreateExprIread( - GlobalTables::GetTypeTable().GetCompactPtr(), - GlobalTables::GetTypeTable().GetOrCreatePointerType(*GlobalTables::GetTypeTable().GetCompactPtr()), 0, addrNode); + *GlobalTables::GetTypeTable().GetCompactPtr(), + *GlobalTables::GetTypeTable().GetOrCreatePointerType(*GlobalTables::GetTypeTable().GetCompactPtr()), 0, addrNode); stmt->SetOpCode(OP_virtualicallassigned); stmt->GetNopnd().insert(stmt->GetNopnd().begin(), readFuncPtr); stmt->SetNumOpnds(stmt->GetNumOpnds() + 1); diff --git a/src/mpl2mpl/src/vtable_impl.cpp b/src/mpl2mpl/src/vtable_impl.cpp index 7fe08919372488451ef75820a2e34a1e5770db93..80637b42d8e6b0ce48c2bfbc63d5824640ec05b5 100644 --- a/src/mpl2mpl/src/vtable_impl.cpp +++ b/src/mpl2mpl/src/vtable_impl.cpp @@ -110,10 +110,10 @@ void VtableImpl::ReplaceResolveInterface(StmtNode *stmt, const ResolveFuncNode * MIRType *compactPtrType = GlobalTables::GetTypeTable().GetCompactPtr(); PrimType compactPtrPrim = compactPtrType->GetPrimType(); BaseNode *offsetNode = builder->CreateIntConst(hashCode * kTabEntrySize, PTY_u32); - BaseNode *addrNode = builder->CreateExprBinary(OP_add, GlobalTables::GetTypeTable().GetPtr(), + BaseNode *addrNode = builder->CreateExprBinary(OP_add, *GlobalTables::GetTypeTable().GetPtr(), builder->CreateExprRegread(PTY_ptr, pregItabAddress), offsetNode); BaseNode *readFuncPtr = builder->CreateExprIread( - compactPtrType, GlobalTables::GetTypeTable().GetOrCreatePointerType(*compactPtrType), 0, addrNode); + *compactPtrType, *GlobalTables::GetTypeTable().GetOrCreatePointerType(*compactPtrType), 0, addrNode); PregIdx pregFuncPtr = currFunc->GetPregTab()->CreatePreg(compactPtrPrim); RegassignNode *funcPtrAssign = builder->CreateStmtRegassign(compactPtrPrim, pregFuncPtr, readFuncPtr); currFunc->GetBody()->InsertBefore(stmt, funcPtrAssign); @@ -132,7 +132,7 @@ void VtableImpl::ReplaceResolveInterface(StmtNode *stmt, const ResolveFuncNode * opnds.push_back(signatureNode); StmtNode *mccCallStmt = builder->CreateStmtCallRegassigned(mccItabFunc->GetPuidx(), opnds, pregFuncPtr, OP_callassigned); - BaseNode *checkExpr = builder->CreateExprCompare(OP_eq, GlobalTables::GetTypeTable().GetUInt1(), compactPtrType, + BaseNode *checkExpr = builder->CreateExprCompare(OP_eq, *GlobalTables::GetTypeTable().GetUInt1(), *compactPtrType, builder->CreateExprRegread(compactPtrPrim, pregFuncPtr), builder->CreateIntConst(0, compactPtrPrim)); IfStmtNode *ifStmt = static_cast(builder->CreateStmtIf(checkExpr));