diff --git a/src/mapleall/maple_me/src/alias_class.cpp b/src/mapleall/maple_me/src/alias_class.cpp index 24138cc294ca9a2c93b6399bded654f0ba115187..af5da5d3fb487b7060757653bf8655ca0bddafa8 100644 --- a/src/mapleall/maple_me/src/alias_class.cpp +++ b/src/mapleall/maple_me/src/alias_class.cpp @@ -417,14 +417,27 @@ bool AliasClass::SetNextLevNADSForPtrIntegerCopy(AliasElem &lhsAe, const AliasEl PrimType rhsPtyp = realRhs.GetPrimType(); if (lhsPtyp != rhsPtyp) { if (IsPotentialAddress(lhsPtyp, &mirModule) && !IsPotentialAddress(rhsPtyp, &mirModule)) { + // ptr <- (ptr)integer lhsAe.SetNextLevNotAllDefsSeen(true); return true; } else if (!IsPotentialAddress(lhsPtyp, &mirModule) && IsPotentialAddress(rhsPtyp, &mirModule)) { + // integer <- (integer)ptr AliasInfo realRhsAinfo = CreateAliasElemsExpr(realRhs); if (realRhsAinfo.ae != nullptr) { realRhsAinfo.ae->SetNextLevNotAllDefsSeen(true); } return true; + } else if (IsPotentialAddress(lhsPtyp, &mirModule) && + realRhs.GetOpCode() == OP_constval && + static_cast(realRhs).GetConstVal()->IsZero()) { + // special case, pointer initial : ptr <- 0 + // In some cases for some language like C, pointers may be initialized as null pointer at first, + // and assigned a new value in other program site. If we do not handle this case, all pointers + // with 0 intial value will be set nextLevNADS and their nextLev will be unionized after this step. + // The result is right, but the set of nextLevNADS will be very large, leading to a great amount of + // aliasing pointers and the imprecision of the alias analyse result. + // Hence we do nothing but return true here to skip setting pointer nextLevNADS. + return true; } } return false; diff --git a/src/mplfe/ast_input/include/ast_expr.h b/src/mplfe/ast_input/include/ast_expr.h index 31357eac3dfbbc2cf9ca61eca9fa197d396b2b65..4f765302c256482003d3bb710bec8f9cde8729d5 100644 --- a/src/mplfe/ast_input/include/ast_expr.h +++ b/src/mplfe/ast_input/include/ast_expr.h @@ -59,7 +59,7 @@ class ASTExpr { } ASTDecl *GetASTDecl() const { - return refedDecl; + return GetASTDeclImpl(); } ASTOp GetASTOp() { @@ -98,6 +98,11 @@ class ASTExpr { } virtual MIRConst *GenerateMIRConstImpl() const; virtual UniqueFEIRExpr Emit2FEExprImpl(std::list &stmts) const = 0; + + virtual ASTDecl *GetASTDeclImpl() const { + return refedDecl; + } + ASTOp op; MIRType *mirType = nullptr; ASTDecl *refedDecl = nullptr; @@ -172,6 +177,10 @@ class ASTImplicitCastExpr : public ASTExpr { MIRConst *GenerateMIRConstImpl() const override; UniqueFEIRExpr Emit2FEExprImpl(std::list &stmts) const override; + ASTDecl *GetASTDeclImpl() const override { + return child->GetASTDecl(); + } + private: MIRConst *GenerateMIRDoubleConst() const; MIRConst *GenerateMIRFloatConst() const; @@ -472,6 +481,14 @@ class ASTInitListExpr : public ASTExpr { return isUnionInitListExpr; } + void SetHasArrayFiller(bool flag) { + hasArrayFiller = flag; + } + + bool HasArrayFiller() const { + return hasArrayFiller; + } + private: MIRConst *GenerateMIRConstImpl() const override; UniqueFEIRExpr Emit2FEExprImpl(std::list &stmts) const override; @@ -487,6 +504,7 @@ class ASTInitListExpr : public ASTExpr { std::string varName; ParentFlag parentFlag = kNoParent; bool isUnionInitListExpr = false; + bool hasArrayFiller = false; }; class ASTBinaryConditionalOperator : public ASTExpr { @@ -646,6 +664,16 @@ class ASTArraySubscriptExpr : public ASTExpr { return idxExprs; } + void SetBaseExprType(MIRType *ty) { + baseExprTypes.push_back(ty); + } + + const std::vector &GetBaseExprType() const { + return baseExprTypes; + } + + int32 TranslateArraySubscript2Offset() const; + void SetMemberExpr(ASTExpr &astExpr) { memberExpr = &astExpr; } @@ -668,8 +696,9 @@ class ASTArraySubscriptExpr : public ASTExpr { private: UniqueFEIRExpr Emit2FEExprImpl(std::list &stmts) const override; - ASTExpr *baseExpr; + ASTExpr *baseExpr = nullptr; ASTExpr *memberExpr = nullptr; + std::vector baseExprTypes; std::vector idxExprs; bool isAddrOf = false; std::string baseExprVarName; @@ -750,11 +779,11 @@ class ASTMemberExpr : public ASTExpr { UniqueFEIRExpr Emit2FEExprImpl(std::list &stmts) const override; void Emit2FEExprImplForArrayElemIsStruct(UniqueFEIRExpr baseFEExpr, std::string &tmpStructName, std::list &stmts) const; - ASTExpr *baseExpr; + ASTExpr *baseExpr = nullptr; std::string memberName; - MIRType *memberType; - MIRType *baseType; - bool isArrow; + MIRType *memberType = nullptr; + MIRType *baseType = nullptr; + bool isArrow = false; }; class ASTDesignatedInitUpdateExpr : public ASTExpr { diff --git a/src/mplfe/ast_input/src/ast_expr.cpp b/src/mplfe/ast_input/src/ast_expr.cpp index 3450698dd3f8ddf6d5451ea0b4b1a0839acb90bb..85a0c67071e65341f235f035ebe650a314a2114e 100644 --- a/src/mplfe/ast_input/src/ast_expr.cpp +++ b/src/mplfe/ast_input/src/ast_expr.cpp @@ -447,25 +447,32 @@ UniqueFEIRExpr ASTUOLNotExpr::Emit2FEExprImpl(std::list &stmts) UniqueFEIRExpr ASTUOPostIncExpr::Emit2FEExprImpl(std::list &stmts) const { ASTExpr *childExpr = expr; CHECK_FATAL(childExpr != nullptr, "childExpr is nullptr"); - PrimType subPrimType = subType->GetPrimType(); - - UniqueFEIRVar selfVar = FEIRBuilder::CreateVarNameForC(refedDecl->GenerateUniqueVarName(), *subType, isGlobal, false); - UniqueFEIRVar selfMoveVar = selfVar->Clone(); + UniqueFEIRExpr childFEIRExpr = childExpr->Emit2FEExpr(stmts); + UniqueFEIRExpr readSelfExpr; + UniqueFEIRVar selfVar; + if (childExpr->GetASTOp() == kASTMemberExpr) { + readSelfExpr = childFEIRExpr->Clone(); + } else { + selfVar = FEIRBuilder::CreateVarNameForC(refedDecl->GenerateUniqueVarName(), *subType, isGlobal, false); + readSelfExpr = FEIRBuilder::CreateExprDRead(selfVar->Clone()); + } UniqueFEIRVar tempVar = FEIRBuilder::CreateVarNameForC(tempVarName, *subType); - UniqueFEIRVar tempMoveVar = tempVar->Clone(); - UniqueFEIRExpr readSelfExpr = FEIRBuilder::CreateExprDRead(std::move(selfMoveVar)); - UniqueFEIRStmt readSelfstmt = FEIRBuilder::CreateStmtDAssign(std::move(tempMoveVar), std::move(readSelfExpr)); + UniqueFEIRStmt readSelfstmt = FEIRBuilder::CreateStmtDAssign(tempVar->Clone(), std::move(readSelfExpr)); stmts.emplace_back(std::move(readSelfstmt)); - - UniqueFEIRExpr childFEIRExpr = childExpr->Emit2FEExpr(stmts); - UniqueFEIRExpr incIecExpr = (subPrimType == PTY_ptr) ? - std::make_unique(pointeeLen, PTY_i32) : - FEIRBuilder::CreateExprConstAnyScalar(subPrimType, 1); - UniqueFEIRExpr selfAddExpr = FEIRBuilder::CreateExprMathBinary(OP_add, std::move(childFEIRExpr), + PrimType subPrimType = subType->GetPrimType(); + UniqueFEIRExpr incIecExpr = (subPrimType == PTY_ptr) ? std::make_unique(pointeeLen, PTY_i32) : + FEIRBuilder::CreateExprConstAnyScalar(subPrimType, 1); + UniqueFEIRExpr selfAddExpr = FEIRBuilder::CreateExprMathBinary(OP_add, childFEIRExpr->Clone(), std::move(incIecExpr)); - UniqueFEIRStmt selfAddStmt = FEIRBuilder::CreateStmtDAssign(std::move(selfVar), std::move(selfAddExpr)); + UniqueFEIRStmt selfAddStmt; + if (childExpr->GetASTOp() == kASTMemberExpr) { + auto ireadFEExpr = static_cast(childFEIRExpr.get()); + selfAddStmt = std::make_unique(ireadFEExpr->GetClonedPtrType(), ireadFEExpr->GetClonedOpnd(), + std::move(selfAddExpr), ireadFEExpr->GetFieldID()); + } else { + selfAddStmt = FEIRBuilder::CreateStmtDAssign(std::move(selfVar), std::move(selfAddExpr)); + } stmts.emplace_back(std::move(selfAddStmt)); - UniqueFEIRExpr readTempExpr = FEIRBuilder::CreateExprDRead(std::move(tempVar)); return readTempExpr; } @@ -473,26 +480,33 @@ UniqueFEIRExpr ASTUOPostIncExpr::Emit2FEExprImpl(std::list &stmt UniqueFEIRExpr ASTUOPostDecExpr::Emit2FEExprImpl(std::list &stmts) const { ASTExpr *childExpr = expr; CHECK_FATAL(childExpr != nullptr, "childExpr is nullptr"); - PrimType subPrimType = subType->GetPrimType(); - - UniqueFEIRVar selfVar = FEIRBuilder::CreateVarNameForC(refedDecl->GenerateUniqueVarName(), *subType, isGlobal, false); - UniqueFEIRVar selfMoveVar = selfVar->Clone(); + UniqueFEIRExpr childFEIRExpr = childExpr->Emit2FEExpr(stmts); + UniqueFEIRExpr readSelfExpr; + UniqueFEIRVar selfVar; + if (childExpr->GetASTOp() == kASTMemberExpr) { + readSelfExpr = childFEIRExpr->Clone(); + } else { + selfVar = FEIRBuilder::CreateVarNameForC(refedDecl->GenerateUniqueVarName(), *subType, isGlobal, false); + readSelfExpr = FEIRBuilder::CreateExprDRead(selfVar->Clone()); + } UniqueFEIRVar tempVar = FEIRBuilder::CreateVarNameForC(tempVarName, *subType); UniqueFEIRVar tempMoveVar = tempVar->Clone(); - UniqueFEIRExpr readSelfExpr = FEIRBuilder::CreateExprDRead(std::move(selfMoveVar)); - UniqueFEIRStmt readSelfstmt = FEIRBuilder::CreateStmtDAssign(std::move(tempMoveVar), - std::move(readSelfExpr)); + UniqueFEIRStmt readSelfstmt = FEIRBuilder::CreateStmtDAssign(std::move(tempMoveVar), std::move(readSelfExpr)); stmts.emplace_back(std::move(readSelfstmt)); - - UniqueFEIRExpr childFEIRExpr = childExpr->Emit2FEExpr(stmts); - UniqueFEIRExpr incDecExpr = (subPrimType == PTY_ptr) ? - std::make_unique(pointeeLen, PTY_i32) : - FEIRBuilder::CreateExprConstAnyScalar(subPrimType, 1); - UniqueFEIRExpr selfAddExpr = FEIRBuilder::CreateExprMathBinary(OP_sub, std::move(childFEIRExpr), + PrimType subPrimType = subType->GetPrimType(); + UniqueFEIRExpr incDecExpr = (subPrimType == PTY_ptr) ? std::make_unique(pointeeLen, PTY_i32) : + FEIRBuilder::CreateExprConstAnyScalar(subPrimType, 1); + UniqueFEIRExpr selfSubExpr = FEIRBuilder::CreateExprMathBinary(OP_sub, childFEIRExpr->Clone(), std::move(incDecExpr)); - UniqueFEIRStmt selfAddStmt = FEIRBuilder::CreateStmtDAssign(std::move(selfVar), std::move(selfAddExpr)); - stmts.emplace_back(std::move(selfAddStmt)); - + UniqueFEIRStmt selfSubStmt; + if (childExpr->GetASTOp() == kASTMemberExpr) { + auto ireadFEExpr = static_cast(childFEIRExpr.get()); + selfSubStmt = std::make_unique(ireadFEExpr->GetClonedPtrType(), ireadFEExpr->GetClonedOpnd(), + std::move(selfSubExpr), ireadFEExpr->GetFieldID()); + } else { + selfSubStmt = FEIRBuilder::CreateStmtDAssign(std::move(selfVar), std::move(selfSubExpr)); + } + stmts.emplace_back(std::move(selfSubStmt)); UniqueFEIRExpr readTempExpr = FEIRBuilder::CreateExprDRead(std::move(tempVar)); return readTempExpr; } @@ -502,18 +516,26 @@ UniqueFEIRExpr ASTUOPreIncExpr::Emit2FEExprImpl(std::list &stmts CHECK_FATAL(childExpr != nullptr, "childExpr is nullptr"); UniqueFEIRExpr childFEIRExpr = childExpr->Emit2FEExpr(stmts); PrimType subPrimType = subType->GetPrimType(); - UniqueFEIRExpr incIecExpr = (subPrimType == PTY_ptr) ? - std::make_unique(pointeeLen, PTY_i32) : - FEIRBuilder::CreateExprConstAnyScalar(subPrimType, 1); - UniqueFEIRExpr astUOPreIncExpr = FEIRBuilder::CreateExprMathBinary(OP_add, std::move(childFEIRExpr), + UniqueFEIRExpr incIecExpr = (subPrimType == PTY_ptr) ? std::make_unique(pointeeLen, PTY_i32) : + FEIRBuilder::CreateExprConstAnyScalar(subPrimType, 1); + UniqueFEIRExpr astUOPreIncExpr = FEIRBuilder::CreateExprMathBinary(OP_add, childFEIRExpr->Clone(), std::move(incIecExpr)); - UniqueFEIRVar selfVar = FEIRBuilder::CreateVarNameForC(refedDecl->GenerateUniqueVarName(), *subType, isGlobal, false); - UniqueFEIRVar selfMoveVar = selfVar->Clone(); - UniqueFEIRStmt stmt = FEIRBuilder::CreateStmtDAssign(std::move(selfMoveVar), std::move(astUOPreIncExpr)); + UniqueFEIRStmt stmt; + UniqueFEIRExpr retExpr; + if (childExpr->GetASTOp() == kASTMemberExpr) { + auto ireadFEExpr = static_cast(childFEIRExpr.get()); + stmt = std::make_unique(ireadFEExpr->GetClonedPtrType(), ireadFEExpr->GetClonedOpnd(), + std::move(astUOPreIncExpr), ireadFEExpr->GetFieldID()); + retExpr = std::move(childFEIRExpr); + } else { + UniqueFEIRVar selfVar = FEIRBuilder::CreateVarNameForC(refedDecl->GenerateUniqueVarName(), + *subType, isGlobal, false); + UniqueFEIRVar selfMoveVar = selfVar->Clone(); + stmt = FEIRBuilder::CreateStmtDAssign(std::move(selfMoveVar), std::move(astUOPreIncExpr)); + retExpr = FEIRBuilder::CreateExprDRead(std::move(selfVar)); + } stmts.emplace_back(std::move(stmt)); - - UniqueFEIRExpr feirRefExpr = FEIRBuilder::CreateExprDRead(std::move(selfVar)); - return feirRefExpr; + return retExpr; } UniqueFEIRExpr ASTUOPreDecExpr::Emit2FEExprImpl(std::list &stmts) const { @@ -521,18 +543,26 @@ UniqueFEIRExpr ASTUOPreDecExpr::Emit2FEExprImpl(std::list &stmts CHECK_FATAL(childExpr != nullptr, "childExpr is nullptr"); UniqueFEIRExpr childFEIRExpr = childExpr->Emit2FEExpr(stmts); PrimType subPrimType = subType->GetPrimType(); - UniqueFEIRExpr incDecExpr = (subPrimType == PTY_ptr) ? - std::make_unique(pointeeLen, PTY_i32) : - FEIRBuilder::CreateExprConstAnyScalar(subPrimType, 1); - UniqueFEIRExpr astUOPreIncExpr = FEIRBuilder::CreateExprMathBinary(OP_sub, std::move(childFEIRExpr), + UniqueFEIRExpr incDecExpr = (subPrimType == PTY_ptr) ? std::make_unique(pointeeLen, PTY_i32) : + FEIRBuilder::CreateExprConstAnyScalar(subPrimType, 1); + UniqueFEIRExpr astUOPreDecExpr = FEIRBuilder::CreateExprMathBinary(OP_sub, childFEIRExpr->Clone(), std::move(incDecExpr)); - UniqueFEIRVar selfVar = FEIRBuilder::CreateVarNameForC(refedDecl->GenerateUniqueVarName(), *subType, isGlobal, false); - UniqueFEIRVar selfMoveVar = selfVar->Clone(); - UniqueFEIRStmt stmt = FEIRBuilder::CreateStmtDAssign(std::move(selfMoveVar), std::move(astUOPreIncExpr)); + UniqueFEIRStmt stmt; + UniqueFEIRExpr retExpr; + if (childExpr->GetASTOp() == kASTMemberExpr) { + auto ireadFEExpr = static_cast(childFEIRExpr.get()); + stmt = std::make_unique(ireadFEExpr->GetClonedPtrType(), ireadFEExpr->GetClonedOpnd(), + std::move(astUOPreDecExpr), ireadFEExpr->GetFieldID()); + retExpr = std::move(childFEIRExpr); + } else { + UniqueFEIRVar selfVar = FEIRBuilder::CreateVarNameForC(refedDecl->GenerateUniqueVarName(), *subType, + isGlobal, false); + UniqueFEIRVar selfMoveVar = selfVar->Clone(); + stmt = FEIRBuilder::CreateStmtDAssign(std::move(selfMoveVar), std::move(astUOPreDecExpr)); + retExpr = FEIRBuilder::CreateExprDRead(std::move(selfVar)); + } stmts.emplace_back(std::move(stmt)); - - UniqueFEIRExpr feirRefExpr = FEIRBuilder::CreateExprDRead(std::move(selfVar)); - return feirRefExpr; + return retExpr; } MIRConst *ASTUOAddrOfExpr::GenerateMIRConstImpl() const { @@ -545,6 +575,24 @@ MIRConst *ASTUOAddrOfExpr::GenerateMIRConstImpl() const { mirSymbol->GetStIdx(), 0, *(var->GetTypeDesc().front())); return konst; } + case kASTSubscriptExpr: { +#ifndef USE_OPS + CHECK_FATAL(false, "Unsupported"); + return nullptr; +#else + ASTDecl *var = static_cast(expr)->GetBaseExpr()->GetASTDecl(); + MIRSymbol *mirSymbol = FEManager::GetMIRBuilder().GetOrCreateGlobalDecl( + var->GenerateUniqueVarName(), *(var->GetTypeDesc().front())); + int32 offset = static_cast(expr)->TranslateArraySubscript2Offset(); + MIRAddrofConst *konst = FEManager::GetModule().GetMemPool()->New( + mirSymbol->GetStIdx(), 0, *(var->GetTypeDesc().front()), offset); + return konst; +#endif + } + case kASTMemberExpr: { + CHECK_FATAL(false, "MemberExpr and SubscriptExpr nested NIY"); + return nullptr; + } default: { CHECK_FATAL(false, "lValue in expr: %d NIY", expr->GetASTOp()); } @@ -602,7 +650,6 @@ UniqueFEIRExpr ASTUOAddrOfExpr::Emit2FEExprImpl(std::list &stmts fieldID = FEUtils::GetStructFieldID(structType, fieldName); addrOfExpr = FEIRBuilder::CreateExprAddrofVar(std::move(tmpVar)); static_cast(addrOfExpr.get())->SetFieldID(fieldID); - static_cast(addrOfExpr.get())->SetFieldType(memberExpr->GetMemberType()); } } else if (astOp == kASTSubscriptExpr) { ASTArraySubscriptExpr *arraySubExpr = static_cast(childExpr); @@ -833,11 +880,26 @@ MIRConst *ASTInitListExpr::GenerateMIRConstForArray() const { #ifndef USE_OPS CHECK_FATAL(false, "Not support"); #else - for (size_t i = 0; i < fillers.size(); ++i) { - if (fillers[i]->GetASTOp() == kASTImplicitValueInitExpr) { - continue; + if (HasArrayFiller()) { + for (size_t i = 0; i < fillers.size(); ++i) { + if (fillers[i]->GetASTOp() == kASTImplicitValueInitExpr) { + continue; + } + if (fillers[i]->GetASTOp() == kASTOpInitListExpr) { + for (auto subFiller : static_cast(fillers[i])->fillers) { + aggConst->AddItem(subFiller->GenerateMIRConst(), 0); + } + } else { + aggConst->AddItem(fillers[i]->GenerateMIRConst(), 0); + } + } + } else { + for (size_t i = 0; i < fillers.size(); ++i) { + if (fillers[i]->GetASTOp() == kASTImplicitValueInitExpr) { + continue; + } + aggConst->AddItem(fillers[i]->GenerateMIRConst(), 0); } - aggConst->AddItem(fillers[i]->GenerateMIRConst(), 0); } #endif return aggConst; @@ -1069,6 +1131,16 @@ UniqueFEIRExpr ASTStringLiteral::Emit2FEExprImpl(std::list &stmt return expr; } +// ---------- ASTArraySubscriptExpr ---------- +int32 ASTArraySubscriptExpr::TranslateArraySubscript2Offset() const { + int32 offset = 0; + for (std::size_t i = 0; i < idxExprs.size(); ++i) { + CHECK_FATAL(idxExprs[i]->GetConstantValue() != nullptr, "Not constant value for constant initializer"); + offset += baseExprTypes[i]->GetSize() * idxExprs[i]->GetConstantValue()->val.i64; + } + return offset; +} + UniqueFEIRExpr ASTArraySubscriptExpr::Emit2FEExprImpl(std::list &stmts) const { std::list indexExprs; UniqueFEIRExpr arrayStoreForCExpr; @@ -1183,8 +1255,6 @@ UniqueFEIRExpr ASTMemberExpr::Emit2FEExprImpl(std::list &stmts) if (memberFEType->IsArray()) { auto addrofExpr = std::make_unique(std::move(tmpVar)); addrofExpr->SetFieldID(fieldID); - addrofExpr->SetFieldName(fieldName); - addrofExpr->SetFieldType(memberType); return addrofExpr; } else { return FEIRBuilder::CreateExprDReadAggField(std::move(tmpVar), fieldID, std::move(memberFEType)); @@ -1353,6 +1423,7 @@ UniqueFEIRExpr ASTAssignExpr::ProcessAssign(std::list &stmts, Un return leftFEExpr; } else if (leftFEExpr->GetKind() == FEIRNodeKind::kExprArrayStoreForC) { ProcessAssign4ExprArrayStoreForC(stmts, leftFEExpr->Clone(), rightFEExpr->Clone()); + return leftFEExpr; } else if (leftFEExpr->GetKind() == FEIRNodeKind::kExprFieldLoadForC) { auto exprFieldLoadForC = static_cast(leftFEExpr.get()); UniqueFEIRVar varStruct = exprFieldLoadForC->GetStructVar().Clone(); @@ -1361,6 +1432,7 @@ UniqueFEIRExpr ASTAssignExpr::ProcessAssign(std::list &stmts, Un UniqueFEIRStmt stmt = FEIRBuilder::CreateStmtFieldStoreForC(std::move(varStruct), std::move(rightFEExpr), structType, fieldID); stmts.emplace_back(std::move(stmt)); + return leftFEExpr; } return nullptr; } diff --git a/src/mplfe/ast_input/src/ast_parser.cpp b/src/mplfe/ast_input/src/ast_parser.cpp index bb9a0a79fa2bbcffc5776b736635830d30774de3..98981af67f7fd0f0a54cd57abdffebefd9aa57df 100644 --- a/src/mplfe/ast_input/src/ast_parser.cpp +++ b/src/mplfe/ast_input/src/ast_parser.cpp @@ -739,7 +739,7 @@ ASTExpr *ASTParser::ProcessExprUnaryOperator(MapleAllocator &allocator, const cl if (clangOpCode == clang::UO_PostInc || clangOpCode == clang::UO_PostDec || clangOpCode == clang::UO_PreInc || clangOpCode == clang::UO_PreDec) { const auto *declRefExpr = llvm::dyn_cast(subExpr); - if (declRefExpr->getDecl()->getKind() == clang::Decl::Var) { + if (declRefExpr != nullptr && declRefExpr->getDecl()->getKind() == clang::Decl::Var) { const auto *varDecl = llvm::cast(declRefExpr->getDecl()->getCanonicalDecl()); astUOExpr->SetGlobal(!varDecl->isLocalVarDeclOrParm()); } @@ -881,6 +881,9 @@ ASTExpr *ASTParser::ProcessExprInitListExpr(MapleAllocator &allocator, const cla } } } else { + if (expr.hasArrayFiller()) { + astInitListExpr->SetHasArrayFiller(true); + } for (uint32 i = 0; i < n; ++i) { const clang::Expr *eExpr = le[i]; ASTExpr *astExpr = ProcessExpr(allocator, eExpr); @@ -964,6 +967,8 @@ ASTExpr *ASTParser::ProcessExprArraySubscriptExpr(MapleAllocator &allocator, con auto base = exprTmp->getBase(); while (exprTmp != nullptr && exprTmp->getStmtClass() == clang::Stmt::ArraySubscriptExprClass) { base = exprTmp->getBase(); + MIRType *baseExprType = astFile->CvtType(exprTmp->getType()); + astArraySubscriptExpr->SetBaseExprType(baseExprType); ASTExpr *idxExpr = ProcessExpr(allocator, exprTmp->getIdx()); astArraySubscriptExpr->SetIdxExpr(idxExpr); if (idxExpr == nullptr) { diff --git a/src/mplfe/common/include/feir_stmt.h b/src/mplfe/common/include/feir_stmt.h index 1e77ea0107f49a5137bad15aa9c7428518153661..5fcfe43a43e245f65e675bae5a4f4e2a926ccf3f 100644 --- a/src/mplfe/common/include/feir_stmt.h +++ b/src/mplfe/common/include/feir_stmt.h @@ -33,6 +33,7 @@ #include "fe_struct_elem_info.h" #include "feir_var_type_scatter.h" #include "fe_options.h" +#include "feir_type_helper.h" namespace maple { class FEIRBuilder; @@ -485,7 +486,9 @@ class FEIRExprRegRead : public FEIRExpr { class FEIRExprAddrof : public FEIRExpr { public: explicit FEIRExprAddrof(const std::vector &arrayIn) - : FEIRExpr(FEIRNodeKind::kExprAddrof), array(arrayIn) {} + : FEIRExpr(FEIRNodeKind::kExprAddrof, + FEIRTypeHelper::CreateTypeNative(*GlobalTables::GetTypeTable().GetPtrType())), + array(arrayIn) {} ~FEIRExprAddrof() = default; protected: @@ -500,17 +503,11 @@ class FEIRExprAddrof : public FEIRExpr { class FEIRExprAddrofVar : public FEIRExpr { public: explicit FEIRExprAddrofVar(std::unique_ptr argVarSrc) - : FEIRExpr(FEIRNodeKind::kExprAddrofVar), varSrc(std::move(argVarSrc)) {} + : FEIRExpr(FEIRNodeKind::kExprAddrofVar, + FEIRTypeHelper::CreateTypeNative(*GlobalTables::GetTypeTable().GetPtrType())), + varSrc(std::move(argVarSrc)) {} ~FEIRExprAddrofVar() = default; - void SetFieldName(std::string argFieldName) { - fieldName = argFieldName; - } - - void SetFieldType(MIRType *type) { - fieldType = type; - } - void SetFieldID(FieldID id) { fieldID = id; } @@ -531,8 +528,6 @@ class FEIRExprAddrofVar : public FEIRExpr { private: std::unique_ptr varSrc; FieldID fieldID = 0; - std::string fieldName; - MIRType *fieldType = nullptr; MIRConst *cst = nullptr; }; @@ -541,7 +536,7 @@ class FEIRExprIAddrof : public FEIRExpr { public: FEIRExprIAddrof(UniqueFEIRType pointeeType, FieldID id, UniqueFEIRExpr expr) : FEIRExpr(FEIRNodeKind::kExprIAddrof, - std::make_unique(*GlobalTables::GetTypeTable().GetPtrType())), + FEIRTypeHelper::CreateTypeNative(*GlobalTables::GetTypeTable().GetPtrType())), ptrType(std::move(pointeeType)), fieldID(id), subExpr(std::move(expr)) {} @@ -577,10 +572,13 @@ class FEIRExprIAddrof : public FEIRExpr { UniqueFEIRExpr subExpr; }; +// ---------- FEIRExprAddrofFunc ---------- class FEIRExprAddrofFunc : public FEIRExpr { public: explicit FEIRExprAddrofFunc(const std::string &addr) - : FEIRExpr(FEIRNodeKind::kExprAddrofFunc), funcAddr(addr) {} + : FEIRExpr(FEIRNodeKind::kExprAddrofFunc, + FEIRTypeHelper::CreateTypeNative(*GlobalTables::GetTypeTable().GetPtrType())), + funcAddr(addr) {} ~FEIRExprAddrofFunc() = default; protected: @@ -747,7 +745,6 @@ class FEIRExprIRead : public FEIRExpr { protected: std::unique_ptr CloneImpl() const override; BaseNode *GenMIRNodeImpl(MIRBuilder &mirBuilder) const override; - PrimType GetPrimTypeImpl() const override; private: UniqueFEIRType ptrType = nullptr; @@ -1030,12 +1027,16 @@ class FEIRExprArrayStoreForC : public FEIRExpr { std::unique_ptr CloneImpl() const override; BaseNode *GenMIRNodeImpl(MIRBuilder &mirBuilder) const override; PrimType GetPrimTypeImpl() const override; + FEIRType *GetTypeImpl() const override; + const FEIRType &GetTypeRefImpl() const override; private: UniqueFEIRExpr exprArray; mutable std::list exprIndexs; + UniqueFEIRType elemType = nullptr; UniqueFEIRType typeNative = nullptr; bool isAddrOf = false; + UniqueFEIRType ptrType = FEIRTypeHelper::CreateTypeNative(*GlobalTables::GetTypeTable().GetPtrType()); // for array in struct UniqueFEIRExpr exprStruct = nullptr; @@ -1102,7 +1103,6 @@ class FEIRExprCStyleCast : public FEIRExpr { protected: std::unique_ptr CloneImpl() const override; BaseNode *GenMIRNodeImpl(MIRBuilder &mirBuilder) const override; - PrimType GetPrimTypeImpl() const override; private: MIRType *srcType = nullptr; @@ -2019,6 +2019,13 @@ class FEIRExprFieldLoadForC : public FEIRExpr { return varField->GetType()->GetPrimType(); } + FEIRType *GetTypeImpl() const override { + return varField->GetType().get(); + } + const FEIRType &GetTypeRefImpl() const override { + return *GetTypeImpl(); + } + private: UniqueFEIRVar varObj = nullptr; UniqueFEIRVar varField = nullptr; diff --git a/src/mplfe/common/src/feir_stmt.cpp b/src/mplfe/common/src/feir_stmt.cpp index bebf62418b7353645243e6ac98ec4824764f5c7b..a1d7574f149217978d5896c02d0a850dd8a0f24e 100644 --- a/src/mplfe/common/src/feir_stmt.cpp +++ b/src/mplfe/common/src/feir_stmt.cpp @@ -2196,7 +2196,7 @@ void FEIRExprConst::CheckRawValue2SetZero() { // ---------- FEIRExprSizeOfType ---------- FEIRExprSizeOfType::FEIRExprSizeOfType(UniqueFEIRType ty) : FEIRExpr(FEIRNodeKind::kExprSizeOfType, - std::make_unique(*GlobalTables::GetTypeTable().GetPrimType(PTY_u32))), + FEIRTypeHelper::CreateTypeNative(*GlobalTables::GetTypeTable().GetPrimType(PTY_u32))), feirType(std::move(ty)) {} std::unique_ptr FEIRExprSizeOfType::CloneImpl() const { @@ -2286,10 +2286,6 @@ std::unique_ptr FEIRExprIRead::CloneImpl() const { return expr; } -PrimType FEIRExprIRead::GetPrimTypeImpl() const { - return type->GetPrimType(); -} - BaseNode *FEIRExprIRead::GenMIRNodeImpl(MIRBuilder &mirBuilder) const { MIRType *returnType = type->GenerateMIRTypeAuto(); MIRType *pointerType = ptrType->GenerateMIRTypeAuto(); @@ -2353,8 +2349,6 @@ BaseNode *FEIRExprIAddrof::GenMIRNodeImpl(MIRBuilder &mirBuilder) const { std::unique_ptr FEIRExprAddrofVar::CloneImpl() const { std::unique_ptr expr = std::make_unique(varSrc->Clone()); expr->SetFieldID(fieldID); - expr->SetFieldName(fieldName); - expr->SetFieldType(fieldType); return expr; } @@ -2364,15 +2358,11 @@ BaseNode *FEIRExprAddrofVar::GenMIRNodeImpl(MIRBuilder &mirBuilder) const { varSymbol->SetKonst(cst); } MIRType *type = varSrc->GetType()->GenerateMIRTypeAuto(); - AddrofNode *node = mirBuilder.CreateExprAddrof(fieldID, *varSymbol); - FieldID fieldID = this->fieldID; - if ((type->IsMIRStructType() || type->GetKind() == MIRTypeKind::kTypeUnion) && - (!fieldName.empty() || (fieldID != 0))) { - if (fieldID == 0) { - fieldID = FEUtils::GetStructFieldID(static_cast(type), fieldName); - } - node = mirBuilder.CreateExprAddrof(fieldID, *varSymbol); + if (fieldID != 0) { + CHECK_FATAL((type->IsMIRStructType() || type->GetKind() == MIRTypeKind::kTypeUnion), + "if fieldID is not 0, then the variable must be a structure"); } + AddrofNode *node = mirBuilder.CreateExprAddrof(fieldID, *varSymbol); return node; } @@ -2397,7 +2387,9 @@ BaseNode *FEIRExprAddrofFunc::GenMIRNodeImpl(MIRBuilder &mirBuilder) const { // ---------- FEIRExprAddrofArray ---------- FEIRExprAddrofArray::FEIRExprAddrofArray(UniqueFEIRType argTypeNativeArray, UniqueFEIRExpr argExprArray, std::string argArrayName, std::list &argExprIndexs) - : FEIRExpr(FEIRNodeKind::kExprAddrofArray), typeNativeArray(std::move(argTypeNativeArray)), + : FEIRExpr(FEIRNodeKind::kExprAddrofArray, + FEIRTypeHelper::CreateTypeNative(*GlobalTables::GetTypeTable().GetPtrType())), + typeNativeArray(std::move(argTypeNativeArray)), exprArray(std::move(argExprArray)), arrayName(argArrayName) { SetIndexsExprs(argExprIndexs); @@ -3335,6 +3327,10 @@ FEIRExprArrayStoreForC::FEIRExprArrayStoreForC(UniqueFEIRExpr argExprArray, std: typeNative(std::move(argTypeNative)), arrayName(argArrayName) { SetIndexsExprs(argExprIndexs); + CHECK_NULL_FATAL(typeNative); + MIRType *ptrMIRArrayType = typeNative->GenerateMIRTypeAuto(); + MIRType *elemMIRType = static_cast(ptrMIRArrayType)->GetElemType(); + elemType = FEIRTypeHelper::CreateTypeNative(*elemMIRType); } FEIRExprArrayStoreForC::FEIRExprArrayStoreForC(UniqueFEIRExpr argExprArray, std::list &argExprIndexs, @@ -3348,6 +3344,10 @@ FEIRExprArrayStoreForC::FEIRExprArrayStoreForC(UniqueFEIRExpr argExprArray, std: typeNativeStruct(std::move(argStructTypeNative)), arrayName(argArrayName) { SetIndexsExprs(argExprIndexs); + CHECK_NULL_FATAL(typeNative); + MIRType *ptrMIRArrayType = typeNative->GenerateMIRTypeAuto(); + MIRType *elemMIRType = static_cast(ptrMIRArrayType)->GetElemType(); + elemType = FEIRTypeHelper::CreateTypeNative(*elemMIRType); } // only ArraySubscriptExpr is right value, left not need @@ -3368,15 +3368,19 @@ BaseNode *FEIRExprArrayStoreForC::GenMIRNodeImpl(MIRBuilder &mirBuilder) const { #endif } BaseNode *nodeAddrof = nullptr; - MIRSymbol *mirSymbol = exprArray->GetVarUses().front()->GenerateMIRSymbol(mirBuilder); - auto mirtype = mirSymbol->GetType(); - if (mirtype->GetKind() == kTypePointer) { + if (exprArray->GetKind() == kExprIAddrof) { nodeAddrof = exprArray->GenMIRNode(mirBuilder); } else { - if (mirSymbol->GetKonst() == nullptr && exprArray->GetKind() == kExprAddrofVar) { - mirSymbol->SetKonst(static_cast(exprArray.get())->GetVarValue()); + MIRSymbol *mirSymbol = exprArray->GetVarUses().front()->GenerateMIRSymbol(mirBuilder); + auto mirtype = mirSymbol->GetType(); + if (mirtype->GetKind() == kTypePointer) { + nodeAddrof = exprArray->GenMIRNode(mirBuilder); + } else { + if (mirSymbol->GetKonst() == nullptr && exprArray->GetKind() == kExprAddrofVar) { + mirSymbol->SetKonst(static_cast(exprArray.get())->GetVarValue()); + } + nodeAddrof = mirBuilder.CreateExprAddrof(fieldID, *mirSymbol); } - nodeAddrof = mirBuilder.CreateExprAddrof(fieldID, *mirSymbol); } nds.push_back(nodeAddrof); for (auto &e : exprIndexs) { @@ -3419,6 +3423,19 @@ PrimType FEIRExprArrayStoreForC::GetPrimTypeImpl() const { } } +FEIRType *FEIRExprArrayStoreForC::GetTypeImpl() const { + CHECK_NULL_FATAL(typeNative); + if (isAddrOf) { + return ptrType.get(); + } else { + return elemType.get(); + } +} + +const FEIRType &FEIRExprArrayStoreForC::GetTypeRefImpl() const { + return *GetTypeImpl(); +} + // ---------- FEIRExprArrayLoad ---------- FEIRExprArrayLoad::FEIRExprArrayLoad(UniqueFEIRExpr argExprArray, UniqueFEIRExpr argExprIndex, UniqueFEIRType argTypeArray) @@ -3479,10 +3496,13 @@ FEIRExprCStyleCast::FEIRExprCStyleCast(MIRType *src, UniqueFEIRExpr sub, bool isArr2Pty) : FEIRExpr(FEIRNodeKind::kExprCStyleCast), - srcType(std::move(src)), - destType(std::move(dest)), + srcType(src), + destType(dest), subExpr(std::move(sub)), - isArray2Pointer(isArr2Pty) {} + isArray2Pointer(isArr2Pty) { + CHECK_NULL_FATAL(dest); + type = FEIRTypeHelper::CreateTypeNative(*dest); +} std::unique_ptr FEIRExprCStyleCast::CloneImpl() const { auto expr = std::make_unique(srcType, destType, @@ -3491,11 +3511,6 @@ std::unique_ptr FEIRExprCStyleCast::CloneImpl() const { return expr; } -PrimType FEIRExprCStyleCast::GetPrimTypeImpl() const { - CHECK_NULL_FATAL(destType); - return destType->GetPrimType(); -} - BaseNode *FEIRExprCStyleCast::GenMIRNodeImpl(MIRBuilder &mirBuilder) const { BaseNode *sub = subExpr.get()->GenMIRNode(mirBuilder); BaseNode *cvt = nullptr;